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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
12a8dc8b21bf5a6be9512e13ba9475a311df092d | ef3a7391b0a5c5d8e276355e97cbe4de621d500c | /venv/Lib/site-packages/torch/include/ATen/core/LegacyDeviceTypeInit.h | dd3a5529a488994bf65ba816c4e25b31a5f13322 | [
"Apache-2.0"
] | permissive | countBMB/BenjiRepo | 143f6da5d198ea6f06404b4559e1f4528b71b3eb | 79d882263baaf2a11654ca67d2e5593074d36dfa | refs/heads/master | 2022-12-11T07:37:04.807143 | 2019-12-25T11:26:29 | 2019-12-25T11:26:29 | 230,090,428 | 1 | 1 | Apache-2.0 | 2022-12-08T03:21:09 | 2019-12-25T11:05:59 | Python | UTF-8 | C++ | false | false | 1,015 | h | #pragma once
// The legacy mechanism for initializing device types; this is used by
// LegacyTypeDispatch.
#include <c10/core/DeviceType.h>
#include <c10/macros/Macros.h>
#include <c10/util/Registry.h>
#include <ATen/core/ScalarType.h>
namespace at {
struct CAFFE2_API LegacyDeviceTypeInitInterface {
virtual ~LegacyDeviceTypeInitInterface() {}
virtual void initCPU() const {
AT_ERROR("cannot use CPU without ATen library");
}
virtual void initCUDA() const {
AT_ERROR("cannot use CUDA without ATen CUDA library");
}
virtual void initHIP() const {
AT_ERROR("cannot use HIP without ATen HIP library");
}
};
struct CAFFE2_API LegacyDeviceTypeInitArgs {};
C10_DECLARE_REGISTRY(
LegacyDeviceTypeInitRegistry,
LegacyDeviceTypeInitInterface,
LegacyDeviceTypeInitArgs);
#define REGISTER_LEGACY_TYPE_INIT(clsname) \
C10_REGISTER_CLASS(LegacyDeviceTypeInitRegistry, clsname, clsname)
CAFFE2_API const LegacyDeviceTypeInitInterface& getLegacyDeviceTypeInit();
} // namespace at
| [
"bengmen92@gmail.com"
] | bengmen92@gmail.com |
15b24c8e73d1dc44bface0376f6f70e8a601f40b | dcfe1699c1f93cd1f6817f1ecd9886e568dad770 | /engine/core/memory/memory_manager.h | 68a0caecf322fa558f656a7b2a36249e8ef5d114 | [
"MIT"
] | permissive | RikoOphorst/Tremble-OLD | c96f8143a99eaa7467cf3f87398ad82e65ca5022 | 650fa53402f9c6114642e0cc8515b2ed517d40d6 | refs/heads/master | 2021-06-08T04:35:25.395741 | 2016-11-05T17:40:39 | 2016-11-05T17:40:39 | 72,647,196 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,123 | h | #pragma once
//#include "allocators/allocator.h"
#include "allocators/free_list_allocator.h"
//#include "allocators/linear_allocator.h"
//#include "allocators/pool_allocator.h"
//#include "allocators/proxy_allocator.h"
//#include "allocators/stack_allocator.h"
#include "pch.h"
namespace engine
{
/**
* @brief An overall memory manager class. Handles allocation of allocators in our game.
*
* A single memory manager is meant to exist in a process. Different systems can allocate an allocator with a big chunk of memory for itself.
* That allocator then manages the memory for each system.
* @author Anton Gavrilov
*/
class MemoryManager
{
public:
MemoryManager(size_t memory); //!< @param memory Amount of memory, that you want this memory manager to have.
~MemoryManager(); //!< Frees all the memory in the memory manager
/**
* @brief Get a new allocator to manage a piece of memory for a subsystem of a game.
* @param size Size, that you wish the allocator to have
* @tparam AllocatorClass Class of the allocator that you want to get. Has to be a derived class from engine::Allocator
* @return A pointer tio the initialized allocator
*/
template<typename AllocatorClass>
AllocatorClass* GetNewAllocator(size_t size)
{
if (std::is_base_of<Allocator, AllocatorClass>() == true)
{
void* p = all_allocators_->Allocate(sizeof(AllocatorClass) + size, alignof(AllocatorClass));
return new (p) AllocatorClass(size, pointer_math::Add(p, sizeof(AllocatorClass)));
}
return nullptr;
}
/**
* @brief Remove an allocator from the memory manager
* @param p A pointer to the alocator that you want to deallocate
*/
template<typename AllocatorClass>
void DeleteAllocator(AllocatorClass* p)
{
p->~AllocatorClass();
all_allocators_->Deallocate(p);
}
private:
FreeListAllocator* all_allocators_; //!< A pointer to the free list allocator that manages all the allocators
void* memory_; //!< A pointer to the memory, that is allocated for the memory manager
size_t memory_size_; //!< The size of the memory, that is in use by the memory manager
};
} | [
"riko_ophorst@hotmail.com"
] | riko_ophorst@hotmail.com |
60aded838c8cc6c71aed5d44e81214d53f8d2ad8 | 20fffb1bc2795021c4612ad4b408d96fa5b761cf | /POJ/POJ 1679.cpp | e6ab19d1e4057b51a3b3a461e6ad236324edbcfd | [] | no_license | myk502/ACM | 244c0a614ab2454332d11fd9afd7a5434d22b090 | 7c4d55a4655e58de89307965a322dd862758adbd | refs/heads/master | 2021-01-01T16:42:05.678466 | 2018-10-01T14:31:57 | 2018-10-01T14:34:42 | 97,893,148 | 7 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 2,200 | cpp | #include<cstdio>
#include<iostream>
#include<cstring>
#include<queue>
#include<climits>
#include<cmath>
#include<string>
#include<map>
#include<algorithm>
using namespace std;
int n,m,pre[110];
struct Edge
{
int from;
int to;
int cost;
};
Edge a[10010];
int indexx;
int find_ancestor(int x)
{
int r=x;
while(pre[r]!=r)
{
r=pre[r];
}
int i=x,j;
while(i!=r)
{
j=pre[i];
pre[i]=r;
i=j;
}
return r;
}
void join(int x,int y)
{
int fx=find_ancestor(x);
int fy=find_ancestor(y);
if(fx!=fy)
pre[fx]=fy;
}
bool cmp(Edge xx,Edge yy)
{
return(xx.cost<yy.cost);
}
int main(void)
{
int t,u,v,w,cnt,flag,ans;
cin>>t;
while(t--)
{
cnt=0;
cin>>n>>m;
flag=0;
ans=0;
for(int i=1;i<=n;i++)
pre[i]=i;
for(int i=0;i<m;i++)
{
scanf("%d%d%d",&u,&v,&w);
Edge input;
input.from=u;
input.to=v;
input.cost=w;
a[i]=input;
}
sort(a,a+m,cmp);
indexx=0;
while(cnt<n-1)
{
Edge temp=a[indexx];
int uu=temp.from,vv=temp.to,ww=temp.cost;
int fauu=find_ancestor(uu),favv=find_ancestor(vv);
if(find_ancestor(uu)!=find_ancestor(vv))
{
for(int j=indexx+1;j<m;j++)
{
Edge tempp=a[j];
int uuu=tempp.from,vvv=tempp.to,www=tempp.cost;
if(www!=ww)
break;
int fauuu=find_ancestor(uuu),favvv=find_ancestor(vvv);
if((fauu==fauuu)&&(favv==favvv))
flag=1;
if((fauu==favvv)&&(fauuu==favv))
flag=1;
}
cnt++;
join(uu,vv);
ans+=ww;
}
indexx++;
}
if(flag==1)
printf("Not Unique!\n");
else
printf("%d\n",ans);
}
return 0;
}
| [
"525039107@qq.com"
] | 525039107@qq.com |
cced036998b4bbabb24f5a34f195574a9a25cdfc | 3abe45130d4f614f68c6551b59014a20d3470b58 | /src/primitives/deterministicmint.h | a2b03d4b5f596a6b86656af5394c0ef83383e4be | [
"MIT"
] | permissive | dre060/YAADI | faab94150263848ef16fe6a865cff7d2a7893e00 | cdb07c723f559ce883e33d64bce55b6ee5539142 | refs/heads/main | 2023-05-17T15:01:43.672809 | 2021-06-06T04:23:41 | 2021-06-06T04:23:41 | 374,243,648 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,473 | h | // Copyright (c) 2018 The PIVX developers
// Copyright (c) 2018 The yaadi developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#ifndef yaadi_DETERMINISTICMINT_H
#define yaadi_DETERMINISTICMINT_H
#include <libzerocoin/Denominations.h>
#include <uint256.h>
#include <serialize.h>
//struct that is safe to store essential mint data, without holding any information that allows for actual spending (serial, randomness, private key)
class CDeterministicMint
{
private:
uint8_t nVersion;
uint32_t nCount;
uint256 hashSeed;
uint256 hashSerial;
uint256 hashStake;
uint256 hashPubcoin;
uint256 txid;
int nHeight;
libzerocoin::CoinDenomination denom;
bool isUsed;
public:
CDeterministicMint();
CDeterministicMint(uint8_t nVersion, const uint32_t& nCount, const uint256& hashSeed, const uint256& hashSerial, const uint256& hashPubcoin, const uint256& hashStake);
libzerocoin::CoinDenomination GetDenomination() const { return denom; }
uint32_t GetCount() const { return nCount; }
int GetHeight() const { return nHeight; }
uint256 GetSeedHash() const { return hashSeed; }
uint256 GetSerialHash() const { return hashSerial; }
uint256 GetStakeHash() const { return hashStake; }
uint256 GetPubcoinHash() const { return hashPubcoin; }
uint256 GetTxHash() const { return txid; }
uint8_t GetVersion() const { return nVersion; }
bool IsUsed() const { return isUsed; }
void SetDenomination(const libzerocoin::CoinDenomination denom) { this->denom = denom; }
void SetHeight(const int& nHeight) { this->nHeight = nHeight; }
void SetNull();
void SetStakeHash(const uint256& hashStake) { this->hashStake = hashStake; }
void SetTxHash(const uint256& txid) { this->txid = txid; }
void SetUsed(const bool isUsed) { this->isUsed = isUsed; }
std::string ToString() const;
ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion)
{
READWRITE(this->nVersion);
READWRITE(nCount);
READWRITE(hashSeed);
READWRITE(hashSerial);
READWRITE(hashStake);
READWRITE(hashPubcoin);
READWRITE(txid);
READWRITE(nHeight);
READWRITE(denom);
READWRITE(isUsed);
};
};
#endif //yaadi_DETERMINISTICMINT_H
| [
"ipedrero84@gmail.com"
] | ipedrero84@gmail.com |
2962dfb266039935205f03324b4b97e97167277a | 7446390f0213548cebe1362b2953438de8420d9e | /Analysis/MssmHbb/interface/HbbLimits.h | adf9b03b4bc4d0094433c08360955b866391f3c5 | [] | no_license | desy-cms/analysis | c223db1075dc7b21414e039501965438c1b3b031 | e1bd297c8ac1db4cdd2855caa7d652308196eaa8 | refs/heads/develop | 2021-04-09T17:12:11.830400 | 2017-05-16T13:07:25 | 2017-05-16T13:07:25 | 43,806,324 | 6 | 18 | null | 2017-04-18T12:57:01 | 2015-10-07T09:30:16 | C++ | UTF-8 | C++ | false | false | 4,568 | h | /*
* HbbLimits.h
*
* Created on: Dec 13, 2016
* Author: shevchen
*/
#include <string>
#include <iostream>
#include <map>
#include "Analysis/MssmHbb/interface/Luminosity.h"
#include "Analysis/MssmHbb/macros/Drawer/HbbStyle.cc"
#include "TH3.h"
#include <TH2.h>
#include <TH1.h>
#include "TLegend.h"
#include "TGraph.h"
#include "TMultiGraph.h"
#include "TGraphAsymmErrors.h"
#ifndef MSSMHBB_INTERFACE_HBBLIMITS_H_
#define MSSMHBB_INTERFACE_HBBLIMITS_H_
// Root includes
#include <TTree.h>
#include <TMath.h>
#include <TH1.h>
#include <TH3F.h>
// cpp includes
#include <string>
#include <iostream>
#include <fstream>
#include <vector>
//my includes
#include "Analysis/MssmHbb/interface/Limit.h"
#include "Analysis/MssmHbb/interface/utilLib.h"
// MSSM tools
#include "Analysis/MssmHbb/macros/signal/mssm_xs_tools.h"
#include "Analysis/MssmHbb/macros/signal/mssm_xs_tools.C"
namespace analysis {
namespace mssmhbb {
class HbbLimits {
public:
HbbLimits();
HbbLimits(const bool& blindData, const bool& test = false);
HbbLimits(const bool& blindData, const std::string& boson, const bool& test = false);
virtual ~HbbLimits();
struct THDMScan{
TH2D expected;
TH2D observed;
};
// Method to read Limits from the combine output
std::vector<Limit> ReadCombineLimits(const std::string& file_name);
// Method to read one limit
const Limit ReadCombineLimit(const std::string& tfile_name, const bool& blindData);
// Method to set higgs boson to be used: A/H/Degenarated
void SetHiggsBoson(const std::string& boson);
// Method to get tanBeta limits according to theoretical Br and Sigma
const std::vector<Limit> GetMSSMLimits(const std::vector<Limit>& GxBR_limits, const std::string& benchmark_path, const std::string& uncert = "", const bool& UP = false, const std::string& benchmark_ref_path = "", const double& tanBref = -1);
// Method to get 2HDM 3D GxBR
TH3D Get2HDM_GxBR_3D(const std::string& benchmark_path);
// Method to get 2HDM 2D GxBR for particular value of VAR
TH2D Get2HDM_GxBR_2D(const TH3& GxBR, const double& var, const std::string& axis = "X");
// Method to get 2D limits of G_95%CL / G_pred for particular mass point
THDMScan Get2HDMmuScan(const TH2& GxBR_2hdm, const Limit& GxBR_95CL);
// Method to calculate 2HDM limits
std::vector<Limit> Get2HDM_Limits(const TH2& GxBR_2hdm, const Limit& GxBR_95CL, const double& xmin = -1, const double& xmax = 1);
// Method to plot Brazil 2HDM limits
const std::vector<Limit> Get2HDM_1D_Limits(const TH2& GxBR_2hdm,const std::vector<Limit>& GxBR_limits);
// Make output .txt with limits written in a human readable way
void Write(const std::vector<Limit>& limits, const std::string& name);
// Method to receive tanBeta value from Sigma x BR in MSSM interpretation
double MSSMTanBeta(const std::string& benchmark_path, double mA, double xsection, const std::string& uncert = "", const bool& UP = false, const std::string& benchmark_ref_path = "", const double& tanBref = -1);
// Method to receive tanBeta value for 1D Siga x BR in 2HDMinterpretation
double THDMTanBeta(const TH2& GxBR_2hdm, double mA, double xsection);
// Method to get contour of atlas plot
TGraph GetAtlasZhll_flipped();
// // Method to get 2HDM tanBeta vs MA limits
// const std::vector<Limit> Get2HDM_tanB_mA_Limits(const std::vector<Limit>& GxBR_limits, const std::string& benchmark_path, const double& sinB_A);
// // Method to get 2HDM sin(beta-alpha) vs tanBeta limits for particular value of mA
// const std::vector<Limit> Get2HDM_cosB_A_tanB_Limits(const std::vector<Limit>& GxBR_limits, const std::string& benchmark_path, const double& mA);
// const std::vector<Limit> Get2HDM_cosB_A_tanB_Limits(const Limit& GxBR_limit, const std::string& benchmark_path, const double& mA); // TODO: Implement!
void LimitPlotter(const std::vector<Limit>& limits,
const std::vector<Limit>& differ_limits,
TLegend& leg,
const std::string& output = "",
const float& yMin = 1,
const float& yMax = 60,
const float& xMin = 200,
const float& xMax = 700,
const std::string& Lumi = "2.69 fb^{-1}",
const std::string& xtitle = "m_{A} [GeV]",
const std::string& ytitle = "tan#beta",
const bool& logY = true);
private:
bool blindData_;
std::string boson_;
bool TEST_;
HbbStyle style_;
protected:
void CheckHiggsBoson();
void SetTHDMHistos(TFile& file,std::map<std::string,TH3D*>&);
};
inline void HbbLimits::SetHiggsBoson(const std::string& boson) {
boson_ = boson;
}
} /* namespace MssmHbb */
} /* namespace Analysis */
#endif /* MSSMHBB_INTERFACE_HBBLIMITS_H_ */
| [
"shevchenko.rostislav@gmail.com"
] | shevchenko.rostislav@gmail.com |
264d4ff635befc5c138c817b264b9d8c88c85957 | f7b2758ba036bf7a817f21fa4f909bee2890c521 | /source/hpp/ovcxfer.hpp | 37539d8a61c855c322af11a30d306bc8219c4257 | [] | no_license | kputy/Orpheus | 4f47d9d3c7fa22af10aa8d4fce05054038f1148c | 5b5186fb59c2f791952a9c1f563eed335b6ea01c | refs/heads/master | 2021-01-18T07:00:34.402335 | 2015-03-07T11:01:08 | 2015-03-07T11:01:08 | 41,523,922 | 0 | 1 | null | 2015-08-28T03:03:48 | 2015-08-28T03:03:48 | null | UTF-8 | C++ | false | false | 4,918 | hpp | // CodeGear C++Builder
// Copyright (c) 1995, 2014 by Embarcadero Technologies, Inc.
// All rights reserved
// (DO NOT EDIT: machine generated header) 'ovcxfer.pas' rev: 28.00 (Windows)
#ifndef OvcxferHPP
#define OvcxferHPP
#pragma delphiheader begin
#pragma option push
#pragma option -w- // All warnings off
#pragma option -Vx // Zero-length empty class member
#pragma pack(push,8)
#include <System.hpp> // Pascal unit
#include <SysInit.hpp> // Pascal unit
#include <Winapi.Windows.hpp> // Pascal unit
#include <System.Classes.hpp> // Pascal unit
#include <Vcl.Controls.hpp> // Pascal unit
#include <Vcl.ExtCtrls.hpp> // Pascal unit
#include <Vcl.Forms.hpp> // Pascal unit
#include <Vcl.StdCtrls.hpp> // Pascal unit
#include <System.SysUtils.hpp> // Pascal unit
#include <ovcbase.hpp> // Pascal unit
#include <ovcconst.hpp> // Pascal unit
#include <ovcdata.hpp> // Pascal unit
#include <ovcef.hpp> // Pascal unit
#include <ovcrlbl.hpp> // Pascal unit
#include <ovcedit.hpp> // Pascal unit
//-- user supplied -----------------------------------------------------------
namespace Ovcxfer
{
//-- type declarations -------------------------------------------------------
enum DECLSPEC_DENUM TxfrStringtype : unsigned char { xfrString, xfrPChar, xfrShortString };
struct TListBoxTransfer;
typedef TListBoxTransfer *PListBoxTransfer;
#pragma pack(push,1)
struct DECLSPEC_DRECORD TListBoxTransfer
{
public:
int ItemIndex;
System::Classes::TStrings* Items;
};
#pragma pack(pop)
struct TComboBoxTransfer;
typedef TComboBoxTransfer *PComboBoxTransfer;
#pragma pack(push,1)
struct DECLSPEC_DRECORD TComboBoxTransfer
{
public:
int ItemIndex;
System::UnicodeString Text;
System::Classes::TStrings* Items;
};
#pragma pack(pop)
struct TComboBoxTransfer_xfrPChar;
typedef TComboBoxTransfer_xfrPChar *PComboBoxTransfer_xfrPChar;
#pragma pack(push,1)
struct DECLSPEC_DRECORD TComboBoxTransfer_xfrPChar
{
public:
int ItemIndex;
System::StaticArray<System::WideChar, 256> Text;
System::Classes::TStrings* Items;
};
#pragma pack(pop)
struct TComboBoxTransfer_xfrShortString;
typedef TComboBoxTransfer_xfrShortString *PComboBoxTransfer_xfrShortString;
#pragma pack(push,1)
struct DECLSPEC_DRECORD TComboBoxTransfer_xfrShortString
{
public:
int ItemIndex;
System::SmallString<255> Text;
System::Classes::TStrings* Items;
};
#pragma pack(pop)
class DELPHICLASS TOvcTransfer;
class PASCALIMPLEMENTATION TOvcTransfer : public Ovcbase::TOvcComponent
{
typedef Ovcbase::TOvcComponent inherited;
protected:
System::Classes::TList* xfrList;
System::Word __fastcall xfrGetComponentDataSize(System::Classes::TComponent* C, TxfrStringtype xfrStringtype);
public:
void __fastcall GetTransferList(System::Classes::TList* L);
System::Word __fastcall GetTransferBufferSizePrim(System::Classes::TComponent* *CNA, const int CNA_High, TxfrStringtype xfrStringtype);
System::Word __fastcall GetTransferBufferSize(System::Classes::TComponent* *CNA, const int CNA_High);
System::Word __fastcall GetTransferBufferSizeZ(System::Classes::TComponent* *CNA, const int CNA_High);
System::Word __fastcall GetTransferBufferSizeS(System::Classes::TComponent* *CNA, const int CNA_High);
void __fastcall TransferFromFormPrim(System::Classes::TComponent* *CNA, const int CNA_High, void *Data, TxfrStringtype xfrStringtype);
void __fastcall TransferFromForm(System::Classes::TComponent* *CNA, const int CNA_High, void *Data);
void __fastcall TransferFromFormZ(System::Classes::TComponent* *CNA, const int CNA_High, void *Data);
void __fastcall TransferFromFormS(System::Classes::TComponent* *CNA, const int CNA_High, void *Data);
void __fastcall TransferToFormPrim(System::Classes::TComponent* *CNA, const int CNA_High, const void *Data, TxfrStringtype xfrStringtype);
void __fastcall TransferToForm(System::Classes::TComponent* *CNA, const int CNA_High, const void *Data);
void __fastcall TransferToFormZ(System::Classes::TComponent* *CNA, const int CNA_High, const void *Data);
void __fastcall TransferToFormS(System::Classes::TComponent* *CNA, const int CNA_High, const void *Data);
public:
/* TOvcComponent.Create */ inline __fastcall virtual TOvcTransfer(System::Classes::TComponent* AOwner) : Ovcbase::TOvcComponent(AOwner) { }
/* TOvcComponent.Destroy */ inline __fastcall virtual ~TOvcTransfer(void) { }
};
//-- var, const, procedure ---------------------------------------------------
static const System::Byte xfrMaxPChar = System::Byte(0xff);
} /* namespace Ovcxfer */
#if !defined(DELPHIHEADER_NO_IMPLICIT_NAMESPACE_USE) && !defined(NO_USING_NAMESPACE_OVCXFER)
using namespace Ovcxfer;
#endif
#pragma pack(pop)
#pragma option pop
#pragma delphiheader end.
//-- end unit ----------------------------------------------------------------
#endif // OvcxferHPP
| [
"romankassebaum@users.noreply.github.com"
] | romankassebaum@users.noreply.github.com |
c23aab76666a81798c67aada0566ccc41acb48b6 | 600df3590cce1fe49b9a96e9ca5b5242884a2a70 | /components/security_interstitials/core/ssl_error_ui.cc | 320fbbe0447a1c34ec725e93fb25dfb188b2f28a | [
"BSD-3-Clause"
] | permissive | metux/chromium-suckless | efd087ba4f4070a6caac5bfbfb0f7a4e2f3c438a | 72a05af97787001756bae2511b7985e61498c965 | refs/heads/orig | 2022-12-04T23:53:58.681218 | 2017-04-30T10:59:06 | 2017-04-30T23:35:58 | 89,884,931 | 5 | 3 | BSD-3-Clause | 2022-11-23T20:52:53 | 2017-05-01T00:09:08 | null | UTF-8 | C++ | false | false | 7,560 | cc | // Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "components/security_interstitials/core/ssl_error_ui.h"
#include "base/i18n/time_formatting.h"
#include "components/security_interstitials/core/common_string_util.h"
#include "components/security_interstitials/core/metrics_helper.h"
#include "components/ssl_errors/error_classification.h"
#include "components/ssl_errors/error_info.h"
#include "grit/components_strings.h"
#include "ui/base/l10n/l10n_util.h"
namespace security_interstitials {
namespace {
// URL for help page.
const char kHelpURL[] = "https://support.google.com/chrome/answer/6098869";
bool IsMasked(int options, SSLErrorUI::SSLErrorOptionsMask mask) {
return ((options & mask) != 0);
}
} // namespace
SSLErrorUI::SSLErrorUI(const GURL& request_url,
int cert_error,
const net::SSLInfo& ssl_info,
int display_options,
const base::Time& time_triggered,
ControllerClient* controller)
: request_url_(request_url),
cert_error_(cert_error),
ssl_info_(ssl_info),
time_triggered_(time_triggered),
requested_strict_enforcement_(
IsMasked(display_options, STRICT_ENFORCEMENT)),
soft_override_enabled_(IsMasked(display_options, SOFT_OVERRIDE_ENABLED)),
hard_override_enabled_(
!IsMasked(display_options, HARD_OVERRIDE_DISABLED)),
controller_(controller),
user_made_decision_(false) {
controller_->metrics_helper()->RecordUserDecision(MetricsHelper::SHOW);
controller_->metrics_helper()->RecordUserInteraction(
MetricsHelper::TOTAL_VISITS);
ssl_errors::RecordUMAStatistics(soft_override_enabled_, time_triggered_,
request_url, cert_error_,
*ssl_info_.cert.get());
}
SSLErrorUI::~SSLErrorUI() {
// If the page is closing without an explicit decision, record it as not
// proceeding.
if (!user_made_decision_) {
controller_->metrics_helper()->RecordUserDecision(
MetricsHelper::DONT_PROCEED);
}
controller_->metrics_helper()->RecordShutdownMetrics();
}
void SSLErrorUI::PopulateStringsForHTML(base::DictionaryValue* load_time_data) {
DCHECK(load_time_data);
// Shared with other errors.
common_string_util::PopulateSSLLayoutStrings(cert_error_, load_time_data);
common_string_util::PopulateSSLDebuggingStrings(ssl_info_, time_triggered_,
load_time_data);
common_string_util::PopulateNewIconStrings(load_time_data);
// Shared values for both the overridable and non-overridable versions.
load_time_data->SetBoolean("bad_clock", false);
load_time_data->SetString("tabTitle",
l10n_util::GetStringUTF16(IDS_SSL_V2_TITLE));
load_time_data->SetString("heading",
l10n_util::GetStringUTF16(IDS_SSL_V2_HEADING));
load_time_data->SetString(
"primaryParagraph",
l10n_util::GetStringFUTF16(
IDS_SSL_V2_PRIMARY_PARAGRAPH,
common_string_util::GetFormattedHostName(request_url_)));
if (soft_override_enabled_)
PopulateOverridableStrings(load_time_data);
else
PopulateNonOverridableStrings(load_time_data);
}
void SSLErrorUI::PopulateOverridableStrings(
base::DictionaryValue* load_time_data) {
DCHECK(soft_override_enabled_);
base::string16 url(common_string_util::GetFormattedHostName(request_url_));
ssl_errors::ErrorInfo error_info = ssl_errors::ErrorInfo::CreateError(
ssl_errors::ErrorInfo::NetErrorToErrorType(cert_error_),
ssl_info_.cert.get(), request_url_);
load_time_data->SetBoolean("overridable", true);
load_time_data->SetString("explanationParagraph", error_info.details());
load_time_data->SetString(
"primaryButtonText",
l10n_util::GetStringUTF16(IDS_SSL_OVERRIDABLE_SAFETY_BUTTON));
load_time_data->SetString(
"finalParagraph",
l10n_util::GetStringFUTF16(IDS_SSL_OVERRIDABLE_PROCEED_PARAGRAPH, url));
}
void SSLErrorUI::PopulateNonOverridableStrings(
base::DictionaryValue* load_time_data) {
DCHECK(!soft_override_enabled_);
base::string16 url(common_string_util::GetFormattedHostName(request_url_));
ssl_errors::ErrorInfo::ErrorType type =
ssl_errors::ErrorInfo::NetErrorToErrorType(cert_error_);
load_time_data->SetBoolean("overridable", false);
load_time_data->SetString(
"explanationParagraph",
l10n_util::GetStringFUTF16(IDS_SSL_NONOVERRIDABLE_MORE, url));
load_time_data->SetString("primaryButtonText",
l10n_util::GetStringUTF16(IDS_SSL_RELOAD));
// Customize the help link depending on the specific error type.
// Only mark as HSTS if none of the more specific error types apply,
// and use INVALID as a fallback if no other string is appropriate.
load_time_data->SetInteger("errorType", type);
int help_string = IDS_SSL_NONOVERRIDABLE_INVALID;
switch (type) {
case ssl_errors::ErrorInfo::CERT_REVOKED:
help_string = IDS_SSL_NONOVERRIDABLE_REVOKED;
break;
case ssl_errors::ErrorInfo::CERT_PINNED_KEY_MISSING:
help_string = IDS_SSL_NONOVERRIDABLE_PINNED;
break;
case ssl_errors::ErrorInfo::CERT_INVALID:
help_string = IDS_SSL_NONOVERRIDABLE_INVALID;
break;
default:
if (requested_strict_enforcement_)
help_string = IDS_SSL_NONOVERRIDABLE_HSTS;
}
load_time_data->SetString("finalParagraph",
l10n_util::GetStringFUTF16(help_string, url));
}
void SSLErrorUI::HandleCommand(SecurityInterstitialCommands command) {
switch (command) {
case CMD_DONT_PROCEED:
controller_->metrics_helper()->RecordUserDecision(
MetricsHelper::DONT_PROCEED);
user_made_decision_ = true;
controller_->GoBack();
break;
case CMD_PROCEED:
if (hard_override_enabled_) {
controller_->metrics_helper()->RecordUserDecision(
MetricsHelper::PROCEED);
controller_->Proceed();
user_made_decision_ = true;
}
break;
case CMD_DO_REPORT:
controller_->SetReportingPreference(true);
break;
case CMD_DONT_REPORT:
controller_->SetReportingPreference(false);
break;
case CMD_SHOW_MORE_SECTION:
controller_->metrics_helper()->RecordUserInteraction(
security_interstitials::MetricsHelper::SHOW_ADVANCED);
break;
case CMD_OPEN_HELP_CENTER:
controller_->metrics_helper()->RecordUserInteraction(
security_interstitials::MetricsHelper::SHOW_LEARN_MORE);
controller_->OpenUrlInCurrentTab(GURL(kHelpURL));
break;
case CMD_RELOAD:
controller_->metrics_helper()->RecordUserInteraction(
security_interstitials::MetricsHelper::RELOAD);
controller_->Reload();
break;
case CMD_OPEN_REPORTING_PRIVACY:
controller_->OpenExtendedReportingPrivacyPolicy();
break;
case CMD_OPEN_WHITEPAPER:
controller_->OpenExtendedReportingWhitepaper();
break;
case CMD_OPEN_DATE_SETTINGS:
case CMD_OPEN_DIAGNOSTIC:
case CMD_OPEN_LOGIN:
case CMD_REPORT_PHISHING_ERROR:
// Not supported by the SSL error page.
NOTREACHED() << "Unsupported command: " << command;
case CMD_ERROR:
case CMD_TEXT_FOUND:
case CMD_TEXT_NOT_FOUND:
// Commands are for testing.
break;
}
}
} // security_interstitials
| [
"enrico.weigelt@gr13.net"
] | enrico.weigelt@gr13.net |
48ffa973b301c5db19996611da5709082d75230f | cbb120e86051a2ffa2368f4fa147d9172a3d7a05 | /src/miner.cpp | 85aac1480ec5445f46b56ee6e1d9511b830435f7 | [
"MIT"
] | permissive | forexcoins/Forexcoin | f08249d699b3a0e3a5ab00e820bd1c73f7bea0ce | bce90c0f4cf392b54400a58c93bde29b2741e97d | refs/heads/master | 2021-01-10T11:46:12.311526 | 2016-02-26T09:56:59 | 2016-02-26T09:56:59 | 52,595,250 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 19,937 | cpp | // Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2012 The Bitcoin developers
// Copyright (c) 2013 The NovaCoin developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "txdb.h"
#include "miner.h"
#include "kernel.h"
using namespace std;
//////////////////////////////////////////////////////////////////////////////
//
// BitcoinMiner
//
extern unsigned int nMinerSleep;
int static FormatHashBlocks(void* pbuffer, unsigned int len)
{
unsigned char* pdata = (unsigned char*)pbuffer;
unsigned int blocks = 1 + ((len + 8) / 64);
unsigned char* pend = pdata + 64 * blocks;
memset(pdata + len, 0, 64 * blocks - len);
pdata[len] = 0x80;
unsigned int bits = len * 8;
pend[-1] = (bits >> 0) & 0xff;
pend[-2] = (bits >> 8) & 0xff;
pend[-3] = (bits >> 16) & 0xff;
pend[-4] = (bits >> 24) & 0xff;
return blocks;
}
static const unsigned int pSHA256InitState[8] =
{0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19};
void SHA256Transform(void* pstate, void* pinput, const void* pinit)
{
SHA256_CTX ctx;
unsigned char data[64];
SHA256_Init(&ctx);
for (int i = 0; i < 16; i++)
((uint32_t*)data)[i] = ByteReverse(((uint32_t*)pinput)[i]);
for (int i = 0; i < 8; i++)
ctx.h[i] = ((uint32_t*)pinit)[i];
SHA256_Update(&ctx, data, sizeof(data));
for (int i = 0; i < 8; i++)
((uint32_t*)pstate)[i] = ctx.h[i];
}
// Some explaining would be appreciated
class COrphan
{
public:
CTransaction* ptx;
set<uint256> setDependsOn;
double dPriority;
double dFeePerKb;
COrphan(CTransaction* ptxIn)
{
ptx = ptxIn;
dPriority = dFeePerKb = 0;
}
void print() const
{
printf("COrphan(hash=%s, dPriority=%.1f, dFeePerKb=%.1f)\n",
ptx->GetHash().ToString().substr(0,10).c_str(), dPriority, dFeePerKb);
BOOST_FOREACH(uint256 hash, setDependsOn)
printf(" setDependsOn %s\n", hash.ToString().substr(0,10).c_str());
}
};
uint64_t nLastBlockTx = 0;
uint64_t nLastBlockSize = 0;
int64_t nLastCoinStakeSearchInterval = 0;
// We want to sort transactions by priority and fee, so:
typedef boost::tuple<double, double, CTransaction*> TxPriority;
class TxPriorityCompare
{
bool byFee;
public:
TxPriorityCompare(bool _byFee) : byFee(_byFee) { }
bool operator()(const TxPriority& a, const TxPriority& b)
{
if (byFee)
{
if (a.get<1>() == b.get<1>())
return a.get<0>() < b.get<0>();
return a.get<1>() < b.get<1>();
}
else
{
if (a.get<0>() == b.get<0>())
return a.get<1>() < b.get<1>();
return a.get<0>() < b.get<0>();
}
}
};
// CreateNewBlock: create new block (without proof-of-work/proof-of-stake)
CBlock* CreateNewBlock(CWallet* pwallet, bool fProofOfStake, int64_t* pFees)
{
// Create new block
auto_ptr<CBlock> pblock(new CBlock());
if (!pblock.get())
return NULL;
CBlockIndex* pindexPrev = pindexBest;
// Create coinbase tx
CTransaction txNew;
txNew.vin.resize(1);
txNew.vin[0].prevout.SetNull();
txNew.vout.resize(1);
if (!fProofOfStake)
{
CReserveKey reservekey(pwallet);
CPubKey pubkey;
if (!reservekey.GetReservedKey(pubkey))
return NULL;
txNew.vout[0].scriptPubKey.SetDestination(pubkey.GetID());
}
else
{
// Height first in coinbase required for block.version=2
txNew.vin[0].scriptSig = (CScript() << pindexPrev->nHeight+1) + COINBASE_FLAGS;
assert(txNew.vin[0].scriptSig.size() <= 100);
txNew.vout[0].SetEmpty();
}
// Add our coinbase tx as first transaction
pblock->vtx.push_back(txNew);
// Largest block you're willing to create:
unsigned int nBlockMaxSize = GetArg("-blockmaxsize", MAX_BLOCK_SIZE_GEN/2);
// Limit to betweeen 1K and MAX_BLOCK_SIZE-1K for sanity:
nBlockMaxSize = std::max((unsigned int)1000, std::min((unsigned int)(MAX_BLOCK_SIZE-1000), nBlockMaxSize));
// How much of the block should be dedicated to high-priority transactions,
// included regardless of the fees they pay
unsigned int nBlockPrioritySize = GetArg("-blockprioritysize", 27000);
nBlockPrioritySize = std::min(nBlockMaxSize, nBlockPrioritySize);
// Minimum block size you want to create; block will be filled with free transactions
// until there are no more or the block reaches this size:
unsigned int nBlockMinSize = GetArg("-blockminsize", 0);
nBlockMinSize = std::min(nBlockMaxSize, nBlockMinSize);
// Fee-per-kilobyte amount considered the same as "free"
// Be careful setting this: if you set it to zero then
// a transaction spammer can cheaply fill blocks using
// 1-satoshi-fee transactions. It should be set above the real
// cost to you of processing a transaction.
int64_t nMinTxFee = MIN_TX_FEE;
if (mapArgs.count("-mintxfee"))
ParseMoney(mapArgs["-mintxfee"], nMinTxFee);
pblock->nBits = GetNextTargetRequired(pindexPrev, fProofOfStake);
// Collect memory pool transactions into the block
int64_t nFees = 0;
{
LOCK2(cs_main, mempool.cs);
CTxDB txdb("r");
// Priority order to process transactions
list<COrphan> vOrphan; // list memory doesn't move
map<uint256, vector<COrphan*> > mapDependers;
// This vector will be sorted into a priority queue:
vector<TxPriority> vecPriority;
vecPriority.reserve(mempool.mapTx.size());
for (map<uint256, CTransaction>::iterator mi = mempool.mapTx.begin(); mi != mempool.mapTx.end(); ++mi)
{
CTransaction& tx = (*mi).second;
if (tx.IsCoinBase() || tx.IsCoinStake() || !tx.IsFinal())
continue;
COrphan* porphan = NULL;
double dPriority = 0;
int64_t nTotalIn = 0;
bool fMissingInputs = false;
BOOST_FOREACH(const CTxIn& txin, tx.vin)
{
// Read prev transaction
CTransaction txPrev;
CTxIndex txindex;
if (!txPrev.ReadFromDisk(txdb, txin.prevout, txindex))
{
// This should never happen; all transactions in the memory
// pool should connect to either transactions in the chain
// or other transactions in the memory pool.
if (!mempool.mapTx.count(txin.prevout.hash))
{
printf("ERROR: mempool transaction missing input\n");
if (fDebug) assert("mempool transaction missing input" == 0);
fMissingInputs = true;
if (porphan)
vOrphan.pop_back();
break;
}
// Has to wait for dependencies
if (!porphan)
{
// Use list for automatic deletion
vOrphan.push_back(COrphan(&tx));
porphan = &vOrphan.back();
}
mapDependers[txin.prevout.hash].push_back(porphan);
porphan->setDependsOn.insert(txin.prevout.hash);
nTotalIn += mempool.mapTx[txin.prevout.hash].vout[txin.prevout.n].nValue;
continue;
}
int64_t nValueIn = txPrev.vout[txin.prevout.n].nValue;
nTotalIn += nValueIn;
int nConf = txindex.GetDepthInMainChain();
dPriority += (double)nValueIn * nConf;
}
if (fMissingInputs) continue;
// Priority is sum(valuein * age) / txsize
unsigned int nTxSize = ::GetSerializeSize(tx, SER_NETWORK, PROTOCOL_VERSION);
dPriority /= nTxSize;
// This is a more accurate fee-per-kilobyte than is used by the client code, because the
// client code rounds up the size to the nearest 1K. That's good, because it gives an
// incentive to create smaller transactions.
double dFeePerKb = double(nTotalIn-tx.GetValueOut()) / (double(nTxSize)/1000.0);
if (porphan)
{
porphan->dPriority = dPriority;
porphan->dFeePerKb = dFeePerKb;
}
else
vecPriority.push_back(TxPriority(dPriority, dFeePerKb, &(*mi).second));
}
// Collect transactions into block
map<uint256, CTxIndex> mapTestPool;
uint64_t nBlockSize = 1000;
uint64_t nBlockTx = 0;
int nBlockSigOps = 100;
bool fSortedByFee = (nBlockPrioritySize <= 0);
TxPriorityCompare comparer(fSortedByFee);
std::make_heap(vecPriority.begin(), vecPriority.end(), comparer);
while (!vecPriority.empty())
{
// Take highest priority transaction off the priority queue:
double dPriority = vecPriority.front().get<0>();
double dFeePerKb = vecPriority.front().get<1>();
CTransaction& tx = *(vecPriority.front().get<2>());
std::pop_heap(vecPriority.begin(), vecPriority.end(), comparer);
vecPriority.pop_back();
// Size limits
unsigned int nTxSize = ::GetSerializeSize(tx, SER_NETWORK, PROTOCOL_VERSION);
if (nBlockSize + nTxSize >= nBlockMaxSize)
continue;
// Legacy limits on sigOps:
unsigned int nTxSigOps = tx.GetLegacySigOpCount();
if (nBlockSigOps + nTxSigOps >= MAX_BLOCK_SIGOPS)
continue;
// Timestamp limit
if (tx.nTime > GetAdjustedTime() || (fProofOfStake && tx.nTime > pblock->vtx[0].nTime))
continue;
// Transaction fee
int64_t nMinFee = tx.GetMinFee(nBlockSize, GMF_BLOCK);
// Skip free transactions if we're past the minimum block size:
if (fSortedByFee && (dFeePerKb < nMinTxFee) && (nBlockSize + nTxSize >= nBlockMinSize))
continue;
// Prioritize by fee once past the priority size or we run out of high-priority
// transactions:
if (!fSortedByFee &&
((nBlockSize + nTxSize >= nBlockPrioritySize) || (dPriority < COIN * 144 / 250)))
{
fSortedByFee = true;
comparer = TxPriorityCompare(fSortedByFee);
std::make_heap(vecPriority.begin(), vecPriority.end(), comparer);
}
// Connecting shouldn't fail due to dependency on other memory pool transactions
// because we're already processing them in order of dependency
map<uint256, CTxIndex> mapTestPoolTmp(mapTestPool);
MapPrevTx mapInputs;
bool fInvalid;
if (!tx.FetchInputs(txdb, mapTestPoolTmp, false, true, mapInputs, fInvalid))
continue;
int64_t nTxFees = tx.GetValueIn(mapInputs)-tx.GetValueOut();
if (nTxFees < nMinFee)
continue;
nTxSigOps += tx.GetP2SHSigOpCount(mapInputs);
if (nBlockSigOps + nTxSigOps >= MAX_BLOCK_SIGOPS)
continue;
if (!tx.ConnectInputs(txdb, mapInputs, mapTestPoolTmp, CDiskTxPos(1,1,1), pindexPrev, false, true))
continue;
mapTestPoolTmp[tx.GetHash()] = CTxIndex(CDiskTxPos(1,1,1), tx.vout.size());
swap(mapTestPool, mapTestPoolTmp);
// Added
pblock->vtx.push_back(tx);
nBlockSize += nTxSize;
++nBlockTx;
nBlockSigOps += nTxSigOps;
nFees += nTxFees;
if (fDebug && GetBoolArg("-printpriority"))
{
printf("priority %.1f feeperkb %.1f txid %s\n",
dPriority, dFeePerKb, tx.GetHash().ToString().c_str());
}
// Add transactions that depend on this one to the priority queue
uint256 hash = tx.GetHash();
if (mapDependers.count(hash))
{
BOOST_FOREACH(COrphan* porphan, mapDependers[hash])
{
if (!porphan->setDependsOn.empty())
{
porphan->setDependsOn.erase(hash);
if (porphan->setDependsOn.empty())
{
vecPriority.push_back(TxPriority(porphan->dPriority, porphan->dFeePerKb, porphan->ptx));
std::push_heap(vecPriority.begin(), vecPriority.end(), comparer);
}
}
}
}
}
nLastBlockTx = nBlockTx;
nLastBlockSize = nBlockSize;
if (fDebug && GetBoolArg("-printpriority"))
printf("CreateNewBlock(): total size %"PRIu64"\n", nBlockSize);
if (!fProofOfStake)
pblock->vtx[0].vout[0].nValue = GetProofOfWorkReward(nFees);
if (pFees)
*pFees = nFees;
// Fill in header
pblock->hashPrevBlock = pindexPrev->GetBlockHash();
pblock->nTime = max(pindexPrev->GetPastTimeLimit()+1, pblock->GetMaxTransactionTime());
pblock->nTime = max(pblock->GetBlockTime(), PastDrift(pindexPrev->GetBlockTime()));
if (!fProofOfStake)
pblock->UpdateTime(pindexPrev);
pblock->nNonce = 0;
}
return pblock.release();
}
void IncrementExtraNonce(CBlock* pblock, CBlockIndex* pindexPrev, unsigned int& nExtraNonce)
{
// Update nExtraNonce
static uint256 hashPrevBlock;
if (hashPrevBlock != pblock->hashPrevBlock)
{
nExtraNonce = 0;
hashPrevBlock = pblock->hashPrevBlock;
}
++nExtraNonce;
unsigned int nHeight = pindexPrev->nHeight+1; // Height first in coinbase required for block.version=2
pblock->vtx[0].vin[0].scriptSig = (CScript() << nHeight << CBigNum(nExtraNonce)) + COINBASE_FLAGS;
assert(pblock->vtx[0].vin[0].scriptSig.size() <= 100);
pblock->hashMerkleRoot = pblock->BuildMerkleTree();
}
void FormatHashBuffers(CBlock* pblock, char* pmidstate, char* pdata, char* phash1)
{
//
// Pre-build hash buffers
//
struct
{
struct unnamed2
{
int nVersion;
uint256 hashPrevBlock;
uint256 hashMerkleRoot;
unsigned int nTime;
unsigned int nBits;
unsigned int nNonce;
}
block;
unsigned char pchPadding0[64];
uint256 hash1;
unsigned char pchPadding1[64];
}
tmp;
memset(&tmp, 0, sizeof(tmp));
tmp.block.nVersion = pblock->nVersion;
tmp.block.hashPrevBlock = pblock->hashPrevBlock;
tmp.block.hashMerkleRoot = pblock->hashMerkleRoot;
tmp.block.nTime = pblock->nTime;
tmp.block.nBits = pblock->nBits;
tmp.block.nNonce = pblock->nNonce;
FormatHashBlocks(&tmp.block, sizeof(tmp.block));
FormatHashBlocks(&tmp.hash1, sizeof(tmp.hash1));
// Byte swap all the input buffer
for (unsigned int i = 0; i < sizeof(tmp)/4; i++)
((unsigned int*)&tmp)[i] = ByteReverse(((unsigned int*)&tmp)[i]);
// Precalc the first half of the first hash, which stays constant
SHA256Transform(pmidstate, &tmp.block, pSHA256InitState);
memcpy(pdata, &tmp.block, 128);
memcpy(phash1, &tmp.hash1, 64);
}
bool CheckWork(CBlock* pblock, CWallet& wallet, CReserveKey& reservekey)
{
uint256 hashBlock = pblock->GetHash();
uint256 hashTarget = CBigNum().SetCompact(pblock->nBits).getuint256();
if(!pblock->IsProofOfWork())
return error("CheckWork() : %s is not a proof-of-work block", hashBlock.GetHex().c_str());
if (hashBlock > hashTarget)
return error("CheckWork() : proof-of-work not meeting target");
//// debug print
printf("CheckWork() : new proof-of-work block found \n hash: %s \ntarget: %s\n", hashBlock.GetHex().c_str(), hashTarget.GetHex().c_str());
pblock->print();
printf("generated %s\n", FormatMoney(pblock->vtx[0].vout[0].nValue).c_str());
// Found a solution
{
LOCK(cs_main);
if (pblock->hashPrevBlock != hashBestChain)
return error("CheckWork() : generated block is stale");
// Remove key from key pool
reservekey.KeepKey();
// Track how many getdata requests this block gets
{
LOCK(wallet.cs_wallet);
wallet.mapRequestCount[hashBlock] = 0;
}
// Process this block the same as if we had received it from another node
if (!ProcessBlock(NULL, pblock))
return error("CheckWork() : ProcessBlock, block not accepted");
}
return true;
}
bool CheckStake(CBlock* pblock, CWallet& wallet)
{
uint256 proofHash = 0, hashTarget = 0;
uint256 hashBlock = pblock->GetHash();
if(!pblock->IsProofOfStake())
return error("CheckStake() : %s is not a proof-of-stake block", hashBlock.GetHex().c_str());
// verify hash target and signature of coinstake tx
if (!CheckProofOfStake(pblock->vtx[1], pblock->nBits, proofHash, hashTarget))
return error("CheckStake() : proof-of-stake checking failed");
//// debug print
printf("CheckStake() : new proof-of-stake block found \n hash: %s \nproofhash: %s \ntarget: %s\n", hashBlock.GetHex().c_str(), proofHash.GetHex().c_str(), hashTarget.GetHex().c_str());
pblock->print();
printf("out %s\n", FormatMoney(pblock->vtx[1].GetValueOut()).c_str());
// Found a solution
{
LOCK(cs_main);
if (pblock->hashPrevBlock != hashBestChain)
return error("CheckStake() : generated block is stale");
// Track how many getdata requests this block gets
{
LOCK(wallet.cs_wallet);
wallet.mapRequestCount[hashBlock] = 0;
}
// Process this block the same as if we had received it from another node
if (!ProcessBlock(NULL, pblock))
return error("CheckStake() : ProcessBlock, block not accepted");
}
return true;
}
void StakeMiner(CWallet *pwallet)
{
SetThreadPriority(THREAD_PRIORITY_LOWEST);
// Make this thread recognisable as the mining thread
RenameThread("Forexcoin-miner");
bool fTryToSync = true;
while (true)
{
if (fShutdown)
return;
while (pwallet->IsLocked())
{
nLastCoinStakeSearchInterval = 0;
MilliSleep(1000);
if (fShutdown)
return;
}
while (vNodes.empty() || IsInitialBlockDownload())
{
nLastCoinStakeSearchInterval = 0;
fTryToSync = true;
MilliSleep(1000);
if (fShutdown)
return;
}
if (fTryToSync)
{
fTryToSync = false;
if (vNodes.size() < 3 || nBestHeight < GetNumBlocksOfPeers())
{
MilliSleep(60000);
continue;
}
}
//
// Create new block
//
int64_t nFees;
auto_ptr<CBlock> pblock(CreateNewBlock(pwallet, true, &nFees));
if (!pblock.get())
return;
// Trying to sign a block
if (pblock->SignBlock(*pwallet, nFees))
{
SetThreadPriority(THREAD_PRIORITY_NORMAL);
CheckStake(pblock.get(), *pwallet);
SetThreadPriority(THREAD_PRIORITY_LOWEST);
MilliSleep(500);
}
else
MilliSleep(nMinerSleep);
}
}
| [
"Adika.michael@hotmail.com"
] | Adika.michael@hotmail.com |
0e88745dfe16e809ced21778879e0008d20fa71a | 536656cd89e4fa3a92b5dcab28657d60d1d244bd | /chrome/browser/ui/views/device_chooser_content_view.cc | dfd5cc57b1b4e88f8bc35db266db3e6db5c29a7e | [
"BSD-3-Clause"
] | permissive | ECS-251-W2020/chromium | 79caebf50443f297557d9510620bf8d44a68399a | ac814e85cb870a6b569e184c7a60a70ff3cb19f9 | refs/heads/master | 2022-08-19T17:42:46.887573 | 2020-03-18T06:08:44 | 2020-03-18T06:08:44 | 248,141,336 | 7 | 8 | BSD-3-Clause | 2022-07-06T20:32:48 | 2020-03-18T04:52:18 | null | UTF-8 | C++ | false | false | 14,421 | cc | // Copyright 2016 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/ui/views/device_chooser_content_view.h"
#include "base/numerics/safe_conversions.h"
#include "base/stl_util.h"
#include "chrome/browser/ui/views/chrome_layout_provider.h"
#include "chrome/grit/generated_resources.h"
#include "components/strings/grit/components_strings.h"
#include "components/vector_icons/vector_icons.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/base/resource/resource_bundle.h"
#include "ui/gfx/color_palette.h"
#include "ui/gfx/geometry/point.h"
#include "ui/gfx/geometry/rect.h"
#include "ui/gfx/image/image_skia.h"
#include "ui/gfx/paint_vector_icon.h"
#include "ui/resources/grit/ui_resources.h"
#include "ui/views/accessibility/view_accessibility.h"
#include "ui/views/controls/button/image_button.h"
#include "ui/views/controls/button/image_button_factory.h"
#include "ui/views/controls/button/label_button.h"
#include "ui/views/controls/button/md_text_button.h"
#include "ui/views/controls/scroll_view.h"
#include "ui/views/controls/styled_label.h"
#include "ui/views/controls/table/table_view.h"
#include "ui/views/controls/throbber.h"
#include "ui/views/layout/box_layout.h"
#include "ui/views/layout/fill_layout.h"
#include "ui/views/widget/widget.h"
namespace {
constexpr int kHelpButtonTag = 1;
constexpr int kReScanButtonTag = 2;
} // namespace
class BluetoothStatusContainer : public views::View {
public:
explicit BluetoothStatusContainer(views::ButtonListener* listener);
void ShowScanningLabelAndThrobber();
void ShowReScanButton(bool enabled);
private:
friend class DeviceChooserContentView;
views::LabelButton* re_scan_button_;
views::Throbber* throbber_;
views::Label* scanning_label_;
DISALLOW_COPY_AND_ASSIGN(BluetoothStatusContainer);
};
BluetoothStatusContainer::BluetoothStatusContainer(
views::ButtonListener* listener) {
SetLayoutManager(std::make_unique<views::FillLayout>());
auto* rescan_container = AddChildView(std::make_unique<views::View>());
rescan_container
->SetLayoutManager(std::make_unique<views::BoxLayout>(
views::BoxLayout::Orientation::kHorizontal))
->set_cross_axis_alignment(views::BoxLayout::CrossAxisAlignment::kCenter);
auto re_scan_button = views::MdTextButton::CreateSecondaryUiButton(
listener,
l10n_util::GetStringUTF16(IDS_BLUETOOTH_DEVICE_CHOOSER_RE_SCAN));
re_scan_button->SetTooltipText(
l10n_util::GetStringUTF16(IDS_BLUETOOTH_DEVICE_CHOOSER_RE_SCAN_TOOLTIP));
re_scan_button->SetFocusForPlatform();
re_scan_button->set_tag(kReScanButtonTag);
re_scan_button_ = rescan_container->AddChildView(std::move(re_scan_button));
auto* scan_container = AddChildView(std::make_unique<views::View>());
auto* scan_layout =
scan_container->SetLayoutManager(std::make_unique<views::BoxLayout>(
views::BoxLayout::Orientation::kHorizontal));
scan_layout->set_cross_axis_alignment(
views::BoxLayout::CrossAxisAlignment::kCenter);
scan_layout->set_between_child_spacing(
ChromeLayoutProvider::Get()->GetDistanceMetric(
views::DISTANCE_RELATED_CONTROL_HORIZONTAL));
throbber_ = scan_container->AddChildView(std::make_unique<views::Throbber>());
auto scanning_label = std::make_unique<views::Label>(
l10n_util::GetStringUTF16(IDS_BLUETOOTH_DEVICE_CHOOSER_SCANNING_LABEL),
views::style::CONTEXT_LABEL, views::style::STYLE_DISABLED);
scanning_label->SetTooltipText(l10n_util::GetStringUTF16(
IDS_BLUETOOTH_DEVICE_CHOOSER_SCANNING_LABEL_TOOLTIP));
scanning_label_ = scan_container->AddChildView(std::move(scanning_label));
}
void BluetoothStatusContainer::ShowScanningLabelAndThrobber() {
re_scan_button_->SetVisible(false);
throbber_->SetVisible(true);
scanning_label_->SetVisible(true);
throbber_->Start();
}
void BluetoothStatusContainer::ShowReScanButton(bool enabled) {
re_scan_button_->SetVisible(true);
re_scan_button_->SetEnabled(enabled);
throbber_->Stop();
throbber_->SetVisible(false);
scanning_label_->SetVisible(false);
}
DeviceChooserContentView::DeviceChooserContentView(
views::TableViewObserver* table_view_observer,
std::unique_ptr<ChooserController> chooser_controller)
: chooser_controller_(std::move(chooser_controller)) {
chooser_controller_->set_view(this);
SetPreferredSize({402, 320});
SetLayoutManager(std::make_unique<views::FillLayout>());
std::vector<ui::TableColumn> table_columns = {ui::TableColumn()};
auto table_view = std::make_unique<views::TableView>(
this, table_columns,
chooser_controller_->ShouldShowIconBeforeText() ? views::ICON_AND_TEXT
: views::TEXT_ONLY,
!chooser_controller_->AllowMultipleSelection() /* single_selection */);
table_view_ = table_view.get();
table_view->SetSelectOnRemove(false);
table_view->set_observer(table_view_observer);
table_view->GetViewAccessibility().OverrideName(l10n_util::GetStringUTF16(
IDS_DEVICE_CHOOSER_ACCNAME_COMPATIBLE_DEVICES_LIST));
table_parent_ = AddChildView(
views::TableView::CreateScrollViewWithTable(std::move(table_view)));
const auto add_centering_view = [this](auto view) {
auto* container = AddChildView(std::make_unique<views::View>());
auto* layout =
container->SetLayoutManager(std::make_unique<views::BoxLayout>(
views::BoxLayout::Orientation::kHorizontal));
layout->set_main_axis_alignment(
views::BoxLayout::MainAxisAlignment::kCenter);
layout->set_cross_axis_alignment(
views::BoxLayout::CrossAxisAlignment::kCenter);
layout->set_inside_border_insets(gfx::Insets(0, 6));
container->AddChildView(std::move(view));
return container;
};
auto no_options_help =
std::make_unique<views::Label>(chooser_controller_->GetNoOptionsText());
no_options_help->SetMultiLine(true);
no_options_view_ = add_centering_view(std::move(no_options_help));
base::string16 link_text = l10n_util::GetStringUTF16(
IDS_BLUETOOTH_DEVICE_CHOOSER_TURN_ON_BLUETOOTH_LINK_TEXT);
size_t offset = 0;
base::string16 text = l10n_util::GetStringFUTF16(
IDS_BLUETOOTH_DEVICE_CHOOSER_TURN_ADAPTER_OFF, link_text, &offset);
auto adapter_off_help = std::make_unique<views::StyledLabel>(text, this);
adapter_off_help->AddStyleRange(
gfx::Range(0, link_text.size()),
views::StyledLabel::RangeStyleInfo::CreateForLink());
adapter_off_view_ = add_centering_view(std::move(adapter_off_help));
UpdateTableView();
}
DeviceChooserContentView::~DeviceChooserContentView() {
chooser_controller_->set_view(nullptr);
table_view_->set_observer(nullptr);
table_view_->SetModel(nullptr);
}
gfx::Size DeviceChooserContentView::GetMinimumSize() const {
// Let the dialog shrink when its parent is smaller than the preferred size.
return gfx::Size();
}
int DeviceChooserContentView::RowCount() {
return base::checked_cast<int>(chooser_controller_->NumOptions());
}
base::string16 DeviceChooserContentView::GetText(int row, int column_id) {
DCHECK_GE(row, 0);
DCHECK_LT(row, RowCount());
base::string16 text = chooser_controller_->GetOption(size_t{row});
return chooser_controller_->IsPaired(row)
? l10n_util::GetStringFUTF16(
IDS_DEVICE_CHOOSER_DEVICE_NAME_AND_PAIRED_STATUS_TEXT, text)
: text;
}
void DeviceChooserContentView::SetObserver(ui::TableModelObserver* observer) {}
gfx::ImageSkia DeviceChooserContentView::GetIcon(int row) {
DCHECK(chooser_controller_->ShouldShowIconBeforeText());
DCHECK_GE(row, 0);
DCHECK_LT(row, RowCount());
if (chooser_controller_->IsConnected(row)) {
return gfx::CreateVectorIcon(vector_icons::kBluetoothConnectedIcon,
TableModel::kIconSize, gfx::kChromeIconGrey);
}
int level = chooser_controller_->GetSignalStrengthLevel(row);
if (level == -1)
return gfx::ImageSkia();
constexpr int kSignalStrengthLevelImageIds[5] = {
IDR_SIGNAL_0_BAR, IDR_SIGNAL_1_BAR, IDR_SIGNAL_2_BAR, IDR_SIGNAL_3_BAR,
IDR_SIGNAL_4_BAR};
DCHECK_GE(level, 0);
DCHECK_LT(size_t{level}, base::size(kSignalStrengthLevelImageIds));
return *ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
kSignalStrengthLevelImageIds[level]);
}
void DeviceChooserContentView::OnOptionsInitialized() {
is_initialized_ = true;
table_view_->OnModelChanged();
UpdateTableView();
}
void DeviceChooserContentView::OnOptionAdded(size_t index) {
is_initialized_ = true;
table_view_->OnItemsAdded(base::checked_cast<int>(index), 1);
UpdateTableView();
}
void DeviceChooserContentView::OnOptionRemoved(size_t index) {
table_view_->OnItemsRemoved(base::checked_cast<int>(index), 1);
UpdateTableView();
}
void DeviceChooserContentView::OnOptionUpdated(size_t index) {
table_view_->OnItemsChanged(base::checked_cast<int>(index), 1);
UpdateTableView();
}
void DeviceChooserContentView::OnAdapterEnabledChanged(bool enabled) {
// No row is selected since the adapter status has changed.
// This will also disable the OK button if it was enabled because
// of a previously selected row.
table_view_->Select(-1);
adapter_enabled_ = enabled;
UpdateTableView();
bluetooth_status_container_->ShowReScanButton(enabled);
if (GetWidget() && GetWidget()->GetRootView())
GetWidget()->GetRootView()->Layout();
}
void DeviceChooserContentView::OnRefreshStateChanged(bool refreshing) {
if (refreshing) {
// No row is selected since the chooser is refreshing. This will also
// disable the OK button if it was enabled because of a previously
// selected row.
table_view_->Select(-1);
UpdateTableView();
}
if (refreshing)
bluetooth_status_container_->ShowScanningLabelAndThrobber();
else
bluetooth_status_container_->ShowReScanButton(true /* enabled */);
if (GetWidget() && GetWidget()->GetRootView())
GetWidget()->GetRootView()->Layout();
}
void DeviceChooserContentView::StyledLabelLinkClicked(views::StyledLabel* label,
const gfx::Range& range,
int event_flags) {
chooser_controller_->OpenAdapterOffHelpUrl();
}
void DeviceChooserContentView::ButtonPressed(views::Button* sender,
const ui::Event& event) {
if (sender->tag() == kHelpButtonTag) {
chooser_controller_->OpenHelpCenterUrl();
} else {
DCHECK_EQ(kReScanButtonTag, sender->tag());
// Refreshing will cause the table view to yield focus, which
// will land on the help button. Instead, briefly let the
// rescan button take focus. When it hides itself, focus will
// advance to the "Cancel" button as desired.
sender->RequestFocus();
chooser_controller_->RefreshOptions();
}
}
base::string16 DeviceChooserContentView::GetWindowTitle() const {
return chooser_controller_->GetTitle();
}
std::unique_ptr<views::View> DeviceChooserContentView::CreateExtraView() {
const auto make_help_button = [this]() {
auto help_button = views::CreateVectorImageButton(this);
views::SetImageFromVectorIcon(help_button.get(),
vector_icons::kHelpOutlineIcon);
help_button->SetFocusForPlatform();
help_button->SetTooltipText(l10n_util::GetStringUTF16(IDS_LEARN_MORE));
help_button->set_tag(kHelpButtonTag);
return help_button;
};
const auto make_bluetooth_status_container = [this]() {
auto bluetooth_status_container =
std::make_unique<BluetoothStatusContainer>(this);
bluetooth_status_container_ = bluetooth_status_container.get();
return bluetooth_status_container;
};
const bool add_bluetooth = chooser_controller_->ShouldShowReScanButton();
if (!chooser_controller_->ShouldShowHelpButton())
return add_bluetooth ? make_bluetooth_status_container() : nullptr;
if (!add_bluetooth)
return make_help_button();
auto container = std::make_unique<views::View>();
auto layout = std::make_unique<views::BoxLayout>(
views::BoxLayout::Orientation::kHorizontal, gfx::Insets(),
ChromeLayoutProvider::Get()->GetDistanceMetric(
views::DISTANCE_RELATED_CONTROL_HORIZONTAL));
container->SetLayoutManager(std::move(layout))
->set_cross_axis_alignment(views::BoxLayout::CrossAxisAlignment::kCenter);
container->AddChildView(make_help_button());
container->AddChildView(make_bluetooth_status_container());
return container;
}
bool DeviceChooserContentView::IsDialogButtonEnabled(
ui::DialogButton button) const {
return chooser_controller_->BothButtonsAlwaysEnabled() ||
button != ui::DIALOG_BUTTON_OK ||
!table_view_->selection_model().empty();
}
void DeviceChooserContentView::Accept() {
std::vector<size_t> indices(
table_view_->selection_model().selected_indices().begin(),
table_view_->selection_model().selected_indices().end());
chooser_controller_->Select(indices);
}
void DeviceChooserContentView::Cancel() {
chooser_controller_->Cancel();
}
void DeviceChooserContentView::Close() {
chooser_controller_->Close();
}
void DeviceChooserContentView::UpdateTableView() {
bool has_options = adapter_enabled_ && RowCount() > 0;
if (!is_initialized_ && GetWidget() &&
GetWidget()->GetFocusManager()->GetFocusedView()) {
is_initialized_ = true; // Can show no_options_view_ after initial focus.
}
table_parent_->SetVisible(has_options);
table_view_->SetEnabled(has_options &&
!chooser_controller_->TableViewAlwaysDisabled());
// Do not set to visible until initialization is complete, in order to prevent
// message from briefly flashing and being read by screen reader.
no_options_view_->SetVisible(!has_options && adapter_enabled_ &&
is_initialized_);
adapter_off_view_->SetVisible(!adapter_enabled_);
}
views::LabelButton* DeviceChooserContentView::ReScanButtonForTesting() {
return bluetooth_status_container_->re_scan_button_;
}
views::Throbber* DeviceChooserContentView::ThrobberForTesting() {
return bluetooth_status_container_->throbber_;
}
views::Label* DeviceChooserContentView::ScanningLabelForTesting() {
return bluetooth_status_container_->scanning_label_;
}
| [
"pcding@ucdavis.edu"
] | pcding@ucdavis.edu |
0363f9df19b5f586af5adedd1252fb730a4786d2 | 8fa7f86ed5db77a122469c4e6c16adf700002cd6 | /separ.h | cf10a7b785f24907dead3e625bd144d1c2da416b | [] | no_license | longway34/Separator | 71dd4fea38e1a38f6a4bdca1d5a946fd0a6a96a4 | 73614df4f5116d6d7f3bd99029c6ef2ff14632dc | refs/heads/master | 2021-08-10T12:05:32.768563 | 2017-11-12T14:52:26 | 2017-11-12T14:52:26 | 110,437,384 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,810 | h | /***************************************************************************
* Copyright (C) 2006 by and *
* and@andrey *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifndef SEPAR_H
#define SEPAR_H
#include <iostream>
#include <cstdlib>
#include <pthread.h>
#include <signal.h>
#include <sys/time.h>
#include <math.h>
#include <sys/socket.h>
#include <unistd.h>
#include "sdevice.h"
/**
@author and
*/
const bool TESTPL = false;
const int SIZE_SPK = 512;
const int MAX_OBL = 6;
const int MAX_CH = 4;
const int MIN_TIME= 1;
const int MAX_TIME= 600;
const int S_SPK =256;
const int BF_IM =10;
const int MN_GZ =4;
const int MAX_GR =5;
const int MAX_GIST=200;
const int KC_TIME=5;
const int MAX_KC=250*KC_TIME;
const double CON_USTPUW = 18307;
const int TIMEPL = 250*120;
const int U_SIZE = 250;
const int DELAY_RGU = 30;
const int ROW = 2;
struct sobl{
//unsigned short
double ls;
//unsigned short
double rs;
};
struct sep_ust{
sobl obl[MAX_CH][MAX_OBL];
double gmz[MAX_CH];
double sh1[6];
double sh2[6];
double sh3[6];
double kh1[2];
double kh2[2];
double kh3[2];
double prg[MAX_CH][6];
double prg2[MAX_CH][6];
double tiz[MAX_GR];
double fh12;
double fotb;
double fotbR2;
double maxg1;
double ming1;
double gcol;
double kruch;
double usl[MAX_CH];
double totb;
double totbR2;
double k_im[2][MAX_CH];
double b_im[2][MAX_CH];
double k_zd[2][MAX_CH];
double b_zd[2][MAX_CH];
double kprMin;
double kprMax;
double alg;
double sep_row;
};
struct ssep_work {
//double i_kn[MAX_CH+1];
//double i_xw[MAX_CH+1];
//double i_km[MAX_CH+1];
double i_prd[MAX_CH][4];
//double p_cr[MAX_CH];
//double p_crk[MAX_CH];
//double p_crx[MAX_CH];
double p_prd[MAX_CH][4];
double p_tk[MAX_CH];
double p_tkh1[MAX_CH];
double p_tkh2[MAX_CH];
double p_tkh3[MAX_CH];
double wcount[MAX_CH];
double s_rst[MAX_CH][MAX_GR];
double error ;
};
struct sspk{
unsigned short spk[S_SPK];
};
struct sgist{
int gist[MAX_GIST];
};
struct sim_work{
double dl[ROW];
double wt[ROW];
double im[ROW];
};
class Separ{
public:
int sock;
sep_ust *wust;
ssep_work sep_work;
sspk *ch[MAX_CH];
sspk *kch[MAX_CH];
sgist *gch[MAX_CH];
sim_work im_work;
int timekspk[MAX_CH];
unsigned short kod[MAX_CH];
int kw1,kw2,mka1,mka2;
double loterm,hiterm,tterm;
bool f_Reset;
Separ();
~Separ();
void setspk(int tm);
bool flag_spk();
void setudeu();
void setptdeu();
void startsep();
void stopsep();
int setm50(int num,int km);
int getm50(int num);
int getchannel();
int getmintime();
int getmaxtime();
int getszspk();
bool test_ust();
void clrkspk(int ch);
int getszgist();
void getren();
void setren(int ch,int kw,int mka);
void on_offsep(bool f);
void on_offpren(bool f);
void on_offexp(bool f,int ch);
void on_offiw(bool f);
void on_offosw(bool f);
void setterm(int l,int h);
void start_puw();
void stop_puw();
void set_puw(int ust);
void set_rgu(int rgu);
void set_rgu2(int rgu);
int get_rgu2();
void testim(int ch,int gr,int dl);
void stop_im();
void reset();
int getblk();
void initada();
void set_stopall();
void set_im();
int sizeUst();
protected:
sep_ust *ust;
SDevice mySDevice;
pthread_t thread_id;
pthread_cond_t flag_cv;
pthread_mutex_t flag_mutex;
pthread_mutex_t flag_mutex_wait;
struct sigaction sa;
struct itimerval timer;
struct timeval tv,atv;
int time,atime;
int rez;
int max_time;
bool f_spk;
int count;
int time_end;
bool f_kon;
bool f_kon2;
int countPl;
double kpdl;
double bpdl;
//GMZ
bool f_sep;
int intgm[MAX_CH];
int sumgm[MAX_CH][MAX_OBL];
bool fgm_io[MAX_CH];
bool f_rech[MAX_CH];
int prgm[MAX_CH];
int ngm[MAX_CH];
int lgm[MAX_CH];
int countgm[MAX_CH];
sobl oblgm[MAX_CH][MAX_OBL];
double h1sum[MAX_CH],h2sum[MAX_CH];
int fl_time[MAX_CH][BF_IM];
int cn_time[MAX_CH][BF_IM];
int dl_1[MAX_CH][BF_IM];
int dl_2[MAX_CH][BF_IM];
int r2_fl_time[MAX_CH][BF_IM];
int r2_cn_time[MAX_CH][BF_IM];
int r2_dl_1[MAX_CH][BF_IM];
int r2_dl_2[MAX_CH][BF_IM];
int t_ind[MAX_CH];
static void* execute(void* unused);
void real_execute();
static void timer_handler(int signum);
void getspk();
bool f_sm50;
bool f_gm50;
int m50_num,m50_km;
int musl[MAX_CH];
int wrm[MAX_CH];
int kms[MAX_CH];
int akms[MAX_CH];
int countkc[MAX_CH];
bool botb[MAX_CH];
//PUW
int ustpuw,tkustpuw;
bool f_puw;
int count_u;
double u_cet;
double setust;
//TEST_IM
int im_ch;
int im_d1;
int im_d2;
int count_im;
bool f_im;
bool f_stop;
//GMZ
void my_gmz();
void gm_in(int ch);
void gm_out(int ch);
void rec_h(int ch);
void rec_im(int ch);
void work_im(int ch);
//PUW
void work_puw();
void work_im();
//RGU
bool f_rgu;
int m_rgu;
bool f_stop_rgu;
int count_rgu;
void work_rgu();
// PL
void stopAll();
//ROW 2
void sum_h_i(int ch,int n);
void alg0(int ch,double h1,double h2,double h3);
void alg1(int ch,double h1,double h2,double h3);
void alg2(int ch,double h1,double h2,double h3);
void alg3(int ch,double h1,double h2,double h3);
//
bool f_wim;
};
#endif
| [
"longway34@gmail.com"
] | longway34@gmail.com |
a32cab94dc2b4c2387b69d4e87acdc370dd46a20 | 5b46f96a2eda33e39913d3aacb304d229dbcd8ce | /engine/Source/SpriteComponent.cpp | 1529603e364fd983b395d8d892803615abafdc5e | [] | no_license | Valakor/CSCI-580 | 6ad1da58caa603344ca10bdeba24afc94c1e0c58 | 6f4f69074bd26850bf549035e3f157a422c9d6da | refs/heads/master | 2021-01-10T15:23:43.785683 | 2015-12-02T00:09:42 | 2015-12-02T00:09:42 | 45,649,738 | 0 | 0 | null | 2015-12-03T11:27:06 | 2015-11-06T00:49:44 | C++ | UTF-8 | C++ | false | false | 521 | cpp | #include "SpriteComponent.h"
#include "Actor.h"
#include <SDL/SDL.h>
#include "Renderer.h"
IMPL_COMPONENT(SpriteComponent, DrawComponent);
SpriteComponent::SpriteComponent(Actor& owner)
:DrawComponent(owner)
{
}
void SpriteComponent::Draw(Renderer& render)
{
if (!mTexture)
{
return;
}
Matrix4 scale = Matrix4::CreateScale(static_cast<float>(mTexture->GetWidth()), static_cast<float>(mTexture->GetHeight()), 1.0f);
render.DrawSprite(mTexture, scale * mOwner.GetWorldTransform());
}
| [
"pohlmann@usc.edu"
] | pohlmann@usc.edu |
56795db6803647e622651c3290f9a661c5f33633 | 0dca3325c194509a48d0c4056909175d6c29f7bc | /dbfs/include/alibabacloud/dbfs/model/GetDbfsResult.h | b1402893f34c2b06d80e37d3840bb2a8debc0439 | [
"Apache-2.0"
] | permissive | dingshiyu/aliyun-openapi-cpp-sdk | 3eebd9149c2e6a2b835aba9d746ef9e6bef9ad62 | 4edd799a79f9b94330d5705bb0789105b6d0bb44 | refs/heads/master | 2023-07-31T10:11:20.446221 | 2021-09-26T10:08:42 | 2021-09-26T10:08:42 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,242 | h | /*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_DBFS_MODEL_GETDBFSRESULT_H_
#define ALIBABACLOUD_DBFS_MODEL_GETDBFSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/dbfs/DBFSExport.h>
namespace AlibabaCloud
{
namespace DBFS
{
namespace Model
{
class ALIBABACLOUD_DBFS_EXPORT GetDbfsResult : public ServiceResult
{
public:
struct DBFSInfo
{
struct TagList
{
std::string tagKey;
int id;
std::string tagValue;
};
struct EcsListItem
{
std::string ecsId;
};
struct EbsListItem
{
int sizeG;
std::string ebsId;
};
std::string status;
std::string description;
std::string category;
std::string createdTime;
std::string kMSKeyId;
std::string zoneId;
bool enableRaid;
std::vector<EcsListItem> ecsList;
int sizeG;
std::string performanceLevel;
std::string fsId;
std::string dBFSClusterId;
std::string payType;
bool encryption;
std::string lastUmountTime;
std::string fsName;
std::vector<EbsListItem> ebsList;
std::string usedScene;
int raidStrip;
std::string lastMountTime;
std::string regionId;
int attachNodeNumber;
std::vector<TagList> tags;
};
GetDbfsResult();
explicit GetDbfsResult(const std::string &payload);
~GetDbfsResult();
DBFSInfo getDBFSInfo()const;
protected:
void parse(const std::string &payload);
private:
DBFSInfo dBFSInfo_;
};
}
}
}
#endif // !ALIBABACLOUD_DBFS_MODEL_GETDBFSRESULT_H_ | [
"sdk-team@alibabacloud.com"
] | sdk-team@alibabacloud.com |
651f3d786cbf2c8d8d47551b185e498446daa760 | 366e3a877c42869d17ab85c2384c3d98da2b579b | /Student_OMP/src/cpp/core/omp/02_Slice/07_pi_for_promotionTab.cpp | d331e77efb190956b03ca28f3ceb6ce3e9a57b85 | [] | no_license | sylvain1811/WCuda | 21ff9b66e87058d25b5cda27d41f893350c40f8d | 080fda79e74c695809dc71bb361cee34b9862c11 | refs/heads/master | 2021-05-05T14:29:09.478535 | 2018-04-30T17:16:46 | 2018-04-30T17:16:46 | 118,453,141 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,260 | cpp | #include <omp.h>
#include "MathTools.h"
#include "OmpTools.h"
#include "../02_Slice/00_pi_tools.h"
/*----------------------------------------------------------------------*\
|* Declaration *|
\*---------------------------------------------------------------------*/
/*--------------------------------------*\
|* Imported *|
\*-------------------------------------*/
/*--------------------------------------*\
|* Public *|
\*-------------------------------------*/
bool isPiOMPforPromotionTab_Ok(int n);
/*--------------------------------------*\
|* Private *|
\*-------------------------------------*/
static double piOMPforPromotionTab(int n);
static void syntaxeSimplifier(double* tabSumThread, int n);
static void syntaxeFull(double* tabSumThread, int n);
/*----------------------------------------------------------------------*\
|* Implementation *|
\*---------------------------------------------------------------------*/
/*--------------------------------------*\
|* Public *|
\*-------------------------------------*/
bool isPiOMPforPromotionTab_Ok(int n)
{
return isAlgoPI_OK(piOMPforPromotionTab, n, "Pi OMP for promotion tab");
}
/*--------------------------------------*\
|* Private *|
\*-------------------------------------*/
/**
* De-synchronisation avec PromotionTab
*/
double piOMPforPromotionTab(int n)
{
const double DX = 1 / (double) n;
double sum = 0;
const int NB_THREAD = OmpTools::setAndGetNaturalGranularity();
double tabSommeThread[NB_THREAD];
// Initialisation séquentielle
for (int c = 0; c < NB_THREAD; c++)
{
tabSommeThread[c] = 0;
}
#pragma omp parallel for
for (int i = 0; i < n; i++)
{
double xi = i * DX;
const int TID = OmpTools::getTid();
tabSommeThread[TID] += fpi(xi);
}
// Reduction sequentielle du tableau promu -> GRATUIT
double somme = 0;
for (int i = 0; i < NB_THREAD; i++)
{
somme += tabSommeThread[i];
}
return somme * DX;
}
/*----------------------------------------------------------------------*\
|* End *|
\*---------------------------------------------------------------------*/
| [
"sylvain.renaud@he-arc.ch"
] | sylvain.renaud@he-arc.ch |
fb4fa5d46fe3c809f531f6e6efb9ca55c6e3d726 | 49e150b4bf0655743d88d30c127183044e318889 | /bg.hpp | e707cb3425bed8ac38490ef42c6f910daa863fd1 | [] | no_license | jonigata/pasta_webgl | d79b2c26ca55ea94370a5e3acaf9cd5fcf9b6787 | 773836c7dc83d8dc65801402a16316919751913b | refs/heads/master | 2021-09-03T13:52:17.189813 | 2018-01-09T14:56:29 | 2018-01-09T14:56:29 | 116,162,456 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 789 | hpp | // 2014/09/20 Naoyuki Hirayama
#ifndef BG_HPP_
#define BG_HPP_
#include "textured_piece.hpp"
class BG {
public:
BG() {
piece_.set_texture("city_night002.png");
add_vertex(0, 0);
add_vertex(1, 0);
add_vertex(0, 1);
add_vertex(1, 1);
piece_.add_index(0);
piece_.add_index(1);
piece_.add_index(2);
piece_.add_index(2);
piece_.add_index(1);
piece_.add_index(3);
piece_.build();
}
void add_vertex(float x, float y){
Color c {{1.0f ,1.0f ,1.0f, 1.0f}};
piece_.add_vertex(x, y, 0, 0, 0, 1, c, x, 1-y);
}
void render() {
piece_.render();
}
private:
TexturedPiece piece_;
};
#endif // BG_HPP_
| [
"naoyuki.hirayama@gmail.com"
] | naoyuki.hirayama@gmail.com |
84441d0b3b3bacda5501967f40afeaaa4b7218ea | 073484a15c53c891074bfa612b19bc7c7cbe9937 | /pizza2.cpp | b2bc299de05579619e599c656ae879e6dbb1e2aa | [] | no_license | KarthikNarla/MapReduce-programs | bfbe59ee1e7de5ca5914ed986a581c4098ef75ee | 8671fc3a2a1a1f8953870424de3af5b73182eefd | refs/heads/master | 2021-01-15T16:51:41.706504 | 2017-08-14T09:19:12 | 2017-08-14T09:19:12 | 99,730,159 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 287 | cpp | #include <bits/stdc++.h>
using namespace std;
int main() {
double tradius, cradius;
cin>>tradius>>cradius;
double presult= tradius*tradius;
double result = (((tradius - cradius)* (tradius-cradius))/presult);
printf("%.6f\n", (result*100));
return 0;
}
| [
"karthiknarla22@gmail.com"
] | karthiknarla22@gmail.com |
f1b6ce1ee35e8c1a2e7f391611a7b07edeb53154 | 717cfbb815d7232f69b7836e6b8a19ab1c8214ec | /sstd_qt_and_qml_library/application/sstd_application_environment.hpp | 45ffa96bc94fb8cd2093a86546ead6be632ca5fd | [] | no_license | ngzHappy/QtQmlBook | b1014fb862aa6b78522e06ec59b94b13951edd56 | 296fabfd4dc47b884631598c05a2f123e1e5a3b5 | refs/heads/master | 2020-04-09T04:34:41.261770 | 2019-02-26T13:13:15 | 2019-02-26T13:13:15 | 160,028,971 | 4 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 485 | hpp | #pragma once
#include <sstd_library.hpp>
#include "../global/sstd_qt_and_qml_global.hpp"
namespace sstd {
/*用于在QApplication构造之前构造*/
class EXPORT_SSTD_QT_AND_QML_LIBRARY ApplicationEnvironment :
SSTD_BEGIN_DEFINE_VIRTUAL_CLASS(ApplicationEnvironment) {
public:
ApplicationEnvironment();
private:
SSTD_DELETE_COPY_ASSIGN(ApplicationEnvironment);
SSTD_END_DEFINE_VIRTUAL_CLASS(ApplicationEnvironment);
};
}/**/
| [
"zhaixueqiang@hotmail.com"
] | zhaixueqiang@hotmail.com |
77db58ddf4a4724b2d9a867623da09091472e475 | d3f6b5f34e00f6e69297b8c0f93abda4ece9f55b | /leituraEEscrita/leituraEEscrita/Source.cpp | d9e3e5d8b42fd297eccb46264f19152e92b6307e | [] | no_license | carlosfl11/P3D | db489fdf312b85ea8292b281b35582827d0688d9 | c263a03f88feacf8737c5a54c58c6b6dcec9518b | refs/heads/master | 2020-04-25T21:30:41.500307 | 2018-05-11T15:22:35 | 2018-05-11T15:22:35 | null | 0 | 0 | null | null | null | null | ISO-8859-1 | C++ | false | false | 2,084 | cpp | #include <iostream>
#include <fstream>
#include <string>
using namespace std;
int escrita() {
ofstream ficheiro("meuficheiro.txt");
if (ficheiro.is_open()) {
cout << "Ficheiro criado e alterado!\n";
ficheiro << "Primeira linha.\n";
ficheiro << "Segunda linha.\n";
ficheiro.close();
}
else {
cout << "Erro ao abrir o ficheiro!\n";
}
return 0;
};
void leitura() {
string linha;
ifstream ficheiro("meuficheiro.txt");
if (ficheiro.is_open()) {
// Lê, linha a linha, até ao final do ficheiro
while (getline(ficheiro, linha)) {
cout << linha << endl;
}
ficheiro.close();
}
else {
cout << "Erro ao abrir o ficheiro!\n";
}
};
void lerPalavra() {
char linha[100];
ifstream ficheiro("meuficheiro.txt");
if (ficheiro.is_open()) {
// Lê, palavra a palavra, até ao final do ficheiro
while (!ficheiro.eof()) {
ficheiro >> linha;
cout << linha << endl;
}
ficheiro.close();
}
else {
cout << "Erro ao abrir o ficheiro!\n";
}
};
void lerChar() {
char c;
ifstream ficheiro("meuficheiro.txt");
if (ficheiro.is_open()) {
// Lê, carácter a carácter, até ao final do ficheiro
while (!ficheiro.eof()) {
c = ficheiro.get();
cout << c;
}
ficheiro.close();
}
else {
cout << "Erro ao abrir o ficheiro!\n";
}
};
// escrever em binario
struct _s {
char a;
int b;
float c;
};
void escreverBin() {
struct _s data1[2] = { { 'A', 1, 1.1f },{ 'B', 2, 2.2f } };
struct _s data2[2];
fstream fileRW;
fileRW.open("ficheiro.dat", ios::out | ios::binary | ios::trunc);
fileRW.write((char *)data1, 2 * sizeof(struct _s));
fileRW.close();
fileRW.open("ficheiro.dat", ios::in | ios::binary | ios::_Nocreate);
fileRW.read((char *)data2, 2 * sizeof(struct _s));
fileRW.close();
for (int i = 0; i < 2; i++)
cout << data2[i].a << " " << data2[i].b << " " << data2[i].c << endl;
}
int main() {
cout << "-- escrita\n";
escrita();
cout << "-- leitura\n";
leitura();
cout << "-- ler linha\n";
lerPalavra();
cout << "-- ler char\n";
lerChar();
cin.get();
system("cls");
escreverBin();
cin.get();
return 0;
} | [
"32069840+ninjanazal@users.noreply.github.com"
] | 32069840+ninjanazal@users.noreply.github.com |
c2713e277e51cda2ab3044319311c7a44bab8cad | e6407f3ac4a3bfda7d930c4319c10028189a76c7 | /include/CollisionTile.h | e790cc37cd3b2ecf87975299654da731e47bd3d8 | [] | no_license | SuperTails/ProjectTails | 55dd0930b593539c14fb81234243e55b54bd80f4 | d5815a77d47a0c4c818b5eb0912dca40ccc5b79c | refs/heads/master | 2021-07-02T06:20:12.753406 | 2020-01-19T22:00:55 | 2020-01-19T22:00:55 | 91,393,663 | 2 | 0 | null | 2017-05-17T23:13:37 | 2017-05-15T23:32:14 | C++ | UTF-8 | C++ | false | false | 1,803 | h | #pragma once
#include "DataReader.h"
#include "Player.h"
#include <array>
#include <json.hpp>
class CollisionTile {
public:
static const std::size_t heightMapSize = 16;
CollisionTile() = default;
CollisionTile(int idx, int fl) : dataIndex(idx), flags(fl) {};
void setHeights(const std::array< int, heightMapSize >& heights) noexcept;
void setHeight(int index, int height) { dataList[dataIndex].heightMap[index] = height; };
void setAngle(double ang) { dataList[dataIndex].angle = ang; };
int getHeight(int ind) const { return dataList[dataIndex].heightMap[ind]; };
int getAngle() const;
int getAngle(Direction dir) const;
void setIndex(int idx) { dataIndex = idx; };
int getIndex() const { return dataIndex; };
int flags = 0;
static void loadFromImage(const std::string& image);
private:
int dataIndex = 0;
struct CollisionTileData {
CollisionTileData() = default;
CollisionTileData(const CollisionTileData&) = default;
CollisionTileData(CollisionTileData&&) = default;
CollisionTileData(std::array< int, heightMapSize > hMap, double ang);
constexpr CollisionTileData& operator=(CollisionTileData&) = default;
constexpr CollisionTileData& operator=(const CollisionTileData&) = default;
std::array < int, heightMapSize > heightMap{};
double angle{};
};
static CollisionTileData loadCollisionTile(const Surface& surface, SDL_Point topLeft);
static void setCollisionList(const std::vector< CollisionTileData >& list);
public:
static std::vector< CollisionTileData > dataList;
static void test();
};
// dir:
// 0 = from the right
// 1 = from the bottom
// 2 = from the left
// 3 = from the top
int getHeight(const CollisionTile &tile, int idx, Direction dir);
std::optional< SDL_Point > surfacePos(const CollisionTile &tile, int idx, Direction dir);
| [
"sciencedude2003@gmail.com"
] | sciencedude2003@gmail.com |
e35a8760738e4b965046e19ffc23493b073092a8 | c3a758c536c82e3def0a714445a4e40b27787180 | /Babe/Command/Commands/Plugin/BabeLoadPluginCmd.cpp | b5aec0d336ae715ea5b5e3bdabf458ad810956a1 | [] | no_license | catuss-a/SkypeLIKE | fefe9670a6e8a364bdabc321f95e73bab7db8fc4 | d9cb175db408c7635fc24e67b1c3096b11c215c4 | refs/heads/master | 2020-04-14T16:18:04.821689 | 2014-03-13T16:49:05 | 2014-03-13T16:49:05 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,892 | cpp | //
// BabeLoadPluginCmd.cpp for in /home/champi_d//AdvancedCPP/Babel/Mercurial/babel-2014-champi_d/Babe
//
// Made by alexandre champion
// Login <champi_d@epitech.net>
//
// Started on Mon Nov 28 17:26:45 2011 alexandre champion
// Last update Sat Dec 3 15:19:45 2011 alexandre champion
//
#include "BabeLoadPluginCmd.hpp"
#include "BabeApplicationManager.hpp"
#include "BabePluginManager.hpp"
#include "BabeCommandManager.hpp"
#include "BabeSystemManager.hpp"
namespace Babe
{
LoadPluginCmd::LoadPluginCmd(std::string const& pluginPath)
: ICommand(HIGH),
mName("loadplugin"),
mPluginPath(pluginPath)
{
}
LoadPluginCmd::LoadPluginCmd(CommandParser::ArgVector& args)
: ICommand(HIGH),
mName("loadplugin")
{
if (args.empty())
return ;
mPluginPath = args.front();
}
void LoadPluginCmd::exec()
{
if (mPluginPath.empty())
return ;
Plugin* plugin = PluginManager::getSingletonPtr()->getPluginByFileName(mPluginPath);
if (!plugin)
{
if (PluginManager::getSingletonPtr()->loadPlugin(mPluginPath))
{
Plugin* plugin = PluginManager::getSingletonPtr()->getPluginByFileName(mPluginPath);
System* system = SystemManager::getSingletonPtr()->getSystemByName(plugin->getSystemName());
system->shutdown();
if (!plugin->initialize())
{
LOGE("Couldn't initialise the plugin '" + plugin->getName() + "'");
CommandManager::getSingletonPtr()->setReturnMessage("Plugin \"" + mPluginPath + "\" failed : Couldn't initialise the plugin '" + plugin->getName() + "'");
return ;
}
system->init();
CommandManager::getSingletonPtr()->setReturnMessage("Plugin \"" + mPluginPath + "\" loaded");
}
else
CommandManager::getSingletonPtr()->setReturnMessage("Failed to load plugin \"" + mPluginPath + "\"");
}
else
{
std::string pluginName = plugin->getName();
System* system = SystemManager::getSingletonPtr()->getSystemByName(plugin->getSystemName());
std::string systemPluginName = system->getPluginName();
if (pluginName != systemPluginName)
{
system->shutdown();
if (!plugin->initialize())
{
LOGE("Couldn't initialise the plugin '" + plugin->getName() + "'");
CommandManager::getSingletonPtr()->setReturnMessage("Couldn't initialise the plugin '" + plugin->getName() + "'");
return ;
}
system->init();
CommandManager::getSingletonPtr()->setReturnMessage("Plugin \"" + mPluginPath + "\" loaded. System " + system->getName() + " initialized.");
}
else
CommandManager::getSingletonPtr()->setReturnMessage("Plugin \"" + mPluginPath + "\" already loaded.");
}
}
std::string const& LoadPluginCmd::getName() const
{
return mName;
}
std::string const& LoadPluginCmd::stringify()
{
mStringified = mName + " " + mPluginPath;
return mStringified;
}
} // End of namespace Babe
| [
"axel.catusse@gmail.com"
] | axel.catusse@gmail.com |
480cf87e09fc61af9318b075628a2acdeefc24e4 | 3e52a128b8ffa42e097ae290171d39c5244fa04d | /Console/Win32Project1/AllocCon.cpp | 595ae8fe2480511550c913c2cd13996914b344a1 | [] | no_license | awakening95/BoB_Study | 74331348301e65d48c080ad11e6b3109624df6cb | 82805e026b95d0d48eb3a04b9f5bcad6528a1d1e | refs/heads/master | 2020-03-26T16:20:33.347056 | 2018-09-01T08:25:31 | 2018-09-01T08:25:31 | 145,095,493 | 0 | 0 | null | null | null | null | UHC | C++ | false | false | 1,011 | cpp | #include "stdafx.h"
#include <stdio.h>
#include <tchar.h>
LRESULT CALLBACK WndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam)
{
HDC hdc;
PAINTSTRUCT ps;
DWORD dw;
TCHAR *str = "New Console is created";
TCHAR *Mes = TEXT("마우스 왼쪽 버튼을 누르면 새로운 콘솔 윈도우를 만듭니다");
switch (iMessage) {
case WM_LBUTTONDOWN:
if (AllocConsole() == FALSE) {
//콘솔 생성 실패
puts("");
}
// 출력하는 함수 //
/* 핸들값, 문자열 담은 변수, 문자열의 길이, 함수 호출 후 전송한 실제 길이, NULL */
WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), str, lstrlen(str), &dw, NULL);
Sleep(3000);
FreeConsole();
break;
case WM_PAINT:
// GUI 창 띄우기
hdc = BeginPaint(hWnd, &ps);
// GUI 내에 50, 50 위치에 메세지 출력
TextOut(hdc, 50, 50, Mes, lstrlen(Mes));
EndPaint(hWnd, &ps);
return 0;
case WM_DESTROY:
PostQuitMessage(0);
return 0;
}
return(DefWindowProc(hWnd, iMessage, wParam, lParam));
} | [
"gusdnr420@naver.com"
] | gusdnr420@naver.com |
997e7eb87253f49ff5d5cedbbdd7d9fd9bb12ca5 | 98054c0fc0415cd7d7733ed63c69d1d25547b338 | /src/HTTP/HttpParserErrorCodes.cpp | 1ec7e8d415721ee5fc6658c29421149d29f0c3bf | [
"MIT"
] | permissive | freelacoin/freelabit | 18dc3f23f0671cb73d1df8a22baca43305549eae | f5a2fa5b9258e5e5688d3281e45503f14e0cb914 | refs/heads/freelabit | 2021-12-11T08:33:30.992223 | 2021-08-31T16:42:48 | 2021-08-31T16:42:48 | 102,800,887 | 3 | 6 | MIT | 2018-05-12T04:02:35 | 2017-09-08T01:01:08 | C++ | UTF-8 | C++ | false | false | 506 | cpp | // Copyright (c) 2011-2017 The Cryptonote developers
// Copyright (c) 2014-2017 XDN developers
// Copyright (c) 2016-2017 BXC developers
// Copyright (c) 2017 Royalties developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "HttpParserErrorCodes.h"
namespace CryptoNote {
namespace error {
HttpParserErrorCategory HttpParserErrorCategory::INSTANCE;
} //namespace error
} //namespace CryptoNote
| [
"ericvesprini@yahoo.com"
] | ericvesprini@yahoo.com |
09fc815c8853470103e6932f929d1cb39a23efa8 | aab2b891bdb9f3d431e56c997b35bb3e0ead56a3 | /untitled1/multiplyByTwo.cpp | c7c453ad323e7f199d70378c6c56d829e39ab4f3 | [] | no_license | marcinbielinski/CLion | ed2bf76a6b4332b2ead64abb8a38b2b4bfa032d5 | e12c4cdae9c21b59c776c87d3399ce76a788ab6a | refs/heads/master | 2022-12-19T03:52:25.911739 | 2020-09-14T10:43:16 | 2020-09-14T10:43:16 | 295,383,908 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,552 | cpp | // Standard library - allows printing and taking input
//#include <iostream>
//
//// Area of main function that is taken line by line upon building a program
//int main()
//{
// // Welcome prompt
// std::cout << "This program multiplies your number by 2! \n";
//
// // Zero initializing variable "x" temporary because user is assigning it in next statement
// int x{0};
//
// // Prompt for user asking for a number
// std::cout << "Please enter your number: \n";
//
// // User inputs his desirable number to multiply
// std::cin >> x;
//
// // Ending statement with a multiplying expression
// std::cout << "Your number after multiplication is equal to: " << x * 2;
//
// // Finishing process, code 0 implies that everything went smoothly
// return 0;
//}
//#include <iostream>
//
//int main()
//{
// std::cout << "Enter an integer: ";
//
// int num{ 0 };
//
// std::cin >> num;
//
// std::cout << "Double " << num << " is: " << num * 2 << "\n";
//
// std::cout << "Triple " << num << " is: " << num * 3 << "\n";
//
// return 0;
//}
//#include <iostream>
//
//int main()
//{
//
// std::cout << "Enter an integer: ";
//
// int x {}; // direct zero init when asking for input
//
// std::cin >> x;
//
// std::cout << "Enter another integer: ";
//
// int y {}; // direct zero init when asking for input
//
// std::cin >> y;
//
// std::cout << x << " + " << y << " is: " << x + y << "\n";
//
// std::cout << x << " - " << y << " is: " << x - y << "\n";
//
// return 0;
//}; | [
"howlempyrean@gmail.com"
] | howlempyrean@gmail.com |
7a9b6c90531d20934106e46944dc4c4b56c9c4be | b4393b82bcccc59e2b89636f1fde16d82f060736 | /src/utils/CachePruning.cpp | 8fb7a2dfd559f1e62d4b621a8ffa601d96148f2b | [] | no_license | phpmvc/polarphp | abb63ed491a0175aa43c873b1b39811f4eb070a2 | eb0b406e515dd550fd99b9383d4b2952fed0bfa9 | refs/heads/master | 2020-04-08T06:51:03.842159 | 2018-11-23T06:32:04 | 2018-11-23T06:32:04 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 10,967 | cpp | // This source file is part of the polarphp.org open source project
//
// Copyright (c) 2017 - 2018 polarphp software foundation
// Copyright (c) 2017 - 2018 zzu_softboy <zzu_softboy@163.com>
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See http://polarphp.org/LICENSE.txt for license information
// See http://polarphp.org/CONTRIBUTORS.txt for the list of polarphp project authors
//
// Created by softboy on 2018/07/03.
#include "polarphp/utils/CachePruning.h"
#include "polarphp/utils/Debug.h"
#include "polarphp/utils/ErrorCode.h"
#include "polarphp/utils/Error.h"
#include "polarphp/utils/FileSystem.h"
#include "polarphp/utils/Path.h"
#include "polarphp/utils/RawOutStream.h"
#include <set>
#include <system_error>
#define DEBUG_TYPE "cache-pruning"
namespace polar {
namespace utils {
namespace {
/// Write a new timestamp file with the given path. This is used for the pruning
/// interval option.
static void write_timestamp_file(StringRef timestampFile)
{
std::error_code errorCode;
RawFdOutStream outstream(timestampFile.getStr(), errorCode, polar::fs::F_None);
}
static Expected<std::chrono::seconds> parse_duration(StringRef duration)
{
if (duration.empty()) {
return make_error<StringError>("duration must not be empty",
inconvertible_error_code());
}
StringRef numStr = duration.slice(0, duration.getSize() - 1);
uint64_t num;
if (numStr.getAsInteger(0, num)) {
return make_error<StringError>("'" + numStr + "' not an integer",
inconvertible_error_code());
}
switch (duration.back()) {
case 's':
return std::chrono::seconds(num);
case 'm':
return std::chrono::minutes(num);
case 'h':
return std::chrono::hours(num);
default:
return make_error<StringError>("'" + duration +
"' must end with one of 's', 'm' or 'h'",
inconvertible_error_code());
}
}
} // anonymous namespace
Expected<CachePruningPolicy>
parse_cache_pruning_policy(StringRef policyStr)
{
CachePruningPolicy policy;
std::pair<StringRef, StringRef> pair = {"", policyStr};
while (!pair.second.empty()) {
pair = pair.second.split(':');
StringRef key, value;
std::tie(key, value) = pair.first.split('=');
if (key == "prune_interval") {
auto durationOrErr = parse_duration(value);
if (!durationOrErr) {
return durationOrErr.takeError();
}
policy.m_interval = *durationOrErr;
} else if (key == "prune_after") {
auto durationOrErr = parse_duration(value);
if (!durationOrErr)
return durationOrErr.takeError();
policy.m_expiration = *durationOrErr;
} else if (key == "cache_size") {
if (value.back() != '%') {
return make_error<StringError>("'" + value + "' must be a percentage",
inconvertible_error_code());
}
StringRef sizeStr = value.dropBack();
uint64_t size;
if (sizeStr.getAsInteger(0, size)) {
return make_error<StringError>("'" + sizeStr + "' not an integer",
inconvertible_error_code());
}
if (size > 100) {
return make_error<StringError>("'" + sizeStr +
"' must be between 0 and 100",
inconvertible_error_code());
}
policy.m_maxSizePercentageOfAvailableSpace = size;
} else if (key == "cache_size_bytes") {
uint64_t mult = 1;
switch (tolower(value.back())) {
case 'k':
mult = 1024;
value = value.dropBack();
break;
case 'm':
mult = 1024 * 1024;
value = value.dropBack();
break;
case 'g':
mult = 1024 * 1024 * 1024;
value = value.dropBack();
break;
}
uint64_t size;
if (value.getAsInteger(0, size)) {
return make_error<StringError>("'" + value + "' not an integer",
inconvertible_error_code());
}
policy.m_maxSizeBytes = size * mult;
} else if (key == "cache_size_files") {
if (value.getAsInteger(0, policy.m_maxSizeFiles)) {
return make_error<StringError>("'" + value + "' not an integer",
inconvertible_error_code());
}
} else {
return make_error<StringError>("Unknown key: '" + key + "'",
inconvertible_error_code());
}
}
return policy;
}
/// Prune the cache of files that haven't been accessed in a long time.
bool prune_cache(StringRef path, CachePruningPolicy policy)
{
using namespace std::chrono;
if (path.empty()) {
return false;
}
bool isPathDir;
if (polar::fs::is_directory(path, isPathDir)) {
return false;
}
if (!isPathDir) {
return false;
}
policy.m_maxSizePercentageOfAvailableSpace =
std::min(policy.m_maxSizePercentageOfAvailableSpace, 100u);
if (policy.m_expiration == seconds(0) &&
policy.m_maxSizePercentageOfAvailableSpace == 0 &&
policy.m_maxSizeBytes == 0 && policy.m_maxSizeFiles == 0) {
POLAR_DEBUG(debug_stream() << "No pruning settings set, exit early\n");
// Nothing will be pruned, early exit
return false;
}
// Try to stat() the timestamp file.
SmallString<128> timestampFile(path);
polar::fs::path::append(timestampFile, "llvmcache.timestamp");
polar::fs::FileStatus fileStatus;
const auto currentTime = system_clock::now();
if (auto errorCode = polar::fs::status(timestampFile, fileStatus)) {
if (errorCode == ErrorCode::no_such_file_or_directory) {
// If the timestamp file wasn't there, create one now.
write_timestamp_file(timestampFile);
} else {
// Unknown error?
return false;
}
} else {
if (!policy.m_interval) {
return false;
}
if (policy.m_interval != seconds(0)) {
// Check whether the time stamp is older than our pruning interval.
// If not, do nothing.
const auto timeStampModTime = fileStatus.getLastModificationTime();
auto timeStampAge = currentTime - timeStampModTime;
if (timeStampAge <= *policy.m_interval) {
POLAR_DEBUG(debug_stream() << "Timestamp file too recent ("
<< duration_cast<seconds>(timeStampAge).count()
<< "s old), do not prune.\n");
return false;
}
}
// Write a new timestamp file so that nobody else attempts to prune.
// There is a benign race condition here, if two processes happen to
// notice at the same time that the timestamp is out-of-date.
write_timestamp_file(timestampFile);
}
// Keep track of space. Needs to be kept ordered by size for determinism.
std::set<std::pair<uint64_t, std::string>> fileSizes;
uint64_t totalSize = 0;
// Walk the entire directory cache, looking for unused files.
std::error_code errorCode;
SmallString<128> cachePathNative;
polar::fs::path::native(path, cachePathNative);
// Walk all of the files within this directory.
for (polar::fs::DirectoryIterator file(cachePathNative, errorCode), fileEnd;
file != fileEnd && !errorCode; file.increment(errorCode)) {
// Ignore any files not beginning with the string "llvmcache-". This
// includes the timestamp file as well as any files created by the user.
// This acts as a safeguard against data loss if the user specifies the
// wrong directory as their cache directory.
if (!polar::fs::path::filename(file->getPath()).startsWith("polarcache-")) {
continue;
}
// Look at this file. If we can't stat it, there's nothing interesting
// there.
OptionalError<polar::fs::BasicFileStatus> statusOrErr = file->getStatus();
if (!statusOrErr) {
POLAR_DEBUG(debug_stream() << "Ignore " << file->getPath() << " (can't stat)\n");
continue;
}
// If the file hasn't been used recently enough, delete it
const auto fileAccessTime = statusOrErr->getLastAccessedTime();
auto fileAge = currentTime - fileAccessTime;
if (policy.m_expiration != seconds(0) && fileAge > policy.m_expiration) {
POLAR_DEBUG(debug_stream() << "Remove " << file->getPath() << " ("
<< duration_cast<seconds>(fileAge).count() << "s old)\n");
polar::fs::remove(file->getPath());
continue;
}
// Leave it here for now, but add it to the list of size-based pruning.
totalSize += statusOrErr->getSize();
fileSizes.insert({statusOrErr->getSize(), std::string(file->getPath())});
}
auto fileAndSize = fileSizes.rbegin();
size_t numFiles = fileSizes.size();
auto removeCacheFile = [&]() {
// Remove the file.
polar::fs::remove(fileAndSize->second);
// Update size
totalSize -= fileAndSize->first;
numFiles--;
POLAR_DEBUG(debug_stream() << " - Remove " << fileAndSize->second << " (size "
<< fileAndSize->first << "), new occupancy is " << totalSize
<< "%\n");
++fileAndSize;
};
// Prune for number of files.
if (policy.m_maxSizeFiles) {
while (numFiles > policy.m_maxSizeFiles) {
removeCacheFile();
}
}
// Prune for size now if needed
if (policy.m_maxSizePercentageOfAvailableSpace > 0 || policy.m_maxSizeBytes > 0) {
auto errOrSpaceInfo = polar::fs::disk_space(path);
if (!errOrSpaceInfo) {
report_fatal_error("Can't get available size");
}
polar::fs::SpaceInfo spaceInfo = errOrSpaceInfo.get();
auto availableSpace = totalSize + spaceInfo.free;
if (policy.m_maxSizePercentageOfAvailableSpace == 0) {
policy.m_maxSizePercentageOfAvailableSpace = 100;
}
if (policy.m_maxSizeBytes == 0) {
policy.m_maxSizeBytes = availableSpace;
}
auto totalSizeTarget = std::min<uint64_t>(
availableSpace * policy.m_maxSizePercentageOfAvailableSpace / 100ull,
policy.m_maxSizeBytes);
POLAR_DEBUG(debug_stream() << "Occupancy: " << ((100 * totalSize) / availableSpace)
<< "% target is: " << policy.m_maxSizePercentageOfAvailableSpace
<< "%, " << policy.m_maxSizeBytes << " bytes\n");
// Remove the oldest accessed files first, till we get below the threshold.
while (totalSize > totalSizeTarget && fileAndSize != fileSizes.rend()) {
removeCacheFile();
}
}
return true;
}
} // utils
} // polar
| [
"zzu_softboy@163.com"
] | zzu_softboy@163.com |
a4b19c619881ada9ce1a46b85629b25c2b9cb9d2 | d77d525bcf0b94c5f552e782390236113049183d | /simple spaceship/ADXL345/ADXL345.ino | 790850f008415b20bba0a8ee227367a847bfa0d5 | [] | no_license | ravi94/Repo | 1a5400f444ddcabb7b187c91856dcdef1c762a8e | cec4de248227e946c1f4cb696f49f08f4b56de2d | refs/heads/master | 2021-01-19T02:13:28.692202 | 2013-04-19T09:04:58 | 2013-04-19T09:04:58 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,533 | ino | #include <Wire.h>
#define DEVICE (0x53)
#define TO_READ (6)
byte buff[TO_READ] ;
char str1[512], str2[512];
void setup()
{
Wire.begin();
Serial.begin(9600);
writeTo(DEVICE, 0x2D, 0);
writeTo(DEVICE, 0x2D, 16);
writeTo(DEVICE, 0x2D, 8);
}
void loop()
{
int regAddress = 0x32;
int x, y, z;
readFrom(DEVICE, regAddress, TO_READ, buff);
x = (((int)buff[1]) << 8) | buff[0];
y = (((int)buff[3])<< 8) | buff[2];
z = (((int)buff[5]) << 8) | buff[4];
//sprintf(str, "%d %d %d", x, y, z);
// Serial.println(str);
// delay(15);
//Serial.println(x);
x=map(x, -250, 290, 0, 255); //var in range2 = map(var in range1, low_lim1, high_lim1, low_lim2, high_lim2);
y=map(y, -250, 290, 0, 255);
sprintf(str1, "$%d", y);
sprintf(str2,"#%d", x);
//Serial.println(str);
Serial.println(str1);
Serial.println(str2);
delay(10);
// analogWrite(11,x);
}
void writeTo(int device, byte address, byte val) {
Wire.beginTransmission(device);
Wire.write(address);
Wire.write(val);
Wire.endTransmission();
}
void readFrom(int device, byte address, int num, byte buff[]) {
Wire.beginTransmission(device);
Wire.write(address);
Wire.endTransmission();
Wire.beginTransmission(device);
Wire.requestFrom(device, num);
int i = 0;
while(Wire.available())
{
buff[i] = Wire.read();
i++;
}
Wire.endTransmission();
}
| [
"ravibhushan94@gmail.com"
] | ravibhushan94@gmail.com |
2ef8ee7c55fe8df029aedf329a2c7c8971a88a41 | 553298299eed97e2c22835bb7c3912f5006c3c28 | /Common/Obj8/Global/PointsCounts.hpp | a9822f0e7af635e510464f9670f65e8ab0b2c1ab | [] | no_license | SchaichAlonso/StaticsMapping | 853d8f8bd6df0f02b755830902ba36199278d7f9 | 9b33139f853a45e3c1a3535d445e89ba6772f9e5 | refs/heads/master | 2022-11-03T03:09:14.964266 | 2022-10-19T17:02:10 | 2022-10-19T17:02:10 | 110,700,210 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 818 | hpp | #pragma once
#include <QtGlobal>
#include <Obj8/Parameter/Integer.hpp>
#include <Obj8/Record.hpp>
namespace Obj8
{
namespace Global
{
struct PointsCounts : Record
{
PointsCounts ();
PointsCounts (StringRef, Parser::LexerContext *);
virtual ~PointsCounts ();
virtual void accept (AbstractVisitor *, bool) Q_DECL_OVERRIDE;
virtual RecordPointer instantiate (StringRef, Parser::LexerContext *) const Q_DECL_OVERRIDE;
virtual String name () const Q_DECL_OVERRIDE;
virtual String toString () const Q_DECL_OVERRIDE;
int vertices () const;
int lineVertices () const;
int lights () const;
int indices () const;
protected:
Parameter::Integer m_tris, m_lines, m_lites, m_indices;
};
}
}
| [
"alonso.schaich@sodgeit.de"
] | alonso.schaich@sodgeit.de |
29d8934e1e60f634fc4d3c695603eda4f76c7e71 | 2348000ede440b3513010c29a154ca70b22eb88e | /src/CPP/src/leetcode/SimplifyPath.cpp | e7bbf493be9a39e3e79996d67633c96eeb5d00b9 | [] | no_license | ZhenyingZhu/ClassicAlgorithms | 76438e02ecc813b75646df87f56d9588ffa256df | 86c90c23ea7ed91e8ce5278f334f0ce6e034a38c | refs/heads/master | 2023-08-27T20:34:18.427614 | 2023-08-25T06:08:00 | 2023-08-25T06:08:00 | 24,016,875 | 2 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,700 | cpp | /*
* [Source] https://leetcode.com/problems/simplify-path/
* [Difficulty]: Medium
* [Tag]: Stack
* [Tag]: String
*/
#include <iostream>
using namespace std;
// [Solution]: Split string by '/'. Use a stack. If find "..", pop, if "." or empty, do nothing.
// [Corner Case]: only "/", then stack is empty.
class Solution {
};
/* Java solution
https://github.com/ZhenyingZhu/ClassicAlgorithms/blob/master/src/algorithms/datastructure/SimplifyPath.java
*/
/* Java solution
public class Solution {
public String simplifyPath(String path) {
if(path==null || path.length()<=0) return null;
if(path.equals("/")) return "/";
char[] array=path.toCharArray();
Stack<String> stack=new Stack<String>();
int idx=1;
while(idx<array.length){
if(array[idx]=='/'){ // a slash
idx++;
continue;
}
String dir=getDirectory(array, idx);
if(!dir.equals(".")){ // current dir
if(dir.equals("..")){ // parent dir
if(!stack.empty()) stack.pop();
}else{
stack.push(dir);
}
idx=idx+dir.length()+1;
}else{
idx=idx+2;
}
}
if(stack.empty()) return "/";
Stack<String> reverse=new Stack<String>();
while(!stack.empty()){
reverse.push(stack.pop());
}
StringBuffer result=new StringBuffer();
while(!reverse.empty()){
result.append('/');
result.append(reverse.pop());
}
return result.toString();
}
public String getDirectory(char[] path, int start){
StringBuffer directory=new StringBuffer();
int index=start;
while(index<path.length){
if(path[index]=='/') break;
directory.append(path[index]);
index++;
}
return directory.toString();
}
}
*/
int main() {
Solution sol;
return 0;
}
| [
"zz2283@columbia.edu"
] | zz2283@columbia.edu |
0c07da322b429edaf4e270493b9ef4b823077b1a | 5bcedc9c0b9c92f795cd04927bc1b752b8bbe6f3 | /gtkmm_examples/src/cairo_thin_lines/examplewindow.h | 0d9f4a961f6c4dc6e7e6e3d63437d925a0d4476b | [
"FSFAP"
] | permissive | hamedobaidy/gtkmm_eclipse_examples | 8d466523b8e680b3d77bf0026320321aa56a22e3 | 379c7b8e7640aef67ec189b10c54442251c2a2b8 | refs/heads/master | 2021-01-20T15:33:35.355311 | 2015-09-15T15:52:20 | 2015-09-15T15:52:20 | 38,481,378 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 524 | h | /*
* examplewindow.h
*
* Created on: Jul 3, 2015
* Author: hamed
*/
#ifndef EXAMPLEWINDOW_H_
#define EXAMPLEWINDOW_H_
#include <gtkmm/window.h>
#include <gtkmm/grid.h>
#include <gtkmm/checkbutton.h>
#include "myarea.h"
class ExampleWindow : public Gtk::Window
{
public:
ExampleWindow();
virtual ~ExampleWindow();
protected:
//Signal handlers:
void on_button_toggled();
private:
Gtk::Grid m_Container;
MyArea m_Area_Lines;
Gtk::CheckButton m_Button_FixLines;
};
#endif /* EXAMPLEWINDOW_H_ */
| [
"hamed.obaidy@gmail.com"
] | hamed.obaidy@gmail.com |
c6022d160c847bd2bea5a9dfb03cf0efd53957f5 | 961714d4298245d9c762e59c716c070643af2213 | /ThirdParty-mod/tinyxml/tinyxml.cpp | 615187f0924e6632e33e9cb1a49084ab4d6d836f | [
"MIT",
"Zlib"
] | permissive | blockspacer/HQEngine | b072ff13d2c1373816b40c29edbe4b869b4c69b1 | 8125b290afa7c62db6cc6eac14e964d8138c7fd0 | refs/heads/master | 2023-04-22T06:11:44.953694 | 2018-10-02T15:24:43 | 2018-10-02T15:24:43 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 38,381 | cpp | /*
www.sourceforge.net/projects/tinyxml
Original code by Lee Thomason (www.grinninglizard.com)
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any
damages arising from the use of this software.
Permission is granted to anyone to use this software for any
purpose, including commercial applications, and to alter it and
redistribute it freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must
not claim that you wrote the original software. If you use this
software in a product, an acknowledgment in the product documentation
would be appreciated but is not required.
2. Altered source versions must be plainly marked as such, and
must not be misrepresented as being the original software.
3. This notice may not be removed or altered from any source
distribution.
*/
#include <ctype.h>
#ifdef TIXML_USE_STL
#include <sstream>
#include <iostream>
#endif
#include "tinyxml.h"
//wrapper of stdio functions
static void stdio_seek (void* fileHandle, long offset, int origin)
{
fseek((FILE*)fileHandle, offset, origin);
}
static size_t stdio_tell (void* fileHandle)
{
return ftell((FILE*) fileHandle);
}
static size_t stdio_read ( void * ptr, size_t size, size_t count, void * stream )
{
return fread(ptr, size, count, (FILE*) stream);
}
/*----------------------*/
FILE* TiXmlFOpen( const char* filename, const char* mode );
bool TiXmlBase::condenseWhiteSpace = true;
// Microsoft compiler security
FILE* TiXmlFOpen( const char* filename, const char* mode )
{
#if defined(_MSC_VER) && (_MSC_VER >= 1400 )
FILE* fp = 0;
errno_t err = fopen_s( &fp, filename, mode );
if ( !err && fp )
return fp;
return 0;
#else
return fopen( filename, mode );
#endif
}
void TiXmlBase::EncodeString( const TIXML_STRING& str, TIXML_STRING* outString )
{
int i=0;
while( i<(int)str.length() )
{
unsigned char c = (unsigned char) str[i];
if ( c == '&'
&& i < ( (int)str.length() - 2 )
&& str[i+1] == '#'
&& str[i+2] == 'x' )
{
// Hexadecimal character reference.
// Pass through unchanged.
// © -- copyright symbol, for example.
//
// The -1 is a bug fix from Rob Laveaux. It keeps
// an overflow from happening if there is no ';'.
// There are actually 2 ways to exit this loop -
// while fails (error case) and break (semicolon found).
// However, there is no mechanism (currently) for
// this function to return an error.
while ( i<(int)str.length()-1 )
{
outString->append( str.c_str() + i, 1 );
++i;
if ( str[i] == ';' )
break;
}
}
else if ( c == '&' )
{
outString->append( entity[0].str, entity[0].strLength );
++i;
}
else if ( c == '<' )
{
outString->append( entity[1].str, entity[1].strLength );
++i;
}
else if ( c == '>' )
{
outString->append( entity[2].str, entity[2].strLength );
++i;
}
else if ( c == '\"' )
{
outString->append( entity[3].str, entity[3].strLength );
++i;
}
else if ( c == '\'' )
{
outString->append( entity[4].str, entity[4].strLength );
++i;
}
else if ( c < 32 )
{
// Easy pass at non-alpha/numeric/symbol
// Below 32 is symbolic.
char buf[ 32 ];
#if defined(TIXML_SNPRINTF)
TIXML_SNPRINTF( buf, sizeof(buf), "&#x%02X;", (unsigned) ( c & 0xff ) );
#else
sprintf( buf, "&#x%02X;", (unsigned) ( c & 0xff ) );
#endif
//*ME: warning C4267: convert 'size_t' to 'int'
//*ME: Int-Cast to make compiler happy ...
outString->append( buf, (int)strlen( buf ) );
++i;
}
else
{
//char realc = (char) c;
//outString->append( &realc, 1 );
*outString += (char) c; // somewhat more efficient function call.
++i;
}
}
}
TiXmlNode::TiXmlNode( NodeType _type ) : TiXmlBase()
{
parent = 0;
type = _type;
firstChild = 0;
lastChild = 0;
prev = 0;
next = 0;
}
TiXmlNode::~TiXmlNode()
{
TiXmlNode* node = firstChild;
TiXmlNode* temp = 0;
while ( node )
{
temp = node;
node = node->next;
delete temp;
}
}
void TiXmlNode::CopyTo( TiXmlNode* target ) const
{
target->SetValue (value.c_str() );
target->userData = userData;
target->location = location;
}
void TiXmlNode::Clear()
{
TiXmlNode* node = firstChild;
TiXmlNode* temp = 0;
while ( node )
{
temp = node;
node = node->next;
delete temp;
}
firstChild = 0;
lastChild = 0;
}
TiXmlNode* TiXmlNode::LinkEndChild( TiXmlNode* node )
{
assert( node->parent == 0 || node->parent == this );
assert( node->GetDocument() == 0 || node->GetDocument() == this->GetDocument() );
if ( node->Type() == TiXmlNode::TINYXML_DOCUMENT )
{
delete node;
if ( GetDocument() )
GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN );
return 0;
}
node->parent = this;
node->prev = lastChild;
node->next = 0;
if ( lastChild )
lastChild->next = node;
else
firstChild = node; // it was an empty list.
lastChild = node;
return node;
}
TiXmlNode* TiXmlNode::InsertEndChild( const TiXmlNode& addThis )
{
if ( addThis.Type() == TiXmlNode::TINYXML_DOCUMENT )
{
if ( GetDocument() )
GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN );
return 0;
}
TiXmlNode* node = addThis.Clone();
if ( !node )
return 0;
return LinkEndChild( node );
}
TiXmlNode* TiXmlNode::InsertBeforeChild( TiXmlNode* beforeThis, const TiXmlNode& addThis )
{
if ( !beforeThis || beforeThis->parent != this ) {
return 0;
}
if ( addThis.Type() == TiXmlNode::TINYXML_DOCUMENT )
{
if ( GetDocument() )
GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN );
return 0;
}
TiXmlNode* node = addThis.Clone();
if ( !node )
return 0;
node->parent = this;
node->next = beforeThis;
node->prev = beforeThis->prev;
if ( beforeThis->prev )
{
beforeThis->prev->next = node;
}
else
{
assert( firstChild == beforeThis );
firstChild = node;
}
beforeThis->prev = node;
return node;
}
TiXmlNode* TiXmlNode::InsertAfterChild( TiXmlNode* afterThis, const TiXmlNode& addThis )
{
if ( !afterThis || afterThis->parent != this ) {
return 0;
}
if ( addThis.Type() == TiXmlNode::TINYXML_DOCUMENT )
{
if ( GetDocument() )
GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN );
return 0;
}
TiXmlNode* node = addThis.Clone();
if ( !node )
return 0;
node->parent = this;
node->prev = afterThis;
node->next = afterThis->next;
if ( afterThis->next )
{
afterThis->next->prev = node;
}
else
{
assert( lastChild == afterThis );
lastChild = node;
}
afterThis->next = node;
return node;
}
TiXmlNode* TiXmlNode::ReplaceChild( TiXmlNode* replaceThis, const TiXmlNode& withThis )
{
if ( !replaceThis )
return 0;
if ( replaceThis->parent != this )
return 0;
if ( withThis.ToDocument() ) {
// A document can never be a child. Thanks to Noam.
TiXmlDocument* document = GetDocument();
if ( document )
document->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN );
return 0;
}
TiXmlNode* node = withThis.Clone();
if ( !node )
return 0;
node->next = replaceThis->next;
node->prev = replaceThis->prev;
if ( replaceThis->next )
replaceThis->next->prev = node;
else
lastChild = node;
if ( replaceThis->prev )
replaceThis->prev->next = node;
else
firstChild = node;
delete replaceThis;
node->parent = this;
return node;
}
bool TiXmlNode::RemoveChild( TiXmlNode* removeThis )
{
if ( !removeThis ) {
return false;
}
if ( removeThis->parent != this )
{
assert( 0 );
return false;
}
if ( removeThis->next )
removeThis->next->prev = removeThis->prev;
else
lastChild = removeThis->prev;
if ( removeThis->prev )
removeThis->prev->next = removeThis->next;
else
firstChild = removeThis->next;
delete removeThis;
return true;
}
const TiXmlNode* TiXmlNode::FirstChild( const char * _value ) const
{
const TiXmlNode* node;
for ( node = firstChild; node; node = node->next )
{
if ( strcmp( node->Value(), _value ) == 0 )
return node;
}
return 0;
}
const TiXmlNode* TiXmlNode::LastChild( const char * _value ) const
{
const TiXmlNode* node;
for ( node = lastChild; node; node = node->prev )
{
if ( strcmp( node->Value(), _value ) == 0 )
return node;
}
return 0;
}
const TiXmlNode* TiXmlNode::IterateChildren( const TiXmlNode* previous ) const
{
if ( !previous )
{
return FirstChild();
}
else
{
assert( previous->parent == this );
return previous->NextSibling();
}
}
const TiXmlNode* TiXmlNode::IterateChildren( const char * val, const TiXmlNode* previous ) const
{
if ( !previous )
{
return FirstChild( val );
}
else
{
assert( previous->parent == this );
return previous->NextSibling( val );
}
}
const TiXmlNode* TiXmlNode::NextSibling( const char * _value ) const
{
const TiXmlNode* node;
for ( node = next; node; node = node->next )
{
if ( strcmp( node->Value(), _value ) == 0 )
return node;
}
return 0;
}
const TiXmlNode* TiXmlNode::PreviousSibling( const char * _value ) const
{
const TiXmlNode* node;
for ( node = prev; node; node = node->prev )
{
if ( strcmp( node->Value(), _value ) == 0 )
return node;
}
return 0;
}
void TiXmlElement::RemoveAttribute( const char * name )
{
#ifdef TIXML_USE_STL
TIXML_STRING str( name );
TiXmlAttribute* node = attributeSet.Find( str );
#else
TiXmlAttribute* node = attributeSet.Find( name );
#endif
if ( node )
{
attributeSet.Remove( node );
delete node;
}
}
const TiXmlElement* TiXmlNode::FirstChildElement() const
{
const TiXmlNode* node;
for ( node = FirstChild();
node;
node = node->NextSibling() )
{
if ( node->ToElement() )
return node->ToElement();
}
return 0;
}
const TiXmlElement* TiXmlNode::FirstChildElement( const char * _value ) const
{
const TiXmlNode* node;
for ( node = FirstChild( _value );
node;
node = node->NextSibling( _value ) )
{
if ( node->ToElement() )
return node->ToElement();
}
return 0;
}
const TiXmlElement* TiXmlNode::NextSiblingElement() const
{
const TiXmlNode* node;
for ( node = NextSibling();
node;
node = node->NextSibling() )
{
if ( node->ToElement() )
return node->ToElement();
}
return 0;
}
const TiXmlElement* TiXmlNode::NextSiblingElement( const char * _value ) const
{
const TiXmlNode* node;
for ( node = NextSibling( _value );
node;
node = node->NextSibling( _value ) )
{
if ( node->ToElement() )
return node->ToElement();
}
return 0;
}
const TiXmlDocument* TiXmlNode::GetDocument() const
{
const TiXmlNode* node;
for( node = this; node; node = node->parent )
{
if ( node->ToDocument() )
return node->ToDocument();
}
return 0;
}
TiXmlElement::TiXmlElement (const char * _value)
: TiXmlNode( TiXmlNode::TINYXML_ELEMENT )
{
firstChild = lastChild = 0;
value = _value;
}
#ifdef TIXML_USE_STL
TiXmlElement::TiXmlElement( const std::string& _value )
: TiXmlNode( TiXmlNode::TINYXML_ELEMENT )
{
firstChild = lastChild = 0;
value = _value;
}
#endif
TiXmlElement::TiXmlElement( const TiXmlElement& copy)
: TiXmlNode( TiXmlNode::TINYXML_ELEMENT )
{
firstChild = lastChild = 0;
copy.CopyTo( this );
}
TiXmlElement& TiXmlElement::operator=( const TiXmlElement& base )
{
ClearThis();
base.CopyTo( this );
return *this;
}
TiXmlElement::~TiXmlElement()
{
ClearThis();
}
void TiXmlElement::ClearThis()
{
Clear();
while( attributeSet.First() )
{
TiXmlAttribute* node = attributeSet.First();
attributeSet.Remove( node );
delete node;
}
}
const char* TiXmlElement::Attribute( const char* name ) const
{
const TiXmlAttribute* node = attributeSet.Find( name );
if ( node )
return node->Value();
return 0;
}
#ifdef TIXML_USE_STL
const std::string* TiXmlElement::Attribute( const std::string& name ) const
{
const TiXmlAttribute* attrib = attributeSet.Find( name );
if ( attrib )
return &attrib->ValueStr();
return 0;
}
#endif
const char* TiXmlElement::Attribute( const char* name, int* i ) const
{
const TiXmlAttribute* attrib = attributeSet.Find( name );
const char* result = 0;
if ( attrib ) {
result = attrib->Value();
if ( i ) {
attrib->QueryIntValue( i );
}
}
return result;
}
#ifdef TIXML_USE_STL
const std::string* TiXmlElement::Attribute( const std::string& name, int* i ) const
{
const TiXmlAttribute* attrib = attributeSet.Find( name );
const std::string* result = 0;
if ( attrib ) {
result = &attrib->ValueStr();
if ( i ) {
attrib->QueryIntValue( i );
}
}
return result;
}
#endif
const char* TiXmlElement::Attribute( const char* name, double* d ) const
{
const TiXmlAttribute* attrib = attributeSet.Find( name );
const char* result = 0;
if ( attrib ) {
result = attrib->Value();
if ( d ) {
attrib->QueryDoubleValue( d );
}
}
return result;
}
#ifdef TIXML_USE_STL
const std::string* TiXmlElement::Attribute( const std::string& name, double* d ) const
{
const TiXmlAttribute* attrib = attributeSet.Find( name );
const std::string* result = 0;
if ( attrib ) {
result = &attrib->ValueStr();
if ( d ) {
attrib->QueryDoubleValue( d );
}
}
return result;
}
#endif
int TiXmlElement::QueryIntAttribute( const char* name, int* ival ) const
{
const TiXmlAttribute* attrib = attributeSet.Find( name );
if ( !attrib )
return TIXML_NO_ATTRIBUTE;
return attrib->QueryIntValue( ival );
}
int TiXmlElement::QueryUnsignedAttribute( const char* name, unsigned* value ) const
{
const TiXmlAttribute* node = attributeSet.Find( name );
if ( !node )
return TIXML_NO_ATTRIBUTE;
int ival = 0;
int result = node->QueryIntValue( &ival );
*value = (unsigned)ival;
return result;
}
int TiXmlElement::QueryBoolAttribute( const char* name, bool* bval ) const
{
const TiXmlAttribute* node = attributeSet.Find( name );
if ( !node )
return TIXML_NO_ATTRIBUTE;
int result = TIXML_WRONG_TYPE;
if ( StringEqual( node->Value(), "true", true, TIXML_ENCODING_UNKNOWN )
|| StringEqual( node->Value(), "yes", true, TIXML_ENCODING_UNKNOWN )
|| StringEqual( node->Value(), "1", true, TIXML_ENCODING_UNKNOWN ) )
{
*bval = true;
result = TIXML_SUCCESS;
}
else if ( StringEqual( node->Value(), "false", true, TIXML_ENCODING_UNKNOWN )
|| StringEqual( node->Value(), "no", true, TIXML_ENCODING_UNKNOWN )
|| StringEqual( node->Value(), "0", true, TIXML_ENCODING_UNKNOWN ) )
{
*bval = false;
result = TIXML_SUCCESS;
}
return result;
}
#ifdef TIXML_USE_STL
int TiXmlElement::QueryIntAttribute( const std::string& name, int* ival ) const
{
const TiXmlAttribute* attrib = attributeSet.Find( name );
if ( !attrib )
return TIXML_NO_ATTRIBUTE;
return attrib->QueryIntValue( ival );
}
#endif
int TiXmlElement::QueryDoubleAttribute( const char* name, double* dval ) const
{
const TiXmlAttribute* attrib = attributeSet.Find( name );
if ( !attrib )
return TIXML_NO_ATTRIBUTE;
return attrib->QueryDoubleValue( dval );
}
#ifdef TIXML_USE_STL
int TiXmlElement::QueryDoubleAttribute( const std::string& name, double* dval ) const
{
const TiXmlAttribute* attrib = attributeSet.Find( name );
if ( !attrib )
return TIXML_NO_ATTRIBUTE;
return attrib->QueryDoubleValue( dval );
}
#endif
void TiXmlElement::SetAttribute( const char * name, int val )
{
TiXmlAttribute* attrib = attributeSet.FindOrCreate( name );
if ( attrib ) {
attrib->SetIntValue( val );
}
}
#ifdef TIXML_USE_STL
void TiXmlElement::SetAttribute( const std::string& name, int val )
{
TiXmlAttribute* attrib = attributeSet.FindOrCreate( name );
if ( attrib ) {
attrib->SetIntValue( val );
}
}
#endif
void TiXmlElement::SetDoubleAttribute( const char * name, double val )
{
TiXmlAttribute* attrib = attributeSet.FindOrCreate( name );
if ( attrib ) {
attrib->SetDoubleValue( val );
}
}
#ifdef TIXML_USE_STL
void TiXmlElement::SetDoubleAttribute( const std::string& name, double val )
{
TiXmlAttribute* attrib = attributeSet.FindOrCreate( name );
if ( attrib ) {
attrib->SetDoubleValue( val );
}
}
#endif
void TiXmlElement::SetAttribute( const char * cname, const char * cvalue )
{
TiXmlAttribute* attrib = attributeSet.FindOrCreate( cname );
if ( attrib ) {
attrib->SetValue( cvalue );
}
}
#ifdef TIXML_USE_STL
void TiXmlElement::SetAttribute( const std::string& _name, const std::string& _value )
{
TiXmlAttribute* attrib = attributeSet.FindOrCreate( _name );
if ( attrib ) {
attrib->SetValue( _value );
}
}
#endif
void TiXmlElement::Print( FILE* cfile, int depth ) const
{
int i;
assert( cfile );
for ( i=0; i<depth; i++ ) {
fprintf( cfile, " " );
}
fprintf( cfile, "<%s", value.c_str() );
const TiXmlAttribute* attrib;
for ( attrib = attributeSet.First(); attrib; attrib = attrib->Next() )
{
fprintf( cfile, " " );
attrib->Print( cfile, depth );
}
// There are 3 different formatting approaches:
// 1) An element without children is printed as a <foo /> node
// 2) An element with only a text child is printed as <foo> text </foo>
// 3) An element with children is printed on multiple lines.
TiXmlNode* node;
if ( !firstChild )
{
fprintf( cfile, " />" );
}
else if ( firstChild == lastChild && firstChild->ToText() )
{
fprintf( cfile, ">" );
firstChild->Print( cfile, depth + 1 );
fprintf( cfile, "</%s>", value.c_str() );
}
else
{
fprintf( cfile, ">" );
for ( node = firstChild; node; node=node->NextSibling() )
{
if ( !node->ToText() )
{
fprintf( cfile, "\n" );
}
node->Print( cfile, depth+1 );
}
fprintf( cfile, "\n" );
for( i=0; i<depth; ++i ) {
fprintf( cfile, " " );
}
fprintf( cfile, "</%s>", value.c_str() );
}
}
void TiXmlElement::CopyTo( TiXmlElement* target ) const
{
// superclass:
TiXmlNode::CopyTo( target );
// Element class:
// Clone the attributes, then clone the children.
const TiXmlAttribute* attribute = 0;
for( attribute = attributeSet.First();
attribute;
attribute = attribute->Next() )
{
target->SetAttribute( attribute->Name(), attribute->Value() );
}
TiXmlNode* node = 0;
for ( node = firstChild; node; node = node->NextSibling() )
{
target->LinkEndChild( node->Clone() );
}
}
bool TiXmlElement::Accept( TiXmlVisitor* visitor ) const
{
if ( visitor->VisitEnter( *this, attributeSet.First() ) )
{
for ( const TiXmlNode* node=FirstChild(); node; node=node->NextSibling() )
{
if ( !node->Accept( visitor ) )
break;
}
}
return visitor->VisitExit( *this );
}
TiXmlNode* TiXmlElement::Clone() const
{
TiXmlElement* clone = new TiXmlElement( Value() );
if ( !clone )
return 0;
CopyTo( clone );
return clone;
}
const char* TiXmlElement::GetText() const
{
const TiXmlNode* child = this->FirstChild();
if ( child ) {
const TiXmlText* childText = child->ToText();
if ( childText ) {
return childText->Value();
}
}
return 0;
}
TiXmlDocument::TiXmlDocument() : TiXmlNode( TiXmlNode::TINYXML_DOCUMENT )
{
tabsize = 4;
useMicrosoftBOM = false;
ClearError();
}
TiXmlDocument::TiXmlDocument( const char * documentName ) : TiXmlNode( TiXmlNode::TINYXML_DOCUMENT )
{
tabsize = 4;
useMicrosoftBOM = false;
value = documentName;
ClearError();
}
#ifdef TIXML_USE_STL
TiXmlDocument::TiXmlDocument( const std::string& documentName ) : TiXmlNode( TiXmlNode::TINYXML_DOCUMENT )
{
tabsize = 4;
useMicrosoftBOM = false;
value = documentName;
ClearError();
}
#endif
TiXmlDocument::TiXmlDocument( const TiXmlDocument& copy ) : TiXmlNode( TiXmlNode::TINYXML_DOCUMENT )
{
copy.CopyTo( this );
}
TiXmlDocument& TiXmlDocument::operator=( const TiXmlDocument& copy )
{
Clear();
copy.CopyTo( this );
return *this;
}
bool TiXmlDocument::LoadFile( TiXmlEncoding encoding )
{
return LoadFile( Value(), encoding );
}
bool TiXmlDocument::SaveFile() const
{
return SaveFile( Value() );
}
bool TiXmlDocument::LoadFile( const char* _filename, TiXmlEncoding encoding )
{
TIXML_STRING filename( _filename );
value = filename;
// reading in binary mode so that tinyxml can normalize the EOL
FILE* file = TiXmlFOpen( value.c_str (), "rb" );
if ( file )
{
bool result = LoadFile( file, encoding );
fclose( file );
return result;
}
else
{
SetError( TIXML_ERROR_OPENING_FILE, 0, 0, TIXML_ENCODING_UNKNOWN );
return false;
}
}
bool TiXmlDocument::LoadFile( FILE* file, TiXmlEncoding encoding )
{
TiXmlCustomFileStream stream;
stream.fileHandle = file;
stream.seek = &stdio_seek;
stream.tell = &stdio_tell;
stream.read = &stdio_read;
return LoadFile(stream, encoding);
}
bool TiXmlDocument::LoadFile( TiXmlCustomFileStream& fileStream, TiXmlEncoding encoding )
{
if ( !fileStream.fileHandle )
{
SetError( TIXML_ERROR_OPENING_FILE, 0, 0, TIXML_ENCODING_UNKNOWN );
return false;
}
// Delete the existing data:
Clear();
location.Clear();
// Get the file size, so we can pre-allocate the string. HUGE speed impact.
long length = 0;
fileStream.seek( fileStream.fileHandle, 0, SEEK_END );
length = fileStream.tell( fileStream.fileHandle );
fileStream.seek( fileStream.fileHandle, 0, SEEK_SET );
// Strange case, but good to handle up front.
if ( length <= 0 )
{
SetError( TIXML_ERROR_DOCUMENT_EMPTY, 0, 0, TIXML_ENCODING_UNKNOWN );
return false;
}
// Subtle bug here. TinyXml did use fgets. But from the XML spec:
// 2.11 End-of-Line Handling
// <snip>
// <quote>
// ...the XML processor MUST behave as if it normalized all line breaks in external
// parsed entities (including the document entity) on input, before parsing, by translating
// both the two-character sequence #xD #xA and any #xD that is not followed by #xA to
// a single #xA character.
// </quote>
//
// It is not clear fgets does that, and certainly isn't clear it works cross platform.
// Generally, you expect fgets to translate from the convention of the OS to the c/unix
// convention, and not work generally.
/*
while( fgets( buf, sizeof(buf), file ) )
{
data += buf;
}
*/
char* buf = new char[ length+1 ];
buf[0] = 0;
if ( fileStream.read( buf, length, 1, fileStream.fileHandle ) != 1 ) {
delete [] buf;
SetError( TIXML_ERROR_OPENING_FILE, 0, 0, TIXML_ENCODING_UNKNOWN );
return false;
}
// Process the buffer in place to normalize new lines. (See comment above.)
// Copies from the 'p' to 'q' pointer, where p can advance faster if
// a newline-carriage return is hit.
//
// Wikipedia:
// Systems based on ASCII or a compatible character set use either LF (Line feed, '\n', 0x0A, 10 in decimal) or
// CR (Carriage return, '\r', 0x0D, 13 in decimal) individually, or CR followed by LF (CR+LF, 0x0D 0x0A)...
// * LF: Multics, Unix and Unix-like systems (GNU/Linux, AIX, Xenix, Mac OS X, FreeBSD, etc.), BeOS, Amiga, RISC OS, and others
// * CR+LF: DEC RT-11 and most other early non-Unix, non-IBM OSes, CP/M, MP/M, DOS, OS/2, Microsoft Windows, Symbian OS
// * CR: Commodore 8-bit machines, Apple II family, Mac OS up to version 9 and OS-9
const char* p = buf; // the read head
char* q = buf; // the write head
const char CR = 0x0d;
const char LF = 0x0a;
buf[length] = 0;
while( *p ) {
assert( p < (buf+length) );
assert( q <= (buf+length) );
assert( q <= p );
if ( *p == CR ) {
*q++ = LF;
p++;
if ( *p == LF ) { // check for CR+LF (and skip LF)
p++;
}
}
else {
*q++ = *p++;
}
}
assert( q <= (buf+length) );
*q = 0;
Parse( buf, 0, encoding );
delete [] buf;
return !Error();
}
bool TiXmlDocument::SaveFile( const char * filename ) const
{
// The old c stuff lives on...
FILE* fp = TiXmlFOpen( filename, "w" );
if ( fp )
{
bool result = SaveFile( fp );
fclose( fp );
return result;
}
return false;
}
bool TiXmlDocument::SaveFile( FILE* fp ) const
{
if ( useMicrosoftBOM )
{
const unsigned char TIXML_UTF_LEAD_0 = 0xefU;
const unsigned char TIXML_UTF_LEAD_1 = 0xbbU;
const unsigned char TIXML_UTF_LEAD_2 = 0xbfU;
fputc( TIXML_UTF_LEAD_0, fp );
fputc( TIXML_UTF_LEAD_1, fp );
fputc( TIXML_UTF_LEAD_2, fp );
}
Print( fp, 0 );
return (ferror(fp) == 0);
}
void TiXmlDocument::CopyTo( TiXmlDocument* target ) const
{
TiXmlNode::CopyTo( target );
target->error = error;
target->errorId = errorId;
target->errorDesc = errorDesc;
target->tabsize = tabsize;
target->errorLocation = errorLocation;
target->useMicrosoftBOM = useMicrosoftBOM;
TiXmlNode* node = 0;
for ( node = firstChild; node; node = node->NextSibling() )
{
target->LinkEndChild( node->Clone() );
}
}
TiXmlNode* TiXmlDocument::Clone() const
{
TiXmlDocument* clone = new TiXmlDocument();
if ( !clone )
return 0;
CopyTo( clone );
return clone;
}
void TiXmlDocument::Print( FILE* cfile, int depth ) const
{
assert( cfile );
for ( const TiXmlNode* node=FirstChild(); node; node=node->NextSibling() )
{
node->Print( cfile, depth );
fprintf( cfile, "\n" );
}
}
bool TiXmlDocument::Accept( TiXmlVisitor* visitor ) const
{
if ( visitor->VisitEnter( *this ) )
{
for ( const TiXmlNode* node=FirstChild(); node; node=node->NextSibling() )
{
if ( !node->Accept( visitor ) )
break;
}
}
return visitor->VisitExit( *this );
}
const TiXmlAttribute* TiXmlAttribute::Next() const
{
// We are using knowledge of the sentinel. The sentinel
// have a value or name.
if ( next->value.empty() && next->name.empty() )
return 0;
return next;
}
/*
TiXmlAttribute* TiXmlAttribute::Next()
{
// We are using knowledge of the sentinel. The sentinel
// have a value or name.
if ( next->value.empty() && next->name.empty() )
return 0;
return next;
}
*/
const TiXmlAttribute* TiXmlAttribute::Previous() const
{
// We are using knowledge of the sentinel. The sentinel
// have a value or name.
if ( prev->value.empty() && prev->name.empty() )
return 0;
return prev;
}
/*
TiXmlAttribute* TiXmlAttribute::Previous()
{
// We are using knowledge of the sentinel. The sentinel
// have a value or name.
if ( prev->value.empty() && prev->name.empty() )
return 0;
return prev;
}
*/
void TiXmlAttribute::Print( FILE* cfile, int /*depth*/, TIXML_STRING* str ) const
{
TIXML_STRING n, v;
EncodeString( name, &n );
EncodeString( value, &v );
if (value.find ('\"') == TIXML_STRING::npos) {
if ( cfile ) {
fprintf (cfile, "%s=\"%s\"", n.c_str(), v.c_str() );
}
if ( str ) {
(*str) += n; (*str) += "=\""; (*str) += v; (*str) += "\"";
}
}
else {
if ( cfile ) {
fprintf (cfile, "%s='%s'", n.c_str(), v.c_str() );
}
if ( str ) {
(*str) += n; (*str) += "='"; (*str) += v; (*str) += "'";
}
}
}
int TiXmlAttribute::QueryIntValue( int* ival ) const
{
if ( TIXML_SSCANF( value.c_str(), "%d", ival ) == 1 )
return TIXML_SUCCESS;
return TIXML_WRONG_TYPE;
}
int TiXmlAttribute::QueryDoubleValue( double* dval ) const
{
if ( TIXML_SSCANF( value.c_str(), "%lf", dval ) == 1 )
return TIXML_SUCCESS;
return TIXML_WRONG_TYPE;
}
void TiXmlAttribute::SetIntValue( int _value )
{
char buf [64];
#if defined(TIXML_SNPRINTF)
TIXML_SNPRINTF(buf, sizeof(buf), "%d", _value);
#else
sprintf (buf, "%d", _value);
#endif
SetValue (buf);
}
void TiXmlAttribute::SetDoubleValue( double _value )
{
char buf [256];
#if defined(TIXML_SNPRINTF)
TIXML_SNPRINTF( buf, sizeof(buf), "%g", _value);
#else
sprintf (buf, "%g", _value);
#endif
SetValue (buf);
}
int TiXmlAttribute::IntValue() const
{
return atoi (value.c_str ());
}
double TiXmlAttribute::DoubleValue() const
{
return atof (value.c_str ());
}
TiXmlComment::TiXmlComment( const TiXmlComment& copy ) : TiXmlNode( TiXmlNode::TINYXML_COMMENT )
{
copy.CopyTo( this );
}
TiXmlComment& TiXmlComment::operator=( const TiXmlComment& base )
{
Clear();
base.CopyTo( this );
return *this;
}
void TiXmlComment::Print( FILE* cfile, int depth ) const
{
assert( cfile );
for ( int i=0; i<depth; i++ )
{
fprintf( cfile, " " );
}
fprintf( cfile, "<!--%s-->", value.c_str() );
}
void TiXmlComment::CopyTo( TiXmlComment* target ) const
{
TiXmlNode::CopyTo( target );
}
bool TiXmlComment::Accept( TiXmlVisitor* visitor ) const
{
return visitor->Visit( *this );
}
TiXmlNode* TiXmlComment::Clone() const
{
TiXmlComment* clone = new TiXmlComment();
if ( !clone )
return 0;
CopyTo( clone );
return clone;
}
void TiXmlText::Print( FILE* cfile, int depth ) const
{
assert( cfile );
if ( cdata )
{
int i;
fprintf( cfile, "\n" );
for ( i=0; i<depth; i++ ) {
fprintf( cfile, " " );
}
fprintf( cfile, "<![CDATA[%s]]>\n", value.c_str() ); // unformatted output
}
else
{
TIXML_STRING buffer;
EncodeString( value, &buffer );
fprintf( cfile, "%s", buffer.c_str() );
}
}
void TiXmlText::CopyTo( TiXmlText* target ) const
{
TiXmlNode::CopyTo( target );
target->cdata = cdata;
}
bool TiXmlText::Accept( TiXmlVisitor* visitor ) const
{
return visitor->Visit( *this );
}
TiXmlNode* TiXmlText::Clone() const
{
TiXmlText* clone = 0;
clone = new TiXmlText( "" );
if ( !clone )
return 0;
CopyTo( clone );
return clone;
}
TiXmlDeclaration::TiXmlDeclaration( const char * _version,
const char * _encoding,
const char * _standalone )
: TiXmlNode( TiXmlNode::TINYXML_DECLARATION )
{
version = _version;
encoding = _encoding;
standalone = _standalone;
}
#ifdef TIXML_USE_STL
TiXmlDeclaration::TiXmlDeclaration( const std::string& _version,
const std::string& _encoding,
const std::string& _standalone )
: TiXmlNode( TiXmlNode::TINYXML_DECLARATION )
{
version = _version;
encoding = _encoding;
standalone = _standalone;
}
#endif
TiXmlDeclaration::TiXmlDeclaration( const TiXmlDeclaration& copy )
: TiXmlNode( TiXmlNode::TINYXML_DECLARATION )
{
copy.CopyTo( this );
}
TiXmlDeclaration& TiXmlDeclaration::operator=( const TiXmlDeclaration& copy )
{
Clear();
copy.CopyTo( this );
return *this;
}
void TiXmlDeclaration::Print( FILE* cfile, int /*depth*/, TIXML_STRING* str ) const
{
if ( cfile ) fprintf( cfile, "<?xml " );
if ( str ) (*str) += "<?xml ";
if ( !version.empty() ) {
if ( cfile ) fprintf (cfile, "version=\"%s\" ", version.c_str ());
if ( str ) { (*str) += "version=\""; (*str) += version; (*str) += "\" "; }
}
if ( !encoding.empty() ) {
if ( cfile ) fprintf (cfile, "encoding=\"%s\" ", encoding.c_str ());
if ( str ) { (*str) += "encoding=\""; (*str) += encoding; (*str) += "\" "; }
}
if ( !standalone.empty() ) {
if ( cfile ) fprintf (cfile, "standalone=\"%s\" ", standalone.c_str ());
if ( str ) { (*str) += "standalone=\""; (*str) += standalone; (*str) += "\" "; }
}
if ( cfile ) fprintf( cfile, "?>" );
if ( str ) (*str) += "?>";
}
void TiXmlDeclaration::CopyTo( TiXmlDeclaration* target ) const
{
TiXmlNode::CopyTo( target );
target->version = version;
target->encoding = encoding;
target->standalone = standalone;
}
bool TiXmlDeclaration::Accept( TiXmlVisitor* visitor ) const
{
return visitor->Visit( *this );
}
TiXmlNode* TiXmlDeclaration::Clone() const
{
TiXmlDeclaration* clone = new TiXmlDeclaration();
if ( !clone )
return 0;
CopyTo( clone );
return clone;
}
void TiXmlUnknown::Print( FILE* cfile, int depth ) const
{
for ( int i=0; i<depth; i++ )
fprintf( cfile, " " );
fprintf( cfile, "<%s>", value.c_str() );
}
void TiXmlUnknown::CopyTo( TiXmlUnknown* target ) const
{
TiXmlNode::CopyTo( target );
}
bool TiXmlUnknown::Accept( TiXmlVisitor* visitor ) const
{
return visitor->Visit( *this );
}
TiXmlNode* TiXmlUnknown::Clone() const
{
TiXmlUnknown* clone = new TiXmlUnknown();
if ( !clone )
return 0;
CopyTo( clone );
return clone;
}
TiXmlAttributeSet::TiXmlAttributeSet()
{
sentinel.next = &sentinel;
sentinel.prev = &sentinel;
}
TiXmlAttributeSet::~TiXmlAttributeSet()
{
assert( sentinel.next == &sentinel );
assert( sentinel.prev == &sentinel );
}
void TiXmlAttributeSet::Add( TiXmlAttribute* addMe )
{
#ifdef TIXML_USE_STL
assert( !Find( TIXML_STRING( addMe->Name() ) ) ); // Shouldn't be multiply adding to the set.
#else
assert( !Find( addMe->Name() ) ); // Shouldn't be multiply adding to the set.
#endif
addMe->next = &sentinel;
addMe->prev = sentinel.prev;
sentinel.prev->next = addMe;
sentinel.prev = addMe;
}
void TiXmlAttributeSet::Remove( TiXmlAttribute* removeMe )
{
TiXmlAttribute* node;
for( node = sentinel.next; node != &sentinel; node = node->next )
{
if ( node == removeMe )
{
node->prev->next = node->next;
node->next->prev = node->prev;
node->next = 0;
node->prev = 0;
return;
}
}
assert( 0 ); // we tried to remove a non-linked attribute.
}
#ifdef TIXML_USE_STL
TiXmlAttribute* TiXmlAttributeSet::Find( const std::string& name ) const
{
for( TiXmlAttribute* node = sentinel.next; node != &sentinel; node = node->next )
{
if ( node->name == name )
return node;
}
return 0;
}
TiXmlAttribute* TiXmlAttributeSet::FindOrCreate( const std::string& _name )
{
TiXmlAttribute* attrib = Find( _name );
if ( !attrib ) {
attrib = new TiXmlAttribute();
Add( attrib );
attrib->SetName( _name );
}
return attrib;
}
#endif
TiXmlAttribute* TiXmlAttributeSet::Find( const char* name ) const
{
for( TiXmlAttribute* node = sentinel.next; node != &sentinel; node = node->next )
{
if ( strcmp( node->name.c_str(), name ) == 0 )
return node;
}
return 0;
}
TiXmlAttribute* TiXmlAttributeSet::FindOrCreate( const char* _name )
{
TiXmlAttribute* attrib = Find( _name );
if ( !attrib ) {
attrib = new TiXmlAttribute();
Add( attrib );
attrib->SetName( _name );
}
return attrib;
}
#ifdef TIXML_USE_STL
std::istream& operator>> (std::istream & in, TiXmlNode & base)
{
TIXML_STRING tag;
tag.reserve( 8 * 1000 );
base.StreamIn( &in, &tag );
base.Parse( tag.c_str(), 0, TIXML_DEFAULT_ENCODING );
return in;
}
#endif
#ifdef TIXML_USE_STL
std::ostream& operator<< (std::ostream & out, const TiXmlNode & base)
{
TiXmlPrinter printer;
printer.SetStreamPrinting();
base.Accept( &printer );
out << printer.Str();
return out;
}
std::string& operator<< (std::string& out, const TiXmlNode& base )
{
TiXmlPrinter printer;
printer.SetStreamPrinting();
base.Accept( &printer );
out.append( printer.Str() );
return out;
}
#endif
TiXmlHandle TiXmlHandle::FirstChild() const
{
if ( node )
{
TiXmlNode* child = node->FirstChild();
if ( child )
return TiXmlHandle( child );
}
return TiXmlHandle( 0 );
}
TiXmlHandle TiXmlHandle::FirstChild( const char * value ) const
{
if ( node )
{
TiXmlNode* child = node->FirstChild( value );
if ( child )
return TiXmlHandle( child );
}
return TiXmlHandle( 0 );
}
TiXmlHandle TiXmlHandle::FirstChildElement() const
{
if ( node )
{
TiXmlElement* child = node->FirstChildElement();
if ( child )
return TiXmlHandle( child );
}
return TiXmlHandle( 0 );
}
TiXmlHandle TiXmlHandle::FirstChildElement( const char * value ) const
{
if ( node )
{
TiXmlElement* child = node->FirstChildElement( value );
if ( child )
return TiXmlHandle( child );
}
return TiXmlHandle( 0 );
}
TiXmlHandle TiXmlHandle::Child( int count ) const
{
if ( node )
{
int i;
TiXmlNode* child = node->FirstChild();
for ( i=0;
child && i<count;
child = child->NextSibling(), ++i )
{
// nothing
}
if ( child )
return TiXmlHandle( child );
}
return TiXmlHandle( 0 );
}
TiXmlHandle TiXmlHandle::Child( const char* value, int count ) const
{
if ( node )
{
int i;
TiXmlNode* child = node->FirstChild( value );
for ( i=0;
child && i<count;
child = child->NextSibling( value ), ++i )
{
// nothing
}
if ( child )
return TiXmlHandle( child );
}
return TiXmlHandle( 0 );
}
TiXmlHandle TiXmlHandle::ChildElement( int count ) const
{
if ( node )
{
int i;
TiXmlElement* child = node->FirstChildElement();
for ( i=0;
child && i<count;
child = child->NextSiblingElement(), ++i )
{
// nothing
}
if ( child )
return TiXmlHandle( child );
}
return TiXmlHandle( 0 );
}
TiXmlHandle TiXmlHandle::ChildElement( const char* value, int count ) const
{
if ( node )
{
int i;
TiXmlElement* child = node->FirstChildElement( value );
for ( i=0;
child && i<count;
child = child->NextSiblingElement( value ), ++i )
{
// nothing
}
if ( child )
return TiXmlHandle( child );
}
return TiXmlHandle( 0 );
}
bool TiXmlPrinter::VisitEnter( const TiXmlDocument& )
{
return true;
}
bool TiXmlPrinter::VisitExit( const TiXmlDocument& )
{
return true;
}
bool TiXmlPrinter::VisitEnter( const TiXmlElement& element, const TiXmlAttribute* firstAttribute )
{
DoIndent();
buffer += "<";
buffer += element.Value();
for( const TiXmlAttribute* attrib = firstAttribute; attrib; attrib = attrib->Next() )
{
buffer += " ";
attrib->Print( 0, 0, &buffer );
}
if ( !element.FirstChild() )
{
buffer += " />";
DoLineBreak();
}
else
{
buffer += ">";
if ( element.FirstChild()->ToText()
&& element.LastChild() == element.FirstChild()
&& element.FirstChild()->ToText()->CDATA() == false )
{
simpleTextPrint = true;
// no DoLineBreak()!
}
else
{
DoLineBreak();
}
}
++depth;
return true;
}
bool TiXmlPrinter::VisitExit( const TiXmlElement& element )
{
--depth;
if ( !element.FirstChild() )
{
// nothing.
}
else
{
if ( simpleTextPrint )
{
simpleTextPrint = false;
}
else
{
DoIndent();
}
buffer += "</";
buffer += element.Value();
buffer += ">";
DoLineBreak();
}
return true;
}
bool TiXmlPrinter::Visit( const TiXmlText& text )
{
if ( text.CDATA() )
{
DoIndent();
buffer += "<![CDATA[";
buffer += text.Value();
buffer += "]]>";
DoLineBreak();
}
else if ( simpleTextPrint )
{
TIXML_STRING str;
TiXmlBase::EncodeString( text.ValueTStr(), &str );
buffer += str;
}
else
{
DoIndent();
TIXML_STRING str;
TiXmlBase::EncodeString( text.ValueTStr(), &str );
buffer += str;
DoLineBreak();
}
return true;
}
bool TiXmlPrinter::Visit( const TiXmlDeclaration& declaration )
{
DoIndent();
declaration.Print( 0, 0, &buffer );
DoLineBreak();
return true;
}
bool TiXmlPrinter::Visit( const TiXmlComment& comment )
{
DoIndent();
buffer += "<!--";
buffer += comment.Value();
buffer += "-->";
DoLineBreak();
return true;
}
bool TiXmlPrinter::Visit( const TiXmlUnknown& unknown )
{
DoIndent();
buffer += "<";
buffer += unknown.Value();
buffer += ">";
DoLineBreak();
return true;
}
| [
"lehoangq@gmail.com"
] | lehoangq@gmail.com |
951ff7945f9b512ae6ffa2e0dc5f52e40dae1918 | 875b7e7fe1aac12b927c5f7177862d29d945ef25 | /extern/pybind/include/pybind11/numpy.h | 119e4fc50f6eca6c7ba1efd12be56da332b7d425 | [
"MIT",
"BSD-3-Clause"
] | permissive | horizon-research/SPlisHSPlasH_with_time | ea8bceb100a10596b45c6bec517a0f13bb644dc5 | 147ada04d35e354f9cb01675834c1bd80e1b1d23 | refs/heads/master | 2023-04-24T09:14:21.936180 | 2021-05-10T22:31:29 | 2021-05-10T22:31:29 | 366,188,051 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 71,005 | h | /*
pybind11/numpy.h: Basic NumPy support, vectorize() wrapper
Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
All rights reserved. Use of this source code is governed by a
BSD-style license that can be found in the LICENSE file.
*/
#pragma once
#include "pybind11.h"
#include "complex.h"
#include <numeric>
#include <algorithm>
#include <array>
#include <cstdint>
#include <cstdlib>
#include <cstring>
#include <sstream>
#include <string>
#include <functional>
#include <type_traits>
#include <utility>
#include <vector>
#include <typeindex>
#if defined(_MSC_VER)
# pragma warning(push)
# pragma warning(disable: 4127) // warning C4127: Conditional expression is constant
#endif
/* This will be true on all flat address space platforms and allows us to reduce the
whole npy_intp / ssize_t / Py_intptr_t business down to just ssize_t for all size
and dimension types (e.g. shape, strides, indexing), instead of inflicting this
upon the library user. */
static_assert(sizeof(::pybind11::ssize_t) == sizeof(Py_intptr_t), "ssize_t != Py_intptr_t");
static_assert(std::is_signed<Py_intptr_t>::value, "Py_intptr_t must be signed");
// We now can reinterpret_cast between py::ssize_t and Py_intptr_t (MSVC + PyPy cares)
PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
class array; // Forward declaration
PYBIND11_NAMESPACE_BEGIN(detail)
template <> struct handle_type_name<array> { static constexpr auto name = _("numpy.ndarray"); };
template <typename type, typename SFINAE = void> struct npy_format_descriptor;
struct PyArrayDescr_Proxy {
PyObject_HEAD
PyObject *typeobj;
char kind;
char type;
char byteorder;
char flags;
int type_num;
int elsize;
int alignment;
char *subarray;
PyObject *fields;
PyObject *names;
};
struct PyArray_Proxy {
PyObject_HEAD
char *data;
int nd;
ssize_t *dimensions;
ssize_t *strides;
PyObject *base;
PyObject *descr;
int flags;
};
struct PyVoidScalarObject_Proxy {
PyObject_VAR_HEAD
char *obval;
PyArrayDescr_Proxy *descr;
int flags;
PyObject *base;
};
struct numpy_type_info {
PyObject* dtype_ptr;
std::string format_str;
};
struct numpy_internals {
std::unordered_map<std::type_index, numpy_type_info> registered_dtypes;
numpy_type_info *get_type_info(const std::type_info& tinfo, bool throw_if_missing = true) {
auto it = registered_dtypes.find(std::type_index(tinfo));
if (it != registered_dtypes.end())
return &(it->second);
if (throw_if_missing)
pybind11_fail(std::string("NumPy type info missing for ") + tinfo.name());
return nullptr;
}
template<typename T> numpy_type_info *get_type_info(bool throw_if_missing = true) {
return get_type_info(typeid(typename std::remove_cv<T>::type), throw_if_missing);
}
};
inline PYBIND11_NOINLINE void load_numpy_internals(numpy_internals* &ptr) {
ptr = &get_or_create_shared_data<numpy_internals>("_numpy_internals");
}
inline numpy_internals& get_numpy_internals() {
static numpy_internals* ptr = nullptr;
if (!ptr)
load_numpy_internals(ptr);
return *ptr;
}
template <typename T> struct same_size {
template <typename U> using as = bool_constant<sizeof(T) == sizeof(U)>;
};
template <typename Concrete> constexpr int platform_lookup() { return -1; }
// Lookup a type according to its size, and return a value corresponding to the NumPy typenum.
template <typename Concrete, typename T, typename... Ts, typename... Ints>
constexpr int platform_lookup(int I, Ints... Is) {
return sizeof(Concrete) == sizeof(T) ? I : platform_lookup<Concrete, Ts...>(Is...);
}
struct npy_api {
enum constants {
NPY_ARRAY_C_CONTIGUOUS_ = 0x0001,
NPY_ARRAY_F_CONTIGUOUS_ = 0x0002,
NPY_ARRAY_OWNDATA_ = 0x0004,
NPY_ARRAY_FORCECAST_ = 0x0010,
NPY_ARRAY_ENSUREARRAY_ = 0x0040,
NPY_ARRAY_ALIGNED_ = 0x0100,
NPY_ARRAY_WRITEABLE_ = 0x0400,
NPY_BOOL_ = 0,
NPY_BYTE_, NPY_UBYTE_,
NPY_SHORT_, NPY_USHORT_,
NPY_INT_, NPY_UINT_,
NPY_LONG_, NPY_ULONG_,
NPY_LONGLONG_, NPY_ULONGLONG_,
NPY_FLOAT_, NPY_DOUBLE_, NPY_LONGDOUBLE_,
NPY_CFLOAT_, NPY_CDOUBLE_, NPY_CLONGDOUBLE_,
NPY_OBJECT_ = 17,
NPY_STRING_, NPY_UNICODE_, NPY_VOID_,
// Platform-dependent normalization
NPY_INT8_ = NPY_BYTE_,
NPY_UINT8_ = NPY_UBYTE_,
NPY_INT16_ = NPY_SHORT_,
NPY_UINT16_ = NPY_USHORT_,
// `npy_common.h` defines the integer aliases. In order, it checks:
// NPY_BITSOF_LONG, NPY_BITSOF_LONGLONG, NPY_BITSOF_INT, NPY_BITSOF_SHORT, NPY_BITSOF_CHAR
// and assigns the alias to the first matching size, so we should check in this order.
NPY_INT32_ = platform_lookup<std::int32_t, long, int, short>(
NPY_LONG_, NPY_INT_, NPY_SHORT_),
NPY_UINT32_ = platform_lookup<std::uint32_t, unsigned long, unsigned int, unsigned short>(
NPY_ULONG_, NPY_UINT_, NPY_USHORT_),
NPY_INT64_ = platform_lookup<std::int64_t, long, long long, int>(
NPY_LONG_, NPY_LONGLONG_, NPY_INT_),
NPY_UINT64_ = platform_lookup<std::uint64_t, unsigned long, unsigned long long, unsigned int>(
NPY_ULONG_, NPY_ULONGLONG_, NPY_UINT_),
};
typedef struct {
Py_intptr_t *ptr;
int len;
} PyArray_Dims;
static npy_api& get() {
static npy_api api = lookup();
return api;
}
bool PyArray_Check_(PyObject *obj) const {
return (bool) PyObject_TypeCheck(obj, PyArray_Type_);
}
bool PyArrayDescr_Check_(PyObject *obj) const {
return (bool) PyObject_TypeCheck(obj, PyArrayDescr_Type_);
}
unsigned int (*PyArray_GetNDArrayCFeatureVersion_)();
PyObject *(*PyArray_DescrFromType_)(int);
PyObject *(*PyArray_NewFromDescr_)
(PyTypeObject *, PyObject *, int, Py_intptr_t const *,
Py_intptr_t const *, void *, int, PyObject *);
// Unused. Not removed because that affects ABI of the class.
PyObject *(*PyArray_DescrNewFromType_)(int);
int (*PyArray_CopyInto_)(PyObject *, PyObject *);
PyObject *(*PyArray_NewCopy_)(PyObject *, int);
PyTypeObject *PyArray_Type_;
PyTypeObject *PyVoidArrType_Type_;
PyTypeObject *PyArrayDescr_Type_;
PyObject *(*PyArray_DescrFromScalar_)(PyObject *);
PyObject *(*PyArray_FromAny_) (PyObject *, PyObject *, int, int, int, PyObject *);
int (*PyArray_DescrConverter_) (PyObject *, PyObject **);
bool (*PyArray_EquivTypes_) (PyObject *, PyObject *);
int (*PyArray_GetArrayParamsFromObject_)(PyObject *, PyObject *, unsigned char, PyObject **, int *,
Py_intptr_t *, PyObject **, PyObject *);
PyObject *(*PyArray_Squeeze_)(PyObject *);
// Unused. Not removed because that affects ABI of the class.
int (*PyArray_SetBaseObject_)(PyObject *, PyObject *);
PyObject* (*PyArray_Resize_)(PyObject*, PyArray_Dims*, int, int);
private:
enum functions {
API_PyArray_GetNDArrayCFeatureVersion = 211,
API_PyArray_Type = 2,
API_PyArrayDescr_Type = 3,
API_PyVoidArrType_Type = 39,
API_PyArray_DescrFromType = 45,
API_PyArray_DescrFromScalar = 57,
API_PyArray_FromAny = 69,
API_PyArray_Resize = 80,
API_PyArray_CopyInto = 82,
API_PyArray_NewCopy = 85,
API_PyArray_NewFromDescr = 94,
API_PyArray_DescrNewFromType = 96,
API_PyArray_DescrConverter = 174,
API_PyArray_EquivTypes = 182,
API_PyArray_GetArrayParamsFromObject = 278,
API_PyArray_Squeeze = 136,
API_PyArray_SetBaseObject = 282
};
static npy_api lookup() {
module_ m = module_::import("numpy.core.multiarray");
auto c = m.attr("_ARRAY_API");
#if PY_MAJOR_VERSION >= 3
void **api_ptr = (void **) PyCapsule_GetPointer(c.ptr(), NULL);
#else
void **api_ptr = (void **) PyCObject_AsVoidPtr(c.ptr());
#endif
npy_api api;
#define DECL_NPY_API(Func) api.Func##_ = (decltype(api.Func##_)) api_ptr[API_##Func];
DECL_NPY_API(PyArray_GetNDArrayCFeatureVersion);
if (api.PyArray_GetNDArrayCFeatureVersion_() < 0x7)
pybind11_fail("pybind11 numpy support requires numpy >= 1.7.0");
DECL_NPY_API(PyArray_Type);
DECL_NPY_API(PyVoidArrType_Type);
DECL_NPY_API(PyArrayDescr_Type);
DECL_NPY_API(PyArray_DescrFromType);
DECL_NPY_API(PyArray_DescrFromScalar);
DECL_NPY_API(PyArray_FromAny);
DECL_NPY_API(PyArray_Resize);
DECL_NPY_API(PyArray_CopyInto);
DECL_NPY_API(PyArray_NewCopy);
DECL_NPY_API(PyArray_NewFromDescr);
DECL_NPY_API(PyArray_DescrNewFromType);
DECL_NPY_API(PyArray_DescrConverter);
DECL_NPY_API(PyArray_EquivTypes);
DECL_NPY_API(PyArray_GetArrayParamsFromObject);
DECL_NPY_API(PyArray_Squeeze);
DECL_NPY_API(PyArray_SetBaseObject);
#undef DECL_NPY_API
return api;
}
};
inline PyArray_Proxy* array_proxy(void* ptr) {
return reinterpret_cast<PyArray_Proxy*>(ptr);
}
inline const PyArray_Proxy* array_proxy(const void* ptr) {
return reinterpret_cast<const PyArray_Proxy*>(ptr);
}
inline PyArrayDescr_Proxy* array_descriptor_proxy(PyObject* ptr) {
return reinterpret_cast<PyArrayDescr_Proxy*>(ptr);
}
inline const PyArrayDescr_Proxy* array_descriptor_proxy(const PyObject* ptr) {
return reinterpret_cast<const PyArrayDescr_Proxy*>(ptr);
}
inline bool check_flags(const void* ptr, int flag) {
return (flag == (array_proxy(ptr)->flags & flag));
}
template <typename T> struct is_std_array : std::false_type { };
template <typename T, size_t N> struct is_std_array<std::array<T, N>> : std::true_type { };
template <typename T> struct is_complex : std::false_type { };
template <typename T> struct is_complex<std::complex<T>> : std::true_type { };
template <typename T> struct array_info_scalar {
using type = T;
static constexpr bool is_array = false;
static constexpr bool is_empty = false;
static constexpr auto extents = _("");
static void append_extents(list& /* shape */) { }
};
// Computes underlying type and a comma-separated list of extents for array
// types (any mix of std::array and built-in arrays). An array of char is
// treated as scalar because it gets special handling.
template <typename T> struct array_info : array_info_scalar<T> { };
template <typename T, size_t N> struct array_info<std::array<T, N>> {
using type = typename array_info<T>::type;
static constexpr bool is_array = true;
static constexpr bool is_empty = (N == 0) || array_info<T>::is_empty;
static constexpr size_t extent = N;
// appends the extents to shape
static void append_extents(list& shape) {
shape.append(N);
array_info<T>::append_extents(shape);
}
static constexpr auto extents = _<array_info<T>::is_array>(
concat(_<N>(), array_info<T>::extents), _<N>()
);
};
// For numpy we have special handling for arrays of characters, so we don't include
// the size in the array extents.
template <size_t N> struct array_info<char[N]> : array_info_scalar<char[N]> { };
template <size_t N> struct array_info<std::array<char, N>> : array_info_scalar<std::array<char, N>> { };
template <typename T, size_t N> struct array_info<T[N]> : array_info<std::array<T, N>> { };
template <typename T> using remove_all_extents_t = typename array_info<T>::type;
template <typename T> using is_pod_struct = all_of<
std::is_standard_layout<T>, // since we're accessing directly in memory we need a standard layout type
#if !defined(__GNUG__) || defined(_LIBCPP_VERSION) || defined(_GLIBCXX_USE_CXX11_ABI)
// _GLIBCXX_USE_CXX11_ABI indicates that we're using libstdc++ from GCC 5 or newer, independent
// of the actual compiler (Clang can also use libstdc++, but it always defines __GNUC__ == 4).
std::is_trivially_copyable<T>,
#else
// GCC 4 doesn't implement is_trivially_copyable, so approximate it
std::is_trivially_destructible<T>,
satisfies_any_of<T, std::has_trivial_copy_constructor, std::has_trivial_copy_assign>,
#endif
satisfies_none_of<T, std::is_reference, std::is_array, is_std_array, std::is_arithmetic, is_complex, std::is_enum>
>;
// Replacement for std::is_pod (deprecated in C++20)
template <typename T> using is_pod = all_of<
std::is_standard_layout<T>,
std::is_trivial<T>
>;
template <ssize_t Dim = 0, typename Strides> ssize_t byte_offset_unsafe(const Strides &) { return 0; }
template <ssize_t Dim = 0, typename Strides, typename... Ix>
ssize_t byte_offset_unsafe(const Strides &strides, ssize_t i, Ix... index) {
return i * strides[Dim] + byte_offset_unsafe<Dim + 1>(strides, index...);
}
/**
* Proxy class providing unsafe, unchecked const access to array data. This is constructed through
* the `unchecked<T, N>()` method of `array` or the `unchecked<N>()` method of `array_t<T>`. `Dims`
* will be -1 for dimensions determined at runtime.
*/
template <typename T, ssize_t Dims>
class unchecked_reference {
protected:
static constexpr bool Dynamic = Dims < 0;
const unsigned char *data_;
// Storing the shape & strides in local variables (i.e. these arrays) allows the compiler to
// make large performance gains on big, nested loops, but requires compile-time dimensions
conditional_t<Dynamic, const ssize_t *, std::array<ssize_t, (size_t) Dims>>
shape_, strides_;
const ssize_t dims_;
friend class pybind11::array;
// Constructor for compile-time dimensions:
template <bool Dyn = Dynamic>
unchecked_reference(const void *data, const ssize_t *shape, const ssize_t *strides, enable_if_t<!Dyn, ssize_t>)
: data_{reinterpret_cast<const unsigned char *>(data)}, dims_{Dims} {
for (size_t i = 0; i < (size_t) dims_; i++) {
shape_[i] = shape[i];
strides_[i] = strides[i];
}
}
// Constructor for runtime dimensions:
template <bool Dyn = Dynamic>
unchecked_reference(const void *data, const ssize_t *shape, const ssize_t *strides, enable_if_t<Dyn, ssize_t> dims)
: data_{reinterpret_cast<const unsigned char *>(data)}, shape_{shape}, strides_{strides}, dims_{dims} {}
public:
/**
* Unchecked const reference access to data at the given indices. For a compile-time known
* number of dimensions, this requires the correct number of arguments; for run-time
* dimensionality, this is not checked (and so is up to the caller to use safely).
*/
template <typename... Ix> const T &operator()(Ix... index) const {
static_assert(ssize_t{sizeof...(Ix)} == Dims || Dynamic,
"Invalid number of indices for unchecked array reference");
return *reinterpret_cast<const T *>(data_ + byte_offset_unsafe(strides_, ssize_t(index)...));
}
/**
* Unchecked const reference access to data; this operator only participates if the reference
* is to a 1-dimensional array. When present, this is exactly equivalent to `obj(index)`.
*/
template <ssize_t D = Dims, typename = enable_if_t<D == 1 || Dynamic>>
const T &operator[](ssize_t index) const { return operator()(index); }
/// Pointer access to the data at the given indices.
template <typename... Ix> const T *data(Ix... ix) const { return &operator()(ssize_t(ix)...); }
/// Returns the item size, i.e. sizeof(T)
constexpr static ssize_t itemsize() { return sizeof(T); }
/// Returns the shape (i.e. size) of dimension `dim`
ssize_t shape(ssize_t dim) const { return shape_[(size_t) dim]; }
/// Returns the number of dimensions of the array
ssize_t ndim() const { return dims_; }
/// Returns the total number of elements in the referenced array, i.e. the product of the shapes
template <bool Dyn = Dynamic>
enable_if_t<!Dyn, ssize_t> size() const {
return std::accumulate(shape_.begin(), shape_.end(), (ssize_t) 1, std::multiplies<ssize_t>());
}
template <bool Dyn = Dynamic>
enable_if_t<Dyn, ssize_t> size() const {
return std::accumulate(shape_, shape_ + ndim(), (ssize_t) 1, std::multiplies<ssize_t>());
}
/// Returns the total number of bytes used by the referenced data. Note that the actual span in
/// memory may be larger if the referenced array has non-contiguous strides (e.g. for a slice).
ssize_t nbytes() const {
return size() * itemsize();
}
};
template <typename T, ssize_t Dims>
class unchecked_mutable_reference : public unchecked_reference<T, Dims> {
friend class pybind11::array;
using ConstBase = unchecked_reference<T, Dims>;
using ConstBase::ConstBase;
using ConstBase::Dynamic;
public:
// Bring in const-qualified versions from base class
using ConstBase::operator();
using ConstBase::operator[];
/// Mutable, unchecked access to data at the given indices.
template <typename... Ix> T& operator()(Ix... index) {
static_assert(ssize_t{sizeof...(Ix)} == Dims || Dynamic,
"Invalid number of indices for unchecked array reference");
return const_cast<T &>(ConstBase::operator()(index...));
}
/**
* Mutable, unchecked access data at the given index; this operator only participates if the
* reference is to a 1-dimensional array (or has runtime dimensions). When present, this is
* exactly equivalent to `obj(index)`.
*/
template <ssize_t D = Dims, typename = enable_if_t<D == 1 || Dynamic>>
T &operator[](ssize_t index) { return operator()(index); }
/// Mutable pointer access to the data at the given indices.
template <typename... Ix> T *mutable_data(Ix... ix) { return &operator()(ssize_t(ix)...); }
};
template <typename T, ssize_t Dim>
struct type_caster<unchecked_reference<T, Dim>> {
static_assert(Dim == 0 && Dim > 0 /* always fail */, "unchecked array proxy object is not castable");
};
template <typename T, ssize_t Dim>
struct type_caster<unchecked_mutable_reference<T, Dim>> : type_caster<unchecked_reference<T, Dim>> {};
PYBIND11_NAMESPACE_END(detail)
class dtype : public object {
public:
PYBIND11_OBJECT_DEFAULT(dtype, object, detail::npy_api::get().PyArrayDescr_Check_);
explicit dtype(const buffer_info &info) {
dtype descr(_dtype_from_pep3118()(PYBIND11_STR_TYPE(info.format)));
// If info.itemsize == 0, use the value calculated from the format string
m_ptr = descr.strip_padding(info.itemsize ? info.itemsize : descr.itemsize()).release().ptr();
}
explicit dtype(const std::string &format) {
m_ptr = from_args(pybind11::str(format)).release().ptr();
}
dtype(const char *format) : dtype(std::string(format)) { }
dtype(list names, list formats, list offsets, ssize_t itemsize) {
dict args;
args["names"] = names;
args["formats"] = formats;
args["offsets"] = offsets;
args["itemsize"] = pybind11::int_(itemsize);
m_ptr = from_args(args).release().ptr();
}
/// This is essentially the same as calling numpy.dtype(args) in Python.
static dtype from_args(object args) {
PyObject *ptr = nullptr;
if (!detail::npy_api::get().PyArray_DescrConverter_(args.ptr(), &ptr) || !ptr)
throw error_already_set();
return reinterpret_steal<dtype>(ptr);
}
/// Return dtype associated with a C++ type.
template <typename T> static dtype of() {
return detail::npy_format_descriptor<typename std::remove_cv<T>::type>::dtype();
}
/// Size of the data type in bytes.
ssize_t itemsize() const {
return detail::array_descriptor_proxy(m_ptr)->elsize;
}
/// Returns true for structured data types.
bool has_fields() const {
return detail::array_descriptor_proxy(m_ptr)->names != nullptr;
}
/// Single-character type code.
char kind() const {
return detail::array_descriptor_proxy(m_ptr)->kind;
}
private:
static object _dtype_from_pep3118() {
static PyObject *obj = module_::import("numpy.core._internal")
.attr("_dtype_from_pep3118").cast<object>().release().ptr();
return reinterpret_borrow<object>(obj);
}
dtype strip_padding(ssize_t itemsize) {
// Recursively strip all void fields with empty names that are generated for
// padding fields (as of NumPy v1.11).
if (!has_fields())
return *this;
struct field_descr { PYBIND11_STR_TYPE name; object format; pybind11::int_ offset; };
std::vector<field_descr> field_descriptors;
for (auto field : attr("fields").attr("items")()) {
auto spec = field.cast<tuple>();
auto name = spec[0].cast<pybind11::str>();
auto format = spec[1].cast<tuple>()[0].cast<dtype>();
auto offset = spec[1].cast<tuple>()[1].cast<pybind11::int_>();
if (!len(name) && format.kind() == 'V')
continue;
field_descriptors.push_back({(PYBIND11_STR_TYPE) name, format.strip_padding(format.itemsize()), offset});
}
std::sort(field_descriptors.begin(), field_descriptors.end(),
[](const field_descr& a, const field_descr& b) {
return a.offset.cast<int>() < b.offset.cast<int>();
});
list names, formats, offsets;
for (auto& descr : field_descriptors) {
names.append(descr.name);
formats.append(descr.format);
offsets.append(descr.offset);
}
return dtype(names, formats, offsets, itemsize);
}
};
class array : public buffer {
public:
PYBIND11_OBJECT_CVT(array, buffer, detail::npy_api::get().PyArray_Check_, raw_array)
enum {
c_style = detail::npy_api::NPY_ARRAY_C_CONTIGUOUS_,
f_style = detail::npy_api::NPY_ARRAY_F_CONTIGUOUS_,
forcecast = detail::npy_api::NPY_ARRAY_FORCECAST_
};
array() : array(0, static_cast<const double *>(nullptr)) {}
using ShapeContainer = detail::any_container<ssize_t>;
using StridesContainer = detail::any_container<ssize_t>;
// Constructs an array taking shape/strides from arbitrary container types
array(const pybind11::dtype &dt, ShapeContainer shape, StridesContainer strides,
const void *ptr = nullptr, handle base = handle()) {
if (strides->empty())
*strides = detail::c_strides(*shape, dt.itemsize());
auto ndim = shape->size();
if (ndim != strides->size())
pybind11_fail("NumPy: shape ndim doesn't match strides ndim");
auto descr = dt;
int flags = 0;
if (base && ptr) {
if (isinstance<array>(base))
/* Copy flags from base (except ownership bit) */
flags = reinterpret_borrow<array>(base).flags() & ~detail::npy_api::NPY_ARRAY_OWNDATA_;
else
/* Writable by default, easy to downgrade later on if needed */
flags = detail::npy_api::NPY_ARRAY_WRITEABLE_;
}
auto &api = detail::npy_api::get();
auto tmp = reinterpret_steal<object>(api.PyArray_NewFromDescr_(
api.PyArray_Type_, descr.release().ptr(), (int) ndim,
// Use reinterpret_cast for PyPy on Windows (remove if fixed, checked on 7.3.1)
reinterpret_cast<Py_intptr_t*>(shape->data()),
reinterpret_cast<Py_intptr_t*>(strides->data()),
const_cast<void *>(ptr), flags, nullptr));
if (!tmp)
throw error_already_set();
if (ptr) {
if (base) {
api.PyArray_SetBaseObject_(tmp.ptr(), base.inc_ref().ptr());
} else {
tmp = reinterpret_steal<object>(api.PyArray_NewCopy_(tmp.ptr(), -1 /* any order */));
}
}
m_ptr = tmp.release().ptr();
}
array(const pybind11::dtype &dt, ShapeContainer shape, const void *ptr = nullptr, handle base = handle())
: array(dt, std::move(shape), {}, ptr, base) { }
template <typename T, typename = detail::enable_if_t<std::is_integral<T>::value && !std::is_same<bool, T>::value>>
array(const pybind11::dtype &dt, T count, const void *ptr = nullptr, handle base = handle())
: array(dt, {{count}}, ptr, base) { }
template <typename T>
array(ShapeContainer shape, StridesContainer strides, const T *ptr, handle base = handle())
: array(pybind11::dtype::of<T>(), std::move(shape), std::move(strides), ptr, base) { }
template <typename T>
array(ShapeContainer shape, const T *ptr, handle base = handle())
: array(std::move(shape), {}, ptr, base) { }
template <typename T>
explicit array(ssize_t count, const T *ptr, handle base = handle()) : array({count}, {}, ptr, base) { }
explicit array(const buffer_info &info, handle base = handle())
: array(pybind11::dtype(info), info.shape, info.strides, info.ptr, base) { }
/// Array descriptor (dtype)
pybind11::dtype dtype() const {
return reinterpret_borrow<pybind11::dtype>(detail::array_proxy(m_ptr)->descr);
}
/// Total number of elements
ssize_t size() const {
return std::accumulate(shape(), shape() + ndim(), (ssize_t) 1, std::multiplies<ssize_t>());
}
/// Byte size of a single element
ssize_t itemsize() const {
return detail::array_descriptor_proxy(detail::array_proxy(m_ptr)->descr)->elsize;
}
/// Total number of bytes
ssize_t nbytes() const {
return size() * itemsize();
}
/// Number of dimensions
ssize_t ndim() const {
return detail::array_proxy(m_ptr)->nd;
}
/// Base object
object base() const {
return reinterpret_borrow<object>(detail::array_proxy(m_ptr)->base);
}
/// Dimensions of the array
const ssize_t* shape() const {
return detail::array_proxy(m_ptr)->dimensions;
}
/// Dimension along a given axis
ssize_t shape(ssize_t dim) const {
if (dim >= ndim())
fail_dim_check(dim, "invalid axis");
return shape()[dim];
}
/// Strides of the array
const ssize_t* strides() const {
return detail::array_proxy(m_ptr)->strides;
}
/// Stride along a given axis
ssize_t strides(ssize_t dim) const {
if (dim >= ndim())
fail_dim_check(dim, "invalid axis");
return strides()[dim];
}
/// Return the NumPy array flags
int flags() const {
return detail::array_proxy(m_ptr)->flags;
}
/// If set, the array is writeable (otherwise the buffer is read-only)
bool writeable() const {
return detail::check_flags(m_ptr, detail::npy_api::NPY_ARRAY_WRITEABLE_);
}
/// If set, the array owns the data (will be freed when the array is deleted)
bool owndata() const {
return detail::check_flags(m_ptr, detail::npy_api::NPY_ARRAY_OWNDATA_);
}
/// Pointer to the contained data. If index is not provided, points to the
/// beginning of the buffer. May throw if the index would lead to out of bounds access.
template<typename... Ix> const void* data(Ix... index) const {
return static_cast<const void *>(detail::array_proxy(m_ptr)->data + offset_at(index...));
}
/// Mutable pointer to the contained data. If index is not provided, points to the
/// beginning of the buffer. May throw if the index would lead to out of bounds access.
/// May throw if the array is not writeable.
template<typename... Ix> void* mutable_data(Ix... index) {
check_writeable();
return static_cast<void *>(detail::array_proxy(m_ptr)->data + offset_at(index...));
}
/// Byte offset from beginning of the array to a given index (full or partial).
/// May throw if the index would lead to out of bounds access.
template<typename... Ix> ssize_t offset_at(Ix... index) const {
if ((ssize_t) sizeof...(index) > ndim())
fail_dim_check(sizeof...(index), "too many indices for an array");
return byte_offset(ssize_t(index)...);
}
ssize_t offset_at() const { return 0; }
/// Item count from beginning of the array to a given index (full or partial).
/// May throw if the index would lead to out of bounds access.
template<typename... Ix> ssize_t index_at(Ix... index) const {
return offset_at(index...) / itemsize();
}
/**
* Returns a proxy object that provides access to the array's data without bounds or
* dimensionality checking. Will throw if the array is missing the `writeable` flag. Use with
* care: the array must not be destroyed or reshaped for the duration of the returned object,
* and the caller must take care not to access invalid dimensions or dimension indices.
*/
template <typename T, ssize_t Dims = -1> detail::unchecked_mutable_reference<T, Dims> mutable_unchecked() & {
if (Dims >= 0 && ndim() != Dims)
throw std::domain_error("array has incorrect number of dimensions: " + std::to_string(ndim()) +
"; expected " + std::to_string(Dims));
return detail::unchecked_mutable_reference<T, Dims>(mutable_data(), shape(), strides(), ndim());
}
/**
* Returns a proxy object that provides const access to the array's data without bounds or
* dimensionality checking. Unlike `mutable_unchecked()`, this does not require that the
* underlying array have the `writable` flag. Use with care: the array must not be destroyed or
* reshaped for the duration of the returned object, and the caller must take care not to access
* invalid dimensions or dimension indices.
*/
template <typename T, ssize_t Dims = -1> detail::unchecked_reference<T, Dims> unchecked() const & {
if (Dims >= 0 && ndim() != Dims)
throw std::domain_error("array has incorrect number of dimensions: " + std::to_string(ndim()) +
"; expected " + std::to_string(Dims));
return detail::unchecked_reference<T, Dims>(data(), shape(), strides(), ndim());
}
/// Return a new view with all of the dimensions of length 1 removed
array squeeze() {
auto& api = detail::npy_api::get();
return reinterpret_steal<array>(api.PyArray_Squeeze_(m_ptr));
}
/// Resize array to given shape
/// If refcheck is true and more that one reference exist to this array
/// then resize will succeed only if it makes a reshape, i.e. original size doesn't change
void resize(ShapeContainer new_shape, bool refcheck = true) {
detail::npy_api::PyArray_Dims d = {
// Use reinterpret_cast for PyPy on Windows (remove if fixed, checked on 7.3.1)
reinterpret_cast<Py_intptr_t*>(new_shape->data()),
int(new_shape->size())
};
// try to resize, set ordering param to -1 cause it's not used anyway
object new_array = reinterpret_steal<object>(
detail::npy_api::get().PyArray_Resize_(m_ptr, &d, int(refcheck), -1)
);
if (!new_array) throw error_already_set();
if (isinstance<array>(new_array)) { *this = std::move(new_array); }
}
/// Ensure that the argument is a NumPy array
/// In case of an error, nullptr is returned and the Python error is cleared.
static array ensure(handle h, int ExtraFlags = 0) {
auto result = reinterpret_steal<array>(raw_array(h.ptr(), ExtraFlags));
if (!result)
PyErr_Clear();
return result;
}
protected:
template<typename, typename> friend struct detail::npy_format_descriptor;
void fail_dim_check(ssize_t dim, const std::string& msg) const {
throw index_error(msg + ": " + std::to_string(dim) +
" (ndim = " + std::to_string(ndim()) + ")");
}
template<typename... Ix> ssize_t byte_offset(Ix... index) const {
check_dimensions(index...);
return detail::byte_offset_unsafe(strides(), ssize_t(index)...);
}
void check_writeable() const {
if (!writeable())
throw std::domain_error("array is not writeable");
}
template<typename... Ix> void check_dimensions(Ix... index) const {
check_dimensions_impl(ssize_t(0), shape(), ssize_t(index)...);
}
void check_dimensions_impl(ssize_t, const ssize_t*) const { }
template<typename... Ix> void check_dimensions_impl(ssize_t axis, const ssize_t* shape, ssize_t i, Ix... index) const {
if (i >= *shape) {
throw index_error(std::string("index ") + std::to_string(i) +
" is out of bounds for axis " + std::to_string(axis) +
" with size " + std::to_string(*shape));
}
check_dimensions_impl(axis + 1, shape + 1, index...);
}
/// Create array from any object -- always returns a new reference
static PyObject *raw_array(PyObject *ptr, int ExtraFlags = 0) {
if (ptr == nullptr) {
PyErr_SetString(PyExc_ValueError, "cannot create a pybind11::array from a nullptr");
return nullptr;
}
return detail::npy_api::get().PyArray_FromAny_(
ptr, nullptr, 0, 0, detail::npy_api::NPY_ARRAY_ENSUREARRAY_ | ExtraFlags, nullptr);
}
};
template <typename T, int ExtraFlags = array::forcecast> class array_t : public array {
private:
struct private_ctor {};
// Delegating constructor needed when both moving and accessing in the same constructor
array_t(private_ctor, ShapeContainer &&shape, StridesContainer &&strides, const T *ptr, handle base)
: array(std::move(shape), std::move(strides), ptr, base) {}
public:
static_assert(!detail::array_info<T>::is_array, "Array types cannot be used with array_t");
using value_type = T;
array_t() : array(0, static_cast<const T *>(nullptr)) {}
array_t(handle h, borrowed_t) : array(h, borrowed_t{}) { }
array_t(handle h, stolen_t) : array(h, stolen_t{}) { }
PYBIND11_DEPRECATED("Use array_t<T>::ensure() instead")
array_t(handle h, bool is_borrowed) : array(raw_array_t(h.ptr()), stolen_t{}) {
if (!m_ptr) PyErr_Clear();
if (!is_borrowed) Py_XDECREF(h.ptr());
}
array_t(const object &o) : array(raw_array_t(o.ptr()), stolen_t{}) {
if (!m_ptr) throw error_already_set();
}
explicit array_t(const buffer_info& info, handle base = handle()) : array(info, base) { }
array_t(ShapeContainer shape, StridesContainer strides, const T *ptr = nullptr, handle base = handle())
: array(std::move(shape), std::move(strides), ptr, base) { }
explicit array_t(ShapeContainer shape, const T *ptr = nullptr, handle base = handle())
: array_t(private_ctor{}, std::move(shape),
ExtraFlags & f_style
? detail::f_strides(*shape, itemsize())
: detail::c_strides(*shape, itemsize()),
ptr, base) { }
explicit array_t(ssize_t count, const T *ptr = nullptr, handle base = handle())
: array({count}, {}, ptr, base) { }
constexpr ssize_t itemsize() const {
return sizeof(T);
}
template<typename... Ix> ssize_t index_at(Ix... index) const {
return offset_at(index...) / itemsize();
}
template<typename... Ix> const T* data(Ix... index) const {
return static_cast<const T*>(array::data(index...));
}
template<typename... Ix> T* mutable_data(Ix... index) {
return static_cast<T*>(array::mutable_data(index...));
}
// Reference to element at a given index
template<typename... Ix> const T& at(Ix... index) const {
if ((ssize_t) sizeof...(index) != ndim())
fail_dim_check(sizeof...(index), "index dimension mismatch");
return *(static_cast<const T*>(array::data()) + byte_offset(ssize_t(index)...) / itemsize());
}
// Mutable reference to element at a given index
template<typename... Ix> T& mutable_at(Ix... index) {
if ((ssize_t) sizeof...(index) != ndim())
fail_dim_check(sizeof...(index), "index dimension mismatch");
return *(static_cast<T*>(array::mutable_data()) + byte_offset(ssize_t(index)...) / itemsize());
}
/**
* Returns a proxy object that provides access to the array's data without bounds or
* dimensionality checking. Will throw if the array is missing the `writeable` flag. Use with
* care: the array must not be destroyed or reshaped for the duration of the returned object,
* and the caller must take care not to access invalid dimensions or dimension indices.
*/
template <ssize_t Dims = -1> detail::unchecked_mutable_reference<T, Dims> mutable_unchecked() & {
return array::mutable_unchecked<T, Dims>();
}
/**
* Returns a proxy object that provides const access to the array's data without bounds or
* dimensionality checking. Unlike `unchecked()`, this does not require that the underlying
* array have the `writable` flag. Use with care: the array must not be destroyed or reshaped
* for the duration of the returned object, and the caller must take care not to access invalid
* dimensions or dimension indices.
*/
template <ssize_t Dims = -1> detail::unchecked_reference<T, Dims> unchecked() const & {
return array::unchecked<T, Dims>();
}
/// Ensure that the argument is a NumPy array of the correct dtype (and if not, try to convert
/// it). In case of an error, nullptr is returned and the Python error is cleared.
static array_t ensure(handle h) {
auto result = reinterpret_steal<array_t>(raw_array_t(h.ptr()));
if (!result)
PyErr_Clear();
return result;
}
static bool check_(handle h) {
const auto &api = detail::npy_api::get();
return api.PyArray_Check_(h.ptr())
&& api.PyArray_EquivTypes_(detail::array_proxy(h.ptr())->descr, dtype::of<T>().ptr())
&& detail::check_flags(h.ptr(), ExtraFlags & (array::c_style | array::f_style));
}
protected:
/// Create array from any object -- always returns a new reference
static PyObject *raw_array_t(PyObject *ptr) {
if (ptr == nullptr) {
PyErr_SetString(PyExc_ValueError, "cannot create a pybind11::array_t from a nullptr");
return nullptr;
}
return detail::npy_api::get().PyArray_FromAny_(
ptr, dtype::of<T>().release().ptr(), 0, 0,
detail::npy_api::NPY_ARRAY_ENSUREARRAY_ | ExtraFlags, nullptr);
}
};
template <typename T>
struct format_descriptor<T, detail::enable_if_t<detail::is_pod_struct<T>::value>> {
static std::string format() {
return detail::npy_format_descriptor<typename std::remove_cv<T>::type>::format();
}
};
template <size_t N> struct format_descriptor<char[N]> {
static std::string format() { return std::to_string(N) + "s"; }
};
template <size_t N> struct format_descriptor<std::array<char, N>> {
static std::string format() { return std::to_string(N) + "s"; }
};
template <typename T>
struct format_descriptor<T, detail::enable_if_t<std::is_enum<T>::value>> {
static std::string format() {
return format_descriptor<
typename std::remove_cv<typename std::underlying_type<T>::type>::type>::format();
}
};
template <typename T>
struct format_descriptor<T, detail::enable_if_t<detail::array_info<T>::is_array>> {
static std::string format() {
using namespace detail;
static constexpr auto extents = _("(") + array_info<T>::extents + _(")");
return extents.text + format_descriptor<remove_all_extents_t<T>>::format();
}
};
PYBIND11_NAMESPACE_BEGIN(detail)
template <typename T, int ExtraFlags>
struct pyobject_caster<array_t<T, ExtraFlags>> {
using type = array_t<T, ExtraFlags>;
bool load(handle src, bool convert) {
if (!convert && !type::check_(src))
return false;
value = type::ensure(src);
return static_cast<bool>(value);
}
static handle cast(const handle &src, return_value_policy /* policy */, handle /* parent */) {
return src.inc_ref();
}
PYBIND11_TYPE_CASTER(type, handle_type_name<type>::name);
};
template <typename T>
struct compare_buffer_info<T, detail::enable_if_t<detail::is_pod_struct<T>::value>> {
static bool compare(const buffer_info& b) {
return npy_api::get().PyArray_EquivTypes_(dtype::of<T>().ptr(), dtype(b).ptr());
}
};
template <typename T, typename = void>
struct npy_format_descriptor_name;
template <typename T>
struct npy_format_descriptor_name<T, enable_if_t<std::is_integral<T>::value>> {
static constexpr auto name = _<std::is_same<T, bool>::value>(
_("bool"), _<std::is_signed<T>::value>("numpy.int", "numpy.uint") + _<sizeof(T)*8>()
);
};
template <typename T>
struct npy_format_descriptor_name<T, enable_if_t<std::is_floating_point<T>::value>> {
static constexpr auto name = _<std::is_same<T, float>::value || std::is_same<T, double>::value>(
_("numpy.float") + _<sizeof(T)*8>(), _("numpy.longdouble")
);
};
template <typename T>
struct npy_format_descriptor_name<T, enable_if_t<is_complex<T>::value>> {
static constexpr auto name = _<std::is_same<typename T::value_type, float>::value
|| std::is_same<typename T::value_type, double>::value>(
_("numpy.complex") + _<sizeof(typename T::value_type)*16>(), _("numpy.longcomplex")
);
};
template <typename T>
struct npy_format_descriptor<T, enable_if_t<satisfies_any_of<T, std::is_arithmetic, is_complex>::value>>
: npy_format_descriptor_name<T> {
private:
// NB: the order here must match the one in common.h
constexpr static const int values[15] = {
npy_api::NPY_BOOL_,
npy_api::NPY_BYTE_, npy_api::NPY_UBYTE_, npy_api::NPY_INT16_, npy_api::NPY_UINT16_,
npy_api::NPY_INT32_, npy_api::NPY_UINT32_, npy_api::NPY_INT64_, npy_api::NPY_UINT64_,
npy_api::NPY_FLOAT_, npy_api::NPY_DOUBLE_, npy_api::NPY_LONGDOUBLE_,
npy_api::NPY_CFLOAT_, npy_api::NPY_CDOUBLE_, npy_api::NPY_CLONGDOUBLE_
};
public:
static constexpr int value = values[detail::is_fmt_numeric<T>::index];
static pybind11::dtype dtype() {
if (auto ptr = npy_api::get().PyArray_DescrFromType_(value))
return reinterpret_steal<pybind11::dtype>(ptr);
pybind11_fail("Unsupported buffer format!");
}
};
#define PYBIND11_DECL_CHAR_FMT \
static constexpr auto name = _("S") + _<N>(); \
static pybind11::dtype dtype() { return pybind11::dtype(std::string("S") + std::to_string(N)); }
template <size_t N> struct npy_format_descriptor<char[N]> { PYBIND11_DECL_CHAR_FMT };
template <size_t N> struct npy_format_descriptor<std::array<char, N>> { PYBIND11_DECL_CHAR_FMT };
#undef PYBIND11_DECL_CHAR_FMT
template<typename T> struct npy_format_descriptor<T, enable_if_t<array_info<T>::is_array>> {
private:
using base_descr = npy_format_descriptor<typename array_info<T>::type>;
public:
static_assert(!array_info<T>::is_empty, "Zero-sized arrays are not supported");
static constexpr auto name = _("(") + array_info<T>::extents + _(")") + base_descr::name;
static pybind11::dtype dtype() {
list shape;
array_info<T>::append_extents(shape);
return pybind11::dtype::from_args(pybind11::make_tuple(base_descr::dtype(), shape));
}
};
template<typename T> struct npy_format_descriptor<T, enable_if_t<std::is_enum<T>::value>> {
private:
using base_descr = npy_format_descriptor<typename std::underlying_type<T>::type>;
public:
static constexpr auto name = base_descr::name;
static pybind11::dtype dtype() { return base_descr::dtype(); }
};
struct field_descriptor {
const char *name;
ssize_t offset;
ssize_t size;
std::string format;
dtype descr;
};
inline PYBIND11_NOINLINE void register_structured_dtype(
any_container<field_descriptor> fields,
const std::type_info& tinfo, ssize_t itemsize,
bool (*direct_converter)(PyObject *, void *&)) {
auto& numpy_internals = get_numpy_internals();
if (numpy_internals.get_type_info(tinfo, false))
pybind11_fail("NumPy: dtype is already registered");
// Use ordered fields because order matters as of NumPy 1.14:
// https://docs.scipy.org/doc/numpy/release.html#multiple-field-indexing-assignment-of-structured-arrays
std::vector<field_descriptor> ordered_fields(std::move(fields));
std::sort(ordered_fields.begin(), ordered_fields.end(),
[](const field_descriptor &a, const field_descriptor &b) { return a.offset < b.offset; });
list names, formats, offsets;
for (auto& field : ordered_fields) {
if (!field.descr)
pybind11_fail(std::string("NumPy: unsupported field dtype: `") +
field.name + "` @ " + tinfo.name());
names.append(PYBIND11_STR_TYPE(field.name));
formats.append(field.descr);
offsets.append(pybind11::int_(field.offset));
}
auto dtype_ptr = pybind11::dtype(names, formats, offsets, itemsize).release().ptr();
// There is an existing bug in NumPy (as of v1.11): trailing bytes are
// not encoded explicitly into the format string. This will supposedly
// get fixed in v1.12; for further details, see these:
// - https://github.com/numpy/numpy/issues/7797
// - https://github.com/numpy/numpy/pull/7798
// Because of this, we won't use numpy's logic to generate buffer format
// strings and will just do it ourselves.
ssize_t offset = 0;
std::ostringstream oss;
// mark the structure as unaligned with '^', because numpy and C++ don't
// always agree about alignment (particularly for complex), and we're
// explicitly listing all our padding. This depends on none of the fields
// overriding the endianness. Putting the ^ in front of individual fields
// isn't guaranteed to work due to https://github.com/numpy/numpy/issues/9049
oss << "^T{";
for (auto& field : ordered_fields) {
if (field.offset > offset)
oss << (field.offset - offset) << 'x';
oss << field.format << ':' << field.name << ':';
offset = field.offset + field.size;
}
if (itemsize > offset)
oss << (itemsize - offset) << 'x';
oss << '}';
auto format_str = oss.str();
// Sanity check: verify that NumPy properly parses our buffer format string
auto& api = npy_api::get();
auto arr = array(buffer_info(nullptr, itemsize, format_str, 1));
if (!api.PyArray_EquivTypes_(dtype_ptr, arr.dtype().ptr()))
pybind11_fail("NumPy: invalid buffer descriptor!");
auto tindex = std::type_index(tinfo);
numpy_internals.registered_dtypes[tindex] = { dtype_ptr, format_str };
get_internals().direct_conversions[tindex].push_back(direct_converter);
}
template <typename T, typename SFINAE> struct npy_format_descriptor {
static_assert(is_pod_struct<T>::value, "Attempt to use a non-POD or unimplemented POD type as a numpy dtype");
static constexpr auto name = make_caster<T>::name;
static pybind11::dtype dtype() {
return reinterpret_borrow<pybind11::dtype>(dtype_ptr());
}
static std::string format() {
static auto format_str = get_numpy_internals().get_type_info<T>(true)->format_str;
return format_str;
}
static void register_dtype(any_container<field_descriptor> fields) {
register_structured_dtype(std::move(fields), typeid(typename std::remove_cv<T>::type),
sizeof(T), &direct_converter);
}
private:
static PyObject* dtype_ptr() {
static PyObject* ptr = get_numpy_internals().get_type_info<T>(true)->dtype_ptr;
return ptr;
}
static bool direct_converter(PyObject *obj, void*& value) {
auto& api = npy_api::get();
if (!PyObject_TypeCheck(obj, api.PyVoidArrType_Type_))
return false;
if (auto descr = reinterpret_steal<object>(api.PyArray_DescrFromScalar_(obj))) {
if (api.PyArray_EquivTypes_(dtype_ptr(), descr.ptr())) {
value = ((PyVoidScalarObject_Proxy *) obj)->obval;
return true;
}
}
return false;
}
};
#ifdef __CLION_IDE__ // replace heavy macro with dummy code for the IDE (doesn't affect code)
# define PYBIND11_NUMPY_DTYPE(Type, ...) ((void)0)
# define PYBIND11_NUMPY_DTYPE_EX(Type, ...) ((void)0)
#else
#define PYBIND11_FIELD_DESCRIPTOR_EX(T, Field, Name) \
::pybind11::detail::field_descriptor { \
Name, offsetof(T, Field), sizeof(decltype(std::declval<T>().Field)), \
::pybind11::format_descriptor<decltype(std::declval<T>().Field)>::format(), \
::pybind11::detail::npy_format_descriptor<decltype(std::declval<T>().Field)>::dtype() \
}
// Extract name, offset and format descriptor for a struct field
#define PYBIND11_FIELD_DESCRIPTOR(T, Field) PYBIND11_FIELD_DESCRIPTOR_EX(T, Field, #Field)
// The main idea of this macro is borrowed from https://github.com/swansontec/map-macro
// (C) William Swanson, Paul Fultz
#define PYBIND11_EVAL0(...) __VA_ARGS__
#define PYBIND11_EVAL1(...) PYBIND11_EVAL0 (PYBIND11_EVAL0 (PYBIND11_EVAL0 (__VA_ARGS__)))
#define PYBIND11_EVAL2(...) PYBIND11_EVAL1 (PYBIND11_EVAL1 (PYBIND11_EVAL1 (__VA_ARGS__)))
#define PYBIND11_EVAL3(...) PYBIND11_EVAL2 (PYBIND11_EVAL2 (PYBIND11_EVAL2 (__VA_ARGS__)))
#define PYBIND11_EVAL4(...) PYBIND11_EVAL3 (PYBIND11_EVAL3 (PYBIND11_EVAL3 (__VA_ARGS__)))
#define PYBIND11_EVAL(...) PYBIND11_EVAL4 (PYBIND11_EVAL4 (PYBIND11_EVAL4 (__VA_ARGS__)))
#define PYBIND11_MAP_END(...)
#define PYBIND11_MAP_OUT
#define PYBIND11_MAP_COMMA ,
#define PYBIND11_MAP_GET_END() 0, PYBIND11_MAP_END
#define PYBIND11_MAP_NEXT0(test, next, ...) next PYBIND11_MAP_OUT
#define PYBIND11_MAP_NEXT1(test, next) PYBIND11_MAP_NEXT0 (test, next, 0)
#define PYBIND11_MAP_NEXT(test, next) PYBIND11_MAP_NEXT1 (PYBIND11_MAP_GET_END test, next)
#if defined(_MSC_VER) && !defined(__clang__) // MSVC is not as eager to expand macros, hence this workaround
#define PYBIND11_MAP_LIST_NEXT1(test, next) \
PYBIND11_EVAL0 (PYBIND11_MAP_NEXT0 (test, PYBIND11_MAP_COMMA next, 0))
#else
#define PYBIND11_MAP_LIST_NEXT1(test, next) \
PYBIND11_MAP_NEXT0 (test, PYBIND11_MAP_COMMA next, 0)
#endif
#define PYBIND11_MAP_LIST_NEXT(test, next) \
PYBIND11_MAP_LIST_NEXT1 (PYBIND11_MAP_GET_END test, next)
#define PYBIND11_MAP_LIST0(f, t, x, peek, ...) \
f(t, x) PYBIND11_MAP_LIST_NEXT (peek, PYBIND11_MAP_LIST1) (f, t, peek, __VA_ARGS__)
#define PYBIND11_MAP_LIST1(f, t, x, peek, ...) \
f(t, x) PYBIND11_MAP_LIST_NEXT (peek, PYBIND11_MAP_LIST0) (f, t, peek, __VA_ARGS__)
// PYBIND11_MAP_LIST(f, t, a1, a2, ...) expands to f(t, a1), f(t, a2), ...
#define PYBIND11_MAP_LIST(f, t, ...) \
PYBIND11_EVAL (PYBIND11_MAP_LIST1 (f, t, __VA_ARGS__, (), 0))
#define PYBIND11_NUMPY_DTYPE(Type, ...) \
::pybind11::detail::npy_format_descriptor<Type>::register_dtype \
(::std::vector<::pybind11::detail::field_descriptor> \
{PYBIND11_MAP_LIST (PYBIND11_FIELD_DESCRIPTOR, Type, __VA_ARGS__)})
#if defined(_MSC_VER) && !defined(__clang__)
#define PYBIND11_MAP2_LIST_NEXT1(test, next) \
PYBIND11_EVAL0 (PYBIND11_MAP_NEXT0 (test, PYBIND11_MAP_COMMA next, 0))
#else
#define PYBIND11_MAP2_LIST_NEXT1(test, next) \
PYBIND11_MAP_NEXT0 (test, PYBIND11_MAP_COMMA next, 0)
#endif
#define PYBIND11_MAP2_LIST_NEXT(test, next) \
PYBIND11_MAP2_LIST_NEXT1 (PYBIND11_MAP_GET_END test, next)
#define PYBIND11_MAP2_LIST0(f, t, x1, x2, peek, ...) \
f(t, x1, x2) PYBIND11_MAP2_LIST_NEXT (peek, PYBIND11_MAP2_LIST1) (f, t, peek, __VA_ARGS__)
#define PYBIND11_MAP2_LIST1(f, t, x1, x2, peek, ...) \
f(t, x1, x2) PYBIND11_MAP2_LIST_NEXT (peek, PYBIND11_MAP2_LIST0) (f, t, peek, __VA_ARGS__)
// PYBIND11_MAP2_LIST(f, t, a1, a2, ...) expands to f(t, a1, a2), f(t, a3, a4), ...
#define PYBIND11_MAP2_LIST(f, t, ...) \
PYBIND11_EVAL (PYBIND11_MAP2_LIST1 (f, t, __VA_ARGS__, (), 0))
#define PYBIND11_NUMPY_DTYPE_EX(Type, ...) \
::pybind11::detail::npy_format_descriptor<Type>::register_dtype \
(::std::vector<::pybind11::detail::field_descriptor> \
{PYBIND11_MAP2_LIST (PYBIND11_FIELD_DESCRIPTOR_EX, Type, __VA_ARGS__)})
#endif // __CLION_IDE__
class common_iterator {
public:
using container_type = std::vector<ssize_t>;
using value_type = container_type::value_type;
using size_type = container_type::size_type;
common_iterator() : p_ptr(0), m_strides() {}
common_iterator(void* ptr, const container_type& strides, const container_type& shape)
: p_ptr(reinterpret_cast<char*>(ptr)), m_strides(strides.size()) {
m_strides.back() = static_cast<value_type>(strides.back());
for (size_type i = m_strides.size() - 1; i != 0; --i) {
size_type j = i - 1;
auto s = static_cast<value_type>(shape[i]);
m_strides[j] = strides[j] + m_strides[i] - strides[i] * s;
}
}
void increment(size_type dim) {
p_ptr += m_strides[dim];
}
void* data() const {
return p_ptr;
}
private:
char* p_ptr;
container_type m_strides;
};
template <size_t N> class multi_array_iterator {
public:
using container_type = std::vector<ssize_t>;
multi_array_iterator(const std::array<buffer_info, N> &buffers,
const container_type &shape)
: m_shape(shape.size()), m_index(shape.size(), 0),
m_common_iterator() {
// Manual copy to avoid conversion warning if using std::copy
for (size_t i = 0; i < shape.size(); ++i)
m_shape[i] = shape[i];
container_type strides(shape.size());
for (size_t i = 0; i < N; ++i)
init_common_iterator(buffers[i], shape, m_common_iterator[i], strides);
}
multi_array_iterator& operator++() {
for (size_t j = m_index.size(); j != 0; --j) {
size_t i = j - 1;
if (++m_index[i] != m_shape[i]) {
increment_common_iterator(i);
break;
} else {
m_index[i] = 0;
}
}
return *this;
}
template <size_t K, class T = void> T* data() const {
return reinterpret_cast<T*>(m_common_iterator[K].data());
}
private:
using common_iter = common_iterator;
void init_common_iterator(const buffer_info &buffer,
const container_type &shape,
common_iter &iterator,
container_type &strides) {
auto buffer_shape_iter = buffer.shape.rbegin();
auto buffer_strides_iter = buffer.strides.rbegin();
auto shape_iter = shape.rbegin();
auto strides_iter = strides.rbegin();
while (buffer_shape_iter != buffer.shape.rend()) {
if (*shape_iter == *buffer_shape_iter)
*strides_iter = *buffer_strides_iter;
else
*strides_iter = 0;
++buffer_shape_iter;
++buffer_strides_iter;
++shape_iter;
++strides_iter;
}
std::fill(strides_iter, strides.rend(), 0);
iterator = common_iter(buffer.ptr, strides, shape);
}
void increment_common_iterator(size_t dim) {
for (auto &iter : m_common_iterator)
iter.increment(dim);
}
container_type m_shape;
container_type m_index;
std::array<common_iter, N> m_common_iterator;
};
enum class broadcast_trivial { non_trivial, c_trivial, f_trivial };
// Populates the shape and number of dimensions for the set of buffers. Returns a broadcast_trivial
// enum value indicating whether the broadcast is "trivial"--that is, has each buffer being either a
// singleton or a full-size, C-contiguous (`c_trivial`) or Fortran-contiguous (`f_trivial`) storage
// buffer; returns `non_trivial` otherwise.
template <size_t N>
broadcast_trivial broadcast(const std::array<buffer_info, N> &buffers, ssize_t &ndim, std::vector<ssize_t> &shape) {
ndim = std::accumulate(buffers.begin(), buffers.end(), ssize_t(0), [](ssize_t res, const buffer_info &buf) {
return std::max(res, buf.ndim);
});
shape.clear();
shape.resize((size_t) ndim, 1);
// Figure out the output size, and make sure all input arrays conform (i.e. are either size 1 or
// the full size).
for (size_t i = 0; i < N; ++i) {
auto res_iter = shape.rbegin();
auto end = buffers[i].shape.rend();
for (auto shape_iter = buffers[i].shape.rbegin(); shape_iter != end; ++shape_iter, ++res_iter) {
const auto &dim_size_in = *shape_iter;
auto &dim_size_out = *res_iter;
// Each input dimension can either be 1 or `n`, but `n` values must match across buffers
if (dim_size_out == 1)
dim_size_out = dim_size_in;
else if (dim_size_in != 1 && dim_size_in != dim_size_out)
pybind11_fail("pybind11::vectorize: incompatible size/dimension of inputs!");
}
}
bool trivial_broadcast_c = true;
bool trivial_broadcast_f = true;
for (size_t i = 0; i < N && (trivial_broadcast_c || trivial_broadcast_f); ++i) {
if (buffers[i].size == 1)
continue;
// Require the same number of dimensions:
if (buffers[i].ndim != ndim)
return broadcast_trivial::non_trivial;
// Require all dimensions be full-size:
if (!std::equal(buffers[i].shape.cbegin(), buffers[i].shape.cend(), shape.cbegin()))
return broadcast_trivial::non_trivial;
// Check for C contiguity (but only if previous inputs were also C contiguous)
if (trivial_broadcast_c) {
ssize_t expect_stride = buffers[i].itemsize;
auto end = buffers[i].shape.crend();
for (auto shape_iter = buffers[i].shape.crbegin(), stride_iter = buffers[i].strides.crbegin();
trivial_broadcast_c && shape_iter != end; ++shape_iter, ++stride_iter) {
if (expect_stride == *stride_iter)
expect_stride *= *shape_iter;
else
trivial_broadcast_c = false;
}
}
// Check for Fortran contiguity (if previous inputs were also F contiguous)
if (trivial_broadcast_f) {
ssize_t expect_stride = buffers[i].itemsize;
auto end = buffers[i].shape.cend();
for (auto shape_iter = buffers[i].shape.cbegin(), stride_iter = buffers[i].strides.cbegin();
trivial_broadcast_f && shape_iter != end; ++shape_iter, ++stride_iter) {
if (expect_stride == *stride_iter)
expect_stride *= *shape_iter;
else
trivial_broadcast_f = false;
}
}
}
return
trivial_broadcast_c ? broadcast_trivial::c_trivial :
trivial_broadcast_f ? broadcast_trivial::f_trivial :
broadcast_trivial::non_trivial;
}
template <typename T>
struct vectorize_arg {
static_assert(!std::is_rvalue_reference<T>::value, "Functions with rvalue reference arguments cannot be vectorized");
// The wrapped function gets called with this type:
using call_type = remove_reference_t<T>;
// Is this a vectorized argument?
static constexpr bool vectorize =
satisfies_any_of<call_type, std::is_arithmetic, is_complex, is_pod>::value &&
satisfies_none_of<call_type, std::is_pointer, std::is_array, is_std_array, std::is_enum>::value &&
(!std::is_reference<T>::value ||
(std::is_lvalue_reference<T>::value && std::is_const<call_type>::value));
// Accept this type: an array for vectorized types, otherwise the type as-is:
using type = conditional_t<vectorize, array_t<remove_cv_t<call_type>, array::forcecast>, T>;
};
// py::vectorize when a return type is present
template <typename Func, typename Return, typename... Args>
struct vectorize_returned_array {
using Type = array_t<Return>;
static Type create(broadcast_trivial trivial, const std::vector<ssize_t> &shape) {
if (trivial == broadcast_trivial::f_trivial)
return array_t<Return, array::f_style>(shape);
else
return array_t<Return>(shape);
}
static Return *mutable_data(Type &array) {
return array.mutable_data();
}
static Return call(Func &f, Args &... args) {
return f(args...);
}
static void call(Return *out, size_t i, Func &f, Args &... args) {
out[i] = f(args...);
}
};
// py::vectorize when a return type is not present
template <typename Func, typename... Args>
struct vectorize_returned_array<Func, void, Args...> {
using Type = none;
static Type create(broadcast_trivial, const std::vector<ssize_t> &) {
return none();
}
static void *mutable_data(Type &) {
return nullptr;
}
static detail::void_type call(Func &f, Args &... args) {
f(args...);
return {};
}
static void call(void *, size_t, Func &f, Args &... args) {
f(args...);
}
};
template <typename Func, typename Return, typename... Args>
struct vectorize_helper {
// NVCC for some reason breaks if NVectorized is private
#ifdef __CUDACC__
public:
#else
private:
#endif
static constexpr size_t N = sizeof...(Args);
static constexpr size_t NVectorized = constexpr_sum(vectorize_arg<Args>::vectorize...);
static_assert(NVectorized >= 1,
"pybind11::vectorize(...) requires a function with at least one vectorizable argument");
public:
template <typename T>
explicit vectorize_helper(T &&f) : f(std::forward<T>(f)) { }
object operator()(typename vectorize_arg<Args>::type... args) {
return run(args...,
make_index_sequence<N>(),
select_indices<vectorize_arg<Args>::vectorize...>(),
make_index_sequence<NVectorized>());
}
private:
remove_reference_t<Func> f;
// Internal compiler error in MSVC 19.16.27025.1 (Visual Studio 2017 15.9.4), when compiling with "/permissive-" flag
// when arg_call_types is manually inlined.
using arg_call_types = std::tuple<typename vectorize_arg<Args>::call_type...>;
template <size_t Index> using param_n_t = typename std::tuple_element<Index, arg_call_types>::type;
using returned_array = vectorize_returned_array<Func, Return, Args...>;
// Runs a vectorized function given arguments tuple and three index sequences:
// - Index is the full set of 0 ... (N-1) argument indices;
// - VIndex is the subset of argument indices with vectorized parameters, letting us access
// vectorized arguments (anything not in this sequence is passed through)
// - BIndex is a incremental sequence (beginning at 0) of the same size as VIndex, so that
// we can store vectorized buffer_infos in an array (argument VIndex has its buffer at
// index BIndex in the array).
template <size_t... Index, size_t... VIndex, size_t... BIndex> object run(
typename vectorize_arg<Args>::type &...args,
index_sequence<Index...> i_seq, index_sequence<VIndex...> vi_seq, index_sequence<BIndex...> bi_seq) {
// Pointers to values the function was called with; the vectorized ones set here will start
// out as array_t<T> pointers, but they will be changed them to T pointers before we make
// call the wrapped function. Non-vectorized pointers are left as-is.
std::array<void *, N> params{{ &args... }};
// The array of `buffer_info`s of vectorized arguments:
std::array<buffer_info, NVectorized> buffers{{ reinterpret_cast<array *>(params[VIndex])->request()... }};
/* Determine dimensions parameters of output array */
ssize_t nd = 0;
std::vector<ssize_t> shape(0);
auto trivial = broadcast(buffers, nd, shape);
auto ndim = (size_t) nd;
size_t size = std::accumulate(shape.begin(), shape.end(), (size_t) 1, std::multiplies<size_t>());
// If all arguments are 0-dimension arrays (i.e. single values) return a plain value (i.e.
// not wrapped in an array).
if (size == 1 && ndim == 0) {
PYBIND11_EXPAND_SIDE_EFFECTS(params[VIndex] = buffers[BIndex].ptr);
return cast(returned_array::call(f, *reinterpret_cast<param_n_t<Index> *>(params[Index])...));
}
auto result = returned_array::create(trivial, shape);
if (size == 0) return std::move(result);
/* Call the function */
auto mutable_data = returned_array::mutable_data(result);
if (trivial == broadcast_trivial::non_trivial)
apply_broadcast(buffers, params, mutable_data, size, shape, i_seq, vi_seq, bi_seq);
else
apply_trivial(buffers, params, mutable_data, size, i_seq, vi_seq, bi_seq);
return std::move(result);
}
template <size_t... Index, size_t... VIndex, size_t... BIndex>
void apply_trivial(std::array<buffer_info, NVectorized> &buffers,
std::array<void *, N> ¶ms,
Return *out,
size_t size,
index_sequence<Index...>, index_sequence<VIndex...>, index_sequence<BIndex...>) {
// Initialize an array of mutable byte references and sizes with references set to the
// appropriate pointer in `params`; as we iterate, we'll increment each pointer by its size
// (except for singletons, which get an increment of 0).
std::array<std::pair<unsigned char *&, const size_t>, NVectorized> vecparams{{
std::pair<unsigned char *&, const size_t>(
reinterpret_cast<unsigned char *&>(params[VIndex] = buffers[BIndex].ptr),
buffers[BIndex].size == 1 ? 0 : sizeof(param_n_t<VIndex>)
)...
}};
for (size_t i = 0; i < size; ++i) {
returned_array::call(out, i, f, *reinterpret_cast<param_n_t<Index> *>(params[Index])...);
for (auto &x : vecparams) x.first += x.second;
}
}
template <size_t... Index, size_t... VIndex, size_t... BIndex>
void apply_broadcast(std::array<buffer_info, NVectorized> &buffers,
std::array<void *, N> ¶ms,
Return *out,
size_t size,
const std::vector<ssize_t> &output_shape,
index_sequence<Index...>, index_sequence<VIndex...>, index_sequence<BIndex...>) {
multi_array_iterator<NVectorized> input_iter(buffers, output_shape);
for (size_t i = 0; i < size; ++i, ++input_iter) {
PYBIND11_EXPAND_SIDE_EFFECTS((
params[VIndex] = input_iter.template data<BIndex>()
));
returned_array::call(out, i, f, *reinterpret_cast<param_n_t<Index> *>(std::get<Index>(params))...);
}
}
};
template <typename Func, typename Return, typename... Args>
vectorize_helper<Func, Return, Args...>
vectorize_extractor(const Func &f, Return (*) (Args ...)) {
return detail::vectorize_helper<Func, Return, Args...>(f);
}
template <typename T, int Flags> struct handle_type_name<array_t<T, Flags>> {
static constexpr auto name = _("numpy.ndarray[") + npy_format_descriptor<T>::name + _("]");
};
PYBIND11_NAMESPACE_END(detail)
// Vanilla pointer vectorizer:
template <typename Return, typename... Args>
detail::vectorize_helper<Return (*)(Args...), Return, Args...>
vectorize(Return (*f) (Args ...)) {
return detail::vectorize_helper<Return (*)(Args...), Return, Args...>(f);
}
// lambda vectorizer:
template <typename Func, detail::enable_if_t<detail::is_lambda<Func>::value, int> = 0>
auto vectorize(Func &&f) -> decltype(
detail::vectorize_extractor(std::forward<Func>(f), (detail::function_signature_t<Func> *) nullptr)) {
return detail::vectorize_extractor(std::forward<Func>(f), (detail::function_signature_t<Func> *) nullptr);
}
// Vectorize a class method (non-const):
template <typename Return, typename Class, typename... Args,
typename Helper = detail::vectorize_helper<decltype(std::mem_fn(std::declval<Return (Class::*)(Args...)>())), Return, Class *, Args...>>
Helper vectorize(Return (Class::*f)(Args...)) {
return Helper(std::mem_fn(f));
}
// Vectorize a class method (const):
template <typename Return, typename Class, typename... Args,
typename Helper = detail::vectorize_helper<decltype(std::mem_fn(std::declval<Return (Class::*)(Args...) const>())), Return, const Class *, Args...>>
Helper vectorize(Return (Class::*f)(Args...) const) {
return Helper(std::mem_fn(f));
}
PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
#if defined(_MSC_VER)
#pragma warning(pop)
#endif
| [
"hanlinGao@outlook.com"
] | hanlinGao@outlook.com |
3f06e1fb3edcb8dc4bf252a371af5f4b5de86e75 | 8dc84558f0058d90dfc4955e905dab1b22d12c08 | /third_party/android_ndk/sources/cxx-stl/stlport/stlport/typeinfo.h | 0cea71a57503e9923a20194ea544bc4c9fa742e2 | [
"LicenseRef-scancode-unknown-license-reference",
"LicenseRef-scancode-mit-old-style",
"LicenseRef-scancode-stlport-4.5",
"LGPL-2.0-or-later",
"GPL-1.0-or-later",
"MIT",
"Apache-2.0",
"BSD-3-Clause"
] | permissive | meniossin/src | 42a95cc6c4a9c71d43d62bc4311224ca1fd61e03 | 44f73f7e76119e5ab415d4593ac66485e65d700a | refs/heads/master | 2022-12-16T20:17:03.747113 | 2020-09-03T10:43:12 | 2020-09-03T10:43:12 | 263,710,168 | 1 | 0 | BSD-3-Clause | 2020-05-13T18:20:09 | 2020-05-13T18:20:08 | null | UTF-8 | C++ | false | false | 2,665 | h | /*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
// DMC has hardcoded inclusion of typeinfo.h at the begining of any translation unit.
// So inclusion of this header will directly reference the native header. This is not
// a problem as typeinfo.h is neither a C nor C++ Standard header, this header should
// never be used in user code.
#if defined (__DMC__)
// We define _STLP_OUTERMOST_HEADER_ID to signal to other STLport headers that inclusion
// is done from native typeinfo.h (see exception header).
# define _STLP_OUTERMOST_HEADER_ID 0x874
# include <../include/typeinfo.h>
# undef _STLP_OUTERMOST_HEADER_ID
#else
# ifndef _STLP_OLDSTD_typeinfo
# define _STLP_OLDSTD_typeinfo
# ifndef _STLP_OUTERMOST_HEADER_ID
# define _STLP_OUTERMOST_HEADER_ID 0x874
# include <stl/_prolog.h>
# endif
# ifndef _STLP_NO_TYPEINFO
# if defined (__GNUC__)
# undef _STLP_OLDSTD_typeinfo
# include <typeinfo>
# define _STLP_OLDSTD_typeinfo
# else
# if defined (_STLP_HAS_INCLUDE_NEXT)
# include_next <typeinfo.h>
# elif !defined (__BORLANDC__) || (__BORLANDC__ < 0x580)
# include _STLP_NATIVE_CPP_RUNTIME_HEADER(typeinfo.h)
# else
# include _STLP_NATIVE_CPP_C_HEADER(typeinfo.h)
# endif
# if defined (__BORLANDC__) && (__BORLANDC__ >= 0x580) || \
defined (__DMC__)
using std::type_info;
using std::bad_typeid;
using std::bad_cast;
# endif
# endif
// if <typeinfo> already included, do not import anything
# if defined (_STLP_USE_OWN_NAMESPACE) && !(defined (_STLP_TYPEINFO) && !defined (_STLP_NO_NEW_NEW_HEADER))
_STLP_BEGIN_NAMESPACE
using /*_STLP_VENDOR_EXCEPT_STD */ :: type_info;
# if !(defined(__MRC__) || (defined(__SC__) && !defined(__DMC__)))
using /* _STLP_VENDOR_EXCEPT_STD */ :: bad_typeid;
# endif
using /* _STLP_VENDOR_EXCEPT_STD */ :: bad_cast;
_STLP_END_NAMESPACE
# endif /* _STLP_OWN_NAMESPACE */
# endif /* _STLP_NO_TYPEINFO */
# if (_STLP_OUTERMOST_HEADER_ID == 0x874)
# include <stl/_epilog.h>
# undef _STLP_OUTERMOST_HEADER_ID
# endif
# endif /* _STLP_OLDSTD_typeinfo */
#endif /* __DMC__ */
// Local Variables:
// mode:C++
// End:
| [
"arnaud@geometry.ee"
] | arnaud@geometry.ee |
8e8ad98d86052d1cccc0020065b31da96e811e90 | c0ddf9d6d7ec34872e061b87ef8ad0b603e54efe | /DaramLib/DaramLib/DaramInput.cpp | 44b006137d0cd344e4e3dfbc8ab1da299727fd3d | [] | no_license | daramkun/ProjectPavilion | 945a4f6956800dc28a07205a047b2201ac2a2faf | a112ba4551c821521700854d15642db64cbdefd6 | refs/heads/master | 2020-08-16T00:07:10.505436 | 2019-10-16T01:16:42 | 2019-10-16T01:16:42 | 215,427,712 | 0 | 0 | null | null | null | null | UHC | C++ | false | false | 6,875 | cpp | #define DLLEXPORT
#include "DaramInput.h"
void DaramInput::CreateInput(HWND Handle, bool ExclusiveMode, bool BackgroundMode, bool keyboardUse, bool mouseUse, bool joyUse)
{
HRESULT result;
DWORD exMode, bgMode;
win = Handle;
result = DirectInput8Create(GetModuleHandle(NULL), DIRECTINPUT_VERSION,
IID_IDirectInput8, (VOID**)&input, NULL);
if(FAILED(result))
{
MessageBox(NULL, "Direct Input 생성 오류", "인풋 장치 오류", NULL);
PostQuitMessage(0);
return;
}
this->keyboardUse = keyboardUse;
this->mouseUse = mouseUse;
this->joyUse = joyUse;
if(keyboardUse)
input->CreateDevice(GUID_SysKeyboard, &keyboard, NULL);
if(mouseUse)
input->CreateDevice(GUID_SysMouse, &mouse, NULL);
if(joyUse)
input->CreateDevice(GUID_Joystick, &joystick, NULL);
if(ExclusiveMode)
exMode = DISCL_EXCLUSIVE;
else
exMode = DISCL_NONEXCLUSIVE;
if(BackgroundMode)
bgMode = DISCL_BACKGROUND;
else
bgMode = DISCL_FOREGROUND;
if(keyboard != NULL && keyboardUse)
result = keyboard->SetCooperativeLevel(Handle, exMode | bgMode);
if(mouse != NULL && mouseUse)
result = mouse->SetCooperativeLevel(Handle, exMode | bgMode);
if(joystick != NULL && joyUse)
result = joystick->SetCooperativeLevel(Handle, exMode | bgMode);
if(keyboard != NULL && keyboardUse)
result = keyboard->SetDataFormat(&c_dfDIKeyboard);
if(mouse != NULL && mouseUse)
result = mouse->SetDataFormat(&c_dfDIMouse);
if(joystick != NULL && joyUse)
result = joystick->SetDataFormat(&c_dfDIJoystick);
if(keyboard != NULL && keyboardUse)
keyboard->Acquire();
if(mouse != NULL && mouseUse)
mouse->Acquire();
if(joystick != NULL && joyUse)
joystick->Acquire();
}
bool DaramInput::KeyDown(int key)
{
if(!keyboardUse) return false;
if(diks[key] & 0x80)
{
if(keylast[key])
return false;
else
{
keylast[key] = true;
return true;
}
}
else
{
keylast[key] = false;
return false;
}
}
bool DaramInput::KeyPress(int key)
{
if(!keyboardUse) return false;
return (diks[key] & 0x80) ? true : false;
}
bool DaramInput::KeyUp(int key)
{
if(!keyboardUse) return false;
if(!(diks[key] & 0x80))
{
if(!keylast[key])
return false;
else
{
keylast[key] = false;
return true;
}
}
else
return false;
}
BYTE* DaramInput::GetPressedKey()
{
return diks;
}
bool DaramInput::AnyKeyDown()
{
for(int i = 0; i < 256; i++)
{
if(KeyDown(i))
return true;
}
return false;
}
bool DaramInput::AnyKeyPress()
{
for(int i = 0; i < 256; i++)
{
if(KeyPress(i))
return true;
}
return false;
}
bool DaramInput::AnyKeyUp()
{
for(int i = 0; i < 256; i++)
{
if(KeyUp(i))
return true;
}
return false;
}
bool DaramInput::MouseDown(int mouseKey)
{
if(!mouseUse) return false;
if(mstate.rgbButtons[mouseKey] & 0x80)
{
if(mouselast[mouseKey])
return false;
else
{
mouselast[mouseKey] = true;
return true;
}
}
else
{
mouselast[mouseKey] = false;
return false;
}
}
bool DaramInput::MousePress(int mouseKey)
{
if(!mouseUse) return false;
return (mstate.rgbButtons[mouseKey] & 0x80) ? true : false;
}
bool DaramInput::MouseUp(int mouseKey)
{
if(!mouseUse) return false;
if(!(mstate.rgbButtons[mouseKey] & 0x80))
{
if(!mouselast[mouseKey])
return false;
else
{
mouselast[mouseKey] = false;
return true;
}
}
else
return false;
}
bool DaramInput::AnyMouseDown()
{
for(int i = 0; i < 4; i++)
{
if(MouseDown(i))
return true;
}
return false;
}
bool DaramInput::AnyMousePress()
{
for(int i = 0; i < 4; i++)
{
if(MousePress(i))
return true;
}
return false;
}
bool DaramInput::AnyMouseUp()
{
for(int i = 0; i < 4; i++)
{
if(MouseUp(i))
return true;
}
return false;
}
int DaramInput::GetMouseX()
{
if(!mouseUse) return 0;
return mstate.lX;
}
int DaramInput::GetMouseY()
{
if(!mouseUse) return 0;
return mstate.lY;
}
int DaramInput::GetMouseZ()
{
if(!mouseUse) return 0;
return mstate.lZ;
}
bool DaramInput::JoystickDown(int joykey)
{
if(!joyUse) return false;
if(jstate.rgbButtons[joykey] & 0x80)
{
if(joylast[joykey])
return false;
else
{
joylast[joykey] = true;
return true;
}
}
else
{
joylast[joykey] = false;
return false;
}
}
bool DaramInput::JoystickPress(int joykey)
{
if(!joyUse) return false;
return (jstate.rgbButtons[joykey] & 0x80) ? true : false;
}
bool DaramInput::JoystickUp(int joykey)
{
if(!joyUse) return false;
if(!(jstate.rgbButtons[joykey] & 0x80))
{
if(!joylast[joykey])
return false;
else
{
joylast[joykey] = false;
return true;
}
}
else
return false;
}
bool DaramInput::AnyJoystickDown()
{
for(int i = 0; i < 32; i++)
{
if(JoystickDown(i))
return true;
}
return false;
}
bool DaramInput::AnyJoystickPress()
{
for(int i = 0; i < 32; i++)
{
if(JoystickPress(i))
return true;
}
return false;
}
bool DaramInput::AnyJoystickUp()
{
for(int i = 0; i < 32; i++)
{
if(JoystickUp(i))
return true;
}
return false;
}
int DaramInput::GetJoyX()
{
if(!joyUse) return 0;
return jstate.lX;
}
int DaramInput::GetJoyY()
{
if(!joyUse) return 0;
return jstate.lY;
}
int DaramInput::GetJoyZ()
{
if(!joyUse) return 0;
return jstate.lZ;
}
void DaramInput::UpdateData()
{
if(keyboard != NULL && keyboardUse)
{
ZeroMemory(diks, sizeof(diks));
keyboard->GetDeviceState(sizeof(diks), diks);
}
if(mouse != NULL && mouseUse)
{
ZeroMemory(&mstate, sizeof(mstate));
mouse->GetDeviceState(sizeof(mstate), &mstate);
}
if(joystick != NULL && joyUse)
{
ZeroMemory(&jstate, sizeof(jstate));
joystick->GetDeviceState(sizeof(jstate), &jstate);
}
}
bool DaramInput::IsKeyConn()
{
if(!keyboardUse || keyboard == NULL)
return false;
else
return true;
}
bool DaramInput::IsMsConn()
{
if(!mouseUse || mouse == NULL)
return false;
else
return true;
}
bool DaramInput::IsJoyConn()
{
if(!joyUse || joystick == NULL)
return false;
else
return true;
}
int DaramInput::GetMouseXFromWindow()
{
POINT pt;
GetCursorPos(&pt);
ScreenToClient(win, &pt);
return pt.x;
}
int DaramInput::GetMouseYFromWindow()
{
POINT pt;
GetCursorPos(&pt);
ScreenToClient(win, &pt);
return pt.y;
}
void DaramInput::SetMouseXToWindow(int x)
{
POINT pt;
GetCursorPos(&pt);
ScreenToClient(win, &pt);
pt.x = x;
ClientToScreen(win, &pt);
SetCursorPos(pt.x, pt.y);
}
void DaramInput::SetMouseYToWindow(int y)
{
POINT pt;
GetCursorPos(&pt);
ScreenToClient(win, &pt);
pt.y = y;
ClientToScreen(win, &pt);
SetCursorPos(pt.x, pt.y);
}
void DaramInput::SetMousePositionToWindow(int x, int y)
{
POINT pt;
pt.x = x;
pt.y = y;
ClientToScreen(win, &pt);
SetCursorPos(pt.x, pt.y);
}
void DaramInput::Dispose()
{
if(joyUse || joystick != NULL)
joystick->Release();
if(mouseUse || mouse != NULL)
mouse->Release();
if(keyboardUse || keyboard != NULL)
keyboard->Release();
if(input != NULL)
input->Release();
} | [
"daramkun@live.com"
] | daramkun@live.com |
0391591597f0f49dc5d0f273400b230a3164bb23 | db01d410b680ee860bfd3b60b877248f787e7bc5 | /src/particle_filter.cpp | 8dda45246293317f419beb4ab892b0892eca687e | [
"MIT"
] | permissive | usedlobster/CarND-T2-P3 | 3baf5a476b0e43eba78748820a60218c73ca35f0 | 4c373854d1670abbb4d9446278d58f1641d21e70 | refs/heads/master | 2021-04-30T00:03:50.069051 | 2018-02-19T22:14:00 | 2018-02-19T22:14:00 | 121,568,064 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 9,869 | cpp | /*
* particle_filter.cpp
*
* Created on: Dec 12, 2016
* Author: Tiffany Huang
*/
// completed by usedlobster Feburary 2018.
#include <random>
#include <algorithm>
#include <iostream>
#include <numeric>
#include <math.h>
#include <iostream>
#include <sstream>
#include <string>
#include <iterator>
#include <assert.h>
#include "particle_filter.h"
using namespace std;
void ParticleFilter::init(double x, double y, double theta, double std[]) {
// Set the number of initial particles, to use
// anything > 10 works , 200 seems a good trade off between time / accuracy
num_particles = 200 ;
//Initialize all particles to first position (based on estimates of
// x, y, theta and their uncertainties from GPS) and all weights to 1.
// Add random Gaussian noise to each particle.
// create a ( pseudo ) random number engine
default_random_engine generator ;
// create gaussian distribution generators for each standard deviation.
normal_distribution<double> dist_x( x, std[0] ) ;
normal_distribution<double> dist_y( y, std[1] ) ;
normal_distribution<double> dist_theta( theta, std[2] );
// reserve space for efficiency ,
particles.reserve( num_particles ) ;
// create a random particle - using generators above.
for ( int i=0; i<num_particles; i++) {
Particle a_random_particle ;
a_random_particle.id = i ;
a_random_particle.x = dist_x( generator ) ;
a_random_particle.y = dist_y( generator ) ;
a_random_particle.theta = dist_theta( generator ) ;
particles.push_back( a_random_particle ) ;
}
// need todo this
is_initialized = true ;
}
void ParticleFilter::prediction(double delta_t, double std_pos[], double velocity, double yaw_rate) {
default_random_engine generator ;
// create normal distribution generator with 0 mean , std_pos
normal_distribution<double> dist_x( 0.0, std_pos[0] );
normal_distribution<double> dist_y( 0.0, std_pos[1] );
normal_distribution<double> dist_theta( 0.0, std_pos[2] );
// apply velocity , and yaw change to each particle
for ( auto &p : particles ) {
// if yaw_rate is practically 0
// just move forward in current direction.
if ( fabs( yaw_rate) < 1e-5 ) {
p.x += velocity * delta_t * cos( p.theta ) ;
p.y += velocity * delta_t * sin( p.theta ) ;
} else {
p.x += ( velocity / yaw_rate ) * ( sin( p.theta + yaw_rate * delta_t ) - sin( p.theta )) ;
p.y += ( velocity / yaw_rate ) * ( cos( p.theta ) - cos( p.theta + yaw_rate * delta_t )) ;
p.theta += yaw_rate*delta_t ;
}
// add some noise to the position
p.x += dist_x( generator ) ;
p.y += dist_y( generator ) ;
p.theta += dist_theta( generator ) ;
}
}
void ParticleFilter::dataAssociation(std::vector<LandmarkObs> predicted, std::vector<LandmarkObs>& observations)
{
// go through each observation , and find which landmark is nearest.
; for ( auto &obs : observations ) {
double min_d2 ; // NB: no need to initialize
int nearest_id = -1 ;
for ( auto lm : predicted ) {
//
double d2 = ( obs.x - lm.x )*( obs.x - lm.x ) + ( obs.y - lm.y )*( obs.y - lm.y ) ;
if ( nearest_id < 0 || d2 < min_d2 ) {
nearest_id = lm.id ;
min_d2 = d2 ;
}
}
// record which landmark this observation was closest to.
obs.id = nearest_id ;
}
}
void ParticleFilter::updateWeights(double sensor_range, double std_landmark[],
const std::vector<LandmarkObs> &observations, const Map &map_landmarks) {
// Update the weights of each particle using a mult-variate Gaussian distribution.
// precompute these, as used for each particle.
double sigX = std_landmark[0] ; // sigma_x
double sigY = std_landmark[1] ; // sigma_y
double gNorm = 1.0 / ( 2.0 * M_PI * sigX * sigY ) ; // 1/( 2*pi*sigma_x*sigma_y )
double sig2XX = 2.0 * sigX * sigX ; // twice sigma_x squared
double sig2YY = 2.0 * sigY * sigY ; // twice sigma_y squared
// clear vector list of weights
weights.clear() ;
// for each particle we
for ( auto &p : particles ) {
// create a list of observation in real world space
// as if we had observed them from current particle p .
std::vector< LandmarkObs >real_world_obs ;
double cos_t = cos( p.theta ) ;
double sin_t = sin( p.theta ) ;
for ( auto obs : observations ) {
double mx = p.x + obs.x * cos_t - obs.y * sin_t ;
double my = p.y + obs.x * sin_t + obs.y * cos_t ;
real_world_obs.push_back( LandmarkObs{ obs.id, mx, my } ) ;
}
// create list of possible landmarks - in sensor range ( a square area )
std::vector< LandmarkObs >nearby_landmarks ;
for ( auto lm : map_landmarks.landmark_list ) {
if ( fabs( lm.x_f - p.x ) < sensor_range || fabs( lm.y_f - p.y ) < sensor_range )
nearby_landmarks.push_back( LandmarkObs{ lm.id_i, lm.x_f, lm.y_f } ) ;
}
// associate the real_world_obs with possible landmarks.
dataAssociation( nearby_landmarks, real_world_obs ) ;
// we can calculate the weight of each particle
p.associations.clear() ;
p.sense_x.clear() ;
p.sense_y.clear() ;
if ( nearby_landmarks.size() > 0 ) {
p.weight = 1.0 ;
for ( auto rwo : real_world_obs ) {
if ( rwo.id >= 0 ) {
// rwo.id gives us best landmark to use , its -1 if there is none
// we need to iterate to find it again,
// as we haven't assumed map_landmarks.landmark_lists[rwo.id-1] is the same landmark
// but it probably is. ( acctually is ).
// We have also assumed id's are always >=0
for ( int i=0; i < nearby_landmarks.size() ; i++ ) {
if ( nearby_landmarks[i].id == rwo.id ) {
double dx = rwo.x - nearby_landmarks[i].x ;
double dy = rwo.y - nearby_landmarks[i].y ;
//
p.weight *= gNorm * exp( - ( (( dx * dx ) / sig2XX ) + (( dy * dy ) / sig2YY ))) ;
// we might as well assign debug information here
// rather than create 3 more lists.
p.associations.push_back( rwo.id ) ;
p.sense_x.push_back( rwo.x ) ;
p.sense_y.push_back( rwo.y ) ;
break ;
}
}
}
}
} else
p.weight = 0.0 ; // set to 0 as no landmarks
// keep track of particle weights in a single vector list as well.
// helps with resampling
weights.push_back( p.weight ) ;
}
}
void ParticleFilter::resample() {
default_random_engine gen;
std::discrete_distribution<int> weight_distribution( weights.begin(), weights.end());
std::vector<Particle> resampled_particles ;
resampled_particles.clear() ; // not strictly necessary I know.
for (int i = 0; i < particles.size() ; i++)
resampled_particles.push_back( particles[weight_distribution(gen)] );
particles = resampled_particles ;
// I prefer old wheel method - works just as well , and you can see what its doing
/*
std::uniform_real_distribution<double> uniR(0.0, 1.0 );
double wMax = *std::max_element( weights.begin(), weights.end());
int N = weights.size() ;
double beta = 0.0 ;
int index = int(N*uniR(gen))%N ;
for ( int i=0; i<N; i++) {
beta = beta + 2.0 * uniR(gen) * wMax ;
while ( weights[index] < beta ) {
beta = beta - weights[index] ;
index = (index+1)%N ;
}
resampled_particles.push_back( particles[index] );
}
particles = resampled_particles ;
*/
}
Particle ParticleFilter::SetAssociations(Particle& particle, const std::vector<int>& associations,
const std::vector<double>& sense_x, const std::vector<double>& sense_y) {
//particle: the particle to assign each listed association, and association's (x,y) world coordinates mapping to
// associations: The landmark id that goes along with each listed association
// sense_x: the associations x mapping already converted to world coordinates
// sense_y: the associations y mapping already converted to world coordinates
particle.associations= associations;
particle.sense_x = sense_x;
particle.sense_y = sense_y;
}
string ParticleFilter::getAssociations(Particle best) {
vector<int> v = best.associations;
stringstream ss;
copy( v.begin(), v.end(), ostream_iterator<int>(ss, " "));
string s = ss.str();
s = s.substr(0, s.length()-1); // get rid of the trailing space
return s;
}
string ParticleFilter::getSenseX(Particle best) {
vector<double> v = best.sense_x;
stringstream ss;
copy( v.begin(), v.end(), ostream_iterator<float>(ss, " "));
string s = ss.str();
s = s.substr(0, s.length()-1); // get rid of the trailing space
return s;
}
string ParticleFilter::getSenseY(Particle best) {
vector<double> v = best.sense_y;
stringstream ss;
copy( v.begin(), v.end(), ostream_iterator<float>(ss, " "));
string s = ss.str();
s = s.substr(0, s.length()-1); // get rid of the trailing space
return s;
}
| [
"usedlobster@gmail.com"
] | usedlobster@gmail.com |
a8f5f9a279eb2edc89925a6aa421456d5f475487 | 0ad5d9520e4df29e3a9d700fb8a65bfd0c4da57f | /linux/algorithms/dsa/src/bintree/binnode_travinorder.h | 9cedfc22ca7b1ec27e8f16ea6ec9f914875ae109 | [] | no_license | joeysu33/codenotes | 5793330428348dc2ca022180cbf767d101bc705d | 5eb5296845aeeb8701741549b6d1fe718c323c48 | refs/heads/master | 2022-12-23T01:37:31.444324 | 2021-03-02T00:33:51 | 2021-03-02T00:33:51 | 115,995,226 | 0 | 0 | null | 2022-12-10T05:36:31 | 2018-01-02T08:56:44 | C++ | UTF-8 | C++ | false | false | 1,285 | h | /******************************************************************************************
* Data Structures in C++
* ISBN: 7-302-33064-6 & 7-302-33065-3 & 7-302-29652-2 & 7-302-26883-3
* Junhui DENG, deng@tsinghua.edu.cn
* Computer Science & Technology, Tsinghua University
* Copyright (c) 2006-2013. All rights reserved.
******************************************************************************************/
#pragma once
/*dsa*/#include "../stack/stack.h" //引入栈模板类
/*dsa*/#include "binnode_travinorder_r.h"
/*dsa*/#include "binnode_travinorder_i1.h"
/*dsa*/#include "binnode_travinorder_i2.h"
/*dsa*/#include "binnode_travinorder_i3.h"
/*dsa*/#include "binnode_travinorder_i4.h"
template <typename T> template <typename VST> //元素类型、操作器
void BinNode<T>::travIn ( VST& visit ) { //二叉树中序遍历算法统一入口
switch ( rand() % 5 ) { //此处暂随机选择以做测试，共五种选择
case 1: travIn_I1 ( this, visit ); break; //迭代版#1
case 2: travIn_I2 ( this, visit ); break; //迭代版#2
case 3: travIn_I3 ( this, visit ); break; //迭代版#3
case 4: travIn_I4 ( this, visit ); break; //迭代版#4
default: travIn_R ( this, visit ); break; //递归版
}
}
| [
"davidsu33@qq.com"
] | davidsu33@qq.com |
b78268754f00b66424597b2a609bf43e07b76ba9 | 73cfd700522885a3fec41127e1f87e1b78acd4d3 | /_Include/boost/random/detail/iterator_mixin.hpp | 8fd27c6c7fab3c9bc9536467b927e499ef2b441a | [] | no_license | pu2oqa/muServerDeps | 88e8e92fa2053960671f9f57f4c85e062c188319 | 92fcbe082556e11587887ab9d2abc93ec40c41e4 | refs/heads/master | 2023-03-15T12:37:13.995934 | 2019-02-04T10:07:14 | 2019-02-04T10:07:14 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,538 | hpp | /* boost random/detail/iterator_mixin.hpp header file
*
* Copyright Jens Maurer 2000-2001
* Distributed under the Boost Software License, Version 1.0. (See
* accompanying file LICENSE_1_0.txt or copy at
* http://www.boost.org/LICENSE_1_0.txt)
*
* See http://www.boost.org for most recent version including documentation.
*
* Revision history
*/
#ifndef BOOST_ITERATOR_MIXIN_HPP
#define BOOST_ITERATOR_MIXIN_HPP
#include <boost/operators.hpp>
namespace boost {
// must be in boost namespace, otherwise the inline friend trick fails
template<class Generator, class ResultType>
class generator_iterator_mixin_adapter
: incrementable<Generator>, equality_comparable<Generator>
{
public:
typedef std::input_iterator_tag iterator_category;
typedef ResultType value_type;
typedef std::ptrdiff_t difference_type;
typedef const value_type * pointer;
typedef const value_type & reference;
Generator& operator++() { v = cast()(); return cast(); }
const value_type& operator*() const { return v; }
protected:
// instantiate from derived classes only
generator_iterator_mixin_adapter() { }
void iterator_init() { operator++(); }
private:
Generator & cast() { return static_cast<Generator&>(*this); }
value_type v;
};
} // namespace boost
#endif // BOOST_ITERATOR_MIXIN_HPP
/////////////////////////////////////////////////
// vnDev.Games - Trong.LIVE - DAO VAN TRONG //
////////////////////////////////////////////////////////////////////////////////
| [
"langley.joshua@gmail.com"
] | langley.joshua@gmail.com |
4d40d48f2c78ab0682ab60ce160549df3da8a5a7 | 01345e25f8a9987d13c8776611a62a9b60380481 | /potd-q7/Bar.cpp | e7d30c88ea6bd3c82fe1edfe43a98fb710099de3 | [] | no_license | wenhaoz2/cs225-potd | 4c655e3196c389e0484ac4feb2d9c168e9488feb | d3075969b3724308892ec32a3701824c600ec8d9 | refs/heads/master | 2020-07-29T06:55:53.536377 | 2019-01-02T17:01:27 | 2019-01-02T17:01:27 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 565 | cpp | // your code here
#include "Bar.h"
#include "Foo.h"
#include <string>
using namespace potd;
using namespace std;
Bar::Bar(string name) {
Foo * new_foo = new Foo(name);
this->f_ = new_foo;
}
Bar::Bar(const Bar & existing) {
string name = existing.f_->get_name();
Foo * new_foo = new Foo(name);
this->f_ = new_foo;
}
Bar::~Bar() {
delete(this->f_);
}
Bar & Bar::operator=(const Bar & right) {
delete(this->f_);
Foo * new_foo = new Foo(right.f_->get_name());
this->f_ = new_foo;
return *this;
}
string Bar::get_name() {
return this->f_->get_name();
}
| [
"marcharvey1470@gmail.com"
] | marcharvey1470@gmail.com |
48283814481c0ef9fcc8fbc10151aba205e1f9da | 7873fa1647bab7ecac2bc5a98367aa96f32fb94a | /AMR12D.cpp | 09132271150109e97624290e366f241b3481426d | [] | no_license | pegasus1/SPOJ | 81158badc827e978db0e9c429dc34181f0bfe1ee | eff901d039b63b6a337148dfbe37c1536918bbf8 | refs/heads/master | 2021-01-10T05:32:37.535098 | 2015-06-05T18:20:38 | 2015-06-05T18:20:38 | 36,937,530 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 511 | cpp | #include<stdio.h>
#include<string.h>
#include<algorithm>
int check(char * a,int l)
{
int s = 0;
int x = l-1;
while(s<x)
if(a[s]!=a[x])
return 0;
else
{
s++;
x--;
}
return 1;
}
int main()
{
int t,l;
char s[11];
scanf("%d",&t);
while(t--)
{
int u;
scanf("%s",s);
l = strlen(s);
u = check(s,l);
if(u==1)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| [
"ayush.rajoria@outlook.com"
] | ayush.rajoria@outlook.com |
ce6a3f9c1cdc98d25fcd93d1c24c8258968673d0 | 096961ee99272213aae979902aad0fed8b86a957 | /CodeForces/training/543A.cc | be30411908483f6ff4aed7aa4638a77bc3185ec3 | [] | no_license | yassin64b/competitive-programming | 2d92ee9878e33b5f40da4f0440e994beb595a21b | 180a309da3e12d00c9e4dc384a9aa95ec3e80938 | refs/heads/master | 2021-03-27T15:58:27.450505 | 2020-01-11T16:40:17 | 2020-01-11T16:40:17 | 53,347,417 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,565 | cc | /**
* code generated by JHelper
* More info: https://github.com/AlexeyDmitriev/JHelper
* @author yassin
*/
#include <fstream>
#include <iostream>
#include <vector>
#include <string>
#include <utility>
#include <algorithm>
#include <map>
#include <set>
#include <cmath>
#include <cstdlib>
#include <tuple>
#include <queue>
#include <functional>
#include <stack>
#include <numeric>
#include <cassert>
using namespace std;
class A543 {
public:
void solve(istream &in, ostream &out) {
int n, m, b, mod;
in >> n >> m >> b >> mod;
vector<int> a(n);
for (int i = 0; i < n; ++i) {
in >> a[i];
}
vector<vector<int>> dp(m + 1, vector<int>(b + 1, 0));
dp[0][0] = 1;
for (int i = 0; i < n; ++i) {
for (int j = 0; j <= m; ++j) {
for (int k = 0; k <= b; ++k) {
if (j + 1 <= m && k + a[i] <= b) {
dp[j + 1][k + a[i]] += dp[j][k];
dp[j + 1][k + a[i]] %= mod;
}
//cout << dp[j][k] << " ";
}
//cout << endl;
}
//cout << endl;
}
int res = 0;
for (int k = 0; k <= b; ++k) {
res += dp[m][k];
res %= mod;
}
out << res << "\n";
}
};
int main() {
std::ios::sync_with_stdio(false); cin.tie(nullptr);
A543 solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
| [
"yassin.bahloul@gmx.de"
] | yassin.bahloul@gmx.de |
89202e50e8a84e523bd96e5b577967538011a4ea | 7a2425190626dd2e75dd6cbca9fe47727afbad42 | /src/nstd/hidden_names/log_completion.hpp | 764243fdc39a84c93d8b4f98bc7e87fd7f2c3e78 | [] | no_license | dietmarkuehl/kuhllib | fadd4073c9b09992479e92112ef34c367cb90fad | 482ddc2b910870398a9a2bcaa0a77a145e081f78 | refs/heads/main | 2023-08-31T22:13:02.079530 | 2023-08-21T22:14:14 | 2023-08-21T22:14:14 | 3,148,966 | 71 | 7 | null | 2023-08-21T22:14:15 | 2012-01-10T21:49:09 | C++ | UTF-8 | C++ | false | false | 7,301 | hpp | // nstd/hidden_names/log_completion.hpp -*-C++-*-
// ----------------------------------------------------------------------------
// Copyright (C) 2022 Dietmar Kuehl http://www.dietmar-kuehl.de
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without restriction,
// including without limitation the rights to use, copy, modify,
// merge, publish, distribute, sublicense, and/or sell copies of
// the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
// ----------------------------------------------------------------------------
#ifndef INCLUDED_NSTD_HIDDEN_NAMES_LOG_COMPLETION
#define INCLUDED_NSTD_HIDDEN_NAMES_LOG_COMPLETION
#include "nstd/execution/connect.hpp"
#include "nstd/execution/get_completion_signatures.hpp"
#include "nstd/execution/get_env.hpp"
#include "nstd/execution/receiver.hpp"
#include "nstd/execution/sender.hpp"
#include "nstd/execution/set_error.hpp"
#include "nstd/execution/set_stopped.hpp"
#include "nstd/execution/set_value.hpp"
#include "nstd/utility/forward.hpp"
#include "nstd/utility/move.hpp"
#include <ostream>
#include <string>
// ----------------------------------------------------------------------------
namespace nstd::hidden_names {
inline constexpr struct log_completion_t {
static auto default_stream() -> ::std::ostream&;
template <::nstd::execution::receiver Receiver>
struct receiver {
Receiver d_receiver;
::std::string d_msg;
::std::ostream& d_stream;
friend auto tag_invoke(::nstd::execution::get_env_t, receiver const& self) noexcept {
return ::nstd::execution::get_env(self.d_receiver);
}
template <typename... Args>
friend auto tag_invoke(::nstd::execution::set_value_t, receiver&& self, Args&&... args) noexcept -> void {
self.d_stream << self.d_msg << (self.d_msg.empty()? "": " ") << "set_value(...)\n";
::nstd::execution::set_value(::nstd::utility::move(self.d_receiver),
::nstd::utility::forward<Args>(args)...);
}
template <typename Error>
friend auto tag_invoke(::nstd::execution::set_error_t, receiver&& self, Error&& error) noexcept -> void {
self.d_stream << self.d_msg << (self.d_msg.empty()? "": " ") << "set_error(E)\n";
::nstd::execution::set_error(::nstd::utility::move(self.d_receiver),
::nstd::utility::forward<Error>(error));
}
friend auto tag_invoke(::nstd::execution::set_stopped_t, receiver&& self) noexcept -> void {
self.d_stream << self.d_msg << (self.d_msg.empty()? "": " ") << "set_stopped()\n";
::nstd::execution::set_stopped(::nstd::utility::move(self.d_receiver));
}
};
template <::nstd::execution::sender Sender>
struct sender
: ::nstd::execution::sender_tag {
Sender d_sender;
::std::string d_msg;
::std::ostream& d_stream;
template <::nstd::execution::receiver Receiver>
friend auto tag_invoke(::nstd::execution::connect_t, sender const& self, Receiver&& receiver) {
using receiver_t = ::nstd::hidden_names::log_completion_t::receiver<::nstd::type_traits::remove_cvref_t<Receiver>>;
return ::nstd::execution::connect(
self.d_sender,
receiver_t{
::nstd::utility::forward<Receiver>(receiver),
self.d_msg,
self.d_stream
}
);
}
template <::nstd::execution::receiver Receiver>
friend auto tag_invoke(::nstd::execution::connect_t, sender&& self, Receiver&& receiver) {
using receiver_t = ::nstd::hidden_names::log_completion_t::receiver<::nstd::type_traits::remove_cvref_t<Receiver>>;
return ::nstd::execution::connect(
::nstd::utility::move(self.d_sender),
receiver_t{
::nstd::utility::forward<Receiver>(receiver),
::nstd::utility::move(self.d_msg),
self.d_stream
}
);
}
template <typename Env>
friend auto tag_invoke(::nstd::execution::get_completion_signatures_t, sender const& self, Env env) noexcept {
return ::nstd::execution::get_completion_signatures(self.d_sender, env);
}
};
template <::nstd::execution::sender Sender>
auto operator()(Sender&& sender,
::std::string const& msg,
::std::ostream& stream = ::nstd::hidden_names::log_completion_t::default_stream()) const
-> ::nstd::hidden_names::log_completion_t::sender<::nstd::type_traits::remove_cvref_t<Sender>>
{
return { {}, ::nstd::utility::forward<Sender>(sender), msg, stream };
}
template <::nstd::execution::sender Sender>
auto operator()(Sender&& sender,
::std::ostream& stream = ::nstd::hidden_names::log_completion_t::default_stream()) const
{
return (*this)(::nstd::utility::forward<Sender>(sender), ::std::string(), stream);
}
struct closure
: ::nstd::execution::sender_tag {
::std::string msg;
::std::ostream& stream;
template <::nstd::execution::sender Sender>
auto operator()(Sender&& sender) const {
return ::nstd::hidden_names::log_completion_t()(::nstd::utility::forward<Sender>(sender),
this->msg, this->stream);
}
};
auto operator()(::std::ostream& stream = ::nstd::hidden_names::log_completion_t::default_stream()) const {
return closure{ {}, ::std::string(), stream };
}
auto operator()(::std::string const& msg, ::std::ostream& stream = ::nstd::hidden_names::log_completion_t::default_stream()) const {
return closure{ {}, msg, stream };
}
} log_completion;
}
// ----------------------------------------------------------------------------
#endif
| [
"dietmar.kuehl@me.com"
] | dietmar.kuehl@me.com |
2dbd5fde17b69c00dcaba318bc5ce1b0632b0461 | dd80a584130ef1a0333429ba76c1cee0eb40df73 | /external/chromium_org/third_party/WebKit/Source/wtf/testing/RunAllTests.cpp | 5d27780e99d586068c6249d6eff297fda1cbd7d9 | [
"BSD-3-Clause",
"MIT",
"GPL-1.0-or-later",
"LGPL-2.0-or-later",
"Apache-2.0"
] | permissive | karunmatharu/Android-4.4-Pay-by-Data | 466f4e169ede13c5835424c78e8c30ce58f885c1 | fcb778e92d4aad525ef7a995660580f948d40bc9 | refs/heads/master | 2021-03-24T13:33:01.721868 | 2017-02-18T17:48:49 | 2017-02-18T17:48:49 | 81,847,777 | 0 | 2 | MIT | 2020-03-09T00:02:12 | 2017-02-13T16:47:00 | null | UTF-8 | C++ | false | false | 2,103 | cpp | /*
* Copyright (C) 2013 Google Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#include "wtf/CryptographicallyRandomNumber.h"
#include "wtf/MainThread.h"
#include "wtf/WTF.h"
#include <base/test/test_suite.h>
#include <string.h>
static double CurrentTime()
{
return 0.0;
}
static void AlwaysZeroNumberSource(unsigned char* buf, size_t len)
{
memset(buf, '\0', len);
}
int main(int argc, char** argv)
{
WTF::setRandomSource(AlwaysZeroNumberSource);
WTF::initialize(CurrentTime, 0);
WTF::initializeMainThread(0);
return base::RunUnitTestsUsingBaseTestSuite(argc, argv);
}
| [
"karun.matharu@gmail.com"
] | karun.matharu@gmail.com |
ed3d78b8f0700448ddcfa1dbdc7cf641a42b7a59 | 4060e2d9d840b23979530d88868f15de59fbaf2e | /src/epwing/library.h | c349db14506717539b8f68588e73d75df90be51a | [] | no_license | nellisdev/epwing-exporter | cc7c0d8231630d64ca4d84a8fdd6a6fea0627a40 | 694c9fee00ed1da6e3c69b2130c87951ae2f185f | refs/heads/master | 2023-07-13T15:32:07.235623 | 2021-08-16T14:48:16 | 2021-08-16T14:48:16 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 240 | h | #ifndef EPWING_EXPORTER_EPWING_LIBRARY_H
#define EPWING_EXPORTER_EPWING_LIBRARY_H
namespace epwing {
struct Library final {
Library() noexcept;
~Library() noexcept;
};
}
#endif // EPWING_EXPORTER_EPWING_LIBRARY_H
| [
"marc.szalkiewicz@gmail.com"
] | marc.szalkiewicz@gmail.com |
52461ad31b269bdceb34a9e4a4cf2630c861f66a | 286c7126518a531affc0fda945c34d4553774495 | /multisort/solutions/multisort_mergesort_multiwaybranch_betterconst.cpp | aedcce93c945c40519980427b76b9f328d5df84c | [
"MIT"
] | permissive | indjev99/Competitive-Programming-Problems | fb5fe81089e80d737d3c24e6799d1aac583d22e1 | f5b3203fc2191ba946249af3505259f636f267ef | refs/heads/master | 2023-09-04T07:26:51.528481 | 2023-08-19T00:39:33 | 2023-08-19T00:39:33 | 171,058,102 | 4 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 2,467 | cpp | #include "multisort.h"
#include <algorithm>
#include <numeric>
#include <random>
std::mt19937 generator;
std::vector<int> compTemp;
std::vector<int> storeTemp;
std::vector<int> splits;
std::vector<int> idxs;
std::vector<int> toTake;
std::vector<int> taken;
std::vector<int> srcs;
void mergeSort(int* data, int n, int k, int s)
{
if (n == 1) return;
if (n <= k)
{
compTemp.clear();
std::copy(data, data + n, std::back_inserter(compTemp));
compare(compTemp);
std::copy(compTemp.begin(), compTemp.end(), data);
return;
}
int prev = 0;
for (int i = 1; i <= s; ++i)
{
int curr = n * i / s;
mergeSort(data + prev, curr - prev, k, s);
prev = curr;
}
storeTemp.clear();
for (int i = 0; i <= s; ++i)
{
int curr = n * i / s;
if (i > 0) splits[i - 1] = curr;
if (i < s) idxs[i] = curr;
}
while (true)
{
compTemp.clear();
int notDone = 0;
for (int i = 0; i < s; ++i)
{
if (idxs[i] < splits[i]) ++notDone;
}
if (notDone == 0) break;
toTake.clear();
int prev = 0;
for (int i = 1; i <= notDone; ++i)
{
int curr = k * i / notDone;
toTake.push_back(curr - prev);
prev = curr;
}
std::shuffle(toTake.begin(), toTake.end(), generator);
int ttPos = 0;
for (int i = 0; i < s; ++i)
{
taken[i] = toTake[ttPos];
for (int j = 0; j < toTake[ttPos] && idxs[i] + j < splits[i]; ++j)
{
compTemp.push_back(data[idxs[i] + j]);
srcs[data[idxs[i] + j]] = i;
}
if (idxs[i] < splits[i]) ++ttPos;
}
if (notDone > 1) compare(compTemp);
for (int elem : compTemp)
{
storeTemp.push_back(elem);
++idxs[srcs[elem]];
if (--taken[srcs[elem]] == 0) break;
}
}
std::copy(storeTemp.begin(), storeTemp.end(), data);
}
std::vector<int> multisort(int n, int k)
{
std::vector<int> res(n);
std::iota(res.begin(), res.end(), 0);
int s = 2 + (k > 5) + (k > 18) + (k > 31);
if (k > 58) s = 7 - (k > 91) - (k > 160) - (k > 313);
if (k > 410) s = 7 - (k > 556) - (k > 800);
splits.resize(s);
idxs.resize(s);
taken.resize(s);
srcs.resize(n);
mergeSort(res.data(), n, k, s);
return res;
}
| [
"emil.indjev@gmail.com"
] | emil.indjev@gmail.com |
5a412747ab236d325e050d967989f923715373fc | a904f9c3b0e46bed017bf787ee3ea4d449adb9ab | /7 Wonders Duel/7 Wonders Duel/ActiveProgressTokens.h | 41904eb6d8763c00f8ac8b516cc3310d328ed660 | [] | no_license | rares221/7-wonders-duel | 44e210eb53dd3d7cad5c62e88a1249b70b668fc0 | 21fb6d92defc1c2e6aff30b8e09c4d417789e07c | refs/heads/main | 2023-02-15T03:55:41.897647 | 2021-01-07T18:44:51 | 2021-01-07T18:44:51 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 691 | h | #pragma once
#include <iostream>
#include <array>
#include <string>
#include"ProgressToken.h"
#include<vector>
#include <algorithm>
#include <random>
#include <chrono>
#include <ctime>
class ActiveProgressTokens
{
public:
ActiveProgressTokens() {}
void PopulateProgressTokens();
void ShuffleActiveTokens();
void SetUpProgressTokensForGame();
void DiscardProgressToken(ProgressToken progressToken);
std::vector<ProgressToken> GetActiveProgressTokens() const;
public:
friend std::ostream& operator<<(std::ostream& output, const ActiveProgressTokens& apt);
public:
static const size_t kActiveTokens = 5;
private:
std::vector<ProgressToken> m_activeProgressTokens;
};
| [
"rtaraburca@yahoo.com"
] | rtaraburca@yahoo.com |
67d9aa3f8c76185ab9b5d752ccb7f20769039251 | 1ea09659821c663353ff3d23a91dfe62e5896022 | /examples/SimpleReceive.cpp | a170e68cf423b9109dfa6c14fa22bcaaa5ff855c | [
"MIT"
] | permissive | Multimedia-Orchestra/SimpleOSCMyoHack | de23dc21943c17b2e7781825b38d6d1ef1d0e1fb | efd0b1c52d1bb72a40e2108d9a5e9a877b64e272 | refs/heads/master | 2021-01-01T18:11:11.995894 | 2014-04-06T23:32:46 | 2014-04-06T23:32:46 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,011 | cpp | /*
Example of two different ways to process received OSC messages using oscpack.
Receives the messages from the SimpleSend.cpp example.
*/
#include <iostream>
#include <cstring>
#if defined(__BORLANDC__) // workaround for BCB4 release build intrinsics bug
namespace std {
using ::__strcmp__; // avoid error: E2316 '__strcmp__' is not a member of 'std'.
}
#endif
#include "osc/OscReceivedElements.h"
#include "osc/OscPacketListener.h"
#include "ip/UdpSocket.h"
#define PORT 7000
class ExamplePacketListener : public osc::OscPacketListener {
protected:
virtual void ProcessMessage( const osc::ReceivedMessage& m,
const IpEndpointName& remoteEndpoint )
{
(void) remoteEndpoint; // suppress unused parameter warning
try{
// example of parsing single messages. osc::OsckPacketListener
// handles the bundle traversal.
if( std::strcmp( m.AddressPattern(), "/test1" ) == 0 ){
// example #1 -- argument stream interface
osc::ReceivedMessageArgumentStream args = m.ArgumentStream();
bool a1;
osc::int32 a2;
float a3;
const char *a4;
args >> a1 >> a2 >> a3 >> a4 >> osc::EndMessage;
std::cout << "received '/test1' message with arguments: "
<< a1 << " " << a2 << " " << a3 << " " << a4 << "\n";
}else if( std::strcmp( m.AddressPattern(), "/test2" ) == 0 ){
// example #2 -- argument iterator interface, supports
// reflection for overloaded messages (eg you can call
// (*arg)->IsBool() to check if a bool was passed etc).
osc::ReceivedMessage::const_iterator arg = m.ArgumentsBegin();
bool a1 = (arg++)->AsBool();
int a2 = (arg++)->AsInt32();
float a3 = (arg++)->AsFloat();
const char *a4 = (arg++)->AsString();
if( arg != m.ArgumentsEnd() )
throw osc::ExcessArgumentException();
std::cout << "received '/test2' message with arguments: "
<< a1 << " " << a2 << " " << a3 << " " << a4 << "\n";
}
}catch( osc::Exception& e ){
// any parsing errors such as unexpected argument types, or
// missing arguments get thrown as exceptions.
std::cout << "error while parsing message: "
<< m.AddressPattern() << ": " << e.what() << "\n";
}
}
};
int main(int argc, char* argv[])
{
(void) argc; // suppress unused parameter warnings
(void) argv; // suppress unused parameter warnings
ExamplePacketListener listener;
UdpListeningReceiveSocket s(
IpEndpointName( IpEndpointName::ANY_ADDRESS, PORT ),
&listener );
std::cout << "press ctrl-c to end\n";
s.RunUntilSigInt();
return 0;
}
| [
"niko@mcn.org"
] | niko@mcn.org |
1085c15742ca6bb41ba700eca87d2cb9c5a7d8d8 | 199620098f209fdfcb27313b540ffdf4073a9e03 | /sample_code/pngshow.cxx | 49c3c50d81167d456f03f86272d8527d5e75af20 | [] | no_license | marksun2015/fltk | d48011a3924a796d058cc6be09b58bcd4e078987 | 1f5280334dc595b5faa2d354bd94dc4661f25fca | refs/heads/master | 2021-06-02T23:03:57.479323 | 2018-09-11T07:28:20 | 2018-09-11T07:28:44 | 58,979,413 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 802 | cxx | /* makeinclude add $((LINKFLTKIMG))
* $(CXX) $(ARCHFLAGS) $(LDFLAGS) $< $(LINKFLTK) $(LINKFLTKIMG) $(LDLIBS) -o $@
*
*
*/
#include <FL/Fl_PNG_Image.H>
#include <FL/Fl_Box.H>
#include <FL/Fl.H>
#include <FL/Fl_Double_Window.H>
#include <FL/Fl_Button.H>
#include <FL/Fl_Image.H>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
class Mywin : public Fl_Window {
void resize(int X, int Y, int W, int H) {
Fl_Window::resize(X,Y,W,H);
redraw();
Fl::check();
}
public:
Mywin(int x,int y,int w, int h) : Fl_Window(x,y,w,h) {
}
};
int main() {
Mywin* win = new Mywin(20,20,600,400);
Fl_Box* box = new Fl_Box(100,100,300,200);//for example
Fl_PNG_Image* pngImg = new Fl_PNG_Image("main.png");
box->image(pngImg);
box->show();
win->end();
win->show();
return (Fl::run());
}
| [
"mark@weintek.com"
] | mark@weintek.com |
2b87850cfce5f4cc32159098d9254cb18c870c51 | a638f8d01ba44be8a92541b6e52e8df7d9bd1b1a | /thread_yield/thread_yield.cpp | 790a9c1c67168d1edfc154bd30e5835a4905cacf | [] | no_license | SammyEnigma/C-11-Concurrency | 03a391f41dea9f76757108f8ebbd5dceff782c47 | fa2c0062a59697b7fc6eb4a0b3286acaab30906a | refs/heads/master | 2020-08-02T05:17:16.790417 | 2017-09-20T07:07:06 | 2017-09-20T07:07:06 | 211,246,200 | 0 | 0 | null | 2019-12-14T16:09:11 | 2019-09-27T05:56:36 | null | UTF-8 | C++ | false | false | 544 | cpp | // thread_yield.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include <iostream>
#include <thread>
#include <atomic>
std::atomic<bool> ready(false);
void count1m(int id)
{
while (!ready)
{
std::this_thread::yield();
}
for (volatile int i = 0; i < 1000000; ++i)
{
}
std::cout << id;
}
int main()
{
std::thread task[10];
for (int i = 0; i < 10; ++i)
{
task[i] = std::thread(count1m, i);
}
ready = true;
for (auto& th : task)
{
th.join();
}
std::cout << '\n';
return 0;
}
| [
"dengsheng.wang@deepinfar.com"
] | dengsheng.wang@deepinfar.com |
d90f1df8d6731e325e08a7057d4026cba8d0e347 | 4243054350a33a5cca74e8fdba792e62766d2380 | /src/abnf/Rule_decimal_uchar.cpp | 6d48b218b0003f814ab5273589a5d9d6eeaa3c17 | [
"MIT"
] | permissive | zhangfang/sdp-cpp | f40afb7f25ff2cbeb592f6e1dc12a037c5df4020 | 4bf23de4cf6ade65fedb68a8c8a5baf4bd6a3e6d | refs/heads/master | 2023-02-23T04:27:23.832845 | 2021-01-25T11:47:40 | 2021-01-25T11:47:40 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,850 | cpp | /* -----------------------------------------------------------------------------
* Rule_decimal_uchar.cpp
* -----------------------------------------------------------------------------
*
* Producer : com.parse2.aparse.Parser 2.5
* Produced : Mon Jan 08 13:30:55 CET 2018
*
* -----------------------------------------------------------------------------
*/
#include <string>
using std::string;
#include <vector>
using std::vector;
#include "Rule_decimal_uchar.hpp"
#include "Visitor.hpp"
#include "ParserAlternative.hpp"
#include "ParserContext.hpp"
#include "Rule_DIGIT.hpp"
#include "Rule_POS_DIGIT.hpp"
#include "Rule_decimal_uchar_2xx.hpp"
#include "Rule_decimal_uchar_1xx.hpp"
#include "Rule_decimal_uchar_25x.hpp"
using namespace abnf;
Rule_decimal_uchar::Rule_decimal_uchar(
const string& spelling,
const vector<Rule*>& rules) : Rule(spelling, rules)
{
}
Rule_decimal_uchar::Rule_decimal_uchar(const Rule_decimal_uchar& rule) : Rule(rule)
{
}
Rule_decimal_uchar& Rule_decimal_uchar::operator=(const Rule_decimal_uchar& rule)
{
Rule::operator=(rule);
return *this;
}
Rule* Rule_decimal_uchar::clone() const
{
return new Rule_decimal_uchar(this->spelling, this->rules);
}
void* Rule_decimal_uchar::accept(Visitor& visitor)
{
return visitor.visit(this);
}
Rule_decimal_uchar* Rule_decimal_uchar::parse(ParserContext& context)
{
context.push("decimal-uchar");
bool parsed = true;
int s0 = context.index;
ParserAlternative a0(s0);
vector<const ParserAlternative*> as1;
parsed = false;
{
int s1 = context.index;
ParserAlternative a1(s1);
parsed = true;
if (parsed)
{
bool f1 = true;
int c1 = 0;
Rule* rule = Rule_decimal_uchar_25x::parse(context);
if ((f1 = rule != NULL))
{
a1.add(rule, context.index);
c1++;
}
parsed = c1 == 1;
}
if (parsed)
{
as1.push_back(new ParserAlternative(a1));
}
context.index = s1;
}
{
int s1 = context.index;
ParserAlternative a1(s1);
parsed = true;
if (parsed)
{
bool f1 = true;
int c1 = 0;
Rule* rule = Rule_decimal_uchar_2xx::parse(context);
if ((f1 = rule != NULL))
{
a1.add(rule, context.index);
c1++;
}
parsed = c1 == 1;
}
if (parsed)
{
as1.push_back(new ParserAlternative(a1));
}
context.index = s1;
}
{
int s1 = context.index;
ParserAlternative a1(s1);
parsed = true;
if (parsed)
{
bool f1 = true;
int c1 = 0;
Rule* rule = Rule_decimal_uchar_1xx::parse(context);
if ((f1 = rule != NULL))
{
a1.add(rule, context.index);
c1++;
}
parsed = c1 == 1;
}
if (parsed)
{
as1.push_back(new ParserAlternative(a1));
}
context.index = s1;
}
{
int s1 = context.index;
ParserAlternative a1(s1);
parsed = true;
if (parsed)
{
bool f1 = true;
int c1 = 0;
Rule* rule = Rule_POS_DIGIT::parse(context);
if ((f1 = rule != NULL))
{
a1.add(rule, context.index);
c1++;
}
parsed = c1 == 1;
}
if (parsed)
{
bool f1 = true;
int c1 = 0;
Rule* rule = Rule_DIGIT::parse(context);
if ((f1 = rule != NULL))
{
a1.add(rule, context.index);
c1++;
}
parsed = c1 == 1;
}
if (parsed)
{
as1.push_back(new ParserAlternative(a1));
}
context.index = s1;
}
{
int s1 = context.index;
ParserAlternative a1(s1);
parsed = true;
if (parsed)
{
bool f1 = true;
int c1 = 0;
Rule* rule = Rule_DIGIT::parse(context);
if ((f1 = rule != NULL))
{
a1.add(rule, context.index);
c1++;
}
parsed = c1 == 1;
}
if (parsed)
{
as1.push_back(new ParserAlternative(a1));
}
context.index = s1;
}
const ParserAlternative* b = ParserAlternative::getBest(as1);
if ((parsed = b != NULL))
{
a0.add(b->rules, b->end);
context.index = b->end;
}
for (vector<const ParserAlternative*>::const_iterator a = as1.begin(); a != as1.end(); a++)
{
delete *a;
}
Rule* rule = NULL;
if (parsed)
{
rule = new Rule_decimal_uchar(context.text.substr(a0.start, a0.end - a0.start), a0.rules);
}
else
{
context.index = s0;
}
context.pop("decimal-uchar", parsed);
return (Rule_decimal_uchar*)rule;
}
/* -----------------------------------------------------------------------------
* eof
* -----------------------------------------------------------------------------
*/
| [
"sergio.garcia.murillo@gmail.com"
] | sergio.garcia.murillo@gmail.com |
0fc33f7ea56265adefed3695ae79dce132012ae5 | 1eb2cca85359013f47a476e91f48ab8d8e15dcae | /radion/MvaComputation.h | 4ec841ae11ec8f6f4c2ea20fa1ad4132f314bc01 | [] | no_license | hebda/ggAnalysis | 8acc293deebd63ff01b8662611f0bb697b1e21c2 | ddbaa495a6f5446b75ad993a9fe6c0a92edff553 | refs/heads/master | 2020-03-28T01:03:55.048680 | 2013-10-30T16:31:25 | 2013-10-30T16:31:25 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 14,775 | h | #include "xAna_allAna.h"
#include "VertexSelection.h"
#include "TMVA/Tools.h"
#include "TMVA/Reader.h"
#include <string>
float xAna::sumTrackPtInCone(int phoID, int vtxID, float minPt,
float outerConeRadius, float innerConeRadius,
float etaStripHalfWidth, float dzMax, float d0Max) {
if(vtxID < 0)return -999;
TVector3 vtxpos(vtx[vtxID][0],vtx[vtxID][1],vtx[vtxID][2]);
float sum = 0;
for(int i = 0; i < nTrk; i++){
TVector3 trackp(trkP[i][0],trkP[i][1],trkP[i][2]);
if(trackp.Pt() < minPt)continue;
TVector3 trkVtxVec(trkVtx[i][0],trkVtx[i][1],trkVtx[i][2]);
double deltaz = fabs((vtxpos.Z() - trkVtxVec.Z()) -
( (trkVtxVec.X()-vtxpos.X())*trackp.Px() + (trkVtxVec.Y()-vtxpos.Y())*trackp.Py() )/trackp.Pt() * trackp.Pz()/trackp.Pt() );
if(deltaz > dzMax)continue;
double dxy = (-(trkVtxVec.X() - vtxpos.X())*trackp.Py() + (trkVtxVec.Y() - vtxpos.Y())*trackp.Px())/trackp.Pt();
if(fabs(dxy) > d0Max)continue;
double deta = fabs(phoEtaVtx[phoID][vtxID] - trackp.Eta());
double dphi = fabs(phoPhiVtx[phoID][vtxID] - trackp.Phi());
if(dphi > TMath::Pi())dphi = TMath::TwoPi() - dphi;
double dR = sqrt(deta*deta + dphi*dphi);
if(dR < outerConeRadius && dR >= innerConeRadius && deta >= etaStripHalfWidth)sum += trackp.Pt();
}
return sum;
}
float xAna::worstSumTrackPtInCone(int phoID, int &vtxID, float minPt,
float outerConeRadius, float innerConeRadius,
float etaStripHalfWidth, float dzMax, float d0Max) {
int worstvtxID = -1;
float maxisosum = -1;
for(int i = 0; i < nVtx; i++){
float isosum = sumTrackPtInCone(phoID,i,minPt,outerConeRadius,innerConeRadius,etaStripHalfWidth,dzMax,d0Max);
if(isosum > maxisosum){
maxisosum = isosum;
worstvtxID = i;
}
}
vtxID = worstvtxID;
return maxisosum;
}
//////////////////////
//Setup PhotonID MVA//
//////////////////////
void xAna::Setup_MVA( ) {
/// ------ setup 2011 mva phoID ------ ///
string mvamethod = "BDT";
cout << " Booking 2011 MVA Barrel photon ID with method: " << mvamethod << endl;
phoID_2011[0]->AddVariable("HoE",&phoID_HoE);
phoID_2011[0]->AddVariable("covIEtaIEta",&phoID_covIEtaIEta);
phoID_2011[0]->AddVariable("tIso1abs",&phoID_tIso1abs);
phoID_2011[0]->AddVariable("tIso3abs",&phoID_tIso3abs);
phoID_2011[0]->AddVariable("tIso2abs",&phoID_tIso2abs);
phoID_2011[0]->AddVariable("R9",&phoID_R9);
phoID_2011[0]->AddVariable("absIsoEcal",&phoID_absIsoEcal);
phoID_2011[0]->AddVariable("absIsoHcal",&phoID_absIsoHcal);
phoID_2011[0]->AddVariable("NVertexes",&phoID_NVertexes);
phoID_2011[0]->AddVariable("ScEta",&phoID_ScEta);
phoID_2011[0]->AddVariable("EtaWidth",&phoID_EtaWidth);
phoID_2011[0]->AddVariable("PhiWidth",&phoID_PhiWidth);
phoID_2011[0]->BookMVA(mvamethod.c_str(),"mvaDiscriInputs/PhotonID_Barrel_Weights.xml");
cout << " Booking 2011 MVA Endcap photon ID with method: " << mvamethod << endl;
phoID_2011[1]->AddVariable("HoE",&phoID_HoE);
phoID_2011[1]->AddVariable("covIEtaIEta",&phoID_covIEtaIEta);
phoID_2011[1]->AddVariable("tIso1abs",&phoID_tIso1abs);
phoID_2011[1]->AddVariable("tIso3abs",&phoID_tIso3abs);
phoID_2011[1]->AddVariable("tIso2abs",&phoID_tIso2abs);
phoID_2011[1]->AddVariable("R9",&phoID_R9);
phoID_2011[1]->AddVariable("absIsoEcal",&phoID_absIsoEcal);
phoID_2011[1]->AddVariable("absIsoHcal",&phoID_absIsoHcal);
phoID_2011[1]->AddVariable("NVertexes",&phoID_NVertexes);
phoID_2011[1]->AddVariable("ScEta",&phoID_ScEta);
phoID_2011[1]->AddVariable("EtaWidth",&phoID_EtaWidth);
phoID_2011[1]->AddVariable("PhiWidth",&phoID_PhiWidth);
phoID_2011[1]->BookMVA(mvamethod.c_str(),"mvaDiscriInputs/PhotonID_Endcap_Weights.xml");
/// ---------------------------- ///
/// ------ setup 2012 mva phoID ------ ///
cout << " Booking 2012 MVA Barrel photon ID with method: " << mvamethod << endl;
phoID_2012[0] = new TMVA::Reader("!Color:Silent");
phoID_2012[0]->AddVariable("ph.r9", &phoID_R9 );
phoID_2012[0]->AddVariable("ph.sigietaieta", &phoID_covIEtaIEta );
phoID_2012[0]->AddVariable("ph.scetawidth", &phoID_EtaWidth);
phoID_2012[0]->AddVariable("ph.scphiwidth", &phoID_PhiWidth);
phoID_2012[0]->AddVariable("ph.idmva_CoviEtaiPhi", &phoID_covIEtaIPhi);
phoID_2012[0]->AddVariable("ph.idmva_s4ratio", &phoID_S4);
phoID_2012[0]->AddVariable("ph.idmva_GammaIso", &phoID_pfPhoIso03 );
phoID_2012[0]->AddVariable("ph.idmva_ChargedIso_selvtx", &phoID_pfChIso03 );
phoID_2012[0]->AddVariable("ph.idmva_ChargedIso_worstvtx",&phoID_pfChIso03worst );
phoID_2012[0]->AddVariable("ph.sceta", &phoID_ScEta );
phoID_2012[0]->AddVariable("rho", &phoID_rho);
phoID_2012[0]->BookMVA(mvamethod.c_str(),"mvaDiscriInputs/2012ICHEP_PhotonID_Barrel_BDT.weights.xml");
cout << " Booking 2012 MVA Endcap photon ID with method: " << mvamethod << endl;
phoID_2012[1]->AddVariable("ph.r9", &phoID_R9 );
phoID_2012[1]->AddVariable("ph.sigietaieta", &phoID_covIEtaIEta );
phoID_2012[1]->AddVariable("ph.scetawidth", &phoID_EtaWidth);
phoID_2012[1]->AddVariable("ph.scphiwidth", &phoID_PhiWidth);
phoID_2012[1]->AddVariable("ph.idmva_CoviEtaiPhi", &phoID_covIEtaIPhi);
phoID_2012[1]->AddVariable("ph.idmva_s4ratio", &phoID_S4);
phoID_2012[1]->AddVariable("ph.idmva_GammaIso", &phoID_pfPhoIso03 );
phoID_2012[1]->AddVariable("ph.idmva_ChargedIso_selvtx", &phoID_pfChIso03 );
phoID_2012[1]->AddVariable("ph.idmva_ChargedIso_worstvtx", &phoID_pfChIso03worst );
phoID_2012[1]->AddVariable("ph.sceta", &phoID_ScEta );
phoID_2012[1]->AddVariable("rho", &phoID_rho);
phoID_2012[1]->AddVariable("ph.idmva_PsEffWidthSigmaRR", &phoID_ESEffSigmaRR );
phoID_2012[1]->BookMVA(mvamethod.c_str(),"mvaDiscriInputs/2012ICHEP_PhotonID_Endcap_BDT.weights_PSCorr.xml");
/// ---------------------------- ///
/// --- setup 2011 MVA dipho ---///
cout << " Booking 2011 MVA diphoton dicriminant" << endl;
DiscriDiPho_2011->AddVariable("masserrsmeared/mass",&Ddipho_masserr);
DiscriDiPho_2011->AddVariable("masserrsmearedwrongvtx/mass",&Ddipho_masserrwrongvtx);
DiscriDiPho_2011->AddVariable("vtxprob",&Ddipho_vtxprob);
DiscriDiPho_2011->AddVariable("ph1.pt/mass",&Ddipho_piT1);
DiscriDiPho_2011->AddVariable("ph2.pt/mass",&Ddipho_piT2);
DiscriDiPho_2011->AddVariable("ph1.eta",&Ddipho_eta1);
DiscriDiPho_2011->AddVariable("ph2.eta",&Ddipho_eta2);
DiscriDiPho_2011->AddVariable("TMath::Cos(ph1.phi-ph2.phi)",&Ddipho_cosdPhi);
DiscriDiPho_2011->AddVariable("ph1.idmva",&Ddipho_id1);
DiscriDiPho_2011->AddVariable("ph2.idmva",&Ddipho_id2);
// DiscriDiPho_2011->BookMVA("BDTG","mvaDiscriInputs/MITDiPhotonWeights.xml");
DiscriDiPho_2011->BookMVA("BDTG","mvaDiscriInputs/HggBambu_SMDipho_Jan16_BDTG.weights.xml");
cout << " Booking 2012 MVA diphoton dicriminant" << endl;
DiscriDiPho_2012->AddVariable("masserrsmeared/mass",&Ddipho_masserr);
DiscriDiPho_2012->AddVariable("masserrsmearedwrongvtx/mass",&Ddipho_masserrwrongvtx);
DiscriDiPho_2012->AddVariable("vtxprob",&Ddipho_vtxprob);
DiscriDiPho_2012->AddVariable("ph1.pt/mass",&Ddipho_piT1);
DiscriDiPho_2012->AddVariable("ph2.pt/mass",&Ddipho_piT2);
DiscriDiPho_2012->AddVariable("ph1.eta",&Ddipho_eta1);
DiscriDiPho_2012->AddVariable("ph2.eta",&Ddipho_eta2);
DiscriDiPho_2012->AddVariable("TMath::Cos(ph1.phi-ph2.phi)",&Ddipho_cosdPhi);
DiscriDiPho_2012->AddVariable("ph1.idmva",&Ddipho_id1);
DiscriDiPho_2012->AddVariable("ph2.idmva",&Ddipho_id2);
// DiscriDiPho_2012->BookMVA("BDTG","mvaDiscriInputs/HggBambu_SMDipho_Jun19_BDTG.weights.xml");
DiscriDiPho_2012->BookMVA("BDTG","mvaDiscriInputs/HggBambu_SMDipho_Jul07_BDTG.weights.xml");
/// ------------------------------///
/// ----- setup 2012 MVA VBF -----///
DiscriVBF = new TMVA::Reader("!Color:Silent");
string tmvaVbfMvaWeights = "mvaDiscriInputs/TMVA_vbf_6var_mjj100_diphopt_phopt_BDTG.weights.xml";
DiscriVBF_Method = "BDTG";
cout << " Booking 2012 MVA vbf dicriminant" << endl;
DiscriVBF = new TMVA::Reader( "!Color:!Silent" );
DiscriVBF->AddVariable("jet1pt", &myVBFLeadJPt);
DiscriVBF->AddVariable("jet2pt", &myVBFSubJPt);
DiscriVBF->AddVariable("abs(jet1eta-jet2eta)", &myVBFdEta);
DiscriVBF->AddVariable("mj1j2", &myVBF_Mjj);
DiscriVBF->AddVariable("zepp" , &myVBFZep);
DiscriVBF->AddVariable("dphi" , &myVBFdPhi);
if( DiscriVBF_UseDiPhoPt ) DiscriVBF->AddVariable("diphopt/diphoM", &myVBFDiPhoPtOverM);
if( DiscriVBF_UsePhoPt ) {
DiscriVBF->AddVariable("pho1pt/diphoM", &myVBFLeadPhoPtOverM);
DiscriVBF->AddVariable("pho2pt/diphoM", &myVBFSubPhoPtOverM);
}
DiscriVBF->BookMVA( DiscriVBF_Method, tmvaVbfMvaWeights );
// end of MVA VBF
//setup of MVA for b-jet energy regression
if(doJetRegression==1){
cout<<" Booking b-jet energy regression" << endl;
jetRegres->AddVariable( "jet_eta", &jetRegEta);
jetRegres->AddVariable( "jet_emfrac", &jetRegEMFrac);
jetRegres->AddVariable( "jet_hadfrac", &jetRegHadFrac);
jetRegres->AddVariable( "jet_nconstituents", &jetRegNConstituents);
jetRegres->AddVariable( "jet_vtx3dL", &jetRegVtx3dL);
jetRegres->AddVariable( "MET", &jetRegMET);
jetRegres->AddVariable( "jet_dPhiMETJet", &jetRegDPhiMETJet);
jetRegres->BookMVA("BDTG0","jetRegressionWeights/TMVARegression_Cat0_BDTG.weights.xml");
jetRegres->BookMVA("BDTG1","jetRegressionWeights/TMVARegression_Cat1_BDTG.weights.xml");
}
//end of setup for b-jet energy regression
/// -------------------------------///
/// ----- setup vertex finder -----///
vector<string> tmvaPerVtxVariables;
tmvaPerVtxVariables.push_back("ptbal");
tmvaPerVtxVariables.push_back("ptasym");
tmvaPerVtxVariables.push_back("logsumpt2");
tmvaPerVtxVariables.push_back("limPullToConv");
tmvaPerVtxVariables.push_back("nConv");
string perVtxMvaWeights = "mvaDiscriInputs/TMVAClassification_BDTCat_conversions_tmva_407.weights.xml";
_perVtxMvaMethod = "BDTCat_conversions";
string perEvtMvaWeights = "mvaDiscriInputs/TMVAClassification_evtBDTG_conversions_tmva_407.weights.xml";
_perEvtMvaMethod = "evtBDTG";
string vertexsetup = "configFilesDir/vertex_selection_7TeV.dat";
if( _config->setup().find("2012") != string::npos ) {
perEvtMvaWeights = "mvaDiscriInputs/TMVAClassification_BDTvtxprob2012.weights.xml";
vertexsetup = "configFilesDir/vertex_selection_hcp2012.dat";
_perEvtMvaMethod = "BDTvtxprob2012";
}
_vtxAlgoParams = VertexAlgoParametersReader(vertexsetup);
_vtxAna = new HggVertexAnalyzer(_vtxAlgoParams);
_perVtxReader = 0;
_perEvtReader = 0;
if( perVtxMvaWeights != "" ) {
_perVtxReader = new TMVA::Reader( "!Color:!Silent" );
HggVertexAnalyzer::bookVariables( *_perVtxReader, tmvaPerVtxVariables );
_perVtxReader->BookMVA( _perVtxMvaMethod, perVtxMvaWeights );
}
if( perEvtMvaWeights != "" ) {
_perEvtReader = new TMVA::Reader( "!Color:!Silent" );
HggVertexAnalyzer::bookPerEventVariables( *_perEvtReader );
_perEvtReader->BookMVA( _perEvtMvaMethod, perEvtMvaWeights );
}
cout << " Booking Vertex discriminants" << endl;
cout << " - use conversions : " << _vtxAlgoParams.useAllConversions << endl;
cout << " - single leg sigma1Pix: " << _vtxAlgoParams.singlelegsigma1Pix << endl;
cout << " - check that if use single leg conversion (option=3) then sigma1Pix has meaningful value "
<< endl;
// end of Vertex MVA
}
float xAna::PhoID_MVA( int i, int selVtx ) {
////////////////////
//do photon id mva//
////////////////////
phoID_HoE = phoHoverE[i];
phoID_covIEtaIEta = phoSigmaIEtaIEta[i];
phoID_R9 = phoR9[i];
phoID_absIsoEcal = phoEcalIsoDR03[i] - 0.17*rho25;
phoID_absIsoHcal = phoHcalIsoDR04[i] - 0.17*rho25;
phoID_NVertexes = nVtx;
phoID_ScEta = phoSCEta[i];
phoID_EtaWidth = phoSCEtaWidth[i];
phoID_PhiWidth = phoSCPhiWidth[i];
if( _config->setup() == "Prompt2012_ichep" ) {
phoID_covIEtaIPhi = phoSigmaIEtaIPhi[i];
phoID_S4 = phoS4ratio[i];
phoID_ESEffSigmaRR = phoESEffSigmaRR[i][0];
phoID_rho = rho2012;
phoID_pfPhoIso03 = phoCiCPF4phopfIso03[i];
phoID_pfChIso03 = phoCiCPF4chgpfIso03[i][selVtx];
phoID_pfChIso03worst = -99;
for( int iv=0; iv<nVtxBS ; iv++)
if( phoCiCPF4chgpfIso03[i][iv] > phoID_pfChIso03worst )
phoID_pfChIso03worst = phoCiCPF4chgpfIso03[i][iv];
} else {
int badvtx;
float pho_tkiso_badvtx = worstSumTrackPtInCone(i,badvtx,0,0.4,0.02,0.0,1.0,0.1);
float pho_tkiso_goodvtx = sumTrackPtInCone(i,selVtx,0,0.3,0.02,0.0,1.0,0.1);
phoID_tIso1abs = (pho_tkiso_goodvtx + phoEcalIsoDR03[i] + phoHcalIsoDR04[i] - 0.17*rho25);
phoID_tIso2abs = (pho_tkiso_badvtx + phoEcalIsoDR04[i] + phoHcalIsoDR04[i] - 0.52*rho25);
phoID_tIso3abs = pho_tkiso_goodvtx;
}
return -1;
}
float xAna::DiPhoID_MVA( const TLorentzVector &glead, const TLorentzVector >rail, const TLorentzVector &hcand,
const MassResolution & massResoCalc, float vtxProb,
const float &idlead, const float &idtrail) {
// Ddipho_masserr = massResoCalc.relativeMassResolutionCorrVertex();
Ddipho_masserr = massResoCalc.relativeMassResolutionFab_energy();
Ddipho_masserrwrongvtx = massResoCalc.relativeMassResolutionWrongVertex();
Ddipho_vtxprob = vtxProb;
Ddipho_piT1 = glead.Pt()/hcand.M();
Ddipho_piT2 = gtrail.Pt()/hcand.M();
Ddipho_eta1 = glead.Eta();
Ddipho_eta2 = gtrail.Eta();
Ddipho_cosdPhi = TMath::Cos(glead.Phi()-gtrail.Phi());
Ddipho_id1 = idlead;
Ddipho_id2 = idtrail;
float diphomva = -1;
if( Ddipho_id1 > -0.3 && Ddipho_id2 > -0.3 )
diphomva = Ddipho_mva->EvaluateMVA("BDTG");
/// fill minitree with dipho inputs
_minitree->mtree_massResoRightVtx = Ddipho_masserr;
_minitree->mtree_massResoRandVtx = Ddipho_masserrwrongvtx;
_minitree->mtree_vtxProb = Ddipho_vtxprob;
_minitree->mtree_diphoMva = diphomva;
return diphomva;
}
float xAna::JetRegression(int iJet){
jetRegPt = jetPt[iJet];
jetRegEta = jetEta[iJet];
jetRegEMFrac = jetCEF[iJet]+jetNEF[iJet]+jetMEF[iJet];
jetRegHadFrac = jetCHF[iJet]+jetNHF[iJet];
jetRegNConstituents = jetNConstituents[iJet];
jetRegVtx3dL = jetVtx3dL[iJet];
jetRegMET = recoPfMET;
float tmpPi = 3.1415927, tmpDPhi=fabs(jetPhi[iJet]-recoPfMETPhi);
if(tmpDPhi>tmpPi) tmpDPhi=2*tmpPi-tmpDPhi;
jetRegDPhiMETJet = tmpDPhi;
if(doJetRegression==1){
if(jetPt[iJet]<90) return jetPt[iJet]*jetRegres->EvaluateRegression("BDTG0")[0];
if(jetPt[iJet]>90) return jetPt[iJet]*jetRegres->EvaluateRegression("BDTG1")[0];
}
else return jetPt[iJet];
}
| [
"phebda@princeton.edu"
] | phebda@princeton.edu |
60e18f5a43e139fd1b0e2bf63666633a4d9a908e | a24b3f9b33f511c9535da507d9a8cfcccf1e22ab | /third_party/aten/src/ATen/native/Convolution.cpp | b65759249a2945fd23d1a142523b662f56e35103 | [
"MIT",
"BSD-3-Clause",
"LicenseRef-scancode-generic-cla",
"BSD-2-Clause"
] | permissive | goswamig/caffe2 | 2ba9cc0a0bc7f4630edf3c9656f33be647103287 | cde7f21d1e34ec714bc08dbfab945a1ad30e92ff | refs/heads/master | 2022-12-23T02:57:02.567179 | 2018-04-22T23:32:47 | 2018-04-22T23:32:47 | 130,613,179 | 0 | 1 | NOASSERTION | 2022-12-09T11:20:08 | 2018-04-22T22:31:24 | Jupyter Notebook | UTF-8 | C++ | false | false | 25,723 | cpp | #include "ATen/ATen.h"
#include "ATen/NativeFunctions.h"
#include "ATen/Config.h"
#if AT_CUDNN_ENABLED()
#include "THC/THC.h"
#include "ATen/cudnn/cudnn-wrapper.h"
#endif
#if AT_NNPACK_ENABLED()
#include "nnpack.h"
#endif
namespace at { namespace native {
struct ConvParams {
std::vector<int64_t> stride;
std::vector<int64_t> padding;
std::vector<int64_t> dilation;
bool transposed;
std::vector<int64_t> output_padding;
int groups;
bool benchmark;
bool deterministic;
bool cudnn_enabled;
bool is_strided() const;
bool is_dilated() const;
bool is_padded() const;
bool is_output_padding_neg() const;
bool is_output_padding_big() const;
bool is_padding_neg() const;
void view1d_as_2d();
bool use_cudnn(const at::Tensor& input) const;
bool use_nnpack(const at::Tensor& input) const;
bool is_depthwise(const at::Tensor& input, const at::Tensor& weight) const;
};
std::ostream& operator<<(std::ostream & out, const ConvParams& params) {
out << "ConvParams {"
<< " stride = " << IntList{params.stride}
<< " padding = " << IntList{params.padding}
<< " dilation = " << IntList{params.dilation}
<< " transposed = " << params.transposed
<< " output_padding = " << IntList{params.output_padding}
<< " groups = " << params.groups
<< " benchmark = " << params.benchmark
<< " deterministic = " << params.deterministic
<< " cudnn_enabled = " << params.cudnn_enabled
<< "}";
return out;
}
auto ConvParams::is_strided() const -> bool {
bool is_strided = false;
for (int s : stride) {
is_strided |= (s != 1);
}
return is_strided;
}
auto ConvParams::is_dilated() const -> bool {
bool is_dilated = false;
for (int d : dilation) {
is_dilated |= (d != 1);
}
return is_dilated;
}
auto ConvParams::is_padded() const -> bool {
bool is_padded = false;
for (int p : padding) {
is_padded |= (p != 0);
}
return is_padded;
}
auto ConvParams::is_output_padding_neg() const -> bool {
bool is_non_neg = false;
for (int p : output_padding) {
is_non_neg |= (p < 0);
}
return is_non_neg;
}
auto ConvParams::is_output_padding_big() const -> bool {
bool is_big = false;
for (size_t i = 0; i < output_padding.size(); i++) {
is_big |= (output_padding[i] >= stride[i] || output_padding[i] >= dilation[i]);
}
return is_big;
}
auto ConvParams::is_padding_neg() const -> bool {
bool is_non_neg = false;
for (int p : padding) {
is_non_neg |= (p < 0);
}
return is_non_neg;
}
auto ConvParams::view1d_as_2d() -> void {
if (stride.size() == 1) {
stride.insert(stride.begin(), 1);
padding.insert(padding.begin(), 0);
dilation.insert(dilation.begin(), 1);
output_padding.insert(output_padding.begin(), 0);
}
}
auto ConvParams::use_cudnn(const at::Tensor& input) const -> bool {
#if AT_CUDNN_ENABLED()
if (!input.type().is_cuda() || !cudnn_enabled) {
return false;
}
if (deterministic && is_dilated()) {
// cudnn doesn't support deterministic dilated convolution fully yet
return false;
}
if (is_dilated()) {
cudaDeviceProp* prop = THCState_getCurrentDeviceProperties(globalContext().thc_state);
// NOTE: extra parenthesis around numbers disable clang warnings about dead code
return ((CUDNN_VERSION >= (6021)) || (CUDNN_VERSION >= (6000) && prop->major >= 5)) && !is_output_padding_big();
}
return !is_output_padding_big();
#else
(void)input; // avoid unused parameter warning
#endif
return false;
}
auto ConvParams::use_nnpack(const at::Tensor& input) const -> bool {
#if AT_NNPACK_ENABLED()
return input.type().backend() == kCPU &&
input.type().scalarType() == kFloat && // only on CPU Float Tensors
!is_strided() && // doesn't support strides
!is_dilated() && // or dilation
!transposed && // or transposed tensors
input.ndimension() == 4 && // must be in NCHW format
input.size(0) >= 16; // ensure large enough batch size to ensure perf, tuneable
#endif
return false;
}
// We currently only have depthwise support for the case where groups ==
// nInputPlane and nInputPlane == nOutputPlane (the latter due to the lack of
// a depthwise multiplier)
auto ConvParams::is_depthwise(
const at::Tensor& input, const at::Tensor& weight) const -> bool {
return input.type().is_cuda() &&
!transposed &&
input.ndimension() == 4 &&
input.size(1) == groups &&
groups > 1 && // no point if there is only a single group
weight.size(0) % input.size(1) == 0; // output channels must be a multiple of input channels
}
static void check_input_shape_forward(const at::Tensor& input,
const at::Tensor& weight, const at::Tensor& bias,
int64_t groups, bool transposed) {
int64_t k = input.ndimension();
int64_t weight_dim = weight.ndimension();
if (weight_dim != k) {
std::stringstream ss;
ss << "Expected " << k << "-dimensional weight for " << k
<< "-dimensional input " << input.sizes() << ", but got weight of size "
<< weight.sizes() << " instead";
throw std::runtime_error(ss.str());
}
if (weight.size(0) < groups) {
std::stringstream ss;
ss << "Given groups=" << groups << ", expected weight to be at least "
<< groups << " at dimension 0, but got weight of size " << weight.sizes()
<< " instead";
throw std::runtime_error(ss.str());
}
if (!transposed) {
if (input.size(1) != (weight.size(1) * groups)) {
std::stringstream ss;
ss << "Given groups=" << groups << ", weight" << weight.sizes()
<< ", so expected input" << input.sizes() << " to have "
<< (weight.size(1) * groups) << " channels, but got " << input.size(1)
<< " channels instead";
throw std::runtime_error(ss.str());
}
if (bias.defined() && (bias.ndimension() != 1 || bias.size(0) != weight.size(0))) {
std::stringstream ss;
ss << "Given weight of size " << weight.sizes()
<< ", expected bias to be 1-dimensional with " << weight.size(0) << " elements"
<< ", but got bias of size " << bias.sizes() << " instead";
throw std::runtime_error(ss.str());
}
} else { // transposed
if (input.size(1) != weight.size(0)) {
std::stringstream ss;
ss << "Given transposed=" << transposed << ", weight" << weight.sizes()
<< ", so expected input" << input.sizes() << " to have "
<< weight.size(0) << " channels, but got " << input.size(1)
<< " channels instead";
throw std::runtime_error(ss.str());
}
if (bias.defined() && (bias.ndimension() != 1 || bias.size(0) != weight.size(1) * groups)) {
std::stringstream ss;
ss << "Given transposed=" << transposed << ", weight of size " << weight.sizes()
<< ", expected bias to be 1-dimensional with " << weight.size(1) * groups << " elements"
<< ", but got bias of size " << bias.sizes() << " instead";
throw std::runtime_error(ss.str());
}
}
}
static auto view4d(const at::Tensor& tensor) -> at::Tensor {
if (tensor.ndimension() != 3) throw std::runtime_error("expected 3D tensor");
return tensor.unsqueeze(2);
}
static auto view3d(const at::Tensor& tensor) -> at::Tensor {
if (tensor.ndimension() != 4) throw std::runtime_error("expected 4D tensor");
return tensor.squeeze(2);
}
static at::Tensor subtensor(at::Tensor& tensor, int dim, int groups, int g) {
if (!tensor.defined()) {
return at::Tensor();
}
int64_t n = tensor.sizes()[dim] / groups;
return tensor.narrow(dim, n * g, n).contiguous();
}
at::Tensor conv1d(
const Tensor& input, const Tensor& weight, const Tensor& bias,
IntList stride, IntList padding, IntList dilation, int64_t groups) {
return at::convolution(input, weight, bias, stride, padding, dilation,
false, {{0}}, groups);
}
at::Tensor conv2d(
const Tensor& input, const Tensor& weight, const Tensor& bias,
IntList stride, IntList padding, IntList dilation, int64_t groups) {
return at::convolution(input, weight, bias, stride, padding, dilation,
false, {{0, 0}}, groups);
}
at::Tensor conv3d(
const Tensor& input, const Tensor& weight, const Tensor& bias,
IntList stride, IntList padding, IntList dilation, int64_t groups) {
return at::convolution(input, weight, bias, stride, padding, dilation,
false, {{0, 0, 0}}, groups);
}
at::Tensor conv_transpose1d(
const Tensor& input, const Tensor& weight, const Tensor& bias,
IntList stride, IntList padding, IntList output_padding, int64_t groups, IntList dilation) {
return at::convolution(input, weight, bias, stride, padding, dilation,
true, output_padding, groups);
}
at::Tensor conv_transpose2d(
const Tensor& input, const Tensor& weight, const Tensor& bias,
IntList stride, IntList padding, IntList output_padding, int64_t groups, IntList dilation) {
return at::convolution(input, weight, bias, stride, padding, dilation,
true, output_padding, groups);
}
at::Tensor conv_transpose3d(
const Tensor& input, const Tensor& weight, const Tensor& bias,
IntList stride, IntList padding, IntList output_padding, int64_t groups, IntList dilation) {
return at::convolution(input, weight, bias, stride, padding, dilation,
true, output_padding, groups);
}
at::Tensor convolution(
const Tensor& input, const Tensor& weight, const Tensor& bias,
IntList stride, IntList padding, IntList dilation,
bool transposed, IntList output_padding, int64_t groups) {
auto& ctx = at::globalContext();
return at::_convolution(input, weight, bias, stride, padding, dilation,
transposed, output_padding, groups,
ctx.benchmarkCuDNN(), ctx.deterministicCuDNN(), ctx.userEnabledCuDNN());
}
static inline std::vector<int64_t> convolution_expand_param_if_needed(
IntList list_param, const char *param_name, int64_t expected_dim) {
if (list_param.size() == 1) {
return std::vector<int64_t>(expected_dim, list_param[0]);
} else if ((int64_t) list_param.size() != expected_dim) {
std::ostringstream ss;
ss << "expected " << param_name << " to be a single integer value or a "
<< "list of " << expected_dim << " values to match the convolution "
<< "dimensions, but got " << param_name << "=" << list_param.size();
throw std::runtime_error(ss.str());
} else {
return list_param.vec();
}
}
at::Tensor _convolution(
const Tensor& input_r, const Tensor& weight_r, const Tensor& bias_r,
IntList stride_, IntList padding_, IntList dilation_,
bool transposed_, IntList output_padding_, int64_t groups_,
bool benchmark, bool deterministic, bool cudnn_enabled) {
auto input = input_r.contiguous();
auto weight = weight_r;
auto bias = bias_r;
auto k = input.ndimension();
int64_t dim = k - 2;
if (dim <= 0) {
throw std::runtime_error("input has less dimensions than expected");
}
ConvParams params;
params.stride = convolution_expand_param_if_needed(stride_, "stride", dim);
params.padding = convolution_expand_param_if_needed(padding_, "padding", dim);
params.dilation = convolution_expand_param_if_needed(dilation_, "dilation", dim);
params.transposed = transposed_;
params.output_padding = convolution_expand_param_if_needed(output_padding_, "output_padding", dim);
params.groups = groups_;
params.benchmark = benchmark;
params.deterministic = deterministic;
params.cudnn_enabled = cudnn_enabled;
if (params.is_padding_neg()) throw std::runtime_error("negative padding is not supported");
if (params.is_output_padding_neg()) throw std::runtime_error("negative output_padding is not supported");
check_input_shape_forward(input, weight, bias, params.groups, params.transposed);
if (k == 3) {
params.view1d_as_2d();
input = view4d(input);
weight = view4d(weight);
}
auto output = input.type().tensor();
if (params.is_depthwise(input, weight)) {
/* output.resize_(output_size(input, weight)); */
auto kernel_size = weight.sizes().slice(2);
auto stride = params.stride;
auto padding = params.padding;
auto dilation = params.dilation;
output = at::thnn_conv_depthwise2d(input, weight, kernel_size, bias, stride, padding, dilation);
} else if (params.use_cudnn(input)) {
#if AT_CUDNN_ENABLED()
if (input.type() != weight.type()){
std::stringstream ss;
ss << "Input type (" << input.type().toString() << ") and weight type (" << weight.type().toString() << ") should be the same";
throw std::runtime_error(ss.str());
}
if (bias.defined() && input.type() != bias.type()){
std::stringstream ss;
ss << "Input type (" << input.type().toString() << ") and bias type (" << bias.type().toString() << ") should be the same";
throw std::runtime_error(ss.str());
}
if (params.transposed) {
output = at::cudnn_convolution_transpose(
input, weight, bias,
params.padding, params.output_padding, params.stride, params.dilation, params.groups, params.benchmark, params.deterministic);
} else {
output = at::cudnn_convolution(
input, weight, bias,
params.padding, params.stride, params.dilation, params.groups, params.benchmark, params.deterministic);
}
#endif
} else {
if (params.groups == 1) {
output = at::_convolution_nogroup(
input, weight, bias, params.stride, params.padding, params.dilation, params.transposed, params.output_padding);
} else {
std::vector<Tensor> outputs(params.groups);
for (int g = 0; g < params.groups; ++g) {
auto input_g = subtensor(input, 1, params.groups, g);
auto weight_g = subtensor(weight, 0, params.groups, g);
auto bias_g = subtensor(bias, 0, params.groups, g);
outputs[g] = at::_convolution_nogroup(
input_g, weight_g, bias_g, params.stride, params.padding, params.dilation, params.transposed, params.output_padding);
}
output = at::cat(outputs, 1);
}
}
if (k == 3) {
output = view3d(output);
}
return output;
}
// A generic function for convolution implementations which don't
// natively implement groups (e.g., not CuDNN).
at::Tensor _convolution_nogroup(
const Tensor& input, const Tensor& weight, const Tensor& bias,
IntList stride, IntList padding, IntList dilation,
bool transposed, IntList output_padding) {
ConvParams params;
params.stride = stride;
params.padding = padding;
params.dilation = dilation;
params.transposed = transposed;
params.output_padding = output_padding;
params.groups = 1;
params.benchmark = false;
params.deterministic = false;
params.cudnn_enabled = false;
auto dim = input.ndimension();
auto dilated = params.is_dilated();
auto kernel_size = weight.sizes().slice(2);
if (params.transposed) {
if (dim == 4) {
return at::thnn_conv_transpose2d(
input, weight, kernel_size, bias,
stride, padding, output_padding, dilation);
} else if (dim == 5) {
return at::thnn_conv_transpose3d(
input, weight, kernel_size, bias,
stride, padding, output_padding, dilation);
}
} else { /* Not transposed */
if (dim == 4) {
if (dilated) {
return at::thnn_conv_dilated2d(
input, weight, kernel_size, bias,
stride, padding, dilation);
} else { /* dim == 4, non-dilated */
if (params.use_nnpack(input)) {
#if AT_NNPACK_ENABLED()
return at::nnpack_spatial_convolution(
input, weight, bias,
kernel_size[1], kernel_size[0],
params.padding[1], params.padding[0]);
#endif
} else {
/* CPU implementation has specialized MM kernels
for non-dilated case here */
return at::thnn_conv2d(
input, weight, kernel_size, bias,
stride, padding);
}
}
} else if (dim == 5 && (input.type().is_cuda() || dilated)) {
return at::thnn_conv_dilated3d(
input, weight, kernel_size, bias,
stride, padding, dilation);
} else if (dim == 5) { /* dim == 5, CPU, non-dilated */
/* CPU implementation has specialized MM kernels
for non-dilated case here */
return at::thnn_conv3d(
input, weight, kernel_size, bias,
stride, padding);
}
}
throw std::runtime_error("unsupported ConvNd parameters");
}
static Tensor subvariable(const Tensor& var, int dim, int groups, int g) {
int64_t n = var.sizes()[dim] / groups;
auto result = var.narrow(dim, n * g, n);
return result;
}
std::tuple<Tensor,Tensor,Tensor> _convolution_double_backward(
const Tensor& ggI, const Tensor& ggW_r, const Tensor& ggb,
const Tensor& gO_r, const Tensor& weight_r, const Tensor& input,
IntList stride_, IntList padding_, IntList dilation_,
bool transposed_, IntList output_padding_, int64_t groups_,
bool benchmark, bool deterministic, bool cudnn_enabled,
std::array<bool, 3> output_mask) {
auto ggW = ggW_r;
auto gO = gO_r;
auto weight = weight_r;
ConvParams params;
params.stride = stride_;
params.padding = padding_;
params.dilation = dilation_;
params.transposed = transposed_;
params.output_padding = output_padding_;
params.groups = groups_;
params.benchmark = benchmark;
params.deterministic = deterministic;
params.cudnn_enabled = cudnn_enabled;
// Compute ggO = conv(ggI, w) + conv(i, ggW) + ggb
Tensor ggO;
if (ggI.defined()) {
if (weight.type().is_cuda()) {
weight = weight.contiguous();
}
ggO = at::_convolution(ggI, weight, Tensor(), params.stride, params.padding, params.dilation, params.transposed, params.output_padding, params.groups, params.benchmark, params.deterministic, params.cudnn_enabled);
}
if (ggW.defined()) {
if (ggW.type().is_cuda()) {
ggW = ggW.contiguous();
}
auto ggW_term = at::_convolution(input, ggW, Tensor(), params.stride, params.padding, params.dilation, params.transposed, params.output_padding, params.groups, params.benchmark, params.deterministic, params.cudnn_enabled);
if (ggO.defined()) {
ggO = ggO + ggW_term;
} else {
ggO = ggW_term;
}
}
if (ggb.defined()) {
// View as (1, ggb.size(0), 1, 1...)
// Expand
std::vector<int64_t> new_size(gO.ndimension(), 1);
new_size[1] = ggb.sizes()[0];
auto ggb_contiguous = ggb.contiguous();
auto ggb_view = ggb_contiguous.view(new_size);
// Expand
auto ggb_expanded = ggb_view.expand(gO.sizes());
if (ggO.defined()) {
ggO = ggO + ggb_expanded;
} else {
ggO = ggb_expanded;
}
}
// Compute gW = conv(ggI, gO)
Tensor gW;
if (ggI.defined()) {
// Modified params with correct padding
ConvParams gw_conv_params(params);
// Disable groups as they are handled separately
auto groups = gw_conv_params.groups;
gw_conv_params.groups = 1;
std::swap(gw_conv_params.dilation, gw_conv_params.stride);
// Transpose gO and ggI to accumulate over batch
auto gOt = gO.transpose(0, 1);
auto ggIt = ggI.transpose(0, 1);
Tensor gWt;
// Compute conv
if (groups == 1) {
if (gOt.type().is_cuda()) {
gOt = gOt.contiguous();
}
// Compute conv
if (params.transposed) {
gw_conv_params.transposed = false;
gWt = at::_convolution(gOt, ggIt, Tensor(), gw_conv_params.stride, gw_conv_params.padding, gw_conv_params.dilation, gw_conv_params.transposed, gw_conv_params.output_padding, gw_conv_params.groups, gw_conv_params.benchmark, gw_conv_params.deterministic, gw_conv_params.cudnn_enabled);
} else {
gWt = at::_convolution(ggIt, gOt, Tensor(), gw_conv_params.stride, gw_conv_params.padding, gw_conv_params.dilation, gw_conv_params.transposed, gw_conv_params.output_padding, gw_conv_params.groups, gw_conv_params.benchmark, gw_conv_params.deterministic, gw_conv_params.cudnn_enabled);
}
} else {
std::vector<Tensor> gWt_list(groups);
for (int g = 0; g < groups; ++g) {
auto ggIt_g = subvariable(ggIt, 0, groups, g);
auto gOt_g = subvariable(gOt, 0, groups, g);
if (gOt_g.type().is_cuda()) {
gOt_g = gOt_g.contiguous();
}
// Compute conv
if (params.transposed) {
gw_conv_params.transposed = false;
gWt_list[g] = at::_convolution(gOt_g, ggIt_g, Tensor(), gw_conv_params.stride, gw_conv_params.padding, gw_conv_params.dilation, gw_conv_params.transposed, gw_conv_params.output_padding, gw_conv_params.groups, gw_conv_params.benchmark, gw_conv_params.deterministic, gw_conv_params.cudnn_enabled);
} else {
gWt_list[g] = at::_convolution(ggIt_g, gOt_g, Tensor(), gw_conv_params.stride, gw_conv_params.padding, gw_conv_params.dilation, gw_conv_params.transposed, gw_conv_params.output_padding, gw_conv_params.groups, gw_conv_params.benchmark, gw_conv_params.deterministic, gw_conv_params.cudnn_enabled);
}
}
gWt = at::cat(gWt_list, 1);
}
// Transpose gW to match chan_in and chan_out
gW = gWt.transpose(0, 1);
// narrow gW to only relevant portion
// we do it this way instead of narrowing the input itself because
// the ConvForward kernels don't support asymmetric padding.
auto gW_size = gW.sizes();
auto w_size = weight.sizes();
for (size_t i = 2; i < gW_size.size(); ++i) {
if (gW_size[i] > w_size[i]) {
gW = gW.narrow(i, 0, w_size[i]);
gW_size = gW.sizes();
}
}
}
// Compute gI = convT(ggW, gO.t()) if !transposed
// gI = conv(go, ggw) if transposed
Tensor gI;
if (ggW.defined()) {
ConvParams gi_conv_params(params);
gi_conv_params.transposed = !params.transposed;
if (params.transposed) {
if (gO.type().is_cuda()) {
gO = gO.contiguous();
}
gI = at::_convolution(gO, ggW, Tensor(), gi_conv_params.stride, gi_conv_params.padding, gi_conv_params.dilation, gi_conv_params.transposed, gi_conv_params.output_padding, gi_conv_params.groups, gi_conv_params.benchmark, gi_conv_params.deterministic, gi_conv_params.cudnn_enabled);
// narrow gI to only relevant portion
// we do it this way because negative output_padding is not supported
// TODO: figure out if we can narrow gO and save some compute,
// rather than narrowing the computed gI
auto gI_size = gI.sizes();
auto i_size = input.sizes();
for (size_t i = 2; i < gI_size.size(); ++i) {
if (gI_size[i] > i_size[i]) {
gI = gI.narrow(i, 0, i_size[i]);
gI_size = gI.sizes();
}
}
} else {
auto groups = gi_conv_params.groups;
gi_conv_params.groups = 1;
// swap stride and dilation
std::swap(gi_conv_params.dilation, gi_conv_params.stride);
auto ggWt = ggW.transpose(0, 1);
auto gOt = gO.transpose(0, 1);
// calculate output_padding
// TODO: figure out why this needs to be computed...
auto kernel_size = weight.sizes().slice(2);
auto input_shape = input.sizes().slice(2);
auto grad_output_shape = gO.sizes().slice(2);
if (kernel_size.size() == 1) {
auto expected_input_shape = (kernel_size[0] - 1) * gi_conv_params.stride[1]
- 2 * gi_conv_params.padding[1]
+ (gi_conv_params.dilation[1] * (grad_output_shape[0] - 1) + 1);
if (expected_input_shape != input_shape[0]) {
gi_conv_params.output_padding[1] = input_shape[0] - expected_input_shape;
}
} else {
for(size_t i = 0; i < kernel_size.size(); ++i) {
// Check if whole input has been used or not
auto expected_input_shape = (kernel_size[i] - 1) * gi_conv_params.stride[i]
- 2 * gi_conv_params.padding[i]
+ (gi_conv_params.dilation[i] * (grad_output_shape[i] - 1) + 1);
if (expected_input_shape != input_shape[i]) {
gi_conv_params.output_padding[i] = input_shape[i] - expected_input_shape;
}
}
}
Tensor gIt;
if (params.groups == 1) {
if (gOt.type().is_cuda()) {
gOt = gOt.contiguous();
}
gIt = at::_convolution(ggWt, gOt, Tensor(), gi_conv_params.stride, gi_conv_params.padding, gi_conv_params.dilation, gi_conv_params.transposed, gi_conv_params.output_padding, gi_conv_params.groups, gi_conv_params.benchmark, gi_conv_params.deterministic, gi_conv_params.cudnn_enabled);
} else {
std::vector<Tensor> gIt_list(params.groups);
for (int g = 0; g < groups; ++g) {
auto ggWt_g = subvariable(ggWt, 1, groups, g);
auto gOt_g = subvariable(gOt, 0, groups, g);
if (gOt_g.type().is_cuda()) {
gOt_g = gOt_g.contiguous();
}
gIt_list[g] = at::_convolution(ggWt_g, gOt_g, Tensor(), gi_conv_params.stride, gi_conv_params.padding, gi_conv_params.dilation, gi_conv_params.transposed, gi_conv_params.output_padding, gi_conv_params.groups, gi_conv_params.benchmark, gi_conv_params.deterministic, gi_conv_params.cudnn_enabled);
}
gIt = at::cat(gIt_list, 0);
}
gI = gIt.transpose(0, 1);
}
}
if (output_mask[0] && !ggO.defined()) ggO = at::zeros_like(gO);
if (output_mask[1] && !gI.defined()) gI = at::zeros_like(input);
if (output_mask[2] && !gW.defined()) gW = at::zeros_like(weight);
return std::tuple<Tensor,Tensor,Tensor>{ggO, gI, gW};
}
}} // at::native
| [
"gautamnitc@gmail.com"
] | gautamnitc@gmail.com |
e19529e10373433464b4201e322eb3a495b11821 | 693bd39eb66eade67997bc608fe84e76e66eeec2 | /mpp/base/mpp_task.cpp | 4a2b597388763d51ba89fa13f2d16c5e2c5377c3 | [] | permissive | HermanChen/mpp | 6a1751777b120b764f86e0f34975231054a3c262 | 0af9b5becc76c4685831214808e124e65543297b | refs/heads/develop | 2023-08-17T07:17:49.489974 | 2023-07-31T08:26:14 | 2023-08-11T07:38:17 | 71,088,248 | 139 | 79 | Apache-2.0 | 2023-03-08T09:44:01 | 2016-10-17T01:13:37 | C | UTF-8 | C++ | false | false | 4,028 | cpp | /*
* Copyright 2015 Rockchip Electronics Co. LTD
*
* 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.
*/
#define MODULE_TAG "mpp_task"
#include <string.h>
#include "mpp_task.h"
#include "mpp_task_impl.h"
MPP_RET mpp_task_meta_set_s32(MppTask task, MppMetaKey key, RK_S32 val)
{
if (check_mpp_task_name(task))
return MPP_NOK;
MppTaskImpl *impl = (MppTaskImpl *)task;
return mpp_meta_set_s32(impl->meta, key, val);
}
MPP_RET mpp_task_meta_set_s64(MppTask task, MppMetaKey key, RK_S64 val)
{
if (check_mpp_task_name(task))
return MPP_NOK;
MppTaskImpl *impl = (MppTaskImpl *)task;
return mpp_meta_set_s64(impl->meta, key, val);
}
MPP_RET mpp_task_meta_set_ptr(MppTask task, MppMetaKey key, void *val)
{
if (check_mpp_task_name(task))
return MPP_NOK;
MppTaskImpl *impl = (MppTaskImpl *)task;
return mpp_meta_set_ptr(impl->meta, key, val);
}
MPP_RET mpp_task_meta_set_frame(MppTask task, MppMetaKey key, MppFrame frame)
{
if (check_mpp_task_name(task))
return MPP_NOK;
MppTaskImpl *impl = (MppTaskImpl *)task;
return mpp_meta_set_frame(impl->meta, key, frame);
}
MPP_RET mpp_task_meta_set_packet(MppTask task, MppMetaKey key, MppPacket packet)
{
if (check_mpp_task_name(task))
return MPP_NOK;
MppTaskImpl *impl = (MppTaskImpl *)task;
return mpp_meta_set_packet(impl->meta, key, packet);
}
MPP_RET mpp_task_meta_set_buffer(MppTask task, MppMetaKey key, MppBuffer buffer)
{
if (check_mpp_task_name(task))
return MPP_NOK;
MppTaskImpl *impl = (MppTaskImpl *)task;
return mpp_meta_set_buffer(impl->meta, key, buffer);
}
MPP_RET mpp_task_meta_get_s32(MppTask task, MppMetaKey key, RK_S32 *val, RK_S32 default_val)
{
if (check_mpp_task_name(task))
return MPP_NOK;
MppTaskImpl *impl = (MppTaskImpl *)task;
MPP_RET ret = mpp_meta_get_s32(impl->meta, key, val);
if (ret)
*val = default_val;
return ret;
}
MPP_RET mpp_task_meta_get_s64(MppTask task, MppMetaKey key, RK_S64 *val, RK_S64 default_val)
{
if (check_mpp_task_name(task))
return MPP_NOK;
MppTaskImpl *impl = (MppTaskImpl *)task;
MPP_RET ret = mpp_meta_get_s64(impl->meta, key, val);
if (ret)
*val = default_val;
return ret;
}
MPP_RET mpp_task_meta_get_ptr(MppTask task, MppMetaKey key, void **val, void *default_val)
{
if (check_mpp_task_name(task))
return MPP_NOK;
MppTaskImpl *impl = (MppTaskImpl *)task;
MPP_RET ret = mpp_meta_get_ptr(impl->meta, key, val);
if (ret)
*val = default_val;
return ret;
}
MPP_RET mpp_task_meta_get_frame(MppTask task, MppMetaKey key, MppFrame *frame)
{
if (check_mpp_task_name(task))
return MPP_NOK;
MppTaskImpl *impl = (MppTaskImpl *)task;
MPP_RET ret = mpp_meta_get_frame(impl->meta, key, frame);
if (ret)
*frame = NULL;
return ret;
}
MPP_RET mpp_task_meta_get_packet(MppTask task, MppMetaKey key, MppPacket *packet)
{
if (check_mpp_task_name(task))
return MPP_NOK;
MppTaskImpl *impl = (MppTaskImpl *)task;
MPP_RET ret = mpp_meta_get_packet(impl->meta, key, packet);
if (ret)
*packet = NULL;
return ret;
}
MPP_RET mpp_task_meta_get_buffer(MppTask task, MppMetaKey key, MppBuffer *buffer)
{
if (check_mpp_task_name(task))
return MPP_NOK;
MppTaskImpl *impl = (MppTaskImpl *)task;
MPP_RET ret = mpp_meta_get_buffer(impl->meta, key, buffer);
if (ret)
*buffer = NULL;
return ret;
}
| [
"herman.chen@rock-chips.com"
] | herman.chen@rock-chips.com |
136d12c68551aeb93d32e76fb299692e9d86eb0e | fb3c13324e6a6dd31cf20171e008c7f77fad913d | /2016/QtTest/BasicAlgebra/main.cpp | 4a0da7eb8144d00fa4a9e4473986cfa1796d0912 | [] | no_license | zhaofeng-shu33/tech-chores-archive | 4eb0aae27966d9c6e543a99ce8eef3cbc9ebc331 | 07ed63e552d535b03efdf17293f0194ff725ea2c | refs/heads/master | 2023-01-08T10:54:17.883093 | 2023-01-08T08:36:26 | 2023-01-08T08:36:26 | 253,170,849 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 201 | cpp | //use stack structure to realize basic algebraic computation.
#include <QString>
#include "stdio.h"
int main()
{
QString a("Hello world");
printf("%s",a.toStdString().c_str());
return 0;
}
| [
"616545598@qq.com"
] | 616545598@qq.com |
7f12806cdd670b15aadb12622b42e7fdc742ad85 | 5e1dee44b9f5708793b1da7c84b66bf363312daf | /include/cxxhttp/http-error.h | 534cdaa244e78e8641c17130cfd9c79a62eb157c | [
"MIT"
] | permissive | dbc60/cxxhttp | 0c4841f0797433ba7812a37f2acfabd89049c016 | d874b17e6c2bbf7d66983d43944c53b105aec51b | refs/heads/master | 2021-04-15T18:51:44.918670 | 2017-06-25T17:13:40 | 2017-06-25T17:13:40 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,400 | h | /* HTTP error handling.
*
* Provides some abstractions to send back errors to clients.
*
* See also:
* * Project Documentation: https://ef.gy/documentation/cxxhttp
* * Project Source Code: https://github.com/ef-gy/cxxhttp
* * Licence Terms: https://github.com/ef-gy/cxxhttp/blob/master/COPYING
*
* @copyright
* This file is part of the cxxhttp project, which is released as open source
* under the terms of an MIT/X11-style licence, described in the COPYING file.
*/
#if !defined(CXXHTTP_HTTP_ERROR_H)
#define CXXHTTP_HTTP_ERROR_H
#include <set>
#include <cxxhttp/http-header.h>
#include <cxxhttp/http-session.h>
#include <cxxhttp/http-status.h>
#include <cxxhttp/negotiate.h>
namespace cxxhttp {
namespace http {
/* Error reply handler.
*
* `error` slightly simplifies and unifies error responses to clients, by
* generating an appropriate response when an error needs to be sent.
*/
class error {
public:
/* Allowed methods.
*
* Sent as an `Allow` header, but only if it has been set.
*/
std::set<std::string> allow;
/* Construct with session.
* @pSession Where to send things to.
*
* Keeps track of a session object, which is used when trying to send an error
* to the client.
*/
error(sessionData &pSession) : session(pSession) {}
/* Send error code to client.
* @status The status code to send to the client. Should be an error code.
*
* This constructs and sends a simple error reply to the client.
*/
void reply(unsigned status) const {
std::string type = negotiate(session.inbound.get("Accept"),
"text/markdown, text/plain;q=0.9");
bool negotiationSuccess = !type.empty();
if (type.empty()) {
type = "text/markdown";
}
std::string body =
"# " + statusLine::getDescription(status) +
"\n\n"
"An error occurred while processing your request. " +
(negotiationSuccess ? "" : "Additionally, content type negotiation for "
"this error page failed. ") +
"That's all I know.\n";
parser<headers> p{{{"Content-Type", type}}};
for (const auto &m : allow) {
p.append("Allow", m);
}
session.reply(status, body, p.header);
}
protected:
/* The recorded session.
*
* Set in the constructor and used when sending replies.
*/
sessionData &session;
};
}
}
#endif
| [
"magnus@ef.gy"
] | magnus@ef.gy |
302db66fe2615cac4b28587fff5c3af7a4e60be5 | 71653887a9d519e4dd65d86fb5c50fae1dcf0fce | /Source/Context.cpp | 639b21dc8ab1d7a26c7858c61d69e40cd26b8714 | [
"MIT"
] | permissive | Hopson97/Slonda-Man | 8b26662e56d7e7c9b2cdaf0a0953e5eb52138911 | 169f95b8db9f1cb694ab459973f98287e5979ab6 | refs/heads/master | 2022-07-01T07:02:16.141668 | 2018-12-18T07:37:57 | 2018-12-18T07:37:57 | 107,316,067 | 8 | 2 | MIT | 2022-06-18T17:52:31 | 2017-10-17T19:43:18 | C | UTF-8 | C++ | false | false | 684 | cpp | #include "Context.h"
#include "Glad/glad.h"
#include "GLLib/GLFunctions.h"
Context::Context()
{
sf::ContextSettings settings;
settings.antialiasingLevel = 0;
settings.majorVersion = 3;
settings.minorVersion = 3;
settings.depthBits = 24;
settings.stencilBits = 8;
//window.create(sf::VideoMode::getDesktopMode(), "Slender", sf::Style::Fullscreen, settings);
window.create({1422, 800}, "Slender", sf::Style::Close, settings);
window.setMouseCursorVisible(false);
gladLoadGL();
glViewport(0, 0, window.getSize().x, window.getSize().y);
GL::enable(GL::Cap::DepthTest);
GL::enable(GL::Cap::CullFace);
glCullFace(GL_BACK);
}
| [
"mhopson@hotmail.co.uk"
] | mhopson@hotmail.co.uk |
e695226da3631a207d70b6fab5d21538dc1d4ce1 | a489e3c28cbdbdc68405c161d50db66744ed343c | /src/wallet/coinselection.h | 9bd3b769b2d12d830fcc85399843285711d33a49 | [
"MIT"
] | permissive | satcoin-dev/satcoin | 5284f9f13f3a8797b38f97aa5f3a7c074e648a7e | a68f5965a8c28cfcaf8855a661ea3f15de9ae7d5 | refs/heads/master | 2023-05-08T06:13:54.490717 | 2021-05-31T11:17:18 | 2021-05-31T11:17:18 | 329,268,860 | 4 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 3,685 | h | // Copyright (c) 2017-2018 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#ifndef SATCOIN_WALLET_COINSELECTION_H
#define SATCOIN_WALLET_COINSELECTION_H
#include <amount.h>
#include <primitives/transaction.h>
#include <random.h>
//! target minimum change amount
static constexpr CAmount MIN_CHANGE{COIN / 100};
//! final minimum change amount after paying for fees
static const CAmount MIN_FINAL_CHANGE = MIN_CHANGE/2;
class CInputCoin {
public:
CInputCoin(const CTransactionRef& tx, unsigned int i)
{
if (!tx)
throw std::invalid_argument("tx should not be null");
if (i >= tx->vout.size())
throw std::out_of_range("The output index is out of range");
outpoint = COutPoint(tx->GetHash(), i);
txout = tx->vout[i];
effective_value = txout.nValue;
}
CInputCoin(const CTransactionRef& tx, unsigned int i, int input_bytes) : CInputCoin(tx, i)
{
m_input_bytes = input_bytes;
}
COutPoint outpoint;
CTxOut txout;
CAmount effective_value;
/** Pre-computed estimated size of this output as a fully-signed input in a transaction. Can be -1 if it could not be calculated */
int m_input_bytes{-1};
bool operator<(const CInputCoin& rhs) const {
return outpoint < rhs.outpoint;
}
bool operator!=(const CInputCoin& rhs) const {
return outpoint != rhs.outpoint;
}
bool operator==(const CInputCoin& rhs) const {
return outpoint == rhs.outpoint;
}
};
struct CoinEligibilityFilter
{
const int conf_mine;
const int conf_theirs;
const uint64_t max_ancestors;
const uint64_t max_descendants;
CoinEligibilityFilter(int conf_mine, int conf_theirs, uint64_t max_ancestors) : conf_mine(conf_mine), conf_theirs(conf_theirs), max_ancestors(max_ancestors), max_descendants(max_ancestors) {}
CoinEligibilityFilter(int conf_mine, int conf_theirs, uint64_t max_ancestors, uint64_t max_descendants) : conf_mine(conf_mine), conf_theirs(conf_theirs), max_ancestors(max_ancestors), max_descendants(max_descendants) {}
};
struct OutputGroup
{
std::vector<CInputCoin> m_outputs;
bool m_from_me{true};
CAmount m_value{0};
int m_depth{999};
size_t m_ancestors{0};
size_t m_descendants{0};
CAmount effective_value{0};
CAmount fee{0};
CAmount long_term_fee{0};
OutputGroup() {}
OutputGroup(std::vector<CInputCoin>&& outputs, bool from_me, CAmount value, int depth, size_t ancestors, size_t descendants)
: m_outputs(std::move(outputs))
, m_from_me(from_me)
, m_value(value)
, m_depth(depth)
, m_ancestors(ancestors)
, m_descendants(descendants)
{}
OutputGroup(const CInputCoin& output, int depth, bool from_me, size_t ancestors, size_t descendants) : OutputGroup() {
Insert(output, depth, from_me, ancestors, descendants);
}
void Insert(const CInputCoin& output, int depth, bool from_me, size_t ancestors, size_t descendants);
std::vector<CInputCoin>::iterator Discard(const CInputCoin& output);
bool EligibleForSpending(const CoinEligibilityFilter& eligibility_filter) const;
};
bool SelectCoinsBnB(std::vector<OutputGroup>& utxo_pool, const CAmount& target_value, const CAmount& cost_of_change, std::set<CInputCoin>& out_set, CAmount& value_ret, CAmount not_input_fees);
// Original coin selection algorithm as a fallback
bool KnapsackSolver(const CAmount& nTargetValue, std::vector<OutputGroup>& groups, std::set<CInputCoin>& setCoinsRet, CAmount& nValueRet);
#endif // SATCOIN_WALLET_COINSELECTION_H
| [
"satcoindev@gmail.com"
] | satcoindev@gmail.com |
ec99f3e95043e9cec47243ea02ffd8b9327e6b20 | 2297110bfad913d670b040943afc8b8f32c6bba5 | /Inroductory Problems/Two Sets/main.cpp | 1904db551de8ac105f274cec8ba851edd572da1e | [] | no_license | thanhtoan1742/CSES | eb2a2223f5ee1c18411439868877eaa09eed8650 | 2d30deb140b15f0691bade8118fc546da5c47817 | refs/heads/master | 2023-09-05T16:05:46.447411 | 2021-11-21T02:41:40 | 2021-11-21T02:41:40 | 299,819,379 | 1 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 1,333 | cpp | #include <bits/stdc++.h>
#define sqr(a) ((a) * (a))
#define minimize(a, b) a = min((a), (b))
#define maximize(a, b) a = max((a), (b))
using namespace std;
template<typename T>
void print(T arg) { cout << arg; }
template<typename T, typename ...Ts>
void print(T arg, Ts ...args) {
cout << arg << ' ';
print(args...);
}
template<typename T>
void println(T arg) { cout << arg << '\n'; }
template<typename T, typename ...Ts>
void println(T arg, Ts ...args ) {
cout << arg << ' ';
println(args...);
}
template<typename T>
void read(T& arg) { cin >> arg; }
template<typename T, typename ...Ts>
void read(T& arg, Ts& ...args) {
cin >> arg;
read(args...);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
read(n);
if (n % 4 == 1 || n % 4 == 2)
println("NO");
else {
println("YES");
int start = 1;
if (n % 4 == 3) {
start = 4;
println(n - n / 2);
print(1, 2, ' ');
}
else
println(n - n / 2);
for (int i = start; i <= n; i += 4)
print(i, i + 3, ' ');
print('\n');
println(n / 2);
if (n % 4 == 3)
print(3, ' ');
for (int i = start; i <= n; i += 4)
print(i + 1, i + 2, ' ');
}
} | [
"thanhtoan1742@gmail.com"
] | thanhtoan1742@gmail.com |
0af8fe30a0ed050264b563e44bab2ee039e48623 | 140d78334109e02590f04769ec154180b2eaf78d | /aws-cpp-sdk-dynamodbstreams/include/aws/dynamodbstreams/DynamoDBStreamsClient.h | 543c442f8047b9f537c273132a10e5d4a75356d4 | [
"Apache-2.0",
"MIT",
"JSON"
] | permissive | coderTong/aws-sdk-cpp | da140feb7e5495366a8d2a6a02cf8b28ba820ff6 | 5cd0c0a03b667c5a0bd17394924abe73d4b3754a | refs/heads/master | 2021-07-08T07:04:40.181622 | 2017-08-22T21:50:00 | 2017-08-22T21:50:00 | 101,145,374 | 0 | 1 | Apache-2.0 | 2021-05-04T21:06:36 | 2017-08-23T06:24:37 | C++ | UTF-8 | C++ | false | false | 17,799 | h | /*
* Copyright 2010-2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
#pragma once
#include <aws/dynamodbstreams/DynamoDBStreams_EXPORTS.h>
#include <aws/dynamodbstreams/DynamoDBStreamsErrors.h>
#include <aws/core/client/AWSError.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/dynamodbstreams/model/DescribeStreamResult.h>
#include <aws/dynamodbstreams/model/GetRecordsResult.h>
#include <aws/dynamodbstreams/model/GetShardIteratorResult.h>
#include <aws/dynamodbstreams/model/ListStreamsResult.h>
#include <aws/core/client/AsyncCallerContext.h>
#include <aws/core/http/HttpTypes.h>
#include <future>
#include <functional>
namespace Aws
{
namespace Http
{
class HttpClient;
class HttpClientFactory;
} // namespace Http
namespace Utils
{
template< typename R, typename E> class Outcome;
namespace Threading
{
class Executor;
} // namespace Threading
namespace Json
{
class JsonValue;
} // namespace Json
} // namespace Utils
namespace Auth
{
class AWSCredentials;
class AWSCredentialsProvider;
} // namespace Auth
namespace Client
{
class RetryStrategy;
} // namespace Client
namespace DynamoDBStreams
{
namespace Model
{
class DescribeStreamRequest;
class GetRecordsRequest;
class GetShardIteratorRequest;
class ListStreamsRequest;
typedef Aws::Utils::Outcome<DescribeStreamResult, Aws::Client::AWSError<DynamoDBStreamsErrors>> DescribeStreamOutcome;
typedef Aws::Utils::Outcome<GetRecordsResult, Aws::Client::AWSError<DynamoDBStreamsErrors>> GetRecordsOutcome;
typedef Aws::Utils::Outcome<GetShardIteratorResult, Aws::Client::AWSError<DynamoDBStreamsErrors>> GetShardIteratorOutcome;
typedef Aws::Utils::Outcome<ListStreamsResult, Aws::Client::AWSError<DynamoDBStreamsErrors>> ListStreamsOutcome;
typedef std::future<DescribeStreamOutcome> DescribeStreamOutcomeCallable;
typedef std::future<GetRecordsOutcome> GetRecordsOutcomeCallable;
typedef std::future<GetShardIteratorOutcome> GetShardIteratorOutcomeCallable;
typedef std::future<ListStreamsOutcome> ListStreamsOutcomeCallable;
} // namespace Model
class DynamoDBStreamsClient;
typedef std::function<void(const DynamoDBStreamsClient*, const Model::DescribeStreamRequest&, const Model::DescribeStreamOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeStreamResponseReceivedHandler;
typedef std::function<void(const DynamoDBStreamsClient*, const Model::GetRecordsRequest&, const Model::GetRecordsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetRecordsResponseReceivedHandler;
typedef std::function<void(const DynamoDBStreamsClient*, const Model::GetShardIteratorRequest&, const Model::GetShardIteratorOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetShardIteratorResponseReceivedHandler;
typedef std::function<void(const DynamoDBStreamsClient*, const Model::ListStreamsRequest&, const Model::ListStreamsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListStreamsResponseReceivedHandler;
/**
* <fullname>Amazon DynamoDB Streams</fullname> <p>This is the Amazon DynamoDB
* Streams API Reference. This guide describes the low-level API actions for
* accessing streams and processing stream records. For information about
* application development with DynamoDB Streams, see the <a
* href="http://docs.aws.amazon.com/amazondynamodb/latest/developerguide//Streams.html">Amazon
* DynamoDB Developer Guide</a>.</p> <p>Note that this document is intended for use
* with the following DynamoDB documentation:</p> <ul> <li> <p> <a
* href="http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/">Amazon
* DynamoDB Developer Guide</a> </p> </li> <li> <p> <a
* href="http://docs.aws.amazon.com/amazondynamodb/latest/APIReference/">Amazon
* DynamoDB API Reference</a> </p> </li> </ul> <p>The following are short
* descriptions of each low-level DynamoDB Streams API action, organized by
* function.</p> <ul> <li><p><i>DescribeStream</i> - Returns detailed information
* about a particular stream.</p></li> <li> <p><i>GetRecords</i> - Retrieves the
* stream records from within a shard.</p> </li> <li> <p><i>GetShardIterator</i> -
* Returns information on how to retrieve the streams record from a shard with a
* given shard ID.</p> </li> <li> <p><i>ListStreams</i> - Returns a list of all the
* streams associated with the current AWS account and endpoint.</p> </li> </ul>
*/
class AWS_DYNAMODBSTREAMS_API DynamoDBStreamsClient : public Aws::Client::AWSJsonClient
{
public:
typedef Aws::Client::AWSJsonClient BASECLASS;
/**
* Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config
* is not specified, it will be initialized to default values.
*/
DynamoDBStreamsClient(const Client::ClientConfiguration& clientConfiguration = Client::ClientConfiguration());
/**
* Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config
* is not specified, it will be initialized to default values.
*/
DynamoDBStreamsClient(const Auth::AWSCredentials& credentials, const Client::ClientConfiguration& clientConfiguration = Client::ClientConfiguration());
/**
* Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied,
* the default http client factory will be used
*/
DynamoDBStreamsClient(const std::shared_ptr<Auth::AWSCredentialsProvider>& credentialsProvider,
const Client::ClientConfiguration& clientConfiguration = Client::ClientConfiguration());
virtual ~DynamoDBStreamsClient();
/**
* <p>Returns information about a stream, including the current status of the
* stream, its Amazon Resource Name (ARN), the composition of its shards, and its
* corresponding DynamoDB table.</p> <note><p>You can call <i>DescribeStream</i> at
* a maximum rate of 10 times per second.</p></note> <p>Each shard in the stream
* has a <code>SequenceNumberRange</code> associated with it. If the
* <code>SequenceNumberRange</code> has a <code>StartingSequenceNumber</code> but
* no <code>EndingSequenceNumber</code>, then the shard is still open (able to
* receive more stream records). If both <code>StartingSequenceNumber</code> and
* <code>EndingSequenceNumber</code> are present, the that shared is closed and can
* no longer receive more data.</p>
*/
virtual Model::DescribeStreamOutcome DescribeStream(const Model::DescribeStreamRequest& request) const;
/**
* <p>Returns information about a stream, including the current status of the
* stream, its Amazon Resource Name (ARN), the composition of its shards, and its
* corresponding DynamoDB table.</p> <note><p>You can call <i>DescribeStream</i> at
* a maximum rate of 10 times per second.</p></note> <p>Each shard in the stream
* has a <code>SequenceNumberRange</code> associated with it. If the
* <code>SequenceNumberRange</code> has a <code>StartingSequenceNumber</code> but
* no <code>EndingSequenceNumber</code>, then the shard is still open (able to
* receive more stream records). If both <code>StartingSequenceNumber</code> and
* <code>EndingSequenceNumber</code> are present, the that shared is closed and can
* no longer receive more data.</p>
*
* returns a future to the operation so that it can be executed in parallel to other requests.
*/
virtual Model::DescribeStreamOutcomeCallable DescribeStreamCallable(const Model::DescribeStreamRequest& request) const;
/**
* <p>Returns information about a stream, including the current status of the
* stream, its Amazon Resource Name (ARN), the composition of its shards, and its
* corresponding DynamoDB table.</p> <note><p>You can call <i>DescribeStream</i> at
* a maximum rate of 10 times per second.</p></note> <p>Each shard in the stream
* has a <code>SequenceNumberRange</code> associated with it. If the
* <code>SequenceNumberRange</code> has a <code>StartingSequenceNumber</code> but
* no <code>EndingSequenceNumber</code>, then the shard is still open (able to
* receive more stream records). If both <code>StartingSequenceNumber</code> and
* <code>EndingSequenceNumber</code> are present, the that shared is closed and can
* no longer receive more data.</p>
*
* Queues the request into a thread executor and triggers associated callback when operation has finished.
*/
virtual void DescribeStreamAsync(const Model::DescribeStreamRequest& request, const DescribeStreamResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
/**
* <p>Retrieves the stream records from a given shard.</p> <p>Specify a shard
* iterator using the <code>ShardIterator</code> parameter. The shard iterator
* specifies the position in the shard from which you want to start reading stream
* records sequentially. If there are no stream records available in the portion of
* the shard that the iterator points to, <code>GetRecords</code> returns an empty
* list. Note that it might take multiple calls to get to a portion of the shard
* that contains stream records.</p> <note><p><function>GetRecords</function> can
* retrieve a maximum of 1 MB of data or 2000 stream records, whichever comes
* first.</p></note>
*/
virtual Model::GetRecordsOutcome GetRecords(const Model::GetRecordsRequest& request) const;
/**
* <p>Retrieves the stream records from a given shard.</p> <p>Specify a shard
* iterator using the <code>ShardIterator</code> parameter. The shard iterator
* specifies the position in the shard from which you want to start reading stream
* records sequentially. If there are no stream records available in the portion of
* the shard that the iterator points to, <code>GetRecords</code> returns an empty
* list. Note that it might take multiple calls to get to a portion of the shard
* that contains stream records.</p> <note><p><function>GetRecords</function> can
* retrieve a maximum of 1 MB of data or 2000 stream records, whichever comes
* first.</p></note>
*
* returns a future to the operation so that it can be executed in parallel to other requests.
*/
virtual Model::GetRecordsOutcomeCallable GetRecordsCallable(const Model::GetRecordsRequest& request) const;
/**
* <p>Retrieves the stream records from a given shard.</p> <p>Specify a shard
* iterator using the <code>ShardIterator</code> parameter. The shard iterator
* specifies the position in the shard from which you want to start reading stream
* records sequentially. If there are no stream records available in the portion of
* the shard that the iterator points to, <code>GetRecords</code> returns an empty
* list. Note that it might take multiple calls to get to a portion of the shard
* that contains stream records.</p> <note><p><function>GetRecords</function> can
* retrieve a maximum of 1 MB of data or 2000 stream records, whichever comes
* first.</p></note>
*
* Queues the request into a thread executor and triggers associated callback when operation has finished.
*/
virtual void GetRecordsAsync(const Model::GetRecordsRequest& request, const GetRecordsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
/**
* <p>Returns a shard iterator. A shard iterator provides information about how to
* retrieve the stream records from within a shard. Use the shard iterator in a
* subsequent <code>GetRecords</code> request to read the stream records from the
* shard.</p> <note><p>A shard iterator expires 15 minutes after it is returned to
* the requester.</p></note>
*/
virtual Model::GetShardIteratorOutcome GetShardIterator(const Model::GetShardIteratorRequest& request) const;
/**
* <p>Returns a shard iterator. A shard iterator provides information about how to
* retrieve the stream records from within a shard. Use the shard iterator in a
* subsequent <code>GetRecords</code> request to read the stream records from the
* shard.</p> <note><p>A shard iterator expires 15 minutes after it is returned to
* the requester.</p></note>
*
* returns a future to the operation so that it can be executed in parallel to other requests.
*/
virtual Model::GetShardIteratorOutcomeCallable GetShardIteratorCallable(const Model::GetShardIteratorRequest& request) const;
/**
* <p>Returns a shard iterator. A shard iterator provides information about how to
* retrieve the stream records from within a shard. Use the shard iterator in a
* subsequent <code>GetRecords</code> request to read the stream records from the
* shard.</p> <note><p>A shard iterator expires 15 minutes after it is returned to
* the requester.</p></note>
*
* Queues the request into a thread executor and triggers associated callback when operation has finished.
*/
virtual void GetShardIteratorAsync(const Model::GetShardIteratorRequest& request, const GetShardIteratorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
/**
* <p>Returns an array of stream ARNs associated with the current account and
* endpoint. If the <code>TableName</code> parameter is present, then
* <i>ListStreams</i> will return only the streams ARNs for that table.</p>
* <note><p>You can call <i>ListStreams</i> at a maximum rate of 5 times per
* second.</p></note>
*/
virtual Model::ListStreamsOutcome ListStreams(const Model::ListStreamsRequest& request) const;
/**
* <p>Returns an array of stream ARNs associated with the current account and
* endpoint. If the <code>TableName</code> parameter is present, then
* <i>ListStreams</i> will return only the streams ARNs for that table.</p>
* <note><p>You can call <i>ListStreams</i> at a maximum rate of 5 times per
* second.</p></note>
*
* returns a future to the operation so that it can be executed in parallel to other requests.
*/
virtual Model::ListStreamsOutcomeCallable ListStreamsCallable(const Model::ListStreamsRequest& request) const;
/**
* <p>Returns an array of stream ARNs associated with the current account and
* endpoint. If the <code>TableName</code> parameter is present, then
* <i>ListStreams</i> will return only the streams ARNs for that table.</p>
* <note><p>You can call <i>ListStreams</i> at a maximum rate of 5 times per
* second.</p></note>
*
* Queues the request into a thread executor and triggers associated callback when operation has finished.
*/
virtual void ListStreamsAsync(const Model::ListStreamsRequest& request, const ListStreamsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
private:
void init(const Client::ClientConfiguration& clientConfiguration);
/**Async helpers**/
void DescribeStreamAsyncHelper(const Model::DescribeStreamRequest& request, const DescribeStreamResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
void GetRecordsAsyncHelper(const Model::GetRecordsRequest& request, const GetRecordsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
void GetShardIteratorAsyncHelper(const Model::GetShardIteratorRequest& request, const GetShardIteratorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
void ListStreamsAsyncHelper(const Model::ListStreamsRequest& request, const ListStreamsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
Aws::String m_uri;
std::shared_ptr<Aws::Utils::Threading::Executor> m_executor;
};
} // namespace DynamoDBStreams
} // namespace Aws
| [
"henso@amazon.com"
] | henso@amazon.com |
a449fa59332f80658d1eabec781a6652415e27d7 | 2203f9e82de6157d337aae1fdffcbb11def70a62 | /testdata/samplecdp/config/catering/submissions/accepted/cater.cpp | 500c9b9b673e69568fad747bc1ca46420ce41dce | [] | no_license | Kamo98/DIPLOM_NEW | c55b59ccd0610d4d2867619ca40c9fed0957a786 | 4434a43acedc44fc7b041214f66204a4936ffe6b | refs/heads/master | 2023-04-27T18:22:32.869058 | 2020-05-21T13:21:30 | 2020-05-21T13:21:30 | 265,855,486 | 0 | 0 | null | 2021-05-12T00:29:54 | 2020-05-21T13:27:35 | Java | UTF-8 | C++ | false | false | 3,262 | cpp | #include<iostream>
using namespace std;
const int MAXN = 100;
const int MAXK = 100;
const int MAXV = 10000000;
const long INF = MAXN*MAXV+1;
class Edge
{
public:
int dest;
long weight;
Edge *next;
Edge() :dest(-1), weight(0), next(0)
{}
Edge(int d, long w, Edge* n=0) : dest(d), weight(w), next(n)
{}
};
class Vertex
{
public:
long dist;
int prev;
Edge *alist;
Vertex()
{
dist = INF;
prev = -1;
alist = new Edge();
}
~Vertex()
{
Edge* p = alist;
while (p != 0) {
Edge* tmp = p->next;
delete p;
p = p->next;
}
}
};
class Graph
{
public:
Vertex *v;
int numV;
Graph(int n)
{
numV = n;
v = new Vertex[n];
}
~Graph()
{
delete [] v;
}
void addEdge(int src, int dest, long w)
{
v[src].alist->next = new Edge(dest, w, v[src].alist->next);
}
void removeEdge(int src, int dest)
{
Edge *p = v[src].alist;
while (p->next != 0 && p->next->dest != dest)
p = p->next;
if (p->next == 0)
cout << "ERROR: removal of edge " << src << ',' << dest << " failed" << endl;
else {
Edge *tmp = p->next;
p->next = tmp->next;
addEdge(dest, src, -tmp->weight);
delete tmp;
}
}
};
void bellmanFord(Graph &g, int src)
{
int n = g.numV;
// Step 1: Initialize distances from src to all other vertices as INFINITE
for(int i=0; i<n; i++) {
g.v[i].dist = INF;
g.v[i].prev = -1;
}
g.v[src].dist = 0;
// Step 2: Relax all edges |V| - 1 int dest. A simple shortest path from src
// to any other vertex can have at-most |V| - 1 edges
for (int i = 1; i <= n-1; i++)
{
for (int j = 0; j < n; j++)
{
Edge *p = g.v[j].alist->next;
while (p != 0) {
int w = p->dest;
long weight = p->weight;
if (g.v[j].dist + weight < g.v[w].dist) {
g.v[w].dist = g.v[j].dist + weight;
g.v[w].prev = j;
}
p = p->next;
}
}
}
// Step 3: check for negative-weight cycles. The above step guarantees
// shortest distances if graph doesn't contain negative weight cycle.
// If we get a shorter path, then there is a cycle.
// can't happen in this problem
return;
}
int main()
{
int n, nSets;
while(cin >> n) {
// cin >> n >> nSets;
cin >> nSets;
if (nSets > n)
nSets = n;
Graph g(2*n+2);
for(int j=1; j<=n; j++) {
long cost;
cin >> cost;
g.addEdge(0, 2*j-1, cost-(MAXV+1));
}
for(int i=1; i<=n; i++) {
g.addEdge(2*i-1, 2*i, 0);
for(int j=i+1; j<=n; j++) {
long cost;
cin >> cost;
g.addEdge(2*i, 2*j-1, cost-(MAXV+1));
}
}
for(int i=0; i<=n; i++)
g.addEdge(2*i, 2*n+1, 0);
long ans = 0;
for(int i=0; i<nSets; i++) { // find next augmenting path
bellmanFord(g, 0);
int j=2*n+1;
long dist = g.v[j].dist;
int k = 2*n+1;
int count = 0;
int tmp = g.v[k].prev;
// count net # of neg weight edges on path
while(tmp != -1) {
Edge *p = g.v[tmp].alist->next;
while (p->dest != k) {
p = p->next;
}
if (p->weight < 0)
count++;
else if (p->weight > 0)
count--;
k = tmp;
tmp = g.v[k].prev;
}
// use this count to get true cost of path
dist += count*(MAXV+1);
if (dist == 0)
break;
ans += dist;
while(j != 0) {
int prevj = g.v[j].prev;
if (j != 2*n+1 || prevj != 0) {
g.removeEdge(prevj, j);
}
j = prevj;
}
}
cout << ans << endl;
}
}
| [
"avanesjan.k@gmail.com"
] | avanesjan.k@gmail.com |
499bf1c75b7b70b031f6548a60ecb1b8e8a5b23e | 9c615752e6e0cb71a93e74c138a55f56f638c43f | /main/GeneratedFiles/Debug/moc_huetagreaderwindow.cpp | af8252a841cfd581bd47cd3fd47eaabfdd25c085 | [
"MIT"
] | permissive | DrNeuroSurg/Huetag-Generator-And-Image-Based-Reader | 4df75949b3980e570999834e2da9faf2c6809076 | df38a7af0faf76a352a4ee004ebf9a726b89e6f6 | refs/heads/master | 2020-04-19T17:07:45.955425 | 2017-10-24T13:27:13 | 2017-10-24T13:27:13 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,306 | cpp | /****************************************************************************
** Meta object code from reading C++ file 'huetagreaderwindow.h'
**
** Created by: The Qt Meta Object Compiler version 67 (Qt 5.8.0)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/
#include "../../huetagreaderwindow.h"
#include <QtCore/qbytearray.h>
#include <QtCore/qmetatype.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'huetagreaderwindow.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 67
#error "This file was generated using the moc from 5.8.0. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif
QT_BEGIN_MOC_NAMESPACE
QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
struct qt_meta_stringdata_huetagreaderwindow_t {
QByteArrayData data[16];
char stringdata0[313];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
qptrdiff(offsetof(qt_meta_stringdata_huetagreaderwindow_t, stringdata0) + ofs \
- idx * sizeof(QByteArrayData)) \
)
static const qt_meta_stringdata_huetagreaderwindow_t qt_meta_stringdata_huetagreaderwindow = {
{
QT_MOC_LITERAL(0, 0, 18), // "huetagreaderwindow"
QT_MOC_LITERAL(1, 19, 11), // "browseImage"
QT_MOC_LITERAL(2, 31, 0), // ""
QT_MOC_LITERAL(3, 32, 21), // "updateBinaryThreshold"
QT_MOC_LITERAL(4, 54, 5), // "value"
QT_MOC_LITERAL(5, 60, 29), // "updateContourAreaMinThreshold"
QT_MOC_LITERAL(6, 90, 29), // "updateContourAreaMaxThreshold"
QT_MOC_LITERAL(7, 120, 24), // "updateGaussianKernelSize"
QT_MOC_LITERAL(8, 145, 24), // "updateDecodedMarkerImage"
QT_MOC_LITERAL(9, 170, 17), // "openMarkerManager"
QT_MOC_LITERAL(10, 188, 11), // "openLogFile"
QT_MOC_LITERAL(11, 200, 18), // "onBlurImagePressed"
QT_MOC_LITERAL(12, 219, 26), // "onBinaryThreshImagePressed"
QT_MOC_LITERAL(13, 246, 21), // "onContourImagePressed"
QT_MOC_LITERAL(14, 268, 27), // "onDataCellCoordImagePressed"
QT_MOC_LITERAL(15, 296, 16) // "hideImagePreview"
},
"huetagreaderwindow\0browseImage\0\0"
"updateBinaryThreshold\0value\0"
"updateContourAreaMinThreshold\0"
"updateContourAreaMaxThreshold\0"
"updateGaussianKernelSize\0"
"updateDecodedMarkerImage\0openMarkerManager\0"
"openLogFile\0onBlurImagePressed\0"
"onBinaryThreshImagePressed\0"
"onContourImagePressed\0onDataCellCoordImagePressed\0"
"hideImagePreview"
};
#undef QT_MOC_LITERAL
static const uint qt_meta_data_huetagreaderwindow[] = {
// content:
7, // revision
0, // classname
0, 0, // classinfo
13, 14, // methods
0, 0, // properties
0, 0, // enums/sets
0, 0, // constructors
0, // flags
0, // signalCount
// slots: name, argc, parameters, tag, flags
1, 0, 79, 2, 0x08 /* Private */,
3, 1, 80, 2, 0x08 /* Private */,
5, 1, 83, 2, 0x08 /* Private */,
6, 1, 86, 2, 0x08 /* Private */,
7, 1, 89, 2, 0x08 /* Private */,
8, 0, 92, 2, 0x08 /* Private */,
9, 0, 93, 2, 0x08 /* Private */,
10, 0, 94, 2, 0x08 /* Private */,
11, 0, 95, 2, 0x08 /* Private */,
12, 0, 96, 2, 0x08 /* Private */,
13, 0, 97, 2, 0x08 /* Private */,
14, 0, 98, 2, 0x08 /* Private */,
15, 0, 99, 2, 0x08 /* Private */,
// slots: parameters
QMetaType::Void,
QMetaType::Void, QMetaType::Int, 4,
QMetaType::Void, QMetaType::Int, 4,
QMetaType::Void, QMetaType::Int, 4,
QMetaType::Void, QMetaType::Int, 4,
QMetaType::Void,
QMetaType::Void,
QMetaType::Void,
QMetaType::Void,
QMetaType::Void,
QMetaType::Void,
QMetaType::Void,
QMetaType::Void,
0 // eod
};
void huetagreaderwindow::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
huetagreaderwindow *_t = static_cast<huetagreaderwindow *>(_o);
Q_UNUSED(_t)
switch (_id) {
case 0: _t->browseImage(); break;
case 1: _t->updateBinaryThreshold((*reinterpret_cast< int(*)>(_a[1]))); break;
case 2: _t->updateContourAreaMinThreshold((*reinterpret_cast< int(*)>(_a[1]))); break;
case 3: _t->updateContourAreaMaxThreshold((*reinterpret_cast< int(*)>(_a[1]))); break;
case 4: _t->updateGaussianKernelSize((*reinterpret_cast< int(*)>(_a[1]))); break;
case 5: _t->updateDecodedMarkerImage(); break;
case 6: _t->openMarkerManager(); break;
case 7: _t->openLogFile(); break;
case 8: _t->onBlurImagePressed(); break;
case 9: _t->onBinaryThreshImagePressed(); break;
case 10: _t->onContourImagePressed(); break;
case 11: _t->onDataCellCoordImagePressed(); break;
case 12: _t->hideImagePreview(); break;
default: ;
}
}
}
const QMetaObject huetagreaderwindow::staticMetaObject = {
{ &QMainWindow::staticMetaObject, qt_meta_stringdata_huetagreaderwindow.data,
qt_meta_data_huetagreaderwindow, qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};
const QMetaObject *huetagreaderwindow::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *huetagreaderwindow::qt_metacast(const char *_clname)
{
if (!_clname) return Q_NULLPTR;
if (!strcmp(_clname, qt_meta_stringdata_huetagreaderwindow.stringdata0))
return static_cast<void*>(const_cast< huetagreaderwindow*>(this));
return QMainWindow::qt_metacast(_clname);
}
int huetagreaderwindow::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QMainWindow::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 13)
qt_static_metacall(this, _c, _id, _a);
_id -= 13;
} else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 13)
*reinterpret_cast<int*>(_a[0]) = -1;
_id -= 13;
}
return _id;
}
QT_WARNING_POP
QT_END_MOC_NAMESPACE
| [
"dominicorga@gmail.com"
] | dominicorga@gmail.com |
e8aa959d9e2778592c2aeef690bc37c373b1f4c6 | 6fb58cc2e11bd652c2839074cff5450901b06a7d | /src/main.cpp | 3331b2439d94ea71deefb2108fc2dba81b4ed9f8 | [] | no_license | dawnho/spaceboard | 58b103c5be5ec3964eb18f86a17756a1784e2b26 | 5f2eb699504cb34f0f42bf0c0d6c53afb8cf3a55 | refs/heads/master | 2020-03-21T04:36:38.819566 | 2018-06-07T07:58:56 | 2018-06-07T07:58:56 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,413 | cpp | /**
* Blink
*
* Turns on an LED on for one second,
* then off for one second, repeatedly.
*/
#include "Arduino.h"
#include "limits.h"
#include "Adafruit_NeoPixel.h"
#include "PacketSerial.h"
/*************** Data Types *********************/
static struct State {
State() : badCommandsReceived(0),
commandsReceived(0),
runLED(false) { }
uint32_t badCommandsReceived;
uint32_t commandsReceived;
bool runLED;
} state;
/*************** Prototypes *********************/
void send_state();
void toggle_led();
void onPacket(const uint8_t* buffer, size_t size);
void colorWipe(uint32_t c, uint8_t wait);
void clearStrip();
bool arrayReadBit(uint8_t bit);
void arrayWriteBit(uint8_t bit, bool val);
void arraySend();
void arrayWipe();
/*************** Constants *********************/
#undef LED_BUILTIN
#define LED_BUILTIN 33
#define LED_STRIP_PIN 14 // we chose a pin on GPIO port C in case we switch to DMA
#define LED_COUNT 60
Adafruit_NeoPixel strip = Adafruit_NeoPixel(LED_COUNT, LED_STRIP_PIN, NEO_GRB + NEO_KHZ800);
// the bit-shifted led array (not multi-color leds)
#define ARRAY_DATA_PIN 28
#define ARRAY_CLOCK_PIN 30
#define ARRAY_LATCH_PIN 31
#define ARRAY_COUNT 80
uint8_t array_bytes[(ARRAY_COUNT >> 3) + 1] = {0};
static const uint32_t BaudRate = 115200; // baud
static PacketSerial packetSerial;
/*************** CODE!!!!!! *********************/
void setup()
{
// initialize LED digital pin as an output.
pinMode(LED_BUILTIN, OUTPUT);
// initialize serial
Serial3.begin(BaudRate);
packetSerial.setPacketHandler(&onPacket);
packetSerial.begin(&Serial3);
// initialize leds
strip.begin();
strip.show();
// NOTE: this causes some sort of initialization without which the led strip
// doesn't work at all >:-|
delay(1);
// NOTE: DO NOT REMOVE ABOVE LINE
// allows a quick visual check that all the leds work/a reset just happened
colorWipe(strip.Color(20, 20, 20), 50);
clearStrip();
// initialize led array
pinMode(ARRAY_LATCH_PIN, OUTPUT);
digitalWrite(ARRAY_LATCH_PIN, LOW); // latch should remain low unless we're loading
pinMode(ARRAY_CLOCK_PIN, OUTPUT);
digitalWrite(ARRAY_CLOCK_PIN, LOW); // clock default to low
pinMode(ARRAY_DATA_PIN, OUTPUT);
digitalWrite(ARRAY_DATA_PIN, LOW); // leave data pin low as well
arrayWipe();
Serial.print("boot!\n");
}
void loop()
{
// communicate with the server
packetSerial.update();
}
void onPacket(const uint8_t* buffer, size_t size)
{
toggle_led();
if (size < 1) {
state.badCommandsReceived++;
return;
}
// Protocol from the server:
uint32_t prevBad = state.badCommandsReceived;
switch(buffer[0]) {
// GET_STATE: causes an immediate send of the current state
case 'G':
send_state();
break;
// LATCH: forces a display of the led strip
case 'L':
arraySend();
strip.show();
break;
// CLEAR: resets all of the leds
case 'C':
clearStrip();
break;
// ONE_LED<led>,<r>,<g>,<b>: sets the given led to the given color
case 'O':
if(size == 5) {
strip.setPixelColor(buffer[1], buffer[2], buffer[3], buffer[4]);
break;
} else {
state.badCommandsReceived++;
}
break;
// BATCH<first_led>,<r1>,<g1><b1>...<rN>,<gN>,<bN>: sets a bunch of entries at once
case 'B':
if(size >= 5 && (size - 2) % 3 == 0) {
uint16_t pixel = (uint16_t)buffer[1];
for(uint8_t cur = 2; cur < size; cur += 3) {
strip.setPixelColor(pixel, buffer[cur], buffer[cur+1], buffer[cur+2]);
pixel++;
}
} else {
state.badCommandsReceived++;
}
break;
// ARRAY<byte1>,<byte2>,...,<byteN> sets the array to given data
case 'A':
if(size == 1 + (ARRAY_COUNT / 8)) {
for (unsigned int i = 1; i < size; i++) {
array_bytes[i-1] = buffer[i];
}
} else {
state.badCommandsReceived++;
}
break;
// ON<bit> turns on an led in the array
case '1':
if(size == 2) {
arrayWriteBit(buffer[1], 1);
} else {
state.badCommandsReceived++;
}
break;
// OFF<bit> turns on an led in the array
case '0':
if(size == 2) {
arrayWriteBit(buffer[1], 0);
} else {
state.badCommandsReceived++;
}
break;
// RESET: resets the device
case 'R':
nvic_sys_reset();
break; // we never get here
// some unrecognized command is counted as bad
default:
state.badCommandsReceived++;
break;
}
if (state.badCommandsReceived == prevBad) {
state.commandsReceived += 1;
}
}
// sends the current program state to the computer
void send_state()
{
uint8_t packet[] = {
'S',
(uint8_t)(state.commandsReceived >> 24),
(uint8_t)(state.commandsReceived >> 16),
(uint8_t)(state.commandsReceived >> 8),
(uint8_t)(state.commandsReceived >> 0),
(uint8_t)(state.badCommandsReceived >> 24),
(uint8_t)(state.badCommandsReceived >> 16),
(uint8_t)(state.badCommandsReceived >> 8),
(uint8_t)(state.badCommandsReceived >> 0),
};
packetSerial.send(packet, 9);
// also send over serial link
Serial.print("C:");
Serial.print(state.commandsReceived, DEC);
Serial.print(";");
Serial.print("B:");
Serial.print(state.badCommandsReceived, DEC);
Serial.print(";");
Serial.print("\r\n");
}
void toggle_led()
{
if(state.runLED) {
digitalWrite(LED_BUILTIN, LOW);
state.runLED = false;
} else {
digitalWrite(LED_BUILTIN, HIGH);
state.runLED = true;
}
}
static const uint32_t Blank = strip.Color(0, 0, 0);
void clearStrip() {
for(uint16_t i=0; i<strip.numPixels(); i++) {
strip.setPixelColor(i, Blank);
}
strip.show();
}
// Fill the dots one after the other with a color
void colorWipe(uint32_t c, uint8_t wait) {
for(uint16_t i=0; i<strip.numPixels(); i++) {
strip.setPixelColor(i, c);
strip.show();
delay(wait);
}
}
bool arrayReadBit(uint8_t bit) {
uint8_t byte = array_bytes[bit >> 3];
return (byte >> (bit % 8)) & 1;
}
void arrayWriteBit(uint8_t bit, bool val) {
uint8_t bit_set = 1 << bit % 8;
if (val)
array_bytes[bit >> 3] |= bit_set;
else
array_bytes[bit >> 3] &= ~bit_set;
}
void arraySend() {
for(uint8_t bit = 0; bit < ARRAY_COUNT; bit++) {
// put the data on the wire
digitalWrite(ARRAY_DATA_PIN, arrayReadBit(bit));
// clock the data into the shift register
digitalWrite(ARRAY_CLOCK_PIN, HIGH);
digitalWrite(ARRAY_CLOCK_PIN, LOW);
}
// now latch the data to the output
digitalWrite(ARRAY_LATCH_PIN, HIGH);
digitalWrite(ARRAY_LATCH_PIN, LOW);
}
void arrayWipe() {
uint8_t bit;
toggle_led();
// set pass-through mode for the latch
digitalWrite(ARRAY_LATCH_PIN, HIGH);
// set all the lights to on, one at a time
digitalWrite(ARRAY_DATA_PIN, HIGH);
for(bit = 0; bit < ARRAY_COUNT; bit++) {
digitalWrite(ARRAY_CLOCK_PIN, HIGH);
digitalWrite(ARRAY_CLOCK_PIN, LOW);
delay(20);
}
// pause with all leds turned on
toggle_led();
delay(1000);
// now set them all to off
digitalWrite(ARRAY_DATA_PIN, LOW);
for(bit = 0; bit < ARRAY_COUNT; bit++) {
digitalWrite(ARRAY_CLOCK_PIN, HIGH);
digitalWrite(ARRAY_CLOCK_PIN, LOW);
delay(20);
}
// turn off pass-through
digitalWrite(ARRAY_LATCH_PIN, LOW);
}
| [
"igor47@moomers.org"
] | igor47@moomers.org |
a46bcdb7825e822daf5a494d380b4379a5182285 | aaf86162b5f90e5d3358d9629a84a5af8feaf14b | /HduTraining/2(快速幂)/1001/main.cpp | e792752d1ee1b1f450df831a5f7296b48dfaf60a | [] | no_license | Linsenx/AcmCodes | ffbd5b5b634a693d9d5e8af680dfc8657085f2e1 | 08f6c708c9b47a3e8234dc2f9d2534344c0597c5 | refs/heads/master | 2021-09-14T11:57:43.707852 | 2018-05-13T06:04:00 | 2018-05-13T06:04:00 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,776 | cpp | #include <iostream>
#include <vector>
#include <stdio.h>
using namespace std;
const int MOD = 10000;
struct matrix
{
int row; //行
int col; //列
int m[10][10];
};
matrix mul(matrix a, matrix b)
{
matrix ret;
ret.row = a.row;
ret.col = b.col;
for(int i = 0; i < a.row; ++i) {
for(int j = 0; j < b.col; ++j) {
ret.m[i][j] = 0;
for(int k = 0; k < a.col; ++k) {
ret.m[i][j] = (ret.m[i][j] + a.m[i][k] * b.m[k][j]) % MOD;
}
}
}
return ret;
}
matrix quick_pow(matrix base, int n) {
//构造单位阵
matrix ans;
ans.col = ans.row = base.col; //矩阵幂行列必须相等
for(int i = 0; i < ans.col; ++i) {
for(int j = 0; j < ans.row; ++j) {
if(i == j) ans.m[i][j] = 1;
else ans.m[i][j] = 0;
}
}
while(n) {
if(n & 1) ans = mul(ans, base);
base = mul(base, base);
n >>= 1;
}
return ans;
}
int main()
{
ios::sync_with_stdio(false);
#ifdef ONLINE_JUDGE
#else
freopen("in.txt","r",stdin);
#endif
matrix base;
base.row = base.col = 2;
base.m[0][0] = base.m[0][1] = base.m[1][0] = 1;
base.m[1][1] = 0;
int n;
while(scanf("%d", &n) != EOF && n != -1) {
matrix res = quick_pow(base, n);
printf("%d\n", res.m[0][1]);
}
// matrix a, b, res;
// a.row = 4;
// a.col = 3;
// a.m[0][0]=5;a.m[0][1]=2;a.m[0][2]=4;
// a.m[1][0]=3;a.m[1][1]=8;a.m[1][2]=2;
// a.m[2][0]=6;a.m[2][1]=0;a.m[2][2]=4;
// a.m[3][0]=0;a.m[3][1]=1;a.m[3][2]=6;
//
// b.row = 3;
// b.col = 2;
// b.m[0][0]=2;b.m[0][1]=4;
// b.m[1][0]=1;b.m[1][1]=3;
// b.m[2][0]=3;b.m[2][1]=2;
//
// res = mul(a, b);
// for(int i = 0; i < 4; ++i) {
// for(int j = 0; j < 2; ++j) {
// cout << res.m[i][j] << ',';
// }
// cout << endl;
// }
return 0;
}
| [
"1279707779@qq.com"
] | 1279707779@qq.com |
c99fb2082c8bc094ef7f6ed2f156ad03f78037ee | 4389e93f891bee5dc277e5038308426630e682bf | /peldak/binarysearch.cpp | d979a0a19bc99eb75ba00db8816f12fb8861283f | [] | no_license | cr-lupin/cppgyakorlat | 8f28b35dd3f1e1a84643b224cfafeb6e6c44bbf6 | fcdc7ace055b3659fc986db5ac35d9b25cdabebc | refs/heads/master | 2021-01-24T11:22:02.252819 | 2018-03-01T09:07:03 | 2018-03-01T09:10:34 | 70,221,715 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 300 | cpp | #include <vector>
bool bs(const std::vector<int>& v, int l, int h, int elem)
{
if (l > h) return false;
int mid = (l + h) / 2;
if (v[mid] == elem) return true;
if (v[mid] < elem)
return bs(v, mid + 1, h, elem);
else
return bs(v, l, mid - 1, elem);
}
| [
"lupin@ludens.elte.hu"
] | lupin@ludens.elte.hu |
898bdcf864b0c2c4488a4af556f62ec01505b0a6 | 13771efbe4bd2803f21b75c0edb621a0d68d0f6c | /그래프/교환_그래프_1039.cpp | 41a67a62aa9a1b6d96d46d198f2944f370e91779 | [] | no_license | Flare-k/Algorithm | f6e597bcb376d8c0f50e91556cadf2cceadd786c | 64ab13c5304712292c41a26a4347f010d70daf98 | refs/heads/master | 2023-04-08T21:05:08.130284 | 2023-04-03T13:57:01 | 2023-04-03T13:57:01 | 236,532,243 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,190 | cpp | #include <iostream>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;
int maxx = 0;
const int MAX = 1000001;
bool check[MAX][11];
int K, M;
string target;
struct Node {
string num;
int level;
};
void bfs() {
queue<Node> q;
q.push({target, 0});
while (!q.empty()) {
Node now = q.front();
q.pop();
string str = now.num;
if (now.level == K) {
maxx = max(maxx, stoi(str));
continue;
}
for (int i = 0; i < M - 1; i++) {
for (int j = i + 1; j < M; j++) {
swap(str[i], str[j]);
if (str.front() == '0' || check[stoi(str)][now.level + 1]) {
swap(str[i], str[j]);
continue;
}
q.push({str, now.level + 1});
check[stoi(str)][now.level + 1] = true;
swap(str[i], str[j]);
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> target >> K;
M = target.length();
bfs();
if (maxx != 0) cout << maxx;
else cout << -1;
return 0;
} | [
"rokkyw@naver.com"
] | rokkyw@naver.com |
47b483a24d00733eddaec599d6c1eadae0e8e7a1 | 0e202eb9c800607c175efdafd713ec6427fadaa4 | /image_test/src/hello.cpp | dd8f2952724338d7294fcb4e34995ccb489b8f6d | [] | no_license | alvin113/4gNetComu | 9104fe67cc6a1ece084ae0ad379c777a7386d142 | 44b0644cd76d50864cd6c17dd1f2e4553a925316 | refs/heads/master | 2021-01-11T22:57:48.957703 | 2017-01-10T12:09:30 | 2017-01-10T12:09:30 | 78,529,015 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 659 | cpp | #include <ros/ros.h>
#include <image_transport/image_transport.h>
#include <cv_bridge/cv_bridge.h>
#include <sensor_msgs/image_encodings.h>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/core/core.hpp>
#include <vector>
#include <stdio.h>
#include <stdlib.h>
int main(int argc,char **argv)
{
ros::init(argc,argv,"hello_ros");
ros::NodeHandle nh;
image_transport::ImageTransport it(nh);
ROS_INFO_STREAM("hello ros!");
//cv::Mat image = cv::imread(argv[1], CV_LOAD_IMAGE_COLOR);
cv::Mat num=cv::imread("1.JPG");
cv::namedWindow("logo");
cv::imshow("logo",num);
cv::waitKey(3);
ros::spin();
}
| [
"dragonriver113@163.com"
] | dragonriver113@163.com |
0b2eef0556cb54775d43a7c0a368a8fe812761e4 | f1dc15c8b9907212f0e6cc07ab1d6b80d334a028 | /A5/tutorials/SDL/SDL_OGL.cpp | d9b85fed31be22c8f0fc8fdeef7334e98bbef2ab | [] | no_license | gcbsumid/Graphics-Assignments | 3d2114b1a2981dca9028df309fd51b8f83fe68bc | 30904780326c5a4b4b69001daaab25ff36091750 | refs/heads/master | 2020-05-18T17:58:18.581481 | 2013-12-02T22:54:48 | 2013-12-02T22:54:48 | 13,566,255 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,412 | cpp | /* ***************************************************************
*
* File : SDL_OGL.cpp
*
* Author : Tiberiu Popa
* J. Alexander Clarke
* Date : June 18th, 2002
*
* Modified:
*
* Purpose: Implementation file for SDl with OpenGL framework
*
* Notes: Based on an SDL tutorial from SDL's web site
*
* ****************************************************************/
#include "SDL_OGL.h"
#include <stdio.h>
void ReSizeGLScene(GLsizei width, GLsizei height){
// Reset The Current Viewport
glViewport(0,0,width,height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
// Calculate The Aspect Ratio Of The Window
gluPerspective(40.0, (GLfloat)width/(GLfloat)height, 0.1, 1000.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
int InitGLLights(){
GLfloat light_position1[] = {50, 50, 0, 1};
GLfloat light1[] = {0.5, 0.5, 0.5, 1};
GLfloat light2[] = {0.5, 0.5, .5, 1.0};
GLfloat zero[] = {0, 0, 0 , 0};
// setup
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
glLightf(GL_LIGHT0, GL_SPOT_EXPONENT, 25);
glLightfv(GL_LIGHT0, GL_SPECULAR, light2);
glLightfv(GL_LIGHT0, GL_DIFFUSE, light1);
glLightfv(GL_LIGHT0, GL_AMBIENT, light2);
glLightfv(GL_LIGHT0, GL_POSITION, light_position1);
}
// Initialization
int InitGL(){
glEnable(GL_TEXTURE_2D);
glEnable(GL_NORMALIZE);
glShadeModel(GL_SMOOTH);
glEnable(GL_COLOR_MATERIAL);
// Black Background
glClearColor(0.00f, 0.80f, 0.80f, 0.0f);
glEnable(GL_DEPTH_TEST);
//glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
// initialize the lighs
InitGLLights();
return 1;
}
GLvoid KillGLWindow(){
SDL_Quit();
}
int CreateGLWindow(char* title, int width, int height, int bits, int fullscreenflag)
{
Uint32 flags;
int size;
/* Initialize SDL */
if ( SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO ) < 0 ) {
fprintf(stderr, "Couldn't init SDL: %s\n", SDL_GetError());
return 0;
}
flags = SDL_OPENGL;
if ( fullscreenflag ) {
flags |= SDL_FULLSCREEN;
}
SDL_GL_SetAttribute( SDL_GL_STENCIL_SIZE, 1 );
if ( SDL_SetVideoMode(width, height, 0, flags) == NULL ) {
return 0;
}
SDL_GL_GetAttribute( SDL_GL_STENCIL_SIZE, &size);
ReSizeGLScene(width, height);
if (!InitGL()){
KillGLWindow();
return 0;
}
return 1;
}
| [
"gcbsumid@gmail.com"
] | gcbsumid@gmail.com |
d10b3c21bfacc94ac93661e43315e4d750d3cff8 | 6b2a8dd202fdce77c971c412717e305e1caaac51 | /solutions_5658282861527040_0/C++/nhirokinet/bsmall.cpp | a38a253f06dff70a92c339f7f8f0e93417cd1f4d | [] | 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 | 847 | cpp | // {{{ Boilerplate Code <--------------------------------------------------
// vim:filetype=cpp:foldmethod=marker:foldmarker={{{,}}}
#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <utility>
#include <vector>
#define FOR(I,A,B) for(int I = (A); I < (B); ++I)
#define ALL(A) (A).begin(), (A).end()
using namespace std;
// }}}
int main(){
int T;
cin>>T;
FOR(iteration,0,T){
cout<<"Case #"<<(iteration+1)<<": ";
int A,B,K;
cin>>A>>B>>K;
int ret=0;
FOR(i,0,A){
FOR(j,0,B){
if((i&j)<K){
ret++;
}
}
}
cout<<ret;
cout<<endl;
}
}
| [
"eewestman@gmail.com"
] | eewestman@gmail.com |
12cea8ec584bdbf993582c7d8963d07ef0c3df08 | 51635684d03e47ebad12b8872ff469b83f36aa52 | /external/gcc-12.1.0/libstdc++-v3/testsuite/20_util/is_pod/deprecated-2a.cc | 0176d24f478954df5fe3c8c27b5088d0c245fe61 | [
"LGPL-2.1-only",
"GPL-3.0-only",
"GCC-exception-3.1",
"GPL-2.0-only",
"LGPL-3.0-only",
"LGPL-2.0-or-later",
"Zlib",
"LicenseRef-scancode-public-domain"
] | permissive | zhmu/ananas | 8fb48ddfe3582f85ff39184fc7a3c58725fe731a | 30850c1639f03bccbfb2f2b03361792cc8fae52e | refs/heads/master | 2022-06-25T10:44:46.256604 | 2022-06-12T17:04:40 | 2022-06-12T17:04:40 | 30,108,381 | 59 | 8 | Zlib | 2021-09-26T17:30:30 | 2015-01-31T09:44:33 | C | UTF-8 | C++ | false | false | 1,047 | cc | // Copyright (C) 2020-2022 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library 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, 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
// { dg-options "-std=gnu++2a" }
// { dg-do compile { target c++2a } }
#include <type_traits>
static_assert(std::is_pod<int>::value); // { dg-warning "is deprecated" }
static_assert(std::is_pod_v<int>); // { dg-warning "is deprecated" }
// { dg-prune-output "declared here" }
| [
"rink@rink.nu"
] | rink@rink.nu |
328a65239d54b29d126e4d7a8923fb493dd3f8c1 | 4a36e8a7f598bb910a1cef0732702828106d98ca | /Dragon/include/operators/vision/lrn_op.h | c7ac603203c818f03cc4745b261602880f759263 | [
"BSD-2-Clause"
] | permissive | awesome-archive/Dragon | d5a5e737d63f71ba8b73306051aa9960d48e7447 | b35f9320909d07d138c2f6b345a4c24911f7c521 | refs/heads/master | 2023-08-21T09:07:58.238769 | 2019-03-20T09:01:37 | 2019-03-20T09:01:37 | 177,972,970 | 0 | 0 | BSD-2-Clause | 2020-01-13T03:40:54 | 2019-03-27T10:41:13 | C++ | UTF-8 | C++ | false | false | 4,905 | h | /*!
* Copyright (c) 2017-present, SeetaTech, Co.,Ltd.
*
* Licensed under the BSD 2-Clause License.
* You should have received a copy of the BSD 2-Clause License
* along with the software. If not, See,
*
* <https://opensource.org/licenses/BSD-2-Clause>
*
* ------------------------------------------------------------
*/
#ifndef DRAGON_OPERATORS_VISION_LRN_OP_H_
#define DRAGON_OPERATORS_VISION_LRN_OP_H_
#include "core/operator.h"
namespace dragon {
typedef enum {
ACROSS_CHANNELS,
WITHIN_CHANNEL,
} LRNMode;
template <class Context>
class LRNOp : public Operator<Context> {
public:
LRNOp(const OperatorDef& def, Workspace* ws)
: Operator<Context>(def, ws),
local_size(OperatorBase::Arg<int64_t>("local_size", 5)),
alpha(OperatorBase::Arg<float>("alpha", 0.0001f)),
beta(OperatorBase::Arg<float>("beta", 0.75f)),
k(OperatorBase::Arg<float>("k", 2.f)),
mode(OperatorBase::Arg<string>("mode", "ACROSS_CHANNELS")),
data_format(OperatorBase::Arg<string>("data_format", "NCHW")) {}
USE_OPERATOR_FUNCTIONS;
void RunOnDevice() override;
template <typename T> void RunWithType();
template <typename T> void AcrossRunWithType();
template <typename T> void SplitRunWithType();
template <typename T> void SquareRunWithType();
template <typename T> void PoolRunWithType();
template <typename T> void PowRunWithType();
template <typename T> void ProdRunWithType();
protected:
int local_size;
float alpha, beta, k;
string mode, data_format;
unique_ptr<OperatorBase> sqr_op, pool_op, pow_op, prod_op;
Tensor* sqr_in, *prod_in, *sqr_out, *pool_out, *pow_out;
Tensor* scale;
};
template <class Context>
class LRNGradientOp : public Operator<Context> {
public:
LRNGradientOp(const OperatorDef& def, Workspace* ws)
: Operator<Context>(def, ws),
local_size(OperatorBase::Arg<int64_t>("local_size", 5)),
alpha(OperatorBase::Arg<float>("alpha", 0.0001f)),
beta(OperatorBase::Arg<float>("beta", 0.75f)),
k(OperatorBase::Arg<float>("k", 2.f)),
mode(OperatorBase::Arg<string>("mode", "ACROSS_CHANNELS")),
data_format(OperatorBase::Arg<string>("data_format", "NCHW")) {}
USE_OPERATOR_FUNCTIONS;
void RunOnDevice() override;
template <typename T> void RunWithType();
template <typename T> void AcrossRunWithType();
template <typename T> void SplitRunWithType();
template <typename T> void SquareRunWithType();
template <typename T> void PoolRunWithType();
template <typename T> void PowRunWithType();
template <typename T> void ProdRunWithType();
protected:
int local_size;
float alpha, beta, k;
string mode, data_format;
unique_ptr<OperatorBase> sqr_op, pool_op, pow_op, prod_op;
Tensor* sqr_in, *prod_in, *sqr_out, *pool_out, *pow_out;
Tensor* scale;
};
#ifdef WITH_CUDNN
template <class Context>
class CuDNNLRNOp final : public LRNOp<Context> {
public:
CuDNNLRNOp(const OperatorDef& def, Workspace* ws)
: LRNOp<Context>(def, ws) {
CUDNN_CHECK(cudnnCreateTensorDescriptor(&input_desc));
CUDNN_CHECK(cudnnCreateTensorDescriptor(&output_desc));
CUDNN_CHECK(cudnnCreateLRNDescriptor(&norm_desc));
CUDNN_CHECK(cudnnSetLRNDescriptor(norm_desc,
this->local_size, this->alpha, this->beta, this->k));
}
USE_OPERATOR_FUNCTIONS;
~CuDNNLRNOp() {
CUDNN_CHECK(cudnnDestroyTensorDescriptor(input_desc));
CUDNN_CHECK(cudnnDestroyTensorDescriptor(output_desc));
CUDNN_CHECK(cudnnDestroyLRNDescriptor(norm_desc));
}
void RunOnDevice() override;
template <typename T> void RunWithType();
protected:
cudnnTensorDescriptor_t input_desc, output_desc;
cudnnLRNDescriptor_t norm_desc;
};
template <class Context>
class CuDNNLRNGradientOp final : public LRNGradientOp<Context > {
public:
CuDNNLRNGradientOp(const OperatorDef& def, Workspace* ws)
: LRNGradientOp<Context>(def, ws) {
CUDNN_CHECK(cudnnCreateTensorDescriptor(&input_desc));
CUDNN_CHECK(cudnnCreateTensorDescriptor(&output_desc));
CUDNN_CHECK(cudnnCreateLRNDescriptor(&norm_desc));
CUDNN_CHECK(cudnnSetLRNDescriptor(norm_desc,
this->local_size, this->alpha, this->beta, this->k));
}
USE_OPERATOR_FUNCTIONS;
~CuDNNLRNGradientOp() {
CUDNN_CHECK(cudnnDestroyTensorDescriptor(input_desc));
CUDNN_CHECK(cudnnDestroyTensorDescriptor(output_desc));
CUDNN_CHECK(cudnnDestroyLRNDescriptor(norm_desc));
}
void RunOnDevice() override;
template <typename T> void RunWithType();
protected:
cudnnTensorDescriptor_t input_desc, output_desc;
cudnnLRNDescriptor_t norm_desc;
};
#endif // WITH CUDNN
} // namespace dragon
#endif // DRAGON_OPERATORS_VISION_LRN_OP_H_ | [
"ting.pan@seetatech.com"
] | ting.pan@seetatech.com |
f4d8b0fd170d1532e64f77ddbc7c3a46186b46af | 701e220bb13e5efdc0de945a8d179d53f81d94bb | /42/Nibbler/hdezier-erobert/game/incs/IGUINibbler.hpp | 82c6647156e1bda026c4615894473cce0cbd1894 | [] | no_license | Elojah/Meuh2.0 | 486273ac9d5192c6f945f5ed9a56b3582f2aafb0 | 1706b6cd96deb56af8ab5b2164c05584435c7e35 | refs/heads/master | 2021-01-11T18:20:18.614432 | 2017-05-19T14:35:10 | 2017-05-19T14:35:10 | 28,937,663 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,343 | hpp | // ************************************************************************** //
// //
// ::: :::::::: //
// IGUINibbler.hpp :+: :+: :+: //
// +:+ +:+ +:+ //
// By: erobert <erobert@student.42.fr> +#+ +:+ +#+ //
// +#+#+#+#+#+ +#+ //
// Created: 2015/03/30 18:56:56 by erobert #+# #+# //
// Updated: 2015/04/09 18:35:45 by erobert ### ########.fr //
// //
// ************************************************************************** //
#ifndef I_GUI_NIBBLER_HPP
# define I_GUI_NIBBLER_HPP
# include <list>
# include <vector>
# include "Game.hpp"
class IGUINibbler
{
public:
typedef std::list<Game::sNibbler> tNibbler;
virtual ~IGUINibbler(void) {};
virtual void initMap(std::vector<int> const &map,
int height, int width) = 0;
virtual void updateDisplay(tNibbler const &tN, int apple,
int score) = 0;
virtual Game::eEvent getEvent(void) = 0;
};
#endif
| [
"erobert@student.42.fr"
] | erobert@student.42.fr |
65868448de6332c204f1290276d8324d758693f5 | d374c5b0caf4c375069f77c0efc6fc08867a3635 | /Converters/DisneyResearchLightFieldToMVE/Main.cpp | 671d4fce5c9f22eedaf23f481af2f8c6bb695230 | [
"Apache-2.0",
"BSD-3-Clause"
] | permissive | namibj/TSR | 7466750b09caaf1d470d0f042c7e60877fcf8fc4 | df14f4a9fc175b2a6b0c14b3ace924f2364afe7b | refs/heads/master | 2021-07-20T03:02:56.959890 | 2020-07-01T17:37:42 | 2020-07-01T17:37:42 | 195,549,270 | 0 | 0 | NOASSERTION | 2019-07-06T14:36:14 | 2019-07-06T14:36:14 | null | WINDOWS-1252 | C++ | false | false | 5,283 | cpp | /*
* Copyright (C) 2017 by Author: Aroudj, Samir
* TU Darmstadt - Graphics, Capture and Massively Parallel Computing
* All rights reserved.
*
* This software may be modified and distributed under the terms
* of the BSD 3-Clause license. See the License.txt file for details.
*/
#include "Math/Vector3.h"
#include "Platform/Storage/Directory.h"
#include "Platform/Storage/File.h"
#include "Utilities/HelperFunctions.h"
using namespace Math;
using namespace Platform;
using namespace std;
using namespace Storage;
bool findSourceData(vector<string> &images, vector<string> &depthMaps, const Path &undistortedDir, const Path &depthMapsDir);
bool getArguments(float &focalLengthMM, uint32 &focalLengthPixels, float &cameraSeparationMM,
Path &undistortedDir, Path &depthMapsDir, Path &targetDir,
const char **unformattedArguments, const int32 argumentCount);
bool handleExistingTargetDirectory(const Path &targetDir);
void outputDescription();
int32 main(int32 argumentCount, const char **unformattedArguments)
{
// data paths
Path undistortedDir;
Path depthMapsDir;
Path targetDir;
Path viewsDir;
// camera calibration
float focalLengthMM;
uint32 focalLengthPixels;
float cameraSeparationMM;
// input file names
vector<string> images;
vector<string> depthMaps;
outputDescription();
// get input arguments and source data locations
getArguments(focalLengthMM, focalLengthPixels, cameraSeparationMM, undistortedDir, depthMapsDir, targetDir,
unformattedArguments, argumentCount);
if (!findSourceData(images, depthMaps, undistortedDir, depthMapsDir))
return 1;
// create scene & views directory
if (!handleExistingTargetDirectory(targetDir))
return 2;
if (!Directory::createDirectory(targetDir))
{
cerr << "Could not create target directory: " << targetDir << endl;
return 3;
}
viewsDir = targetDir + "views";
if (!Directory::createDirectory(viewsDir))
{
cerr << "Could not create views directory: " << viewsDir << endl;
return 4;
}
// for each image:
// create folder
// output .ini
// output undistorted image
// output depth map
return 0;
}
bool findSourceData(vector<string> &images, vector<string> &depthMaps, const Path &undistortedDir, const Path &depthMapsDir)
{
Directory::findChildren(images, undistortedDir, ".jpg");
Directory::findChildren(depthMaps, depthMapsDir, ".dmap");
if (0 == images.size())
{
cerr << "Found zero source images. JPG format is required (.jpg)! Aborting.\n";
return false;
}
//if (images.size() != depthMaps.size())
//{
// cerr << "Number of undistorted images is not equal to the number of depth maps.\n";
// cerr << "Only depth maps from author C. Kim in original format (.dmap) are supported! Aborting.\n";
// return false;
//}
return true;
}
bool getArguments(float &focalLengthMM, uint32 &focalLengthPixels, float &cameraSeparationMM,
Path &undistortedDir, Path &depthMapsDir, Path &targetDir,
const char **unformattedArguments, const int32 argumentCount)
{
// process command line arguments
vector<string> arguments;
Utilities::getCommandLineArguments(arguments, unformattedArguments, argumentCount);
if (6 != arguments.size())
{
cout << "Format: <focal length in mm> <focal length in pixels> <camera separation in mm> <undistorted images dir> <depth maps dir> <output dir = MVE scene dir>";
return false;
}
uint32 currentArgument = 0;
sscanf(arguments[currentArgument++].c_str(), "%f", &focalLengthMM);
sscanf(arguments[currentArgument++].c_str(), "%u", &focalLengthPixels);
sscanf(arguments[currentArgument++].c_str(), "%f", &cameraSeparationMM);
undistortedDir = arguments[currentArgument++];
depthMapsDir = arguments[currentArgument++];
targetDir = arguments[currentArgument++];
return true;
}
bool handleExistingTargetDirectory(const Path &targetDir)
{
// check for existance
if (!Directory::exists(targetDir))
return true;
// ask user
cout << "Directory \"" << targetDir << "\" already exists!\n";
cout << "Continue? (y = yes / n = no)\n";
char choice = 'n';
cin >> choice;
// continue?
if (choice == 'y')
{
cout << "Continuing on user request.\n";
return true;
}
// stop
cout << "Stopping on user request.\n";
return false;
}
void outputDescription()
{
cout << "Converter for data from Kim's lightfield reconstruction to MVE.\n\n";
cout << "Input data:\n";
cout << "Scene Reconstruction from High Spatio-Angular Resolution Light Fields\n";
cout << "C. Kim, H. Zimmer, Y. Pritch, A. Sorkine-Hornung, and M. Gross.\n";
cout << "In: ACM Transactions on Graphics 32(4) (Proceedings of ACM SIGGRAPH 2013)\n";
cout << "Please see the project website for more information:\n";
cout << "http://www.disneyresearch.com/project/lightfields" << "\n";
cout << "\n";
cout << "Output data:\n";
cout << "MVE – A Multi-View Reconstruction Environment\n";
cout << "Simon Fuhrmann, Fabian Langguth and Michael Goesele\n";
cout << "In: Proceedings of the Eurographics Workshop on Graphics and Cultural Heritage, Darmstadt, Germany, 2014.\n";
cout << "Please see the project website for more information:\n";
cout << "https://www.gcc.tu-darmstadt.de/home/proj/mve/" << "\n";
cout << "\n";
cout << "Please cite the above papers if you use any part of the datasets or software provided for the papers.\n";
} | [
"samir.aroudj@gris.informatik.tu-darmstadt.de"
] | samir.aroudj@gris.informatik.tu-darmstadt.de |
297ad97a3cd5b0d7a02e001893560f8022c09209 | cf4feadb28100d7885a51968596151ffb500a30d | /Week08/steering/src/Vehicle.h | 1788e7d91bad653ef02d4feec1abbcf603229350 | [] | no_license | hsab/dt_openframeworks_2017 | 023047443c60a38016689dbda73ecb8cdd41e115 | fecce684610c8112f479fd63b7c32ffa4d057b29 | refs/heads/master | 2020-03-22T18:57:22.317179 | 2017-12-14T21:00:35 | 2017-12-14T21:00:35 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 435 | h | #pragma once
#include "ofMain.h"
class Vehicle {
public:
Vehicle() {}
~Vehicle() {}
void setup();
void update();
void draw();
void applyForce (ofVec3f force);
// steering - vehicle applies force to itself:
void seek (ofVec3f target); // seek a target
void avoid (ofVec3f obstacle); // avoid an obstacle
ofVec3f pos, vel, acc;
float maxSpeed, maxForce; // "speed limits"
}; | [
"henrytyler@gmail.com"
] | henrytyler@gmail.com |
a5bfbff0508ac11b9513aaf45561af913bf7918b | dcc4901380e87e1e06e4255362faa5ed329fa732 | /MFSimStatic/Headers/Router/lee_router.h | c2c6f0b275a662a22f27cfbd67b37dcd54fbc474 | [] | no_license | jrswain85/MFSimStatic | 521fbba792870be98021cd83288eda478dc1102c | 9f6ad005ac1820679c9213aebad5557448089ed7 | refs/heads/master | 2020-03-29T04:52:26.899477 | 2018-09-20T04:59:49 | 2018-09-20T04:59:49 | 149,553,231 | 0 | 0 | null | 2018-09-20T04:53:49 | 2018-09-20T04:53:49 | null | UTF-8 | C++ | false | false | 928 | h | /*
* lee_router.h
*
*
*/
#ifndef LEE_ROUTER_H_
#define LEE_ROUTER_H_
#include "../Testing/elapsed_timer.h"
#include "post_subprob_compact_router.h"
#include <stack>
#include "router.h"
//Struct similar to SoukupCell but instead it holds an int called val which marks how far away the source cell is
//from the LeeCell.
struct LeeCell {
int x;
int y;
bool block;
int val;
};
struct RotuingPoint;
class LeeRouter : public PostSubproblemCompactionRouter
{
public:
// Constructors
LeeRouter();
LeeRouter(DmfbArch *dmfbArch);
virtual ~LeeRouter();
protected:
void computeIndivSupProbRoutes(vector<vector<RoutePoint *> *> *subRoutes, vector<Droplet *> *subDrops, map<Droplet *, vector<RoutePoint *> *> *routes);
void routerSpecificInits();
private:
// Members
vector<vector<LeeCell *> *> *board;
//Methods
void mark_cells(LeeCell * source, LeeCell * target);
};
#endif /* LEE_ROUTER_H_ */
| [
"microfludics@cs.ucr.edu"
] | microfludics@cs.ucr.edu |
5c75ff96f55de1ba5acdf168b0c3951a1b66737f | 5c93333a71b27cfd5e5a017f29f74b25e3dd17fd | /SPOJ/QUEST4.cpp | 3b7fc5180c12f91d7cbe92ab6ed5d9bf6790f43e | [] | no_license | sktheboss/ProblemSolving | 7bcd7e8c2de1f4b1d251093c88754e2b1015684b | 5aff87cc10036a0e6ff255ae47e68a5d71cb7e9d | refs/heads/master | 2021-05-29T03:29:28.980054 | 2015-03-11T10:06:00 | 2015-03-11T10:06:00 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,845 | cpp | #include <vector>
#include <list>
#include <map>
#include <set>
#include <queue>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <string.h>
#define fo(i,n) for(int i=0; i<n; i++)
#define foo(i,m,n) for(int i=m; i<n; i++)
#define foe(i,m,n) for(int i=m; i<=n; i++)
#define be(n) n.begin(),n.end()
#define rbe(n) n.rbegin(),n.rend()
#define mp(a,b) make_pair(a,b)
#define pii pair<int,int>
typedef long long ll;
using namespace std;
int n = 242, src = 0, dest = 241;
const int MAX = 250;
int g[MAX][MAX];
bool vis[MAX];
int par[MAX], dist[MAX];
int getPath() {
memset(par, -1, sizeof par);
memset(vis, 0, sizeof vis);
memset(dist, 0, sizeof dist);
dist[src] = 1e9;
for (int k = 0; k < n; k++) {
int maxi = 0, nxt = -1;
for (int i = 0; i < n; i++)
if (!vis[i] && dist[i] > maxi)
nxt = i, maxi = dist[i];
if (nxt == dest)
return dist[dest];
if (nxt == -1)
return -1;
vis[nxt] = 1;
for (int i = 0; i < n; i++) {
if (dist[i] < min(dist[nxt], g[nxt][i]))
dist[i] = min(dist[nxt], g[nxt][i]), par[i] = nxt;
}
}
return -1;
}
void removePath(int r) {
int d = dest;
while (par[d] != -1) {
g[par[d]][d] -= r, g[d][par[d]] += r;
d = par[d];
}
}
int maxFlow() {
int totalFlow = 0, val = 0;
while ((val = getPath()) != -1) {
totalFlow += val;
removePath(val);
}
return totalFlow;
}
int main() {
int tst;
scanf("%d", &tst);
while (tst--) {
int m, r, c;
scanf("%d", &m);
memset(g, 0, sizeof g);
fo(i,m)
scanf("%d%d", &r, &c), g[r + 1][c + 120 + 1] = 1;
foe(i,1,120)
g[0][i] = 1, g[i + 120][dest] = 1;
printf("%d\n",maxFlow());
}
return 0;
}
| [
"fci.islam@gmail.com"
] | fci.islam@gmail.com |
367091c6957dd9fcc61424bd6fdffd6528a92360 | f11ed31357628473e0bfb89902bc9c94157c6c59 | /Poker_Card/Poker_Card_1.1/Poker_Card/PlayingCard.cpp | 45130e9d50f771df0d52c4a02493e7c7c59763ef | [] | no_license | ChouJustice/WinForm-Project | 06da737d6e31578b257955c3c8917691c1777e6f | e923d7c1a70e3420664574a9bd3bcee074aa7135 | refs/heads/master | 2020-03-15T19:56:18.445743 | 2018-08-20T06:41:49 | 2018-08-20T06:41:49 | 132,320,836 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 672 | cpp | #include "StdAfx.h"
#include "PlayingCard.h"
#include "Deck.h"
PlayingCard::PlayingCard(void)
{
playingCard = gcnew array<Card^> (10);
dealCard();
}
void PlayingCard::dealCard(void)
{
Deck^ myDeck;
myDeck = gcnew Deck();
int i;
for(i=0;i<10;i++)
{
playingCard[i] = gcnew Card();
playingCard[i] = myDeck->dealCard();
}
}
int PlayingCard::getHandCard(int i)
{
int s;
int p;
s = playingCard[i]->getSuit();
p = playingCard[i]->getRank();
return (s-1)*13 + p;
}
int PlayingCard::getRank(int i)
{
int r;
r = playingCard[i]->getRank();
return r;
}
int PlayingCard::getSuit(int i)
{
int s;
s = playingCard[i]->getSuit();
return s;
}
| [
"z42442412@gmail.com"
] | z42442412@gmail.com |
7c2be571369f3cc3ae47ca30975d73fe4913d021 | 52ca17dca8c628bbabb0f04504332c8fdac8e7ea | /boost/phoenix/scope/preprocessed/lambda_40.hpp | 7961055459f25ef360b2bbefa99ae3b518f99c10 | [] | no_license | qinzuoyan/thirdparty | f610d43fe57133c832579e65ca46e71f1454f5c4 | bba9e68347ad0dbffb6fa350948672babc0fcb50 | refs/heads/master | 2021-01-16T17:47:57.121882 | 2015-04-21T06:59:19 | 2015-04-21T06:59:19 | 33,612,579 | 0 | 0 | null | 2015-04-08T14:39:51 | 2015-04-08T14:39:51 | null | UTF-8 | C++ | false | false | 82 | hpp | #include "thirdparty/boost_1_58_0/boost/phoenix/scope/preprocessed/lambda_40.hpp"
| [
"qinzuoyan@xiaomi.com"
] | qinzuoyan@xiaomi.com |
a5e805ea2c8ed93a98db30390ac3256116ceafdf | c9cf0586ace11aa32fa67606d237a130a06364ee | /circular-cylinder-2-40/0.9/p | 7938db638b16ba1db17cf144e3afb61ed495cb5b | [] | no_license | jezvonek/CFD-Final-Project | c74cfa21f22545c27d97d85cf30eb6dc8c824dc1 | 7c9a7fb032d74f20888effa0a0b75b212bf899f4 | refs/heads/master | 2022-07-05T14:43:52.967657 | 2020-05-14T03:40:56 | 2020-05-14T03:40:56 | 262,370,756 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 95,930 | /*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: 6.0
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
location "0.9";
object p;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 2 -2 0 0 0 0];
internalField nonuniform List<scalar>
9600
(
-73.6843
-54.0754
-41.3473
-32.2014
-24.8851
-19.1607
-14.7499
-11.3582
-8.75483
-6.76133
-5.23679
-4.0711
-3.17914
-2.49558
-1.97056
-1.5662
-1.2537
-1.01067
-0.820346
-0.676624
-73.6833
-54.1037
-41.3854
-32.2386
-24.9202
-19.1949
-14.784
-11.3926
-8.78983
-6.79697
-5.27291
-4.10742
-3.2153
-2.5312
-2.00528
-1.5997
-1.28573
-1.04099
-0.848746
-0.70353
-73.7019
-54.1338
-41.4232
-32.2773
-24.9577
-19.2317
-14.8208
-11.4298
-8.82776
-6.83555
-5.31199
-4.14671
-3.25445
-2.56983
-2.04303
-1.63626
-1.32083
-1.07439
-0.880244
-0.733552
-73.7345
-54.1702
-41.4626
-32.317
-24.9966
-19.2701
-14.8594
-11.4691
-8.86783
-6.87642
-5.35348
-4.18851
-3.2962
-2.61115
-2.08354
-1.67563
-1.3588
-1.1107
-0.91469
-0.766575
-73.7782
-54.2135
-41.5057
-32.3592
-25.0377
-19.3106
-14.9001
-11.5104
-8.91004
-6.91951
-5.39726
-4.23269
-3.34041
-2.65499
-2.12664
-1.71766
-1.39948
-1.14977
-0.951946
-0.802466
-73.8295
-54.2627
-41.5525
-32.4039
-25.0808
-19.353
-14.9426
-11.5535
-8.95411
-6.96452
-5.44306
-4.27897
-3.3868
-2.70111
-2.1721
-1.76213
-1.44267
-1.19138
-0.991807
-0.841032
-73.8866
-54.3163
-41.6025
-32.4508
-25.1257
-19.397
-14.9866
-11.5982
-8.99976
-7.01118
-5.49057
-4.32705
-3.43509
-2.74922
-2.21965
-1.80877
-1.48809
-1.23531
-1.03403
-0.882042
-73.9483
-54.3737
-41.6552
-32.4996
-25.1721
-19.4423
-15.0319
-11.6441
-9.04665
-7.05914
-5.53946
-4.3766
-3.48495
-2.799
-2.26896
-1.85726
-1.53546
-1.28125
-1.07834
-0.925227
-74.0136
-54.4338
-41.71
-32.55
-25.2197
-19.4886
-15.078
-11.6909
-9.09442
-7.10802
-5.58934
-4.42723
-3.53599
-2.85007
-2.31968
-1.90727
-1.58444
-1.32888
-1.12441
-0.97029
-74.0821
-54.4962
-41.7664
-32.6015
-25.268
-19.5354
-15.1246
-11.7381
-9.14265
-7.15741
-5.63981
-4.47853
-3.5878
-2.90202
-2.37139
-1.95839
-1.63464
-1.37783
-1.1719
-1.01689
-74.1535
-54.5604
-41.824
-32.6537
-25.3166
-19.5824
-15.1712
-11.7853
-9.1909
-7.20687
-5.69039
-4.53003
-3.63991
-2.95439
-2.42365
-2.01018
-1.68564
-1.4277
-1.22041
-1.06467
-74.2279
-54.6261
-41.8823
-32.7062
-25.3652
-19.629
-15.2175
-11.8321
-9.23873
-7.25592
-5.74062
-4.58125
-3.69183
-3.00668
-2.47595
-2.06216
-1.73697
-1.47803
-1.2695
-1.1132
-74.3054
-54.693
-41.9409
-32.7584
-25.4132
-19.675
-15.2629
-11.878
-9.28565
-7.30407
-5.78999
-4.63167
-3.74304
-3.05835
-2.52776
-2.11378
-1.78809
-1.52829
-1.31867
-1.162
-74.3856
-54.7602
-41.9993
-32.8101
-25.4603
-19.7197
-15.3071
-11.9226
-9.33122
-7.35087
-5.83801
-4.68076
-3.79296
-3.10881
-2.57847
-2.16443
-1.83838
-1.57789
-1.36733
-1.21055
-74.468
-54.827
-42.0566
-32.8608
-25.5062
-19.763
-15.3496
-11.9654
-9.37502
-7.39585
-5.88419
-4.728
-3.84103
-3.15746
-2.62741
-2.2134
-1.88712
-1.62607
-1.41473
-1.25812
-74.5545
-54.8937
-42.1126
-32.9101
-25.5504
-19.8044
-15.3901
-12.0062
-9.41663
-7.4386
-5.9281
-4.77292
-3.88673
-3.20369
-2.67391
-2.25993
-1.93346
-1.67194
-1.45988
-1.30345
-74.6541
-54.9643
-42.1675
-32.9569
-25.5919
-19.8429
-15.4276
-12.0441
-9.45556
-7.47871
-5.96933
-4.81508
-3.92957
-3.24695
-2.71734
-2.30333
-1.97665
-1.71467
-1.50167
-1.34498
-74.7821
-55.0453
-42.2214
-32.9995
-25.6291
-19.8776
-15.4617
-12.0788
-9.49142
-7.51581
-6.00753
-4.85412
-3.96914
-3.28672
-2.75706
-2.3428
-2.01576
-1.75304
-1.53863
-1.38248
-74.9357
-55.1352
-42.2736
-33.0377
-25.6627
-19.9093
-15.4931
-12.1108
-9.52455
-7.55013
-6.04286
-4.89011
-4.00538
-3.32279
-2.79255
-2.37738
-2.04894
-1.78408
-1.56772
-1.41547
-75.0473
-55.2117
-42.3233
-33.0749
-25.6957
-19.9407
-15.524
-12.1421
-9.55656
-7.58302
-6.07646
-4.92409
-4.03928
-3.35607
-2.82464
-2.40746
-2.07571
-1.8066
-1.58788
-1.43397
-74.6752
-74.7295
-74.7495
-74.7786
-74.8176
-74.8554
-74.8872
-74.9124
-74.932
-74.9462
-74.9552
-74.9594
-74.9592
-74.9558
-74.9502
-74.9444
-74.9415
-74.9467
-74.9653
-75.0072
-54.8187
-54.8904
-54.9447
-54.9998
-55.0551
-55.104
-55.1447
-55.1779
-55.2045
-55.225
-55.2399
-55.2494
-55.2544
-55.2556
-55.2539
-55.2515
-55.2494
-55.2469
-55.2477
-55.2434
-41.9077
-41.9889
-42.0603
-42.1272
-42.1876
-42.239
-42.2823
-42.3184
-42.348
-42.3716
-42.3894
-42.402
-42.4097
-42.4134
-42.4148
-42.4126
-42.4052
-42.3972
-42.386
-42.3641
-32.6664
-32.7476
-32.821
-32.8884
-32.9474
-32.9972
-33.0395
-33.0753
-33.1049
-33.1285
-33.1467
-33.1595
-33.1672
-33.1721
-33.1728
-33.1663
-33.1578
-33.1489
-33.1324
-33.1094
-25.3258
-25.4022
-25.472
-25.5359
-25.5915
-25.6383
-25.6782
-25.7118
-25.7393
-25.761
-25.7773
-25.7882
-25.7947
-25.7978
-25.7948
-25.7869
-25.7789
-25.767
-25.7489
-25.7266
-19.6304
-19.7012
-19.7662
-19.8254
-19.8766
-19.9196
-19.9558
-19.9859
-20.01
-20.0285
-20.0415
-20.0493
-20.0536
-20.0531
-20.0463
-20.0378
-20.0279
-20.0129
-19.9933
-19.9706
-15.284
-15.3495
-15.4094
-15.4634
-15.5096
-15.5481
-15.5801
-15.606
-15.626
-15.6406
-15.6497
-15.6543
-15.6547
-15.6497
-15.6407
-15.6306
-15.6168
-15.599
-15.5776
-15.5539
-11.977
-12.0373
-12.0921
-12.1406
-12.1816
-12.2155
-12.2429
-12.2644
-12.2801
-12.2904
-12.2955
-12.2963
-12.2924
-12.2834
-12.2723
-12.2588
-12.2413
-12.2208
-12.1976
-12.1724
-9.46716
-9.52246
-9.57202
-9.61518
-9.65114
-9.68024
-9.70314
-9.72017
-9.73154
-9.73754
-9.73872
-9.73526
-9.72685
-9.71497
-9.70096
-9.68337
-9.66267
-9.6398
-9.61462
-9.58771
-7.56699
-7.61734
-7.66182
-7.69985
-7.73094
-7.75546
-7.77393
-7.78662
-7.79371
-7.79561
-7.79286
-7.78522
-7.77303
-7.75824
-7.74055
-7.71939
-7.69593
-7.6707
-7.64358
-7.61504
-6.12898
-6.17457
-6.21421
-6.24741
-6.27392
-6.29412
-6.30839
-6.31697
-6.32009
-6.31818
-6.31155
-6.3
-6.2848
-6.26686
-6.24548
-6.22137
-6.1954
-6.16798
-6.1391
-6.10918
-5.03847
-5.07957
-5.11469
-5.14344
-5.16575
-5.18195
-5.19235
-5.19718
-5.1967
-5.19129
-5.18105
-5.16637
-5.14832
-5.12709
-5.1027
-5.07604
-5.0478
-5.01844
-4.9881
-4.95717
-4.20761
-4.24456
-4.27555
-4.30031
-4.31883
-4.33144
-4.33839
-4.33989
-4.33623
-4.3277
-4.31444
-4.29702
-4.27629
-4.25228
-4.22533
-4.19644
-4.16621
-4.13521
-4.10377
-4.07227
-3.56992
-3.60313
-3.63044
-3.65166
-3.66687
-3.67634
-3.68029
-3.67894
-3.67255
-3.66132
-3.64551
-3.6259
-3.60285
-3.57639
-3.54734
-3.51652
-3.48457
-3.45225
-3.42004
-3.38845
-3.07562
-3.10551
-3.12961
-3.14778
-3.16015
-3.16694
-3.16835
-3.16461
-3.15593
-3.14247
-3.12473
-3.10325
-3.07813
-3.04978
-3.019
-2.98651
-2.95308
-2.91966
-2.88698
-2.85581
-2.68777
-2.71478
-2.7361
-2.75169
-2.76164
-2.76619
-2.76551
-2.75982
-2.74926
-2.73408
-2.71479
-2.69172
-2.665
-2.63515
-2.6029
-2.56896
-2.53421
-2.49981
-2.46677
-2.43653
-2.37917
-2.40369
-2.42267
-2.43606
-2.44402
-2.44671
-2.44432
-2.43705
-2.42501
-2.40848
-2.38797
-2.36364
-2.33563
-2.30457
-2.27105
-2.23578
-2.19971
-2.16426
-2.13068
-2.10167
-2.12972
-2.15223
-2.16934
-2.18102
-2.18742
-2.18869
-2.18502
-2.17655
-2.16343
-2.14598
-2.12458
-2.09927
-2.07035
-2.03835
-2.00378
-1.9673
-1.92989
-1.89325
-1.85883
-1.83119
-1.92464
-1.9457
-1.96148
-1.97201
-1.9774
-1.97782
-1.97342
-1.96434
-1.95074
-1.93297
-1.91124
-1.88563
-1.85645
-1.82413
-1.78911
-1.75197
-1.71362
-1.67596
-1.64077
-1.61665
-1.75442
-1.77336
-1.78726
-1.79616
-1.80017
-1.79943
-1.7941
-1.7843
-1.77021
-1.75211
-1.73017
-1.70448
-1.67529
-1.64296
-1.60779
-1.57023
-1.53096
-1.49144
-1.45308
-1.43462
-71.0928
-71.2742
-71.4185
-71.5903
-71.7877
-71.995
-72.2026
-72.408
-72.6109
-72.8103
-73.0051
-73.1942
-73.3771
-73.5532
-73.7228
-73.8863
-74.0447
-74.201
-74.3574
-74.5205
-51.2905
-51.49
-51.6794
-51.8787
-52.0872
-52.2973
-52.5045
-52.7076
-52.9066
-53.101
-53.2902
-53.4735
-53.6505
-53.821
-53.985
-54.1425
-54.2944
-54.4409
-54.5807
-54.7104
-38.5331
-38.739
-38.9446
-39.1493
-39.3527
-39.5533
-39.7505
-39.9439
-40.133
-40.3174
-40.4967
-40.6703
-40.8379
-40.9991
-41.1538
-41.3018
-41.4429
-41.5765
-41.6999
-41.8119
-29.485
-29.6849
-29.8853
-30.0824
-30.2753
-30.4646
-30.6507
-30.8333
-31.0117
-31.1855
-31.3542
-31.5173
-31.6746
-31.8255
-31.9699
-32.1073
-32.2373
-32.3594
-32.4716
-32.5751
-22.332
-22.5216
-22.7119
-22.8996
-23.0832
-23.2631
-23.4397
-23.6127
-23.7814
-23.9454
-24.1041
-24.2574
-24.4047
-24.5458
-24.6803
-24.8078
-24.9281
-25.0406
-25.1443
-25.2405
-16.8027
-16.9833
-17.1649
-17.3445
-17.5203
-17.6922
-17.8606
-18.0252
-18.1853
-18.3406
-18.4906
-18.6351
-18.7736
-18.9059
-19.0316
-19.1505
-19.2622
-19.3665
-19.4626
-19.5516
-12.6009
-12.7748
-12.9492
-13.1217
-13.2905
-13.4556
-13.6169
-13.7741
-13.9268
-14.0746
-14.217
-14.3538
-14.4846
-14.6092
-14.7272
-14.8385
-14.9427
-15.0397
-15.129
-15.2112
-9.42302
-9.59115
-9.75941
-9.92556
-10.0882
-10.2471
-10.4021
-10.5529
-10.699
-10.84
-10.9757
-11.1056
-11.2296
-11.3473
-11.4585
-11.5629
-11.6604
-11.7508
-11.8338
-11.9099
-7.03287
-7.19585
-7.35849
-7.51885
-7.67577
-7.82889
-7.97803
-8.12279
-8.26276
-8.39759
-8.52694
-8.65055
-8.76814
-8.87948
-8.98431
-9.08247
-9.17375
-9.25807
-9.33512
-9.40542
-5.24733
-5.40532
-5.56258
-5.71741
-5.86879
-6.01632
-6.15974
-6.29866
-6.43271
-6.56153
-6.68485
-6.80239
-6.91391
-7.01918
-7.11799
-7.21018
-7.29559
-7.37414
-7.4456
-7.51038
-3.92104
-4.07401
-4.22599
-4.37536
-4.5212
-4.66314
-4.80085
-4.93397
-5.06214
-5.18507
-5.30248
-5.41413
-5.51977
-5.6192
-5.71223
-5.79872
-5.87853
-5.9516
-6.01773
-6.07727
-2.93955
-3.08741
-3.23414
-3.37806
-3.51834
-3.65462
-3.7866
-3.91392
-4.03628
-4.15341
-4.26504
-4.37095
-4.47091
-4.56471
-4.65221
-4.73327
-4.80776
-4.87564
-4.93675
-4.99135
-2.21399
-2.35676
-2.49832
-2.63683
-2.77154
-2.90216
-3.02843
-3.15003
-3.26669
-3.37816
-3.48419
-3.58457
-3.67909
-3.76754
-3.8498
-3.92573
-3.99524
-4.05826
-4.11469
-4.16473
-1.67639
-1.81423
-1.95086
-2.08407
-2.21327
-2.33833
-2.45902
-2.57506
-2.68621
-2.79224
-2.89293
-2.98806
-3.07743
-3.16086
-3.23822
-3.30939
-3.37428
-3.43284
-3.48499
-3.53089
-1.27556
-1.40891
-1.54099
-1.66908
-1.79294
-1.91261
-2.02792
-2.13864
-2.24456
-2.34545
-2.44111
-2.53132
-2.6159
-2.69467
-2.76751
-2.83432
-2.89501
-2.94953
-2.99782
-3.04
-0.973576
-1.10339
-1.23146
-1.35462
-1.47334
-1.58787
-1.69806
-1.80375
-1.90473
-2.00081
-2.09177
-2.17741
-2.25756
-2.33205
-2.40077
-2.46361
-2.52051
-2.5714
-2.61625
-2.65517
-0.741847
-0.870086
-0.994974
-1.11337
-1.22713
-1.33678
-1.44213
-1.54308
-1.63945
-1.73105
-1.81767
-1.89911
-1.97521
-2.04582
-2.11081
-2.1701
-2.2236
-2.27129
-2.31312
-2.34917
-0.556121
-0.685638
-0.808837
-0.922883
-1.03206
-1.1372
-1.23813
-1.33479
-1.42703
-1.51465
-1.59744
-1.67522
-1.7478
-1.81505
-1.87686
-1.93313
-1.98379
-2.0288
-2.06813
-2.10184
-0.398976
-0.533176
-0.656591
-0.767224
-0.872446
-0.973627
-1.07071
-1.16366
-1.25235
-1.33657
-1.41611
-1.49078
-1.56042
-1.62487
-1.68404
-1.73784
-1.7862
-1.82907
-1.86644
-1.89835
-0.299682
-0.440218
-0.559324
-0.66453
-0.764562
-0.860599
-0.952698
-1.04086
-1.1249
-1.20458
-1.27971
-1.35011
-1.41563
-1.47615
-1.53157
-1.58182
-1.62685
-1.66664
-1.70116
-1.73045
1.55282
1.51762
1.45636
1.36257
1.22062
1.00824
0.695303
0.241236
-0.407486
-1.32002
-2.58435
-4.31121
-6.63885
-9.73998
-13.8375
-19.2205
-26.1713
-34.9505
-47.3721
-66.8292
1.49346
1.45497
1.39102
1.2943
1.14932
0.934063
0.618583
0.162469
-0.487674
-1.40098
-2.66552
-4.39225
-6.71979
-9.82131
-13.9203
-19.3066
-26.2627
-35.0467
-47.4668
-66.9193
1.42907
1.38706
1.32027
1.22044
1.07221
0.853816
0.535475
0.0769457
-0.575046
-1.48959
-2.75484
-4.48198
-6.80997
-9.9124
-14.0132
-19.403
-26.3646
-35.1533
-47.5687
-66.9995
1.35989
1.31414
1.24438
1.14129
0.989634
0.767893
0.446456
-0.0147654
-0.668919
-1.58505
-2.8514
-4.57936
-6.90822
-10.012
-14.115
-19.5083
-26.4753
-35.2703
-47.6873
-67.1063
1.28612
1.23641
1.16356
1.05705
0.901783
0.676494
0.351738
-0.112421
-0.769002
-1.687
-2.95473
-4.68379
-7.01384
-10.1193
-14.2249
-19.6221
-26.5952
-35.3988
-47.8237
-67.2421
1.20796
1.15409
1.07802
0.967936
0.80888
0.579839
0.251534
-0.215815
-0.875097
-1.79525
-3.06464
-4.79508
-7.12658
-10.234
-14.3426
-19.7445
-26.7245
-35.5383
-47.9745
-67.3982
1.12562
1.06741
0.988009
0.874192
0.711167
0.478176
0.1461
-0.324692
-0.986953
-1.90956
-3.18092
-4.91307
-7.24636
-10.3562
-14.4683
-19.8754
-26.863
-35.6876
-48.1366
-67.5683
1.03929
0.976579
0.89374
0.776048
0.608886
0.371761
0.0357047
-0.438767
-1.10427
-2.02962
-3.30329
-5.03748
-7.37291
-10.4855
-14.6016
-20.0145
-27.0103
-35.8463
-48.3087
-67.7503
0.949149
0.881808
0.795435
0.673735
0.502283
0.260854
-0.0793733
-0.557745
-1.22675
-2.15513
-3.43139
-5.16796
-7.5059
-10.6216
-14.7422
-20.1614
-27.1662
-36.0141
-48.4907
-67.9437
0.85535
0.783286
0.69331
0.567484
0.391606
0.145727
-0.198844
-0.681317
-1.35405
-2.28572
-3.56488
-5.30414
-7.64495
-10.7642
-14.8897
-20.3158
-27.3301
-36.1907
-48.6823
-68.1479
0.758031
0.681195
0.587576
0.457531
0.277119
0.0266646
-0.322395
-0.809147
-1.48583
-2.42103
-3.70336
-5.44563
-7.78963
-10.9128
-15.0436
-20.4772
-27.5017
-36.3757
-48.8831
-68.3623
0.65732
0.575722
0.478459
0.344135
0.15911
-0.0960115
-0.44968
-0.940864
-1.62168
-2.56064
-3.84641
-5.59197
-7.9395
-11.067
-15.2036
-20.6452
-27.6806
-36.5686
-49.0925
-68.5859
0.553348
0.467079
0.366228
0.227604
0.0379245
-0.221926
-0.580297
-1.07604
-1.76116
-2.7041
-3.99355
-5.74269
-8.09406
-11.2262
-15.369
-20.8191
-27.8661
-36.7689
-49.3099
-68.8183
0.446291
0.355546
0.251224
0.108328
-0.0860101
-0.350622
-0.713766
-1.21419
-1.90377
-2.85089
-4.14425
-5.89724
-8.25276
-11.39
-15.5394
-20.9986
-28.0578
-36.9763
-49.5352
-69.0592
0.336435
0.241548
0.133941
-0.0131637
-0.212141
-0.481535
-0.849516
-1.35473
-2.04893
-3.00041
-4.29793
-6.05502
-8.41498
-11.5575
-15.7139
-21.1827
-28.255
-37.1902
-49.7683
-69.3087
0.224294
0.125775
0.0151033
-0.136151
-0.339768
-0.613987
-0.986896
-1.49703
-2.19602
-3.15208
-4.45398
-6.21544
-8.58012
-11.7283
-15.8921
-21.371
-28.4571
-37.4104
-50.0093
-69.5674
0.110793
0.00935366
-0.104212
-0.259671
-0.468031
-0.747203
-1.12519
-1.64043
-2.3444
-3.30524
-4.61175
-6.3778
-8.74743
-11.9016
-16.073
-21.5622
-28.6628
-37.6362
-50.259
-69.8371
-0.00220065
-0.105819
-0.222462
-0.382542
-0.595993
-0.880402
-1.26373
-1.78431
-2.4935
-3.45937
-4.7707
-6.54157
-8.91638
-12.0766
-16.2559
-21.7558
-28.8712
-37.866
-50.5173
-70.1216
-0.110525
-0.216504
-0.337757
-0.503613
-0.722802
-1.01288
-1.40188
-1.92806
-2.64266
-3.61371
-4.93
-6.70578
-9.08581
-12.2522
-16.4394
-21.9497
-29.0795
-38.0968
-50.7838
-70.4261
-0.205799
-0.315969
-0.448416
-0.622802
-0.848468
-1.14463
-1.53964
-2.07165
-2.79186
-3.76825
-5.08966
-6.87046
-9.25576
-12.4282
-16.6232
-22.1435
-29.2861
-38.3225
-51.0493
-70.7598
1.43985
1.46363
1.46154
1.41185
1.30247
1.11137
0.805913
0.343691
-0.329013
-1.27977
-2.59332
-4.37601
-6.76114
-9.91645
-14.0598
-19.474
-26.4319
-35.1853
-47.5534
-66.9672
1.49378
1.5022
1.48806
1.43467
1.32533
1.13605
0.833884
0.376273
-0.290767
-1.23509
-2.5417
-4.31713
-6.69477
-9.84235
-13.9778
-19.3844
-26.3342
-35.0747
-47.4199
-66.8056
1.55853
1.55495
1.5318
1.47358
1.36155
1.17109
0.869312
0.413583
-0.250262
-1.19034
-2.49193
-4.26182
-6.63356
-9.7749
-13.9037
-19.3034
-26.2457
-34.9729
-47.2858
-66.6162
1.61392
1.60556
1.57762
1.51607
1.4018
1.21005
0.908066
0.453284
-0.208498
-1.14552
-2.44329
-4.20879
-6.57573
-9.71188
-13.8349
-19.2281
-26.1635
-34.8814
-47.1732
-66.4651
1.66452
1.65376
1.62231
1.55803
1.44186
1.249
0.946759
0.492676
-0.167453
-1.10195
-2.39645
-4.15811
-6.52078
-9.65225
-13.77
-19.1574
-26.0869
-34.7996
-47.0828
-66.3551
1.70947
1.69713
1.66304
1.59661
1.47893
1.28519
0.982823
0.529427
-0.129182
-1.06138
-2.35292
-4.11107
-6.46982
-9.59703
-13.7102
-19.0924
-26.0171
-34.7268
-47.0074
-66.2697
1.74742
1.73403
1.69794
1.62984
1.51098
1.31663
1.01431
0.561704
-0.0953787
-1.02537
-2.31411
-4.06901
-6.42418
-9.54758
-13.6567
-19.0347
-25.9555
-34.663
-46.9428
-66.1999
1.77799
1.76385
1.72615
1.65664
1.53681
1.34201
1.03988
0.588165
-0.0673327
-0.995112
-2.28114
-4.03296
-6.38482
-9.50481
-13.6105
-18.9851
-25.9029
-34.6089
-46.8889
-66.1438
1.80117
1.7864
1.74727
1.67648
1.55575
1.36056
1.05867
0.607883
-0.0459956
-0.971556
-2.2549
-4.00374
-6.35247
-9.46935
-13.5721
-18.944
-25.8597
-34.5652
-46.8467
-66.102
1.81704
1.80163
1.76114
1.68908
1.56745
1.37183
1.07014
0.620255
-0.0320297
-0.955395
-2.23609
-3.98203
-6.3278
-9.44183
-13.542
-18.9119
-25.8264
-34.5325
-46.8169
-66.0749
1.82573
1.80958
1.76772
1.69437
1.57174
1.3756
1.074
0.624909
-0.0258713
-0.947119
-2.22526
-3.96839
-6.31135
-9.42279
-13.5208
-18.8893
-25.8034
-34.5111
-46.7996
-66.0621
1.82738
1.81034
1.76707
1.69232
1.56858
1.37177
1.07009
0.621642
-0.0277839
-0.947046
-2.22274
-3.96322
-6.30355
-9.41264
-13.5089
-18.8765
-25.7911
-34.5013
-46.7952
-66.0634
1.82215
1.80404
1.75927
1.68301
1.55801
1.36034
1.05839
0.610368
-0.0378996
-0.955357
-2.22878
-3.96676
-6.30467
-9.41171
-13.5066
-18.8739
-25.7898
-34.5036
-46.8037
-66.0789
1.8102
1.79081
1.74444
1.66653
1.54008
1.34135
1.03891
0.591082
-0.0562584
-0.972129
-2.24349
-3.97918
-6.31489
-9.42017
-13.5141
-18.8817
-25.7997
-34.5182
-46.8258
-66.109
1.79169
1.7708
1.7227
1.64299
1.51491
1.31491
1.01173
0.56384
-0.0828324
-0.997366
-2.26689
-4.00054
-6.33431
-9.43815
-13.5316
-18.9
-25.8211
-34.5454
-46.8617
-66.1541
1.7668
1.74415
1.69419
1.61254
1.48263
1.28113
0.976956
0.528736
-0.117545
-1.03102
-2.29898
-4.03083
-6.36295
-9.46566
-13.5589
-18.9289
-25.8538
-34.5854
-46.9122
-66.2153
1.73568
1.71104
1.65909
1.57532
1.44338
1.24015
0.934739
0.48591
-0.160271
-1.07297
-2.33964
-4.06997
-6.40071
-9.50262
-13.5962
-18.9681
-25.8979
-34.6383
-46.9781
-66.2938
1.69853
1.67162
1.61754
1.53149
1.39734
1.19215
0.88523
0.435503
-0.21088
-1.1231
-2.38878
-4.11787
-6.44751
-9.54896
-13.6432
-19.0177
-25.9529
-34.7038
-47.0599
-66.3925
1.65551
1.62609
1.56974
1.48126
1.34469
1.13732
0.828644
0.377743
-0.269126
-1.18115
-2.44608
-4.17414
-6.50287
-9.60404
-13.6992
-19.0764
-26.0174
-34.78
-47.158
-66.5155
1.60682
1.57461
1.51585
1.42476
1.28556
1.07575
0.765018
0.312616
-0.335089
-1.24728
-2.51182
-4.23921
-6.56733
-9.66845
-13.7648
-19.1449
-26.091
-34.8638
-47.2666
-66.6662
1.54791
1.6129
1.59867
1.55422
1.49002
1.41106
1.32125
1.22342
1.11985
1.01236
0.902448
0.791315
0.679918
0.569013
0.459185
0.350872
0.244385
0.139931
0.0376288
-0.0625361
1.51271
1.56698
1.56636
1.53236
1.47478
1.39988
1.31229
1.21542
1.1119
1.00379
0.892739
0.780047
0.666756
0.553683
0.441458
0.330558
0.221328
0.114
0.00871823
-0.094524
1.4883
1.51882
1.51684
1.48623
1.43183
1.35909
1.27262
1.17603
1.07212
0.963101
0.850697
0.736286
0.620958
0.505571
0.390783
0.277097
0.164877
0.0543734
-0.0542521
-0.161016
1.42316
1.43818
1.43213
1.40179
1.34889
1.27752
1.1918
1.09522
0.990639
0.880338
0.766133
0.649473
0.531512
0.413157
0.295112
0.177915
0.0619612
-0.0524724
-0.165199
-0.276249
1.30165
1.30471
1.29282
1.26036
1.2072
1.13608
1.05036
0.953262
0.847532
0.73547
0.618948
0.499479
0.378281
0.256319
0.134349
0.0129543
-0.107434
-0.2265
-0.344029
-0.460064
1.10059
1.09263
1.07328
1.03663
0.981379
0.909098
0.822368
0.723961
0.616449
0.502067
0.382697
0.259892
0.134924
0.00881117
-0.117636
-0.243791
-0.369179
-0.493439
-0.616326
-0.737905
0.786152
0.767728
0.739939
0.697513
0.638547
0.563709
0.474852
0.374279
0.264297
0.147022
0.0242951
-0.102316
-0.231508
-0.362215
-0.493581
-0.624934
-0.755755
-0.885632
-1.01429
-1.14182
0.31522
0.286747
0.25003
0.200725
0.136714
0.0580694
-0.0339639
-0.137542
-0.250656
-0.371359
-0.497885
-0.628689
-0.762454
-0.898084
-1.03469
-1.17154
-1.30809
-1.44386
-1.57855
-1.71228
-0.366183
-0.404409
-0.45027
-0.507174
-0.577223
-0.660691
-0.756807
-0.864135
-0.980968
-1.10555
-1.23624
-1.37153
-1.51011
-1.65088
-1.79292
-1.93547
-2.0779
-2.2197
-2.36053
-2.50059
-1.32566
-1.37338
-1.42841
-1.49331
-1.57007
-1.65913
-1.76005
-1.87174
-1.99278
-2.12163
-2.25676
-2.39674
-2.54032
-2.68637
-2.83396
-2.98229
-3.1307
-3.27856
-3.42555
-3.57195
-2.64793
-2.70486
-2.76893
-2.84199
-2.92586
-3.02102
-3.12729
-3.24383
-3.3695
-3.50294
-3.64277
-3.78765
-3.93637
-4.08782
-4.24106
-4.39526
-4.54967
-4.70361
-4.85675
-5.00949
-4.43928
-4.50513
-4.578
-4.65921
-4.75038
-4.85199
-4.96402
-5.08584
-5.21652
-5.35488
-5.4997
-5.64973
-5.80381
-5.96085
-6.11991
-6.28013
-6.44066
-6.60074
-6.76007
-6.91923
-6.83302
-6.90748
-6.98889
-7.0781
-7.17666
-7.28496
-7.40311
-7.53061
-7.66672
-7.81044
-7.96065
-8.11622
-8.27602
-8.43901
-8.60423
-8.77079
-8.93775
-9.10422
-9.26999
-9.43585
-9.99689
-10.0796
-10.1692
-10.2663
-10.3722
-10.4874
-10.6121
-10.7457
-10.8878
-11.0375
-11.1937
-11.3554
-11.5215
-11.6911
-11.8631
-12.0367
-12.2107
-12.3842
-12.557
-12.7301
-14.1486
-14.2391
-14.3366
-14.4412
-14.5546
-14.6769
-14.8084
-14.9489
-15.0976
-15.254
-15.4171
-15.5859
-15.7594
-15.9365
-16.1163
-16.298
-16.4802
-16.6619
-16.8428
-17.0242
-19.5708
-19.6688
-19.7736
-19.8856
-20.0062
-20.1357
-20.2744
-20.4222
-20.5786
-20.7427
-20.9139
-21.091
-21.2732
-21.4593
-21.6486
-21.8401
-22.0323
-22.2239
-22.4143
-22.6051
-26.5372
-26.6422
-26.753
-26.8707
-26.9973
-27.1335
-27.2795
-27.4352
-27.5999
-27.7729
-27.9534
-28.1404
-28.3329
-28.5299
-28.7304
-28.9335
-29.1377
-29.3413
-29.5435
-29.746
-35.2991
-35.4064
-35.5171
-35.636
-35.7657
-35.9069
-36.0596
-36.223
-36.3965
-36.579
-36.7697
-36.9677
-37.1718
-37.381
-37.5941
-37.8101
-38.0283
-38.2479
-38.4679
-38.6876
-47.656
-47.745
-47.8416
-47.9543
-48.0832
-48.2273
-48.3851
-48.5553
-48.7367
-48.9283
-49.1292
-49.3383
-49.5546
-49.777
-50.004
-50.235
-50.4715
-50.7165
-50.9684
-51.2141
-66.9926
-67.0296
-67.104
-67.2074
-67.3341
-67.4792
-67.6401
-67.8149
-68.0023
-68.2012
-68.4106
-68.6298
-68.858
-69.0941
-69.337
-69.5868
-69.8479
-70.1284
-70.4262
-70.7012
-0.160823
-0.25691
-0.351278
-0.44414
-0.535795
-0.626595
-0.71685
-0.806731
-0.89654
-0.986545
-1.07621
-1.16446
-1.2498
-1.32964
-1.40017
-1.45571
-1.48865
-1.49154
-1.44478
-1.26987
-0.196031
-0.295347
-0.393032
-0.489258
-0.584314
-0.678552
-0.772263
-0.865496
-0.958424
-1.05133
-1.14348
-1.23351
-1.31971
-1.39921
-1.46781
-1.51961
-1.54735
-1.54226
-1.48179
-1.32133
-0.26625
-0.369383
-0.47103
-0.571325
-0.670537
-0.769005
-0.866969
-0.964376
-1.06123
-1.15769
-1.25297
-1.34542
-1.43314
-1.51315
-1.58116
-1.63144
-1.65747
-1.65163
-1.5966
-1.46682
-0.385962
-0.493649
-0.599971
-0.705015
-0.809028
-0.912302
-1.01508
-1.11714
-1.2183
-1.31868
-1.4174
-1.51257
-1.60212
-1.68304
-1.75104
-1.80067
-1.82587
-1.81975
-1.76988
-1.66341
-0.574947
-0.687847
-0.799475
-0.909859
-1.01922
-1.12778
-1.23574
-1.34284
-1.44859
-1.55301
-1.65529
-1.75322
-1.84462
-1.92645
-1.9945
-2.04366
-2.06838
-2.06244
-2.01727
-1.92835
-0.858504
-0.977133
-1.09455
-1.21071
-1.32581
-1.43998
-1.5534
-1.66563
-1.77607
-1.88459
-1.99025
-2.09079
-2.1838
-2.26633
-2.33429
-2.383
-2.40753
-2.40267
-2.36289
-2.2883
-1.26853
-1.39324
-1.51676
-1.63896
-1.75999
-1.8799
-1.99878
-2.11618
-2.23114
-2.34345
-2.45222
-2.55498
-2.64924
-2.73212
-2.79979
-2.84807
-2.87272
-2.86967
-2.83578
-2.77349
-1.84534
-1.97632
-2.10608
-2.2344
-2.36137
-2.48695
-2.61114
-2.73337
-2.8526
-2.96827
-3.07964
-3.18418
-3.27924
-3.36214
-3.42939
-3.47732
-3.50246
-3.50179
-3.4739
-3.42233
-2.64009
-2.77738
-2.91335
-3.04771
-3.18046
-3.31148
-3.44066
-3.56735
-3.69036
-3.80892
-3.92231
-4.02819
-4.12369
-4.20637
-4.27319
-4.32101
-4.34702
-4.34915
-4.32716
-4.28497
-3.7179
-3.86141
-4.00349
-4.14368
-4.28196
-4.41809
-4.55184
-4.68264
-4.80892
-4.9298
-5.04482
-5.15168
-5.24741
-5.3298
-5.39633
-5.44433
-5.47162
-5.47683
-5.46048
-5.42659
-5.16186
-5.31151
-5.45952
-5.60534
-5.74888
-5.88977
-6.02771
-6.1621
-6.29155
-6.41444
-6.53051
-6.63817
-6.73423
-6.81642
-6.8829
-6.9315
-6.96044
-6.9689
-6.95789
-6.93142
-7.07808
-7.23384
-7.3877
-7.53898
-7.68758
-7.83302
-7.9749
-8.11261
-8.24502
-8.36988
-8.48679
-8.59524
-8.6919
-8.77419
-8.84101
-8.89066
-8.92164
-8.93348
-8.92754
-8.90785
-9.60144
-9.76343
-9.92317
-10.0799
-10.2335
-10.3835
-10.5293
-10.6703
-10.8055
-10.9328
-11.0508
-11.1599
-11.2576
-11.3407
-11.4083
-11.4596
-11.4931
-11.5085
-11.5074
-11.4941
-12.903
-13.0715
-13.2374
-13.3998
-13.5587
-13.7134
-13.8634
-14.0079
-14.1461
-14.2764
-14.396
-14.5059
-14.6055
-14.6903
-14.7594
-14.8129
-14.8496
-14.8689
-14.8728
-14.8658
-17.205
-17.3807
-17.5532
-17.7219
-17.8865
-18.0465
-18.2012
-18.3498
-18.4916
-18.6251
-18.748
-18.8595
-18.9609
-19.0489
-19.1206
-19.1772
-19.218
-19.242
-19.2512
-19.2503
-22.795
-22.9789
-23.159
-23.3347
-23.5058
-23.6719
-23.8321
-23.9858
-24.1321
-24.2698
-24.3972
-24.5116
-24.6155
-24.708
-24.7841
-24.8449
-24.8911
-24.9208
-24.9356
-24.9407
-29.9472
-30.1408
-30.3294
-30.5127
-30.6912
-30.8642
-31.0312
-31.1912
-31.3435
-31.4868
-31.6197
-31.74
-31.8478
-31.9451
-32.0277
-32.0943
-32.1467
-32.1833
-32.2049
-32.2167
-38.9026
-39.1056
-39.3014
-39.4921
-39.6783
-39.8595
-40.0347
-40.2029
-40.3629
-40.5137
-40.6538
-40.7816
-40.8955
-40.9979
-41.0883
-41.1618
-41.2208
-41.2682
-41.3035
-41.328
-51.434
-51.6369
-51.8346
-52.0312
-52.2256
-52.4164
-52.6016
-52.7797
-52.9493
-53.1091
-53.258
-53.3949
-53.5183
-53.6271
-53.7238
-53.8081
-53.8808
-53.9515
-54.0214
-54.0698
-70.8871
-71.0708
-71.2665
-71.4681
-71.6712
-71.8717
-72.0671
-72.2555
-72.4351
-72.6047
-72.7633
-72.9105
-73.0456
-73.1676
-73.2759
-73.375
-73.4743
-73.5881
-73.7162
-73.7943
-73.7137
-54.067
-41.3376
-32.2195
-24.9372
-19.241
-14.8501
-11.4718
-8.87848
-6.89452
-5.3814
-4.23044
-3.35704
-2.69561
-2.19528
-1.81626
-1.52655
-1.30091
-1.12203
-0.959895
-73.6251
-54.0322
-41.3237
-32.2063
-24.92
-19.2193
-14.8235
-11.4395
-8.84005
-6.84941
-5.32893
-4.16984
-3.28744
-2.61609
-2.105
-1.71459
-1.41388
-1.18064
-1.00125
-0.844537
-73.5568
-53.9887
-41.2981
-32.1847
-24.8964
-19.1922
-14.792
-11.4033
-8.79864
-6.80239
-5.27591
-4.1104
-3.22124
-2.5429
-2.0248
-1.62777
-1.32155
-1.08455
-0.904134
-0.756359
-73.5024
-53.9472
-41.2674
-32.1578
-24.8686
-19.1616
-14.7581
-11.3656
-8.75702
-6.75663
-5.22585
-4.05598
-3.1625
-2.48008
-1.95839
-1.55864
-1.25103
-1.01407
-0.834544
-0.691806
-73.4578
-53.9094
-41.236
-32.1292
-24.8395
-19.1305
-14.7245
-11.3294
-8.71802
-6.71488
-5.18141
-4.00896
-3.11314
-2.42877
-1.9057
-1.50537
-1.19821
-0.962647
-0.784837
-0.646057
-73.42
-53.876
-41.2065
-32.1011
-24.811
-19.1006
-14.693
-11.2962
-8.6832
-6.67858
-5.14377
-3.97019
-3.07351
-2.38864
-1.86553
-1.46576
-1.15983
-0.925983
-0.749809
-0.61407
-73.3881
-53.8472
-41.18
-32.0754
-24.7849
-19.0736
-14.6649
-11.2672
-8.65362
-6.64851
-5.1134
-3.93969
-3.04311
-2.3586
-1.83615
-1.43738
-1.13284
-0.900574
-0.725675
-0.592096
-73.3619
-53.8233
-41.1575
-32.0531
-24.7621
-19.0503
-14.6411
-11.2433
-8.62971
-6.62486
-5.09015
-3.91698
-3.02106
-2.33734
-1.8158
-1.4181
-1.11477
-0.88374
-0.709668
-0.577488
-73.3416
-53.8046
-41.1398
-32.0352
-24.7436
-19.0314
-14.6222
-11.2246
-8.61158
-6.60747
-5.07361
-3.90135
-3.00634
-2.32353
-1.80291
-1.4061
-1.10368
-0.873447
-0.699739
-0.568325
-73.3276
-53.7916
-41.1271
-32.022
-24.7298
-19.0172
-14.6082
-11.2112
-8.59908
-6.59601
-5.06324
-3.89203
-2.998
-2.31604
-1.79614
-1.39996
-1.09807
-0.868198
-0.694414
-0.563242
-73.3205
-53.7845
-41.1198
-32.0139
-24.7209
-19.0081
-14.5993
-11.2031
-8.59198
-6.59007
-5.05846
-3.88831
-2.99516
-2.31389
-1.79448
-1.3986
-1.09686
-0.866941
-0.692682
-0.561324
-73.3207
-53.7837
-41.1183
-32.0111
-24.7171
-19.0039
-14.5954
-11.2
-8.58994
-6.58921
-5.05873
-3.88954
-2.99712
-2.31633
-1.79715
-1.40125
-1.09932
-0.868979
-0.693896
-0.562002
-73.3288
-53.7895
-41.1226
-32.0137
-24.7183
-19.0045
-14.5963
-11.2016
-8.59261
-6.59301
-5.06357
-3.89521
-3.00336
-2.32283
-1.8036
-1.40741
-1.10498
-0.873885
-0.697684
-0.564973
-73.3448
-53.8016
-41.1325
-32.0215
-24.7244
-19.0099
-14.6017
-11.2077
-8.59969
-6.60114
-5.07262
-3.90495
-3.01347
-2.33299
-1.8135
-1.41676
-1.11354
-0.881436
-0.703874
-0.570129
-73.3687
-53.8195
-41.1477
-32.0344
-24.7353
-19.0197
-14.6115
-11.2181
-8.61093
-6.61331
-5.0856
-3.91847
-3.02721
-2.34659
-1.82662
-1.42911
-1.1249
-0.891559
-0.712443
-0.577496
-73.4017
-53.8439
-41.1682
-32.0522
-24.7507
-19.0338
-14.6254
-11.2324
-8.62605
-6.62928
-5.10227
-3.93556
-3.04437
-2.36346
-1.84285
-1.4444
-1.13902
-0.90428
-0.723464
-0.587193
-73.4498
-53.8776
-41.1945
-32.0745
-24.7701
-19.0515
-14.6428
-11.2502
-8.64468
-6.64874
-5.12238
-3.95602
-3.06481
-2.3835
-1.86214
-1.46264
-1.15596
-0.919692
-0.737072
-0.599389
-73.5226
-53.925
-41.2272
-32.1009
-24.7932
-19.0728
-14.6635
-11.2713
-8.66658
-6.67145
-5.14572
-3.97968
-3.08841
-2.40665
-1.88446
-1.48383
-1.17578
-0.9379
-0.75341
-0.614259
-73.6171
-53.9836
-41.2649
-32.1306
-24.8197
-19.0977
-14.688
-11.296
-8.69194
-6.69751
-5.17233
-4.00653
-3.11514
-2.43287
-1.90982
-1.50801
-1.19854
-0.959001
-0.772606
-0.631957
-73.692
-54.0391
-41.3054
-32.164
-24.8504
-19.1272
-14.7169
-11.3251
-8.72141
-6.72748
-5.20266
-4.03695
-3.14532
-2.46244
-1.93843
-1.53537
-1.22442
-0.98317
-0.794837
-0.652677
-0.358099
-0.212835
-0.146285
-0.0976173
-0.0632259
-0.0390947
-0.024435
-0.0159484
-0.0112647
-0.00860283
-0.00699122
-0.00588512
-0.00504355
-0.00435488
-0.00377266
-0.00327545
-0.00284087
-0.00246006
-0.00211385
-0.00180244
-0.00151721
-0.00125916
-0.00102772
-0.000827046
-0.000651312
-0.000505213
-0.000386435
-0.000288921
-0.000210263
-0.000150155
-0.000103837
-7.00473e-05
-4.29721e-05
-2.53587e-05
-1.33971e-05
-6.4004e-06
2.2553e-07
1.3051e-06
4.62629e-06
2.56913e-06
-0.384713
-0.218812
-0.15088
-0.0979124
-0.0638487
-0.0394908
-0.0250849
-0.016687
-0.0120829
-0.00945204
-0.00784772
-0.00672892
-0.0058597
-0.00513165
-0.00450236
-0.00395221
-0.0034632
-0.00302657
-0.00262749
-0.00226392
-0.00192965
-0.00162622
-0.00135175
-0.00111349
-0.000902037
-0.000722338
-0.000572025
-0.000449383
-0.00034851
-0.0002681
-0.000201799
-0.000153624
-0.000110261
-8.03638e-05
-5.59293e-05
-4.07303e-05
-2.32227e-05
-1.82544e-05
-6.89264e-06
-3.94922e-08
-0.414503
-0.227281
-0.157282
-0.0995299
-0.0653531
-0.0405074
-0.0261562
-0.0177148
-0.0130956
-0.0104314
-0.00879153
-0.00763228
-0.00671731
-0.00593771
-0.00525233
-0.00464292
-0.00409431
-0.00359861
-0.00314363
-0.00272668
-0.00234271
-0.0019934
-0.00167655
-0.00139992
-0.0011531
-0.000940603
-0.000760086
-0.000611505
-0.000487503
-0.000386223
-0.000300663
-0.000236704
-0.000178209
-0.000135696
-9.96166e-05
-7.50775e-05
-4.80988e-05
-3.66708e-05
-1.90418e-05
-2.47899e-06
-0.447466
-0.238272
-0.1655
-0.102496
-0.0677433
-0.0421518
-0.0276491
-0.0190315
-0.0143026
-0.0115418
-0.00982358
-0.00859513
-0.0076151
-0.00677109
-0.00602073
-0.00534631
-0.00473377
-0.00417645
-0.00366301
-0.0031916
-0.00275714
-0.00236122
-0.00200227
-0.00168617
-0.00140418
-0.00115949
-0.00094987
-0.000774417
-0.000626408
-0.000503784
-0.000399709
-0.000318675
-0.000246272
-0.000190858
-0.000143983
-0.000109074
-7.40614e-05
-5.37447e-05
-2.99427e-05
-5.33648e-06
-0.48354
-0.251779
-0.175523
-0.106831
-0.071021
-0.0444305
-0.0295642
-0.0206376
-0.0157046
-0.0127845
-0.0109447
-0.00961759
-0.00855253
-0.00763085
-0.00680683
-0.00606166
-0.00538153
-0.00476001
-0.00418639
-0.00365918
-0.00317331
-0.00273022
-0.00232858
-0.00197277
-0.00165535
-0.00137837
-0.0011395
-0.000937165
-0.000765229
-0.000621228
-0.000498677
-0.000400596
-0.000314268
-0.000245967
-0.000188232
-0.000143101
-9.99792e-05
-7.08003e-05
-4.01884e-05
-8.44459e-06
-0.522621
-0.267781
-0.187319
-0.112553
-0.0751873
-0.0473505
-0.0319043
-0.0225357
-0.0173032
-0.0141603
-0.0121554
-0.0107001
-0.00952989
-0.0085172
-0.00761076
-0.00678908
-0.00603756
-0.00534929
-0.00471371
-0.00412938
-0.00359123
-0.00310032
-0.00265546
-0.00225975
-0.00190662
-0.00159715
-0.00132895
-0.00109981
-0.000903942
-0.000738628
-0.000597516
-0.000482532
-0.00038216
-0.000301047
-0.000232426
-0.000177113
-0.000125794
-8.79714e-05
-5.0454e-05
-1.15535e-05
-0.56457
-0.286242
-0.200846
-0.119679
-0.0802446
-0.0509196
-0.0346738
-0.0247292
-0.0191005
-0.0156708
-0.0134566
-0.0118432
-0.0105477
-0.00943046
-0.00843273
-0.00752865
-0.00670186
-0.00594422
-0.0052449
-0.00460216
-0.00401083
-0.0034715
-0.00298292
-0.0025471
-0.002158
-0.00181591
-0.00151827
-0.00126236
-0.00104258
-0.000855973
-0.000696279
-0.000564467
-0.000449994
-0.000356104
-0.000276565
-0.000211136
-0.000151557
-0.000105209
-6.07536e-05
-1.46522e-05
-0.609225
-0.307122
-0.216048
-0.128225
-0.0861977
-0.0551471
-0.037879
-0.0272229
-0.0210999
-0.0173179
-0.0148496
-0.0130478
-0.0116064
-0.010371
-0.00927294
-0.00828048
-0.00737445
-0.00654479
-0.00577991
-0.00507748
-0.00443209
-0.00384375
-0.00331098
-0.00283478
-0.0024095
-0.00203466
-0.0017075
-0.00142481
-0.00118114
-0.00097325
-0.000794969
-0.000646384
-0.000517772
-0.000411133
-0.000320651
-0.000245168
-0.000177286
-0.000122488
-7.10713e-05
-1.77562e-05
-0.656403
-0.330383
-0.232863
-0.13821
-0.0930553
-0.0600441
-0.0415284
-0.0300228
-0.0233054
-0.0191046
-0.0163363
-0.014315
-0.0127068
-0.0113393
-0.0101316
-0.0090447
-0.00805538
-0.00715099
-0.00631873
-0.00555531
-0.00485498
-0.00421702
-0.00363959
-0.00312277
-0.00266109
-0.00225337
-0.00189661
-0.00158715
-0.00131961
-0.00109044
-0.000893575
-0.000728267
-0.000585488
-0.000466127
-0.000364687
-0.000279201
-0.000202981
-0.000139806
-8.14046e-05
-2.08708e-05
-0.705907
-0.355993
-0.251215
-0.149651
-0.100831
-0.0656237
-0.0456332
-0.0331364
-0.0257223
-0.0210341
-0.0179186
-0.0156461
-0.0138498
-0.0123358
-0.0110092
-0.00982148
-0.0087447
-0.00776282
-0.00686131
-0.00603561
-0.00527946
-0.00459128
-0.00396874
-0.00341104
-0.00291275
-0.00247203
-0.00208559
-0.00174936
-0.00145796
-0.00120754
-0.000992086
-0.000810104
-0.000653137
-0.00052108
-0.000408674
-0.000313229
-0.000228644
-0.000157158
-9.17528e-05
-2.39988e-05
-0.757507
-0.383922
-0.271025
-0.162562
-0.109542
-0.0719008
-0.0502067
-0.0365728
-0.0283568
-0.0231104
-0.0195994
-0.0170429
-0.0150364
-0.0133612
-0.0119058
-0.010611
-0.0094425
-0.00838029
-0.00740764
-0.00651836
-0.00570549
-0.00496649
-0.00429839
-0.00369956
-0.00316446
-0.00269062
-0.00227444
-0.00191143
-0.00159618
-0.00132453
-0.00109049
-0.000891884
-0.000720716
-0.000575989
-0.00045261
-0.000347249
-0.000254278
-0.000174541
-0.000102114
-2.7143e-05
-0.810946
-0.414186
-0.292229
-0.176965
-0.119218
-0.078894
-0.0552656
-0.0403428
-0.0312166
-0.0253385
-0.0213816
-0.0185072
-0.0162678
-0.0144162
-0.012822
-0.0114134
-0.0101488
-0.0090034
-0.00795767
-0.00700351
-0.00613301
-0.0053426
-0.00462852
-0.00398829
-0.00341619
-0.00290913
-0.00246314
-0.00207334
-0.00173425
-0.0014414
-0.00118879
-0.000973593
-0.000788218
-0.000630847
-0.000496496
-0.000381256
-0.000279884
-0.00019195
-0.000112488
-3.03063e-05
-0.866038
-0.446953
-0.314839
-0.192912
-0.129912
-0.0866345
-0.0608352
-0.0444626
-0.0343123
-0.0277252
-0.0232695
-0.0200415
-0.0175454
-0.0155017
-0.0137583
-0.0122291
-0.0108639
-0.00963217
-0.00851137
-0.00749099
-0.00656199
-0.00571954
-0.00495906
-0.00427719
-0.00366791
-0.00312751
-0.00265166
-0.00223508
-0.00187216
-0.00155812
-0.00128695
-0.00105522
-0.000855636
-0.000685647
-0.00054033
-0.000415246
-0.000305463
-0.000209381
-0.000122874
-3.34914e-05
-0.922704
-0.482421
-0.338841
-0.210435
-0.141687
-0.0951638
-0.06695
-0.0489556
-0.0376601
-0.030281
-0.02527
-0.0216504
-0.0188722
-0.0166195
-0.0147157
-0.0130586
-0.011588
-0.0102668
-0.00906886
-0.00798089
-0.00699243
-0.00609733
-0.00529003
-0.00456623
-0.0039196
-0.00334576
-0.00283999
-0.00239661
-0.00200989
-0.00167469
-0.00138498
-0.00113675
-0.000922966
-0.000740386
-0.00058411
-0.000449214
-0.000331017
-0.000226832
-0.000133269
-3.67009e-05
-0.980132
-0.519987
-0.363751
-0.229312
-0.154491
-0.104463
-0.0736142
-0.0538301
-0.0412681
-0.0330123
-0.0273879
-0.0233373
-0.0202506
-0.0177713
-0.0156955
-0.0139029
-0.0123217
-0.0109078
-0.00963041
-0.00847338
-0.00742448
-0.00647607
-0.00562148
-0.00485549
-0.0041713
-0.00356391
-0.00302816
-0.00255798
-0.00214746
-0.00179111
-0.00148288
-0.00121819
-0.000990212
-0.000795063
-0.000627839
-0.00048316
-0.000356548
-0.000244299
-0.000143675
-3.99374e-05
-1.03565
-0.558163
-0.388726
-0.249059
-0.168083
-0.114382
-0.080741
-0.059033
-0.0451038
-0.0358983
-0.0296095
-0.0250928
-0.021674
-0.0189526
-0.0166944
-0.0147595
-0.0130634
-0.0115537
-0.0101951
-0.00896777
-0.00785764
-0.00685539
-0.00595318
-0.00514476
-0.00442289
-0.00378188
-0.00321611
-0.00271913
-0.00228482
-0.00190737
-0.00158064
-0.00129953
-0.00105737
-0.000849675
-0.000671518
-0.000517082
-0.000382057
-0.000261781
-0.00015409
-4.32033e-05
-1.0895
-0.599691
-0.415562
-0.270475
-0.182863
-0.125083
-0.0883943
-0.0645807
-0.0491626
-0.0389264
-0.0319199
-0.0269027
-0.0231299
-0.0201524
-0.0177034
-0.0156211
-0.013807
-0.0121999
-0.010759
-0.00946098
-0.00828944
-0.00723332
-0.00628355
-0.00543283
-0.00467339
-0.00399889
-0.00340325
-0.00287961
-0.00242164
-0.0020232
-0.00167806
-0.00138061
-0.00112433
-0.000904145
-0.000715094
-0.000550943
-0.000407524
-0.000279264
-0.000164509
-4.64983e-05
-1.15549
-0.656495
-0.451206
-0.297562
-0.201354
-0.138131
-0.0975475
-0.0710784
-0.0538214
-0.042331
-0.0344654
-0.0288582
-0.0246751
-0.0214065
-0.0187446
-0.0165014
-0.0145607
-0.0128509
-0.0113246
-0.00995407
-0.00872007
-0.00760953
-0.00661195
-0.00571888
-0.00492197
-0.00421414
-0.00358883
-0.00303874
-0.00255734
-0.00213812
-0.00177476
-0.00146115
-0.00119087
-0.000958312
-0.000758458
-0.000584667
-0.000432903
-0.000296719
-0.000174918
-4.98184e-05
-1.23355
-0.72355
-0.492489
-0.329612
-0.224105
-0.154422
-0.10909
-0.0792851
-0.0596832
-0.046575
-0.0375953
-0.0312214
-0.0265061
-0.0228622
-0.0199292
-0.0174842
-0.0153882
-0.0135552
-0.0119288
-0.0104751
-0.0091709
-0.00800026
-0.00695074
-0.00601231
-0.00517572
-0.00443297
-0.00377686
-0.00319954
-0.00269415
-0.00225377
-0.00187192
-0.00154197
-0.00125758
-0.00101257
-0.00080187
-0.000618419
-0.000458296
-0.000314202
-0.000185344
-5.31781e-05
-1.22172
-0.729829
-0.496297
-0.340361
-0.235091
-0.164213
-0.117151
-0.0856903
-0.0646661
-0.0504376
-0.0406059
-0.0335976
-0.0284116
-0.0244161
-0.0212159
-0.0185635
-0.0163028
-0.0143359
-0.0125991
-0.0110526
-0.00966962
-0.00843136
-0.00732334
-0.00633386
-0.00545269
-0.0046708
-0.00398026
-0.00337263
-0.00284065
-0.00237696
-0.00197483
-0.0016271
-0.00132741
-0.00106904
-0.000846783
-0.000653167
-0.000484292
-0.000332043
-0.000195951
-5.66546e-05
-1.02453
-0.629455
-0.424403
-0.298144
-0.209396
-0.148746
-0.108062
-0.080572
-0.061975
-0.0492342
-0.0403076
-0.0338438
-0.0289766
-0.0251571
-0.0220422
-0.019417
-0.0171463
-0.0151459
-0.0133614
-0.0117591
-0.0103164
-0.00901724
-0.00784903
-0.00680126
-0.00586466
-0.00503075
-0.00429202
-0.00364027
-0.00306836
-0.00256887
-0.00213499
-0.00175926
-0.00143521
-0.00115564
-0.000915059
-0.000705548
-0.000523012
-0.000358372
-0.000211459
-6.17895e-05
-0.949022
-0.616315
-0.419762
-0.301693
-0.216073
-0.155946
-0.114805
-0.0864929
-0.0669674
-0.0533701
-0.0437173
-0.0366668
-0.0313361
-0.0271529
-0.0237505
-0.0208949
-0.0184356
-0.0162775
-0.0143586
-0.0126394
-0.0110936
-0.00970242
-0.00845153
-0.00732921
-0.00632533
-0.00543077
-0.00463739
-0.00393665
-0.00332099
-0.00278264
-0.00231435
-0.00190834
-0.00155774
-0.00125496
-0.000994028
-0.000766742
-0.00056852
-0.000389669
-0.000229909
-6.76756e-05
-0.858156
-0.591403
-0.412947
-0.303385
-0.222162
-0.16323
-0.121908
-0.0928765
-0.0724311
-0.0579301
-0.0474825
-0.0397735
-0.0339147
-0.0293138
-0.0255815
-0.0224629
-0.019791
-0.0174577
-0.0153917
-0.0135467
-0.0118913
-0.0104036
-0.00906678
-0.00786757
-0.00679474
-0.00583829
-0.00498934
-0.00423891
-0.00357892
-0.0030012
-0.00249804
-0.00206131
-0.00168371
-0.0013573
-0.00107558
-0.00083008
-0.000615697
-0.000422207
-0.000249086
-7.37759e-05
-0.768682
-0.558046
-0.400622
-0.299825
-0.224179
-0.167678
-0.127079
-0.0979928
-0.0771058
-0.0620257
-0.0509964
-0.0427641
-0.0364596
-0.0314897
-0.0274545
-0.0240869
-0.0212084
-0.018701
-0.0164862
-0.014512
-0.0127429
-0.0111539
-0.00972633
-0.00844546
-0.00729904
-0.00627631
-0.00536771
-0.00456383
-0.00385612
-0.00323598
-0.00269525
-0.00222543
-0.00181875
-0.0014669
-0.00116283
-0.000897787
-0.00066607
-0.000456941
-0.000269519
-8.03131e-05
-0.687436
-0.521601
-0.385865
-0.29411
-0.224369
-0.170879
-0.131426
-0.102589
-0.0814834
-0.0659761
-0.0544638
-0.0457687
-0.0390531
-0.0337315
-0.0294006
-0.0257848
-0.0226971
-0.0200114
-0.0176427
-0.0155338
-0.0136455
-0.0119499
-0.0104266
-0.00905932
-0.0078349
-0.00674182
-0.00576987
-0.0049092
-0.00415074
-0.00348549
-0.0029048
-0.00239977
-0.00196216
-0.00158325
-0.00125544
-0.000969618
-0.000719482
-0.000493778
-0.000291149
-8.7262e-05
-0.613712
-0.483309
-0.3685
-0.286357
-0.222845
-0.172895
-0.135023
-0.106731
-0.0856148
-0.0698179
-0.0579086
-0.0488016
-0.0417024
-0.036042
-0.0314191
-0.027554
-0.0242531
-0.0213839
-0.0188558
-0.0166067
-0.0145938
-0.0127868
-0.0111629
-0.00970498
-0.00839863
-0.00723162
-0.00619308
-0.00527269
-0.00446087
-0.00374817
-0.00312543
-0.00258336
-0.00211319
-0.00170579
-0.00135299
-0.00104529
-0.000775743
-0.000532597
-0.000313908
-9.45977e-05
-0.546148
-0.443906
-0.348373
-0.276268
-0.219291
-0.173374
-0.137564
-0.11018
-0.0893199
-0.07342
-0.0612371
-0.0517965
-0.0443611
-0.0383888
-0.0334877
-0.0293789
-0.0258658
-0.0228113
-0.0201203
-0.0177269
-0.0155851
-0.0136622
-0.0119337
-0.0103811
-0.00898918
-0.00774484
-0.00663663
-0.00565373
-0.00478603
-0.00402363
-0.00335684
-0.00277594
-0.00227166
-0.00183438
-0.00145537
-0.00112471
-0.00083479
-0.000573353
-0.000337769
-0.000102315
-0.483495
-0.403991
-0.32576
-0.263803
-0.213584
-0.172099
-0.138816
-0.112727
-0.0924251
-0.076646
-0.0643464
-0.0546779
-0.0469749
-0.0407332
-0.0355792
-0.0312406
-0.0275218
-0.024284
-0.0214295
-0.0188896
-0.0166159
-0.0145736
-0.012737
-0.0110862
-0.00960532
-0.00828051
-0.00709972
-0.00605167
-0.00512569
-0.00431141
-0.00359865
-0.00297722
-0.00243729
-0.0019688
-0.00156242
-0.00120775
-0.000896523
-0.000615976
-0.00036269
-0.000110404
-0.424984
-0.364081
-0.301144
-0.249104
-0.20573
-0.168965
-0.138617
-0.114206
-0.0947785
-0.0793682
-0.067135
-0.0573675
-0.0494849
-0.0430319
-0.0376618
-0.0331158
-0.0292042
-0.0257897
-0.0227742
-0.0200878
-0.0176806
-0.0155167
-0.0135692
-0.0118174
-0.0102447
-0.00883663
-0.00758069
-0.00646508
-0.00547866
-0.00461054
-0.00385004
-0.00318649
-0.00260954
-0.00210861
-0.00167376
-0.00129413
-0.000960743
-0.000660324
-0.000388591
-0.000118837
-0.370308
-0.324685
-0.275115
-0.232461
-0.19585
-0.163964
-0.136872
-0.114488
-0.096248
-0.0814654
-0.0695
-0.0597823
-0.0518261
-0.0452351
-0.0396979
-0.0349763
-0.0308915
-0.027312
-0.0241417
-0.0213115
-0.0187715
-0.0164851
-0.0144251
-0.0125704
-0.0109036
-0.00941015
-0.00807696
-0.00689181
-0.0058431
-0.00491947
-0.00410973
-0.00340272
-0.00278755
-0.00225311
-0.00178886
-0.00138344
-0.00102713
-0.000706177
-0.000415345
-0.000127572
-0.319469
-0.286339
-0.248312
-0.214296
-0.184183
-0.157193
-0.133573
-0.113504
-0.0967369
-0.0828356
-0.0713466
-0.0618408
-0.0539314
-0.0472889
-0.0416452
-0.0367891
-0.0325583
-0.0288309
-0.0255163
-0.0225482
-0.0198782
-0.0174704
-0.0152978
-0.0133391
-0.0115771
-0.00999684
-0.00858492
-0.0073288
-0.00621643
-0.00523603
-0.00437589
-0.00362439
-0.00297007
-0.0024013
-0.00190693
-0.00147505
-0.00109524
-0.00075322
-0.000442771
-0.000136547
-0.272627
-0.249594
-0.221393
-0.195124
-0.171086
-0.148864
-0.128807
-0.111259
-0.0962023
-0.0834118
-0.0726008
-0.0634717
-0.0557374
-0.0491397
-0.0434593
-0.0385181
-0.0341754
-0.0303229
-0.0268788
-0.0237822
-0.0209878
-0.0184617
-0.0161779
-0.0141159
-0.0122586
-0.010591
-0.00909973
-0.00777191
-0.00659516
-0.00555726
-0.00464607
-0.00384946
-0.00315543
-0.00255182
-0.00202687
-0.00156813
-0.00116444
-0.00080102
-0.000470619
-0.000145678
-0.229987
-0.214988
-0.195008
-0.175521
-0.157007
-0.139294
-0.122766
-0.107844
-0.0946673
-0.0831749
-0.0732204
-0.0646237
-0.0571921
-0.0507389
-0.0450973
-0.0401264
-0.0357113
-0.0317614
-0.0282069
-0.0249946
-0.0220843
-0.0194453
-0.0170539
-0.0148907
-0.0129393
-0.0111852
-0.00961501
-0.00821571
-0.00697465
-0.00587927
-0.00491698
-0.0040752
-0.00334139
-0.00270286
-0.00214724
-0.00166155
-0.00123391
-0.000849001
-0.000498555
-0.000154851
-0.191739
-0.183019
-0.169782
-0.156091
-0.142466
-0.12889
-0.115737
-0.10344
-0.0922307
-0.0821646
-0.0732067
-0.0652753
-0.0582622
-0.0520489
-0.0465215
-0.0415784
-0.0371338
-0.0331179
-0.0294754
-0.0261633
-0.0231483
-0.0204045
-0.0179111
-0.0156507
-0.0136083
-0.01177
-0.0101226
-0.00865318
-0.00734893
-0.00619698
-0.00518439
-0.00429808
-0.00352504
-0.00285206
-0.00226616
-0.00175386
-0.00130255
-0.000896411
-0.000526143
-0.000163919
-0.158045
-0.154138
-0.146313
-0.137449
-0.128032
-0.118133
-0.108093
-0.0983153
-0.0890703
-0.0804875
-0.0726131
-0.0654434
-0.0589412
-0.0530494
-0.0477042
-0.0428437
-0.0384123
-0.0343629
-0.030657
-0.0272634
-0.0241575
-0.0213191
-0.0187317
-0.0163804
-0.0142519
-0.0123334
-0.0106121
-0.00907543
-0.00771041
-0.00650398
-0.00544287
-0.0045136
-0.00370266
-0.00299639
-0.00238124
-0.00184319
-0.00136899
-0.00094229
-0.000552823
-0.000172696
-0.129059
-0.128759
-0.125169
-0.120213
-0.114304
-0.107563
-0.100284
-0.0928208
-0.0854429
-0.0783196
-0.0715509
-0.0651899
-0.0592556
-0.0537427
-0.0486325
-0.0439001
-0.0395197
-0.0354676
-0.0317227
-0.0282672
-0.025086
-0.0221657
-0.0194944
-0.0170607
-0.0148533
-0.0128607
-0.0110708
-0.00947142
-0.00804963
-0.00679223
-0.00568565
-0.00471609
-0.0038696
-0.00313206
-0.00248943
-0.0019272
-0.00143147
-0.000985429
-0.00057789
-0.00018095
-0.104962
-0.107286
-0.106904
-0.105
-0.101905
-0.0977639
-0.0928237
-0.0873787
-0.0816782
-0.0759053
-0.0701903
-0.0646247
-0.0592686
-0.0541579
-0.049311
-0.0447361
-0.0404346
-0.0364047
-0.032643
-0.0291447
-0.0259047
-0.0229168
-0.0201742
-0.017669
-0.0153922
-0.0133339
-0.011483
-0.0098276
-0.00835495
-0.0070518
-0.00590438
-0.00489858
-0.00402009
-0.0032544
-0.00258701
-0.00200297
-0.00148783
-0.00102433
-0.000600472
-0.000188395
-0.0860072
-0.0901577
-0.0920887
-0.0924487
-0.0914877
-0.0893604
-0.0862752
-0.0824718
-0.0781696
-0.0735494
-0.0687561
-0.0639036
-0.05908
-0.0543506
-0.049763
-0.0453517
-0.0411414
-0.0371494
-0.0333875
-0.0298633
-0.0265808
-0.0235408
-0.0207414
-0.0181781
-0.0158444
-0.0137317
-0.0118299
-0.0101276
-0.00861227
-0.00727068
-0.0060889
-0.00505257
-0.00414711
-0.00335768
-0.0026694
-0.00206697
-0.00153542
-0.00105718
-0.000619504
-0.000194688
-0.0725979
-0.0779105
-0.0813645
-0.083247
-0.0837464
-0.0830208
-0.0812504
-0.078633
-0.0753606
-0.0716055
-0.0675164
-0.0632193
-0.0588183
-0.0543982
-0.0500264
-0.0457561
-0.041629
-0.0376769
-0.0339238
-0.0303868
-0.0270772
-0.0240015
-0.0211618
-0.0185565
-0.0161811
-0.0140283
-0.0120889
-0.0103517
-0.0088047
-0.00743445
-0.00622701
-0.00516788
-0.00424224
-0.00343505
-0.00273114
-0.00211493
-0.00157109
-0.00108178
-0.0006337
-0.000199409
-0.0653387
-0.0712461
-0.0754884
-0.078167
-0.0794372
-0.0794588
-0.0783974
-0.0764273
-0.0737238
-0.0704522
-0.0667615
-0.0627821
-0.0586261
-0.0543876
-0.0501443
-0.0459599
-0.0418851
-0.03796
-0.0342153
-0.0306737
-0.0273509
-0.0242565
-0.0213952
-0.0187671
-0.0163688
-0.0141939
-0.0122336
-0.0104771
-0.00891238
-0.00752613
-0.00630435
-0.00523246
-0.00429554
-0.00347841
-0.00276574
-0.00214181
-0.00159107
-0.00109558
-0.000641547
-0.000202048
-1.52014
-1.53128
-1.53795
-1.54018
-1.53805
-1.53167
-1.52117
-1.50665
-1.48825
-1.46614
-1.44044
-1.41121
-1.3786
-1.34271
-1.30361
-1.26136
-1.21609
-1.16759
-1.11488
-1.07627
-1.27644
-1.28753
-1.29504
-1.29902
-1.29957
-1.29679
-1.29081
-1.28173
-1.2697
-1.25485
-1.23735
-1.2173
-1.19481
-1.16999
-1.14288
-1.11352
-1.08186
-1.04709
-1.00792
-0.97968
-1.08353
-1.09374
-1.10118
-1.1059
-1.10796
-1.10744
-1.10443
-1.099
-1.09126
-1.0813
-1.06923
-1.05513
-1.03907
-1.02114
-1.0014
-0.979899
-0.956672
-0.931115
-0.902762
-0.883153
-0.921105
-0.930589
-0.937886
-0.943037
-0.946091
-0.947111
-0.946161
-0.943307
-0.938623
-0.932186
-0.924078
-0.91437
-0.903139
-0.89047
-0.876438
-0.861135
-0.844618
-0.826507
-0.807004
-0.794053
-0.78163
-0.790755
-0.798159
-0.803875
-0.807945
-0.810418
-0.811347
-0.810785
-0.808792
-0.805429
-0.800765
-0.79486
-0.787779
-0.779593
-0.770367
-0.760176
-0.749048
-0.736746
-0.7238
-0.715168
-0.660468
-0.669339
-0.676854
-0.683039
-0.687927
-0.691554
-0.693963
-0.695194
-0.695295
-0.694313
-0.6923
-0.689306
-0.685384
-0.680592
-0.674989
-0.668639
-0.661563
-0.653653
-0.645598
-0.640261
-0.554572
-0.56321
-0.570776
-0.577288
-0.582771
-0.587253
-0.590767
-0.593344
-0.595021
-0.595836
-0.59583
-0.595041
-0.59351
-0.591287
-0.588419
-0.584959
-0.580917
-0.576266
-0.571696
-0.568753
-0.461993
-0.470379
-0.47791
-0.484602
-0.490473
-0.495544
-0.499839
-0.503382
-0.506202
-0.508326
-0.509788
-0.510614
-0.510838
-0.510497
-0.509629
-0.508273
-0.506434
-0.504123
-0.50196
-0.500727
-0.381154
-0.389253
-0.396666
-0.403404
-0.409481
-0.414911
-0.419712
-0.423903
-0.427505
-0.430538
-0.433026
-0.434991
-0.436456
-0.437452
-0.438006
-0.438147
-0.437874
-0.437218
-0.436689
-0.436667
-0.310713
-0.318492
-0.325716
-0.332391
-0.338528
-0.344135
-0.349226
-0.353815
-0.357915
-0.361544
-0.364717
-0.367453
-0.369767
-0.371682
-0.37322
-0.374399
-0.375218
-0.37571
-0.376278
-0.377097
-0.2495
-0.256937
-0.263918
-0.270448
-0.276532
-0.282177
-0.287392
-0.292187
-0.296572
-0.300559
-0.30416
-0.307389
-0.310256
-0.312779
-0.314973
-0.316852
-0.318414
-0.319689
-0.320985
-0.322377
-0.196503
-0.203584
-0.210287
-0.216612
-0.222564
-0.228146
-0.233364
-0.238225
-0.242736
-0.246907
-0.250745
-0.254262
-0.257466
-0.260367
-0.262979
-0.26531
-0.267359
-0.269153
-0.270922
-0.272691
-0.15085
-0.157576
-0.16398
-0.170064
-0.17583
-0.181279
-0.186417
-0.191247
-0.195773
-0.200003
-0.203943
-0.2076
-0.210981
-0.214094
-0.216949
-0.219553
-0.221905
-0.224027
-0.226089
-0.228088
-0.11181
-0.118189
-0.124291
-0.130116
-0.135665
-0.14094
-0.145942
-0.150675
-0.155142
-0.159347
-0.163293
-0.166987
-0.170437
-0.173646
-0.176622
-0.179371
-0.181894
-0.184207
-0.186433
-0.188557
-0.0787839
-0.0848332
-0.0906408
-0.0962052
-0.101526
-0.106605
-0.111442
-0.116039
-0.120398
-0.124522
-0.128414
-0.132081
-0.135527
-0.138755
-0.141771
-0.144579
-0.147181
-0.149591
-0.151893
-0.15407
-0.0513307
-0.057077
-0.062608
-0.0679216
-0.0730173
-0.0778947
-0.0825543
-0.0869967
-0.0912234
-0.0952376
-0.0990415
-0.102642
-0.106042
-0.109241
-0.112244
-0.115056
-0.117679
-0.120123
-0.122444
-0.124628
-0.0291261
-0.0346046
-0.0398879
-0.0449738
-0.049861
-0.0545489
-0.0590377
-0.0633275
-0.0674197
-0.0713173
-0.075022
-0.0785393
-0.0818706
-0.0850154
-0.0879786
-0.0907636
-0.093373
-0.0958149
-0.0981244
-0.10029
-0.0120846
-0.0173352
-0.0224048
-0.0272918
-0.0319952
-0.0365142
-0.0408489
-0.0449997
-0.0489676
-0.0527545
-0.0563628
-0.059794
-0.0630492
-0.0661305
-0.0690423
-0.0717878
-0.0743694
-0.0767932
-0.0790791
-0.0812205
-0.000177637
-0.0052596
-0.010171
-0.0149102
-0.0194768
-0.0238704
-0.028091
-0.0321389
-0.0360143
-0.0397205
-0.0432534
-0.0466156
-0.0498096
-0.052839
-0.0557084
-0.0584202
-0.0609771
-0.0633837
-0.0656497
-0.0677735
0.00608699
0.001134
-0.00365389
-0.00827774
-0.0127381
-0.0170353
-0.0211697
-0.0251414
-0.0289502
-0.0325915
-0.0360733
-0.0393924
-0.0425525
-0.0455574
-0.0484109
-0.0511149
-0.0536717
-0.0560844
-0.0583574
-0.0604913
-0.353754
-0.4752
-0.561212
-0.643192
-0.725713
-0.805751
-0.882547
-0.956015
-1.02584
-1.0917
-1.15339
-1.21074
-1.26365
-1.31202
-1.35579
-1.3949
-1.42932
-1.45905
-1.48409
-1.50446
-0.292922
-0.389413
-0.456394
-0.523236
-0.593557
-0.662301
-0.727884
-0.790435
-0.849844
-0.905856
-0.958312
-1.00713
-1.05224
-1.0936
-1.13116
-1.16491
-1.19483
-1.22092
-1.24321
-1.26171
-0.253259
-0.344107
-0.404527
-0.461595
-0.521132
-0.578784
-0.632929
-0.684026
-0.732348
-0.777831
-0.820404
-0.860048
-0.89675
-0.930492
-0.96126
-0.989044
-1.01385
-1.03568
-1.05455
-1.07049
-0.225305
-0.305265
-0.35613
-0.402699
-0.451525
-0.499101
-0.54375
-0.585835
-0.625691
-0.663294
-0.698566
-0.731479
-0.762024
-0.790192
-0.815977
-0.839378
-0.860403
-0.879066
-0.895387
-0.909393
-0.196437
-0.263515
-0.30522
-0.343273
-0.38351
-0.423014
-0.46019
-0.495251
-0.528504
-0.559953
-0.58953
-0.617211
-0.642997
-0.666886
-0.688879
-0.708982
-0.727204
-0.74356
-0.758068
-0.770752
-0.164451
-0.219971
-0.254283
-0.285816
-0.319294
-0.352282
-0.383407
-0.412808
-0.440747
-0.467248
-0.492263
-0.515774
-0.537782
-0.558291
-0.577303
-0.594824
-0.610862
-0.625429
-0.638541
-0.650215
-0.13105
-0.17681
-0.205155
-0.231458
-0.259427
-0.287051
-0.313209
-0.337999
-0.361636
-0.384146
-0.405495
-0.425664
-0.444654
-0.462467
-0.479103
-0.494566
-0.508861
-0.521998
-0.533986
-0.54484
-0.0977128
-0.135286
-0.158806
-0.180879
-0.204358
-0.227603
-0.249719
-0.270774
-0.290935
-0.310224
-0.328611
-0.346081
-0.362629
-0.378256
-0.39296
-0.406742
-0.419605
-0.431553
-0.442595
-0.452739
-0.065204
-0.0959973
-0.115681
-0.134381
-0.15424
-0.173948
-0.192799
-0.21084
-0.228195
-0.244879
-0.260868
-0.276144
-0.290702
-0.304539
-0.317653
-0.330041
-0.341703
-0.35264
-0.362858
-0.372361
-0.0341255
-0.059419
-0.0761036
-0.0921408
-0.109106
-0.125972
-0.142197
-0.157809
-0.172897
-0.187471
-0.201507
-0.214992
-0.227916
-0.240275
-0.252063
-0.263278
-0.273916
-0.283977
-0.293462
-0.302373
-0.00501027
-0.0259139
-0.0402711
-0.054209
-0.068866
-0.0834558
-0.0975691
-0.111221
-0.124474
-0.137331
-0.149773
-0.161785
-0.173357
-0.184484
-0.195158
-0.205375
-0.21513
-0.224421
-0.233246
-0.241606
0.0217398
0.00430541
-0.00824717
-0.0205269
-0.0333442
-0.046112
-0.0585273
-0.070596
-0.0823588
-0.0938147
-0.104947
-0.115741
-0.126189
-0.136281
-0.14601
-0.155371
-0.164358
-0.172967
-0.181195
-0.189041
0.0458578
0.0311477
0.0199983
0.00903194
-0.00231889
-0.0136283
-0.0246766
-0.0354629
-0.0460121
-0.0563204
-0.066373
-0.0761569
-0.0856626
-0.0948816
-0.103806
-0.112429
-0.120745
-0.128748
-0.136436
-0.143804
0.0671841
0.0546027
0.04455
0.0346277
0.0244459
0.0143037
0.00435695
-0.00538927
-0.0149483
-0.0243146
-0.0334751
-0.0424179
-0.0511336
-0.0596136
-0.06785
-0.0758357
-0.0835642
-0.0910302
-0.0982289
-0.105157
0.085645
0.074718
0.0655268
0.0564357
0.0471844
0.0379747
0.0289143
0.0200107
0.0112587
0.00266493
-0.00575901
-0.0140024
-0.0220561
-0.0299116
-0.0375613
-0.0449978
-0.0522148
-0.0592064
-0.0659679
-0.072495
0.101214
0.0915578
0.0830414
0.074608
0.0660908
0.0576197
0.0492665
0.0410401
0.0329406
0.0249754
0.0171546
0.00948816
0.00198462
-0.00534795
-0.012502
-0.0194705
-0.0262471
-0.0328261
-0.0392024
-0.0453719
0.113904
0.105205
0.0972092
0.0892867
0.081338
0.0734412
0.0656423
0.0579505
0.0503695
0.0429066
0.0355711
0.0283718
0.0213167
0.0144135
0.00766925
0.00109057
-0.00531641
-0.0115462
-0.0175938
-0.023455
0.123667
0.115645
0.108026
0.100477
0.0929443
0.0854707
0.0780843
0.0707942
0.063606
0.0565269
0.0495654
0.0427291
0.0360255
0.0294616
0.0230439
0.0167785
0.010671
0.00472646
-0.00105035
-0.00665532
0.130498
0.122912
0.115537
0.108234
0.100978
0.0937908
0.0866871
0.0796755
0.0727622
0.0659541
0.0592583
0.0526819
0.0462312
0.0399125
0.0337317
0.0276942
0.0218051
0.016069
0.0104904
0.00507329
0.13403
0.126595
0.119289
0.112065
0.104914
0.0978436
0.0908648
0.0839851
0.0772108
0.0705479
0.0640025
0.0575803
0.0512865
0.0451264
0.0391043
0.0332247
0.0274913
0.0219076
0.016477
0.0112027
0.877653
0.878119
0.878953
0.880345
0.882126
0.884168
0.88627
0.888148
0.889395
0.889438
0.887418
0.882063
0.871363
0.85241
0.820377
0.768687
0.685256
0.554919
0.343244
-0.0144009
0.863296
0.863563
0.864069
0.864888
0.865864
0.866833
0.867556
0.867697
0.866796
0.864209
0.858992
0.849773
0.834452
0.810011
0.771694
0.712939
0.622651
0.486296
0.277237
-0.039695
0.847784
0.847912
0.848117
0.848385
0.848559
0.848438
0.847746
0.846123
0.843081
0.837945
0.829737
0.817052
0.797809
0.769067
0.726392
0.663772
0.57174
0.438686
0.246762
-0.0169241
0.83103
0.83099
0.830839
0.830499
0.829804
0.828531
0.826378
0.822955
0.817745
0.810042
0.798847
0.782748
0.759723
0.726978
0.680481
0.614949
0.522577
0.394889
0.217972
-0.0100287
0.813019
0.812798
0.812268
0.811294
0.809704
0.807259
0.803635
0.798418
0.791069
0.780862
0.766794
0.747481
0.720996
0.684751
0.635163
0.567741
0.476121
0.354444
0.190525
-0.010092
0.793757
0.793357
0.792442
0.790833
0.788349
0.784741
0.77967
0.772708
0.763304
0.750735
0.73402
0.711838
0.682404
0.643394
0.591712
0.523684
0.434197
0.31958
0.169435
-0.00613675
0.773276
0.772699
0.771404
0.769169
0.765808
0.761067
0.754603
0.745983
0.73466
0.719931
0.700864
0.676236
0.644445
0.603472
0.55073
0.483342
0.397331
0.29078
0.155311
0.00260831
0.751645
0.750898
0.749232
0.746393
0.74219
0.736373
0.728602
0.71845
0.70539
0.688756
0.667689
0.641093
0.607574
0.565443
0.512617
0.446951
0.365493
0.267577
0.146808
0.014402
0.728981
0.728072
0.726054
0.722647
0.717659
0.710849
0.70189
0.690372
0.675801
0.657565
0.634897
0.606847
0.572246
0.529735
0.477709
0.414657
0.338516
0.249399
0.142734
0.0282373
0.705453
0.704394
0.702053
0.69813
0.692434
0.684741
0.674743
0.662061
0.646242
0.626743
0.602902
0.573926
0.538875
0.496703
0.446238
0.386485
0.316124
0.235691
0.142175
0.0434545
0.681292
0.680101
0.677475
0.6731
0.666791
0.658347
0.647487
0.633867
0.617089
0.596685
0.572108
0.542721
0.507804
0.466596
0.418298
0.362322
0.297925
0.225838
0.144279
0.0593439
0.656798
0.655494
0.652628
0.647878
0.641068
0.632021
0.620491
0.606177
0.588737
0.567788
0.542893
0.51357
0.479298
0.43956
0.393865
0.341929
0.283437
0.219175
0.14824
0.0752061
0.632343
0.630951
0.627895
0.622853
0.61566
0.606168
0.594167
0.579403
0.561594
0.540438
0.515606
0.486755
0.453537
0.41564
0.37281
0.324983
0.272135
0.215031
0.153348
0.0904494
0.60838
0.606922
0.603729
0.598481
0.591026
0.581246
0.568968
0.553984
0.536073
0.515007
0.490557
0.4625
0.430633
0.394803
0.354933
0.311108
0.263488
0.212776
0.159003
0.104612
0.58544
0.58394
0.580661
0.575288
0.567686
0.557761
0.54538
0.530378
0.512589
0.491853
0.468026
0.440986
0.410642
0.376964
0.339996
0.299919
0.256994
0.211851
0.164718
0.117353
0.56414
0.562619
0.559299
0.553874
0.546223
0.536277
0.523934
0.509072
0.491571
0.471332
0.448278
0.422367
0.393594
0.362015
0.327755
0.291049
0.252208
0.211783
0.170103
0.128428
0.545189
0.543665
0.540339
0.534919
0.527293
0.517414
0.50521
0.490591
0.473477
0.453816
0.431586
0.406804
0.379527
0.349867
0.318001
0.284189
0.248757
0.212189
0.174854
0.137662
0.529399
0.527883
0.524575
0.519194
0.511638
0.501876
0.489858
0.475521
0.458816
0.439726
0.418269
0.394502
0.368525
0.340487
0.31059
0.279106
0.246359
0.212776
0.178735
0.144908
0.517708
0.516202
0.512921
0.507589
0.500114
0.490472
0.478632
0.464549
0.448195
0.429576
0.408736
0.38576
0.360771
0.333939
0.305482
0.27567
0.244821
0.21332
0.181547
0.150031
0.511211
0.509712
0.506449
0.501154
0.493734
0.484172
0.472445
0.458519
0.442377
0.424037
0.403557
0.381033
0.356602
0.330444
0.302779
0.273877
0.244051
0.213661
0.183079
0.152754
1.01424
1.01569
1.01903
1.02468
1.03255
1.04278
1.05552
1.07095
1.08935
1.11105
1.13649
1.16618
1.20071
1.2408
1.28704
1.34021
1.39981
1.46615
1.53082
1.59008
1.00882
1.01022
1.01344
1.01892
1.02655
1.03647
1.04881
1.06374
1.08152
1.10247
1.12696
1.15549
1.18855
1.22683
1.27063
1.3209
1.376
1.43764
1.49255
1.54551
1.00323
1.00459
1.00769
1.01299
1.02037
1.02997
1.04189
1.05631
1.07344
1.09359
1.11709
1.1444
1.17591
1.21227
1.25346
1.30058
1.35081
1.40725
1.45151
1.49717
0.997483
0.998796
1.00177
1.00689
1.01402
1.02328
1.03478
1.04866
1.06512
1.08444
1.10691
1.13293
1.16281
1.19713
1.23556
1.27928
1.3243
1.37506
1.40781
1.44524
0.991576
0.992845
0.995695
1.00063
1.00749
1.01641
1.02747
1.0408
1.05657
1.07502
1.09641
1.1211
1.14926
1.18143
1.21694
1.25704
1.29651
1.34113
1.36155
1.38991
0.985517
0.986743
0.989467
0.994209
1.00081
1.00938
1.01998
1.03274
1.04779
1.06535
1.08563
1.10892
1.13529
1.16519
1.19763
1.23389
1.26749
1.30551
1.31284
1.33135
0.979314
0.980497
0.983095
0.987645
0.993975
1.00218
1.01232
1.02449
1.0388
1.05544
1.07456
1.09641
1.12092
1.14845
1.17767
1.20985
1.23731
1.26827
1.26181
1.26971
0.972971
0.974114
0.976587
0.980944
0.986999
0.994841
1.00451
1.01607
1.02962
1.04531
1.06323
1.08358
1.10615
1.1312
1.15708
1.18497
1.20601
1.22944
1.2086
1.20515
0.966497
0.9676
0.96995
0.974113
0.97989
0.987358
0.996536
1.00748
1.02025
1.03496
1.05166
1.07045
1.09102
1.11349
1.13589
1.15926
1.17365
1.18908
1.15335
1.13776
0.959897
0.960962
0.963192
0.967161
0.972656
0.979745
0.988426
0.998733
1.0107
1.02441
1.03984
1.05703
1.07555
1.09534
1.11414
1.13277
1.1403
1.1472
1.09623
1.06762
0.953177
0.954208
0.956322
0.960097
0.965309
0.972012
0.980187
0.989846
1.001
1.01368
1.02781
1.04336
1.05974
1.07676
1.09186
1.10551
1.10601
1.10383
1.03743
0.99475
0.946346
0.947345
0.949347
0.952929
0.957857
0.96417
0.971831
0.980829
0.991146
1.00277
1.01558
1.02943
1.04364
1.05778
1.06906
1.07753
1.07085
1.05899
0.97715
0.919099
0.939409
0.94038
0.942277
0.945668
0.950311
0.956229
0.963368
0.971692
0.981157
0.99171
1.00316
1.01528
1.02725
1.03843
1.04579
1.04885
1.03487
1.01268
0.915616
0.840537
0.932373
0.933322
0.935119
0.938322
0.942681
0.948201
0.954809
0.962449
0.971046
0.980506
0.990577
1.00092
1.0106
1.01873
1.02208
1.01952
0.998116
0.964919
0.853071
0.758841
0.925245
0.926176
0.927882
0.9309
0.934975
0.940094
0.946165
0.953109
0.960824
0.96917
0.977833
0.986364
0.993698
0.998702
0.997927
0.989546
0.960613
0.915713
0.789741
0.673679
0.918033
0.918951
0.920573
0.923409
0.927201
0.931915
0.937441
0.943679
0.950498
0.957713
0.964942
0.971624
0.976562
0.978357
0.973357
0.958966
0.922375
0.8651
0.725821
0.584595
0.910742
0.911656
0.913206
0.915866
0.919378
0.923686
0.928661
0.934184
0.940096
0.946165
0.951941
0.956746
0.959246
0.957763
0.948444
0.927883
0.883499
0.813285
0.661644
0.49125
0.903385
0.904312
0.905811
0.908312
0.911557
0.915466
0.919891
0.924696
0.9297
0.934626
0.938953
0.941881
0.94193
0.937138
0.923431
0.896572
0.844222
0.760653
0.597795
0.393955
0.895964
0.896919
0.898386
0.900744
0.903735
0.907248
0.91112
0.9152
0.919285
0.923055
0.925915
0.926938
0.924487
0.916297
0.898045
0.86463
0.803872
0.706332
0.532965
0.290938
0.888444
0.889342
0.890699
0.892818
0.895465
0.898504
0.901753
0.905029
0.908084
0.910528
0.91168
0.910474
0.905115
0.893036
0.869667
0.829097
0.759167
0.647049
0.460707
0.17132
1.08298
1.08497
1.08957
1.09723
1.10792
1.1218
1.13908
1.16001
1.18494
1.21426
1.24842
1.28779
1.33271
1.38289
1.43793
1.49383
1.54825
1.5747
1.59018
1.41623
1.08139
1.08336
1.08796
1.09561
1.10629
1.12016
1.13743
1.15836
1.18333
1.21273
1.24705
1.28673
1.33223
1.38335
1.44011
1.49852
1.55792
1.58949
1.61539
1.45527
1.07961
1.08156
1.08614
1.09374
1.10433
1.11809
1.13522
1.156
1.18079
1.21
1.24415
1.2837
1.32921
1.38057
1.43822
1.49835
1.56259
1.60292
1.65083
1.52978
1.07764
1.07958
1.08413
1.09168
1.10219
1.11586
1.13287
1.15351
1.17815
1.20722
1.24125
1.28073
1.32632
1.37799
1.43659
1.49846
1.56707
1.61515
1.67972
1.58928
1.07548
1.0774
1.08192
1.08942
1.09986
1.11343
1.13033
1.15084
1.17534
1.20426
1.23817
1.27759
1.32326
1.37524
1.4347
1.49815
1.57042
1.62497
1.70146
1.63718
1.07312
1.07502
1.07952
1.08696
1.09731
1.11077
1.12754
1.14789
1.17222
1.20097
1.23472
1.27401
1.31968
1.37184
1.43197
1.49674
1.57204
1.63239
1.71847
1.67871
1.07057
1.07245
1.07691
1.08429
1.09454
1.10788
1.12449
1.14468
1.16881
1.19734
1.23087
1.26997
1.31554
1.36776
1.42835
1.49421
1.57196
1.63757
1.73134
1.71377
1.06782
1.06968
1.0741
1.0814
1.09155
1.10475
1.1212
1.14118
1.16509
1.19337
1.22665
1.26549
1.31087
1.36303
1.4239
1.49059
1.57022
1.64046
1.74011
1.74199
1.06487
1.06671
1.07108
1.0783
1.08834
1.10138
1.11765
1.13741
1.16107
1.18907
1.22203
1.26057
1.30567
1.35765
1.41859
1.48587
1.56683
1.641
1.7449
1.76357
1.06172
1.06354
1.06786
1.07498
1.0849
1.09778
1.11384
1.13337
1.15674
1.18442
1.21704
1.25519
1.29993
1.35162
1.41242
1.48004
1.56178
1.63916
1.74589
1.77881
1.05838
1.06017
1.06443
1.07146
1.08123
1.09394
1.10979
1.12905
1.15211
1.17944
1.21165
1.24936
1.29364
1.34491
1.40538
1.47305
1.55507
1.63494
1.74321
1.78795
1.05483
1.0566
1.06079
1.06771
1.07734
1.08986
1.10547
1.12445
1.14718
1.17411
1.20586
1.24307
1.2868
1.33752
1.39745
1.46492
1.5467
1.62833
1.73696
1.79124
1.05109
1.05282
1.05694
1.06375
1.07323
1.08555
1.1009
1.11958
1.14194
1.16844
1.19969
1.23633
1.2794
1.32946
1.38865
1.45563
1.5367
1.61934
1.7272
1.78888
1.04715
1.04885
1.05289
1.05959
1.06889
1.08099
1.09608
1.11443
1.13639
1.16242
1.19312
1.22912
1.27146
1.32071
1.37896
1.44517
1.52507
1.608
1.71401
1.78108
1.04301
1.04468
1.04864
1.0552
1.06433
1.07621
1.09101
1.109
1.13054
1.15607
1.18616
1.22146
1.26296
1.31129
1.36839
1.43356
1.51183
1.59434
1.69744
1.76804
1.03868
1.04032
1.04419
1.05062
1.05956
1.07119
1.08569
1.10331
1.1244
1.14938
1.17882
1.21335
1.25391
1.30118
1.35695
1.42079
1.49699
1.57838
1.67756
1.74994
1.03416
1.03577
1.03954
1.04582
1.05457
1.06594
1.08012
1.09735
1.11796
1.14235
1.17109
1.20478
1.24432
1.29041
1.34464
1.40689
1.48059
1.56019
1.65443
1.72697
1.02946
1.03102
1.03469
1.04083
1.04937
1.06048
1.07432
1.09113
1.11122
1.135
1.16299
1.19578
1.2342
1.27898
1.33148
1.39186
1.46263
1.53981
1.62811
1.69932
1.02456
1.02609
1.02966
1.03564
1.04396
1.05479
1.06828
1.08465
1.10421
1.12733
1.15452
1.18634
1.22355
1.26689
1.31749
1.37572
1.44317
1.5173
1.59868
1.66715
1.01949
1.02098
1.02443
1.03025
1.03835
1.04889
1.06201
1.07792
1.09691
1.11935
1.14568
1.17647
1.21239
1.25416
1.30267
1.35849
1.42221
1.49273
1.56622
1.63066
0.99355
0.992647
0.990721
0.987601
0.98319
0.977417
0.970185
0.961371
0.950837
0.938438
0.924028
0.907463
0.888608
0.867342
0.843572
0.817241
0.788337
0.756921
0.723092
0.687096
0.997314
0.996459
0.994631
0.991662
0.987456
0.981935
0.974997
0.966509
0.95632
0.944273
0.930204
0.913946
0.89534
0.874235
0.850508
0.824071
0.794882
0.76298
0.728437
0.691534
1.0039
1.00313
1.00148
0.998798
0.994974
0.989928
0.983543
0.975672
0.966146
0.95478
0.94138
0.925739
0.907649
0.886908
0.86333
0.836767
0.807114
0.774364
0.738515
0.699885
1.01243
1.01178
1.01038
1.0081
1.00482
1.00045
0.994865
0.987892
0.979339
0.968989
0.956604
0.941923
0.924672
0.904571
0.881344
0.85475
0.824582
0.790753
0.753145
0.712128
1.0221
1.0216
1.02053
1.01875
1.01617
1.01267
1.00811
1.00231
0.995041
0.986052
0.975054
0.961722
0.9457
0.926606
0.904047
0.87765
0.847062
0.812067
0.77237
0.728373
1.03225
1.03193
1.03123
1.03005
1.0283
1.02585
1.02254
1.01817
1.01248
1.0052
0.995985
0.984431
0.970092
0.952465
0.931013
0.905188
0.874439
0.83836
0.796397
0.748931
1.04232
1.0422
1.04192
1.04143
1.04062
1.03936
1.03749
1.03478
1.03097
1.02574
1.0187
1.00937
0.997221
0.981605
0.961813
0.937087
0.906618
0.869725
0.825513
0.774205
1.05188
1.05197
1.05216
1.0524
1.05262
1.05268
1.0524
1.05155
1.04987
1.047
1.04251
1.03588
1.02645
1.01344
0.995965
0.973007
0.94345
0.906224
0.860026
0.80464
1.06061
1.06092
1.06159
1.06261
1.06392
1.06538
1.0668
1.06797
1.06862
1.06838
1.0668
1.06328
1.05709
1.04733
1.0329
1.0125
0.984668
0.947808
0.900195
0.84065
1.06828
1.06882
1.06997
1.0718
1.07423
1.07712
1.08032
1.08362
1.08674
1.08934
1.09094
1.09092
1.08848
1.08258
1.07194
1.05497
1.02985
0.994262
0.946175
0.882522
1.07478
1.07554
1.07718
1.07979
1.08333
1.08767
1.09267
1.09814
1.10383
1.10941
1.11441
1.11819
1.11991
1.11845
1.11234
1.09971
1.07838
1.04515
0.997938
0.930318
1.08004
1.08101
1.08312
1.0865
1.09113
1.09689
1.10366
1.11129
1.11957
1.12819
1.13671
1.14451
1.15074
1.15419
1.15329
1.14587
1.12947
1.09977
1.05521
0.983777
1.08408
1.08525
1.08779
1.09191
1.09757
1.10468
1.11316
1.1229
1.13372
1.14537
1.15746
1.1694
1.18035
1.1891
1.19397
1.19253
1.18216
1.15721
1.11743
1.04226
1.08694
1.08829
1.09124
1.09603
1.10265
1.11104
1.12113
1.13288
1.14614
1.16074
1.17635
1.19245
1.20825
1.22252
1.23357
1.23876
1.23538
1.21632
1.18366
1.10478
1.0887
1.09022
1.09353
1.09895
1.10645
1.11599
1.12758
1.14119
1.15676
1.17418
1.19319
1.21337
1.23401
1.25391
1.27142
1.28367
1.28802
1.27582
1.25259
1.16987
1.08947
1.09113
1.09478
1.10074
1.10903
1.11962
1.13256
1.14788
1.16558
1.18562
1.20786
1.23198
1.25735
1.28287
1.30694
1.32656
1.33914
1.3345
1.32227
1.23479
1.08937
1.09115
1.09508
1.10154
1.11051
1.12203
1.13618
1.15302
1.17265
1.19511
1.22036
1.24818
1.27811
1.30915
1.33976
1.36687
1.38799
1.3915
1.39053
1.29553
1.08851
1.0904
1.09457
1.10145
1.11102
1.12335
1.13854
1.15674
1.17809
1.20272
1.23072
1.26199
1.29621
1.33249
1.36945
1.40384
1.43337
1.44577
1.45698
1.35392
1.08701
1.08899
1.09338
1.10061
1.11068
1.12369
1.13978
1.15912
1.18195
1.20847
1.23888
1.27321
1.31131
1.35238
1.39517
1.43621
1.47339
1.49525
1.52335
1.42759
1.08498
1.087
1.09155
1.09906
1.10951
1.12305
1.13983
1.16009
1.18412
1.2122
1.24466
1.28168
1.3233
1.3689
1.41749
1.46531
1.51038
1.53918
1.58177
1.50249
0.663191
0.653459
0.643663
0.633792
0.623835
0.613796
0.603685
0.593513
0.58329
0.573024
0.562726
0.552404
0.54207
0.531733
0.521403
0.51109
0.500804
0.490555
0.480352
0.470204
0.666938
0.656987
0.646962
0.636867
0.62667
0.616369
0.605976
0.595503
0.58496
0.574358
0.563707
0.553019
0.542304
0.531575
0.520844
0.510121
0.49942
0.488752
0.478129
0.467561
0.673816
0.663242
0.652597
0.641916
0.63113
0.620221
0.609204
0.598097
0.58691
0.575656
0.564347
0.552995
0.541614
0.530216
0.518814
0.507423
0.496055
0.484723
0.473442
0.462223
0.683991
0.672453
0.660846
0.649268
0.63759
0.62577
0.613827
0.601782
0.58965
0.577443
0.565175
0.55286
0.540512
0.528146
0.515778
0.503421
0.491092
0.478804
0.466574
0.454415
0.697542
0.684662
0.671712
0.658896
0.645998
0.632937
0.619734
0.606421
0.593016
0.579531
0.565982
0.552383
0.538752
0.525105
0.511459
0.497831
0.484237
0.470695
0.457221
0.443832
0.714865
0.700246
0.685536
0.671112
0.65664
0.641979
0.627156
0.612214
0.597176
0.582054
0.566865
0.551627
0.536358
0.521077
0.505804
0.490556
0.475353
0.460215
0.44516
0.430206
0.73643
0.71964
0.702688
0.686239
0.669795
0.653129
0.636276
0.619294
0.602212
0.585043
0.567806
0.550519
0.533205
0.515885
0.49858
0.481312
0.464103
0.446975
0.429949
0.413046
0.762846
0.743424
0.723682
0.704732
0.685869
0.666742
0.64739
0.627898
0.608301
0.588613
0.568852
0.549043
0.529209
0.509375
0.489566
0.469806
0.450122
0.430539
0.41108
0.391772
0.794792
0.772272
0.749121
0.727131
0.705343
0.683236
0.660852
0.638308
0.615649
0.592891
0.570054
0.547165
0.524252
0.501345
0.478472
0.455663
0.432946
0.410352
0.387909
0.365646
0.833023
0.806973
0.779721
0.754081
0.728803
0.703129
0.677101
0.65088
0.624526
0.598056
0.571493
0.544869
0.518218
0.491575
0.464973
0.438447
0.412032
0.385762
0.359672
0.333795
0.878356
0.848444
0.816322
0.786342
0.756938
0.727035
0.696664
0.666044
0.635259
0.604327
0.573275
0.542143
0.510974
0.479807
0.448686
0.41765
0.386741
0.356
0.325467
0.295182
0.9317
0.897768
0.859921
0.824807
0.790569
0.75569
0.720174
0.684318
0.64824
0.611967
0.57553
0.53898
0.502371
0.465754
0.429178
0.392695
0.356353
0.3202
0.284286
0.248656
0.994091
0.956229
0.911686
0.870532
0.830667
0.789969
0.748383
0.706319
0.663948
0.621307
0.578438
0.535409
0.492289
0.449144
0.406038
0.363029
0.32018
0.277547
0.235186
0.193154
1.06674
1.02532
0.972967
0.924762
0.878413
0.830955
0.782252
0.732879
0.683079
0.632905
0.582421
0.531721
0.480901
0.430047
0.379239
0.328557
0.278072
0.227854
0.177971
0.128484
1.15098
1.10668
1.0453
0.989018
0.935329
0.880126
0.823207
0.765376
0.706971
0.648067
0.588767
0.52921
0.469529
0.409845
0.350267
0.290896
0.231825
0.17314
0.114921
0.0572375
1.24771
1.20186
1.13059
1.0656
1.00399
0.940237
0.874189
0.806961
0.738985
0.670381
0.601318
0.532007
0.462642
0.393391
0.324406
0.255823
0.187763
0.120332
0.0536225
-0.0122892
1.35569
1.31071
1.23033
1.15765
1.08865
1.01637
0.941042
0.86415
0.786233
0.707524
0.628328
0.548968
0.469727
0.390845
0.312532
0.234971
0.158311
0.0826779
0.00816927
-0.0651467
1.47195
1.42901
1.34227
1.2655
1.19152
1.11248
1.02941
0.944083
0.857158
0.769107
0.680461
0.591707
0.503254
0.415445
0.328569
0.242858
0.158496
0.0756194
-0.00567436
-0.0853417
1.61281
1.56926
1.47992
1.40259
1.32531
1.24115
1.15193
1.05934
0.964259
0.867483
0.769813
0.671938
0.574427
0.477749
0.382276
0.2883
0.19603
0.105612
0.0171274
-0.0694204
1.76107
1.72462
1.6462
1.57099
1.48913
1.39844
1.30139
1.1997
1.09472
0.987654
0.879551
0.771259
0.663462
0.556701
0.451387
0.34782
0.246202
0.146649
0.049201
-0.0462084
0.460122
0.450114
0.440188
0.430353
0.420617
0.410988
0.401472
0.392077
0.382808
0.373677
0.364678
0.355824
0.347121
0.338572
0.330179
0.321947
0.313879
0.305977
0.298243
0.290676
0.457062
0.446641
0.43631
0.42608
0.415959
0.405957
0.396085
0.386348
0.376756
0.36731
0.358022
0.3489
0.33995
0.331178
0.322583
0.31417
0.305944
0.297905
0.290051
0.282373
0.45108
0.440025
0.429069
0.418225
0.407504
0.396915
0.38647
0.376177
0.366044
0.356079
0.346289
0.33668
0.327259
0.318033
0.309006
0.300181
0.291563
0.283154
0.274943
0.266904
0.442342
0.430369
0.418509
0.406776
0.395182
0.383738
0.372456
0.361348
0.350422
0.339688
0.329156
0.318827
0.308709
0.298812
0.289139
0.279695
0.270484
0.261511
0.252751
0.244153
0.430543
0.417371
0.40433
0.391436
0.378701
0.36614
0.353764
0.341586
0.329618
0.317872
0.306356
0.295074
0.284032
0.273241
0.262704
0.252427
0.242416
0.232676
0.223164
0.213798
0.415373
0.400678
0.386137
0.371766
0.357583
0.343602
0.329836
0.3163
0.303007
0.289967
0.277197
0.264699
0.252479
0.240549
0.228911
0.217572
0.206541
0.195824
0.185354
0.17501
0.396289
0.379695
0.363285
0.347078
0.331092
0.315343
0.299848
0.284623
0.269682
0.255039
0.240707
0.226695
0.21301
0.199665
0.186662
0.17401
0.161721
0.149801
0.138155
0.126618
0.372638
0.3537
0.334982
0.316505
0.298292
0.280361
0.262731
0.245422
0.228449
0.211827
0.195571
0.179694
0.164211
0.14913
0.134459
0.120208
0.106393
0.0930252
0.079968
0.0670177
0.343593
0.321774
0.300217
0.278948
0.257992
0.237374
0.217115
0.197237
0.177761
0.158706
0.140087
0.121926
0.104239
0.0870378
0.0703366
0.0541493
0.0384993
0.0233984
0.00865207
-0.00593598
0.308166
0.282815
0.257773
0.233073
0.208745
0.184817
0.161317
0.138274
0.115711
0.0936546
0.0721264
0.0511514
0.0307538
0.0109509
-0.00823694
-0.0267874
-0.0446649
-0.0618619
-0.0786779
-0.0951509
0.265188
0.235517
0.206208
0.1773
0.148829
0.120829
0.0933367
0.066385
0.0400068
0.0142358
-0.0108987
-0.0353638
-0.0591258
-0.0821588
-0.104432
-0.125911
-0.146539
-0.16633
-0.18579
-0.204413
0.213359
0.178435
0.143929
0.109887
0.0763521
0.0433665
0.0109725
-0.0207873
-0.051872
-0.0822375
-0.111844
-0.140646
-0.168597
-0.195656
-0.221777
-0.246904
-0.270943
-0.293961
-0.316854
-0.337732
0.151503
0.110282
0.0695427
0.0293365
-0.010286
-0.0492753
-0.0875816
-0.125154
-0.16194
-0.197885
-0.232934
-0.267026
-0.300091
-0.332067
-0.362876
-0.392418
-0.420524
-0.44737
-0.474505
-0.496983
0.0794537
0.0309367
-0.017011
-0.0643332
-0.110976
-0.156884
-0.202003
-0.246277
-0.289643
-0.332035
-0.373382
-0.413601
-0.452596
-0.490259
-0.52646
-0.560999
-0.593556
-0.624523
-0.656366
-0.677959
0.000149481
-0.0562714
-0.111972
-0.1669
-0.221006
-0.27424
-0.326554
-0.377897
-0.428209
-0.477428
-0.525475
-0.572257
-0.617648
-0.661481
-0.703527
-0.743382
-0.780428
-0.815493
-0.851941
-0.867297
-0.0773563
-0.14149
-0.204657
-0.266829
-0.327981
-0.388095
-0.447156
-0.505152
-0.562063
-0.617866
-0.672517
-0.725944
-0.778007
-0.828469
-0.876931
-0.922556
-0.964184
-1.00337
-1.04346
-1.04382
-0.137257
-0.208062
-0.277582
-0.345848
-0.412896
-0.47878
-0.54357
-0.607347
-0.670195
-0.732202
-0.793421
-0.853842
-0.913327
-0.971527
-1.02767
-1.08
-1.12642
-1.16942
-1.20998
-1.18342
-0.163422
-0.239813
-0.314621
-0.38796
-0.459958
-0.530775
-0.600602
-0.669661
-0.738194
-0.806443
-0.874584
-0.942647
-1.01042
-1.07726
-1.14165
-1.20025
-1.24969
-1.2941
-1.33062
-1.26897
-0.154135
-0.236917
-0.317981
-0.397525
-0.475766
-0.552964
-0.629406
-0.705408
-0.781308
-0.857392
-0.933755
-1.01022
-1.08619
-1.16046
-1.23065
-1.292
-1.34019
-1.38326
-1.42037
-1.33739
-0.139778
-0.231408
-0.321452
-0.410181
-0.497893
-0.584912
-0.671546
-0.758054
-0.844697
-0.931636
-1.01857
-1.10474
-1.18893
-1.26925
-1.34303
-1.40564
-1.45211
-1.49031
-1.52818
-1.44545
0.272671
0.246098
0.221335
0.19854
0.177767
0.159001
0.142174
0.127163
0.113809
0.101934
0.0913598
0.0819153
0.0734476
0.0658236
0.058932
0.0526817
0.0469991
0.0418255
0.0371137
0.0328252
0.0289278
0.0253937
0.0221983
0.0193187
0.0167333
0.0144213
0.0123627
0.0105377
0.00892688
0.00751134
0.00627255
0.00519244
0.00425333
0.00343796
0.00272952
0.00211118
0.00156676
0.00107767
0.000630355
0.000196975
0.263849
0.237214
0.212758
0.190416
0.170206
0.152109
0.136025
0.121782
0.109177
0.098004
0.0880643
0.0791786
0.0711906
0.0639706
0.0574136
0.0514371
0.0459768
0.0409827
0.0364158
0.0322446
0.0284425
0.0249865
0.0218555
0.0190296
0.0164893
0.0142155
0.0121894
0.0103921
0.00880507
0.0074099
0.00618859
0.00512347
0.00419719
0.00339283
0.00269389
0.00208372
0.00154649
0.00106378
0.000622523
0.00019439
0.247245
0.220535
0.196757
0.175365
0.156298
0.139528
0.124887
0.112107
0.100906
0.0910279
0.0822454
0.0743664
0.0672348
0.0607296
0.0547608
0.0492631
0.0441898
0.0395078
0.0351925
0.0312247
0.0275884
0.0242684
0.02125
0.0185182
0.0160572
0.0138506
0.0118818
0.0101335
0.00858858
0.00722952
0.00603922
0.0050007
0.00409726
0.0033125
0.0026304
0.0020348
0.00151036
0.00103904
0.000608343
0.000189785
0.222869
0.196319
0.173825
0.154068
0.136866
0.122174
0.109715
0.0990819
0.0898891
0.0818209
0.0746245
0.068102
0.062107
0.056539
0.0513337
0.0464531
0.0418764
0.0375936
0.0336
0.0298931
0.0264697
0.0233251
0.0204527
0.0178433
0.0154858
0.0133674
0.0114739
0.00979042
0.00830104
0.00698979
0.0058406
0.00483742
0.00396431
0.00320557
0.00254588
0.00196967
0.00146224
0.00100606
0.000589349
0.000183672
0.190369
0.164481
0.144192
0.127017
0.112593
0.100856
0.0913774
0.0835742
0.0769457
0.0711269
0.0658545
0.060943
0.0562738
0.0517828
0.0474451
0.0432599
0.03924
0.0354039
0.0317709
0.028357
0.025174
0.0222286
0.0195228
0.0170541
0.0148162
0.0128001
0.0109945
0.00938656
0.00796232
0.00670721
0.00560636
0.00464476
0.00380738
0.00307933
0.00244607
0.00189274
0.00140539
0.000967078
0.000566848
0.000176466
0.148957
0.12464
0.107921
0.0946067
0.0841068
0.0763422
0.0707016
0.0663988
0.0628316
0.0596161
0.0565106
0.0533706
0.0501301
0.0467811
0.043352
0.0398892
0.0364452
0.033071
0.0298116
0.0267029
0.0237719
0.021037
0.0185086
0.0161908
0.0140819
0.0121768
0.0104669
0.00894164
0.00758882
0.00639539
0.00534773
0.00443195
0.00363397
0.0029398
0.00233572
0.00180767
0.0013425
0.000923942
0.000541916
0.000168504
0.0975345
0.0762747
0.0650496
0.0572647
0.0520766
0.0494329
0.0485145
0.0483366
0.0482414
0.0478819
0.0470845
0.0457835
0.0439945
0.0417864
0.0392541
0.036499
0.0336177
0.0306957
0.0278037
0.0249975
0.0223185
0.019796
0.0174483
0.0152852
0.0133098
0.0115201
0.00991016
0.00847156
0.00719383
0.00606537
0.00507387
0.0042065
0.00345022
0.00279188
0.0022187
0.00171744
0.00127579
0.000878171
0.000515429
0.000160061
0.0347489
0.0188474
0.0157156
0.0155351
0.0172749
0.0209884
0.0256508
0.0301295
0.0338004
0.0364324
0.0379786
0.038495
0.0381091
0.0369855
0.0352963
0.033203
0.0308481
0.0283508
0.0258068
0.02329
0.0208549
0.0185401
0.0163709
0.0143622
0.0125208
0.0108476
0.00933923
0.00798893
0.0067879
0.00572598
0.00479207
0.00397443
0.00326098
0.0026395
0.00209812
0.00162445
0.00120703
0.000830982
0.000488091
0.000151362
-0.0408436
-0.0479954
-0.0397374
-0.0298606
-0.0193896
-0.00806255
0.00293995
0.0124621
0.0200485
0.0256804
0.0295016
0.0317335
0.0326431
0.0325051
0.0315753
0.0300768
0.0281966
0.0260857
0.0238621
0.0216152
0.0194106
0.0172946
0.0152982
0.0134403
0.0117308
0.0101731
0.00876571
0.00750354
0.0063793
0.00538412
0.00450807
0.00374045
0.00307013
0.00248577
0.00197645
0.0015306
0.00113761
0.000783336
0.00046046
0.000142584
-0.130374
-0.124114
-0.100665
-0.0779864
-0.0568557
-0.0367407
-0.0188256
-0.0040645
0.0074246
0.0159364
0.0218687
0.0256478
0.0277005
0.0284202
0.0281472
0.0271643
0.0256993
0.023931
0.021996
0.0199962
0.0180061
0.0160776
0.014246
0.0125334
0.0109519
0.00950685
0.00819839
0.0070229
0.00597435
0.0050451
0.0042263
0.0035082
0.00288062
0.00233309
0.00185557
0.00143735
0.00106863
0.00073598
0.000432971
0.000133867
-0.233788
-0.208431
-0.166044
-0.127654
-0.0939101
-0.064058
-0.0389321
-0.0189589
-0.0037463
0.00740653
0.0152069
0.0203155
0.0233301
0.0247633
0.0250363
0.0244855
0.023374
0.0219031
0.0202238
0.0184476
0.0166547
0.0149013
0.0132254
0.0116511
0.0101926
0.00885633
0.0076438
0.00655258
0.00557779
0.0047129
0.00395007
0.00328045
0.00269473
0.00218327
0.00173693
0.00134581
0.0010009
0.000689486
0.000405952
0.000125314
-0.348345
-0.298417
-0.234348
-0.177336
-0.129207
-0.089081
-0.0567875
-0.0318599
-0.0132591
0.000196302
0.00956437
0.0157551
0.019537
0.0215352
0.0222431
0.0220428
0.0212251
0.0200083
0.0185532
0.0169774
0.0153646
0.0137736
0.0122437
0.0108005
0.00945902
0.00822698
0.00710667
0.00609666
0.0051931
0.00439047
0.00368186
0.00305923
0.00251412
0.00203767
0.0016216
0.00125681
0.000935045
0.00064428
0.000379652
0.000117004
-0.466851
-0.389795
-0.303274
-0.225011
-0.161326
-0.111004
-0.0719534
-0.0425469
-0.021026
-0.00567827
0.00492445
0.0119392
0.0162942
0.0187141
0.0197526
0.0198272
0.0192487
0.0182461
0.0169861
0.0155891
0.0141403
0.0126992
0.0113057
0.00998587
0.00875538
0.00762251
0.00659026
0.00565799
0.00482273
0.00407989
0.00342341
0.00284601
0.00233999
0.00189726
0.00151036
0.00117095
0.000871502
0.000600668
0.000354248
0.000108993
-0.576955
-0.476849
-0.369272
-0.268033
-0.188895
-0.129212
-0.0841595
-0.0509391
-0.0270643
-0.0102734
0.00122288
0.00880976
0.0135551
0.0162655
0.0175409
0.0178233
0.0174357
0.0166122
0.0155213
0.0142834
0.0129836
0.0116806
0.0104141
0.00921008
0.0080843
0.00704537
0.00609676
0.00523847
0.00446834
0.00378257
0.00317593
0.00264177
0.00217316
0.00176271
0.00140374
0.00108865
0.000810578
0.000558863
0.000329864
0.000101317
-0.663109
-0.553357
-0.427139
-0.303326
-0.210792
-0.143321
-0.0933091
-0.0570866
-0.0314781
-0.013699
-0.0016371
0.00628901
0.0112608
0.0141469
0.0155786
0.0160117
0.0157737
0.0150992
0.0141547
0.0130587
0.0118942
0.0107184
0.00956999
0.00847435
0.00744708
0.00649681
0.00562736
0.0048392
0.00413087
0.00349934
0.00294011
0.00244712
0.00201413
0.00163441
0.00130206
0.00101014
0.000752462
0.000518998
0.000306581
9.40012e-05
-0.711054
-0.612976
-0.470109
-0.328032
-0.226328
-0.153195
-0.0994904
-0.06117
-0.034453
-0.0161154
-0.00378379
0.00427912
0.00933933
0.0123066
0.0138292
0.0143669
0.0142455
0.0136954
0.0128786
0.0119099
0.0108689
0.00981068
0.00877223
0.00777813
0.0068435
0.00597685
0.00518218
0.00446036
0.00381058
0.00323046
0.0027162
0.00226227
0.00186308
0.00151255
0.00120547
0.00093556
0.000697245
0.000481139
0.000284437
8.70552e-05
-0.713534
-0.648787
-0.491215
-0.340378
-0.235268
-0.15892
-0.102963
-0.0634733
-0.03623
-0.0177115
-0.00535835
0.00267807
0.00771852
0.0106945
0.0122584
0.0128658
0.0128356
0.0123906
0.0116865
0.0108328
0.00990517
0.00895593
0.00802005
0.00712108
0.00627349
0.00548556
0.00476139
0.00410217
0.00350767
0.00297612
0.00250438
0.00208739
0.00172016
0.00139723
0.00111406
0.000864975
0.000644982
0.000445326
0.000263457
8.0485e-05
-0.685516
-0.659146
-0.489093
-0.341477
-0.238098
-0.160759
-0.103926
-0.0640935
-0.0368337
-0.0184722
-0.00632594
0.00152889
0.00644295
0.00935311
0.0109051
0.011543
0.0115739
0.0112106
0.0106001
0.00984565
0.00901821
0.00816664
0.00732366
0.00651148
0.00574373
0.00502827
0.0043692
0.00376794
0.00322472
0.00273831
0.00230615
0.0019236
0.0015862
0.00128905
0.00102826
0.000798673
0.00059586
0.000411674
0.000243704
7.43152e-05
-0.676267
-0.656766
-0.474931
-0.337395
-0.236746
-0.159144
-0.102152
-0.0625497
-0.0357601
-0.017961
-0.00633552
0.00110452
0.00572229
0.00844336
0.00989299
0.0104939
0.0105345
0.010213
0.00966431
0.00898358
0.00823535
0.00746409
0.00669958
0.0059621
0.00526402
0.00461246
0.0040113
0.00346193
0.0029649
0.00251936
0.0021232
0.00177211
0.00146204
0.00118859
0.00094843
0.000736894
0.000550023
0.000380261
0.000225225
6.85687e-05
-0.649495
-0.619419
-0.44153
-0.324841
-0.230107
-0.154711
-0.0990139
-0.0604543
-0.0345794
-0.0175625
-0.00654428
0.000464798
0.00480272
0.00736367
0.0087423
0.00933511
0.00941034
0.00915093
0.00868044
0.00808627
0.00742728
0.00674408
0.00606395
0.00540568
0.00478063
0.00419545
0.00365398
0.00315774
0.00270768
0.00230345
0.00194349
0.00162388
0.00134099
0.001091
0.000871156
0.000677282
0.000505905
0.00035014
0.000207497
6.30388e-05
-0.396364
-0.453098
-0.333502
-0.274744
-0.210425
-0.151795
-0.103578
-0.067466
-0.0416904
-0.0239208
-0.0119655
-0.0040873
0.000984868
0.00414921
0.00602316
0.00702549
0.0074429
0.00747256
0.00724796
0.00686443
0.00638677
0.00586016
0.00531525
0.00477376
0.00424933
0.00375066
0.00328333
0.00285035
0.00245403
0.00209538
0.00177402
0.00148707
0.00123148
0.00100444
0.000803812
0.000626231
0.00046857
0.000325076
0.000192719
5.82937e-05
-0.314123
-0.399836
-0.294626
-0.253565
-0.195358
-0.141728
-0.0968919
-0.063133
-0.0389762
-0.0223403
-0.0111718
-0.00382816
0.000891915
0.00383459
0.00557896
0.00651471
0.00690787
0.00694159
0.00673904
0.0063886
0.0059503
0.00546595
0.00496375
0.00446398
0.00397904
0.00351699
0.00308299
0.00268001
0.00231033
0.00197511
0.00167415
0.00140504
0.0011647
0.000950842
0.000761453
0.00059367
0.000444391
0.000308676
0.000182917
5.52121e-05
-0.285758
-0.387908
-0.282886
-0.244577
-0.183401
-0.13037
-0.0874232
-0.0560147
-0.033981
-0.0190395
-0.00912091
-0.00265428
0.00147146
0.00402268
0.00551742
0.00630025
0.00660557
0.0065954
0.00637799
0.00603165
0.00560956
0.0051488
0.00467412
0.00420368
0.0037481
0.00331436
0.00290693
0.00252851
0.00218109
0.00186579
0.00158242
0.00132899
0.00110222
0.000900267
0.000721159
0.000562476
0.000421069
0.000292793
0.000173387
5.22824e-05
-0.264019
-0.373694
-0.27126
-0.235695
-0.172738
-0.120825
-0.0797091
-0.0503834
-0.0301544
-0.0166158
-0.00770942
-0.00193913
0.0017249
0.00397995
0.0052926
0.00597036
0.00622179
0.00619184
0.00597669
0.00564666
0.00524947
0.00481846
0.00437564
0.00393753
0.00351335
0.00310931
0.00272936
0.00237612
0.00205135
0.00175619
0.00149051
0.00125282
0.00103966
0.000849646
0.000680834
0.000531264
0.000397736
0.000276915
0.000163862
4.93895e-05
-0.247534
-0.35562
-0.256691
-0.224527
-0.16174
-0.112018
-0.0730428
-0.0457391
-0.0271223
-0.0147851
-0.00672441
-0.00152608
0.00176505
0.00378601
0.00495953
0.00556212
0.00578073
0.00574592
0.00554378
0.00523792
0.00487143
0.00447453
0.00406686
0.00366355
0.00327265
0.00289972
0.00254836
0.00222113
0.00191968
0.00164516
0.00139754
0.00117588
0.000976534
0.000798633
0.000640241
0.000499886
0.000374297
0.000260994
0.000154313
4.65209e-05
-0.237504
-0.338518
-0.242647
-0.212814
-0.150734
-0.103471
-0.066717
-0.0414151
-0.0243477
-0.0131454
-0.00587473
-0.00120665
0.00174119
0.00354852
0.00459668
0.00513336
0.00532534
0.00528986
0.00510355
0.00482384
0.00448943
0.00412765
0.00375585
0.00338786
0.00303062
0.00268908
0.00236651
0.0020655
0.00178751
0.00153375
0.00130426
0.0010987
0.000913233
0.000747495
0.000599558
0.000468459
0.000350824
0.000245076
0.000144764
4.36852e-05
-0.232155
-0.322797
-0.229864
-0.201294
-0.140163
-0.0953323
-0.0607477
-0.0373784
-0.0217911
-0.011664
-0.00513617
-0.000963548
0.00166576
0.00327665
0.00421111
0.00468968
0.00486021
0.00482743
0.00465918
0.0044071
0.00410575
0.00377972
0.0034442
0.0031118
0.00278834
0.00247827
0.00218453
0.00190977
0.00165528
0.00142229
0.00121092
0.00102149
0.000849887
0.000696326
0.000558849
0.000437026
0.000327342
0.000229176
0.000135222
4.08846e-05
-0.22995
-0.307854
-0.217891
-0.189928
-0.130123
-0.0877101
-0.0552355
-0.0337046
-0.0195059
-0.0103776
-0.00453412
-0.00081445
0.00152625
0.00296143
0.00379631
0.00422635
0.00438184
0.00435605
0.00420877
0.00398631
0.00371934
0.00342999
0.00313137
0.00283496
0.00254555
0.0022671
0.00200229
0.00175387
0.00152293
0.00131075
0.0011175
0.00094421
0.000786489
0.000645123
0.000518108
0.000405587
0.000303847
0.000213295
0.000125685
3.81176e-05
-0.22996
-0.293513
-0.206519
-0.178714
-0.120631
-0.0806133
-0.0501934
-0.0304004
-0.0174949
-0.00928674
-0.0040684
-0.000759054
0.00132283
0.00260285
0.00335213
0.0037431
0.00388992
0.0038754
0.00375198
0.00356116
0.00332996
0.00307824
0.00281717
0.00255723
0.00230215
0.00205549
0.00181972
0.00159773
0.00139044
0.00119911
0.00102397
0.000866871
0.000723035
0.000593885
0.000477331
0.000374139
0.000280337
0.000197436
0.000116151
3.53828e-05
-0.231596
-0.279801
-0.195764
-0.167773
-0.11173
-0.0740422
-0.0456096
-0.0274484
-0.0157421
-0.00837849
-0.00372938
-0.000790486
0.00106031
0.00220422
0.00288085
0.00324148
0.00338551
0.00338617
0.00328931
0.00313199
0.00293783
0.00272464
0.00250173
0.00227867
0.00205818
0.00184348
0.00163684
0.0014414
0.00125782
0.00108738
0.00093036
0.000789481
0.000659532
0.000542617
0.00043652
0.000342688
0.000256811
0.000181601
0.00010662
3.2679e-05
-0.234528
-0.266792
-0.185683
-0.15724
-0.103475
-0.0680072
-0.0414789
-0.0248365
-0.0142354
-0.00764295
-0.00350971
-0.000903488
0.000742349
0.0017681
0.00238422
0.0027227
0.00286942
0.00288896
0.00282115
0.00269909
0.00254317
0.00236933
0.00218515
0.00199938
0.00181372
0.00163113
0.0014537
0.0012849
0.00112511
0.00097559
0.000836672
0.000712056
0.000595992
0.000491329
0.000395677
0.000311236
0.000233267
0.000165792
9.70909e-05
3.0005e-05
-0.238637
-0.254606
-0.176355
-0.14724
-0.0959065
-0.0625197
-0.0377996
-0.0225567
-0.0129667
-0.00707322
-0.00340419
-0.00109431
0.000371599
0.0012963
0.00186349
0.00218759
0.00234223
0.00238414
0.00234777
0.00226263
0.00214608
0.00201242
0.0018675
0.00171942
0.00156882
0.00141847
0.00127033
0.00112826
0.000992326
0.000863752
0.000742923
0.00063461
0.000532425
0.000440029
0.000354803
0.000279788
0.000209705
0.000150013
8.7562e-05
2.73595e-05
-0.243971
-0.243406
-0.167887
-0.137885
-0.0890603
-0.0575892
-0.0345689
-0.0206016
-0.0119287
-0.00666326
-0.00340827
-0.00135969
-4.96511e-05
0.000790424
0.00131974
0.00163687
0.00180441
0.00187203
0.00186938
0.00182276
0.00174668
0.00165398
0.00154884
0.00143884
0.00132353
0.00120553
0.00108674
0.000971488
0.000859493
0.000751887
0.000649122
0.000557158
0.000468839
0.000388724
0.000313899
0.000248347
0.000186122
0.000134267
7.80322e-05
2.4741e-05
-0.25069
-0.233388
-0.160405
-0.129287
-0.0829661
-0.0532236
-0.0317832
-0.018964
-0.0111146
-0.00640753
-0.00351786
-0.00169669
-0.000519319
0.000251916
0.000753981
0.0010712
0.0012564
0.00135292
0.00138618
0.00137959
0.00134506
0.0012941
0.00122922
0.00115768
0.00107786
0.000992348
0.000902943
0.000814609
0.00072663
0.000640008
0.00055528
0.000479711
0.000405241
0.000337421
0.000272962
0.000216915
0.000162515
0.000118553
6.85005e-05
2.21472e-05
-0.259032
-0.224758
-0.154045
-0.121547
-0.0776508
-0.049431
-0.0294385
-0.0176375
-0.0105182
-0.00630116
-0.00372937
-0.00210271
-0.00103557
-0.000317949
0.000167071
0.000491145
0.000698581
0.000827032
0.000898322
0.000933253
0.000941291
0.000932827
0.000908679
0.000875975
0.000831859
0.000778943
0.000718954
0.00065763
0.000593755
0.000528128
0.000461403
0.000402282
0.000341641
0.000286126
0.00023199
0.000185496
0.000138884
0.000102873
5.89608e-05
1.95813e-05
-0.269268
-0.217726
-0.148942
-0.114759
-0.0731382
-0.0462187
-0.0275311
-0.0166162
-0.0101342
-0.00633998
-0.00403971
-0.00257552
-0.00159681
-0.00091806
-0.000440222
-0.000102798
0.000131265
0.000294585
0.000405961
0.00048383
0.000535441
0.000570233
0.000587258
0.000593785
0.000585563
0.000565339
0.000534779
0.000500574
0.000460894
0.000416276
0.000367501
0.0003249
0.000278047
0.000234855
0.000190985
0.000154095
0.000115215
8.72507e-05
4.93919e-05
1.70599e-05
-0.281681
-0.212491
-0.145225
-0.109004
-0.0694489
-0.0435937
-0.0260571
-0.0158952
-0.00995804
-0.00652053
-0.0044463
-0.00311323
-0.00220164
-0.00154741
-0.0010672
-0.000710183
-0.000445282
-0.00024427
-9.0818e-05
3.13847e-05
0.000127568
0.000206365
0.000264991
0.000311189
0.000339041
0.000351564
0.000350438
0.000343513
0.000328099
0.000304541
0.000273592
0.000247642
0.000214478
0.000183649
0.000149991
0.000122716
9.14841e-05
7.17526e-05
3.98631e-05
1.45338e-05
-0.296539
-0.209232
-0.143007
-0.104354
-0.0666002
-0.0415625
-0.0250131
-0.0154704
-0.00998585
-0.0068399
-0.00494703
-0.00371426
-0.00284889
-0.00220517
-0.0017133
-0.00133068
-0.0010308
-0.000789443
-0.000591904
-0.000424036
-0.000282329
-0.000158702
-5.80897e-05
2.81655e-05
9.23175e-05
0.000137713
0.000165969
0.000186399
0.000195414
0.000192866
0.000179745
0.000170453
0.000150985
0.000132489
0.000108953
9.14034e-05
6.77576e-05
5.62466e-05
3.16011e-05
1.15695e-05
-0.314086
-0.208111
-0.142389
-0.10087
-0.0646059
-0.0401307
-0.0243953
-0.0153384
-0.0102144
-0.00729524
-0.00553966
-0.00437731
-0.00353819
-0.00289152
-0.00237901
-0.00196443
-0.00162539
-0.00134039
-0.00109718
-0.000881978
-0.000693789
-0.000524923
-0.000381439
-0.000255935
-0.000155079
-7.61567e-05
-1.74735e-05
2.94113e-05
6.20385e-05
8.00232e-05
8.54803e-05
9.16167e-05
8.71427e-05
8.07199e-05
6.81838e-05
5.93806e-05
4.48486e-05
3.91751e-05
2.38833e-05
8.34633e-06
-0.334551
-0.209272
-0.143457
-0.0986088
-0.0634777
-0.0393033
-0.0242013
-0.0154974
-0.010641
-0.00788348
-0.00622166
-0.00510123
-0.00426981
-0.00360762
-0.00306562
-0.00261226
-0.00222923
-0.00189662
-0.00160577
-0.00134151
-0.00110596
-0.000891725
-0.000704807
-0.000541188
-0.000403565
-0.000290629
-0.000200493
-0.000128057
-7.27387e-05
-3.47756e-05
-9.91337e-06
1.04642e-05
2.23105e-05
2.78004e-05
2.7229e-05
2.62585e-05
2.24888e-05
2.03607e-05
1.47325e-05
5.42031e-06
)
;
boundaryField
{
inlet
{
type freestreamPressure;
freestreamValue uniform 0;
supersonic false;
value nonuniform List<scalar>
80
(
0.877653
0.863296
0.847784
0.83103
0.813019
0.793757
0.773276
0.751645
0.728981
0.705453
0.681292
0.656798
0.632343
0.60838
0.58544
0.56414
0.545189
0.529399
0.517708
0.511211
1.01424
1.00882
1.00323
0.997483
0.991576
0.985517
0.979314
0.972971
0.966497
0.959897
0.953177
0.946346
0.939409
0.932373
0.925245
0.918033
0.910742
0.903385
0.895964
0.888444
1.08298
1.08139
1.07961
1.07764
1.07548
1.07312
1.07057
1.06782
1.06487
1.06172
1.05838
1.05483
1.05109
1.04715
1.04301
1.03868
1.03416
1.02946
1.02456
1.01949
0.99355
0.997314
1.0039
1.01243
1.0221
1.03225
1.04232
1.05188
1.06061
1.06828
1.07478
1.08004
1.08408
1.08694
1.0887
1.08947
1.08937
1.08851
1.08701
1.08498
)
;
}
outlet
{
type freestreamPressure;
freestreamValue uniform 0;
supersonic false;
value nonuniform List<scalar>
80
(
-1.49079e-12
-1.58944e-12
-1.67914e-12
-1.76305e-12
-1.83661e-12
-1.89529e-12
-1.93504e-12
-1.95151e-12
-1.94004e-12
-1.89599e-12
-1.8152e-12
-1.69459e-12
-1.53294e-12
-1.33186e-12
-1.09696e-12
-8.38999e-13
-5.74976e-13
-3.28703e-13
-1.30545e-13
-1.54589e-14
7.08217e-14
-1.08414e-15
-6.77053e-14
-1.45247e-13
-2.2902e-13
-3.12072e-13
-3.94019e-13
-4.75201e-13
-5.55672e-13
-6.3541e-13
-7.14402e-13
-7.92632e-13
-8.70073e-13
-9.46696e-13
-1.02247e-12
-1.09736e-12
-1.17125e-12
-1.24397e-12
-1.31579e-12
-1.38822e-12
1.55965e-12
1.48481e-12
1.41245e-12
1.33994e-12
1.26702e-12
1.19394e-12
1.12087e-12
1.04785e-12
9.7494e-13
9.02193e-13
8.29665e-13
7.57407e-13
6.8546e-13
6.13848e-13
5.42741e-13
4.72706e-13
4.02477e-13
3.199e-13
2.29578e-13
1.49015e-13
2.12461e-14
1.78554e-13
4.45849e-13
7.71361e-13
1.11114e-12
1.43237e-12
1.71341e-12
1.94234e-12
2.11482e-12
2.2319e-12
2.29805e-12
2.31966e-12
2.30387e-12
2.25788e-12
2.18843e-12
2.10141e-12
2.00196e-12
1.8953e-12
1.78627e-12
1.67151e-12
)
;
}
top
{
type symmetryPlane;
}
bottom
{
type symmetryPlane;
}
cylinder
{
type zeroGradient;
}
frontandback
{
type empty;
}
}
// ************************************************************************* //
| [
"danieler@login3.stampede2.tacc.utexas.edu"
] | danieler@login3.stampede2.tacc.utexas.edu | |
69a4b3ba98d19cbfd8dbab667ecac7d48e5e6ab3 | 21dfd5124c2f05ef5f98355996dc2313f1a29f5a | /Src/Representations/Infrastructure/TeamMateData.h | dafd9a5e4f55de9be47278818d75c003db9224eb | [
"BSD-2-Clause"
] | permissive | fabba/BH2013-with-coach | 50244c3f69135cc18004a1af9e01604617b6859f | 88d7ddc43456edc5daf0e259c058f6eca2ff8ef6 | refs/heads/master | 2020-05-16T03:21:29.005314 | 2015-03-04T10:41:08 | 2015-03-04T10:41:08 | 31,651,432 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,788 | h | /**
* @file TeamMateData.h
* Declaration of a class representing information about the teammates.
* @author Colin Graf
*/
#pragma once
#include "Representations/Modeling/RobotsModel.h"
#include "Representations/Modeling/RobotPose.h"
#include "Representations/Modeling/ObstacleModel.h"
#include "Representations/Modeling/BallModel.h"
#include "Representations/Modeling/FieldCoverage.h"
#include "Representations/Modeling/SideConfidence.h"
#include "Representations/BehaviorControl/BehaviorStatus.h"
#include "Representations/MotionControl/HeadMotionRequest.h"
#include "Representations/Modeling/ObstacleClusters.h"
/**
* @class TeamMateData
* A class representing information about the teammates.
*/
STREAMABLE(TeamMateData,
{
public:
ENUM(Player,
noPlayer,
firstPlayer,
player1 = firstPlayer,
player2,
player3,
player4,
player5
);
/** drawing function for representation*/
void draw() const,
(unsigned int)(0) currentTimestamp,
(unsigned int)(4000) networkTimeout, /**< The time without packets received after which a teammate is considered absent. */
(unsigned)(0) numOfConnectedTeamMates, /**< The number of robots of which messages were received recently. _Not_ including this robot itself. */
(unsigned)(0) numOfActiveTeamMates, /**< numOfConnectedTeamMates minus all robots that are currently penalized. */
(unsigned)(0) numOfFullyActiveTeamMates, /**< numOfActiveTeamMates minus all robots that are currently not upright or do not have ground contact */
(unsigned)(numOfPlayers) firstTeamMate, /**< player number of first team mate */
(bool)(false) sendThisFrame, /**< The team communication will be sent in this frame. */
(bool)(false) wasConnected, /**< Whether we have been connected to a team mate. */
(unsigned int[numOfPlayers]) timeStamps, /**< The times when messages from different robots arrived. */
(bool[numOfPlayers]) isActive, /**< true, if messages from the respective team mate were recently received and the team mate is currently not penalized. */
(bool[numOfPlayers]) isFullyActive, /**< true, if 'isActive' and has not been fallen down and has ground contact */
(BallModel[numOfPlayers]) ballModels, /**< The last received ball model of each team mate. */
(ObstacleModel[numOfPlayers]) obstacleModels, /**< The last received obstacle model of each team mate. */
(RobotsModel[numOfPlayers]) robotsModels, /**< The last received robots model of each team mate. */
(RobotPose[numOfPlayers]) robotPoses, /**< The last received robot pose of each team mate. */
(SideConfidence[numOfPlayers]) robotsSideConfidence, /**< The last received sideConfidence of each team mate. */
(BehaviorStatus[numOfPlayers]) behaviorStatus, /**< The last received behavior status of each team mate. */
(bool[numOfPlayers]) isPenalized, /**< Tells us if a teammate is penalized. */
(bool[numOfPlayers]) hasGroundContact, /**< Tells us if a teammate has ground contact. */
(bool[numOfPlayers]) isUpright, /**< Tells us if a teammate is fallen down. */
(TeamHeadControlState[numOfPlayers]) teamHeadControlStates,
(FieldCoverage::GridInterval[numOfPlayers]) fieldCoverages, /**< The last received field coverage grid of each team mate. */
(ObstacleClusters[numOfPlayers]) obstacleClusters, /**< The last received obstacle clusters */
(unsigned int[numOfPlayers]) timeLastGroundContact, /**< The time since last ground contact of a team mate. */
(float[numOfPlayers]) cameraHeights, /**<camera heights of team mates> */
// Initialization
for(int i = 0; i < numOfPlayers; ++i)
{
timeStamps[i] = 0;
timeLastGroundContact[i] = 0;
}
});
/**
* @class TeamDataSenderOutput
* An empty dummy representation for the TeamDataSender module
*/
STREAMABLE(TeamDataSenderOutput,
{,
});
| [
"fab_v_cool@hotmail.com"
] | fab_v_cool@hotmail.com |
da8d09bdfbe440b32660136cb1c2d074dbf7bbb3 | 9423c691f8730956cf3bd3f5c5c29db0d59262fd | /code/graphics/cylinder/Application.h | 2fbbccf2a13ba9b47439e11a616cc149180bd978 | [] | no_license | asandler/mipt | bf31d8271f04e41e5887161a43f677bfd381e684 | 761e43b85c0afe03ffead9927a20573e5b19c4c6 | refs/heads/master | 2021-09-16T18:39:07.278068 | 2018-01-03T14:29:32 | 2018-01-03T14:29:32 | 109,857,417 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,642 | h | #pragma once
#define GLM_FORCE_RADIANS
#include <GL/glew.h> // include GLEW and new version of GL on Windows
#include <GLFW/glfw3.h> // GLFW helper library
#include <iostream>
#include <fstream>
#include <string>
#include <sstream>
#include <vector>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp> // glm::translate, glm::rotate, glm::scale, glm::perspective
#include <glm/gtc/type_ptr.hpp> // glm::value_ptr
#include "CommonMaterial.h"
#include "SkyBoxMaterial.h"
#include "Camera.h"
#include "Mesh.h"
class Application {
public:
Application();
~Application();
void initContext(); //Инициализация графического контекста
void initGL(); //Настройка некоторых параметров OpenGL
void makeScene(); //Создание трехмерной сцены
void run(); //Цикл рендеринга
void draw(); //Отрисовать один кадр
void update(); //Обновление
protected:
GLFWwindow* _window;
CommonMaterial _commonMaterial;
Camera _mainCamera;
//параметры освещения
glm::vec4 _lightPos; //in world space
glm::vec3 _ambientColor;
glm::vec3 _diffuseColor;
glm::vec3 _specularColor;
//полигональные 3д-модели
Mesh _terrain;
float _oldTime;
int _num;
bool _forvard;
void makeSceneImplementation(float);
void drawScene(Camera& camera);
void drawBackground(Camera& camera);
};
| [
"asandler@yandex-team.ru"
] | asandler@yandex-team.ru |
d51b96693aa864ab2b54d659621cf7a708833a4c | 7df30808431f94b8e45ee381f2c47269c42797a7 | /bitonicSort64/solution1/sim/autowrap/testbench/bitonic32Dec.cpp_pre.cpp | 76033f69b3a317e390323dbb79ac14aa83167afe | [] | no_license | piyushkumarhcu/BItonic-Sort-64IO | 5e2196d91832a01ffd375e5b5245b6357bfb0b21 | 28e16f87889dfe0cf9ef618d9f0e898bf909c103 | refs/heads/master | 2023-03-08T08:14:26.016896 | 2021-02-23T08:18:57 | 2021-02-23T08:18:57 | 286,395,627 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,693,672 | cpp | # 1 "/afs/cern.ch/user/p/piyush/work/bitonic64/src/bitonic32Dec.cpp"
# 1 "<built-in>"
# 1 "<command-line>"
# 1 "/usr/include/stdc-predef.h" 1 3 4
# 1 "<command-line>" 2
# 1 "/afs/cern.ch/user/p/piyush/work/bitonic64/src/bitonic32Dec.cpp"
# 1 "/afs/cern.ch/user/p/piyush/work/bitonic64/src/bitonicSort.h" 1
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iostream" 1 3
# 36 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iostream" 3
# 37 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iostream" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 1 3
# 196 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 3
# 196 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 3
namespace std
{
typedef long unsigned int size_t;
typedef long int ptrdiff_t;
typedef decltype(nullptr) nullptr_t;
}
# 218 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 3
namespace std
{
inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
}
namespace __gnu_cxx
{
inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
}
# 495 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/os_defines.h" 1 3
# 39 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/os_defines.h" 3
# 1 "/usr/include/features.h" 1 3 4
# 375 "/usr/include/features.h" 3 4
# 1 "/usr/include/sys/cdefs.h" 1 3 4
# 392 "/usr/include/sys/cdefs.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 393 "/usr/include/sys/cdefs.h" 2 3 4
# 376 "/usr/include/features.h" 2 3 4
# 399 "/usr/include/features.h" 3 4
# 1 "/usr/include/gnu/stubs.h" 1 3 4
# 10 "/usr/include/gnu/stubs.h" 3 4
# 1 "/usr/include/gnu/stubs-64.h" 1 3 4
# 11 "/usr/include/gnu/stubs.h" 2 3 4
# 400 "/usr/include/features.h" 2 3 4
# 40 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/os_defines.h" 2 3
# 496 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/cpu_defines.h" 1 3
# 499 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 2 3
# 39 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iostream" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 1 3
# 36 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 3
# 37 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ios" 1 3
# 36 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ios" 3
# 37 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ios" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iosfwd" 1 3
# 36 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iosfwd" 3
# 37 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iosfwd" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stringfwd.h" 1 3
# 37 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stringfwd.h" 3
# 38 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stringfwd.h" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/memoryfwd.h" 1 3
# 46 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/memoryfwd.h" 3
# 47 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/memoryfwd.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 63 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/memoryfwd.h" 3
template<typename>
class allocator;
template<>
class allocator<void>;
template<typename, typename>
struct uses_allocator;
}
# 41 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stringfwd.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<class _CharT>
struct char_traits;
template<> struct char_traits<char>;
template<> struct char_traits<wchar_t>;
template<> struct char_traits<char16_t>;
template<> struct char_traits<char32_t>;
namespace __cxx11 {
template<typename _CharT, typename _Traits = char_traits<_CharT>,
typename _Alloc = allocator<_CharT> >
class basic_string;
typedef basic_string<char> string;
typedef basic_string<wchar_t> wstring;
typedef basic_string<char16_t> u16string;
typedef basic_string<char32_t> u32string;
}
}
# 40 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iosfwd" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/postypes.h" 1 3
# 38 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/postypes.h" 3
# 39 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/postypes.h" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cwchar" 1 3
# 39 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cwchar" 3
# 40 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/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 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include/stdarg.h" 1 3 4
# 40 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include/stdarg.h" 3 4
typedef __builtin_va_list __gnuc_va_list;
# 40 "/usr/include/wchar.h" 2 3 4
# 1 "/usr/include/bits/wchar.h" 1 3 4
# 22 "/usr/include/bits/wchar.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 23 "/usr/include/bits/wchar.h" 2 3 4
# 42 "/usr/include/wchar.h" 2 3 4
# 51 "/usr/include/wchar.h" 3 4
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include/stddef.h" 1 3 4
# 216 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include/stddef.h" 3 4
typedef long unsigned int size_t;
# 357 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/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;
# 104 "/usr/include/wchar.h" 3 4
typedef __mbstate_t mbstate_t;
# 132 "/usr/include/wchar.h" 3 4
extern "C" {
struct tm;
extern wchar_t *wcscpy (wchar_t *__restrict __dest,
const wchar_t *__restrict __src) throw ();
extern wchar_t *wcsncpy (wchar_t *__restrict __dest,
const wchar_t *__restrict __src, size_t __n)
throw ();
extern wchar_t *wcscat (wchar_t *__restrict __dest,
const wchar_t *__restrict __src) throw ();
extern wchar_t *wcsncat (wchar_t *__restrict __dest,
const wchar_t *__restrict __src, size_t __n)
throw ();
extern int wcscmp (const wchar_t *__s1, const wchar_t *__s2)
throw () __attribute__ ((__pure__));
extern int wcsncmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
throw () __attribute__ ((__pure__));
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;
# 181 "/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 ();
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__));
extern "C++" wchar_t *wcschr (wchar_t *__wcs, wchar_t __wc)
throw () __asm ("wcschr") __attribute__ ((__pure__));
extern "C++" const wchar_t *wcschr (const wchar_t *__wcs, wchar_t __wc)
throw () __asm ("wcschr") __attribute__ ((__pure__));
extern "C++" wchar_t *wcsrchr (wchar_t *__wcs, wchar_t __wc)
throw () __asm ("wcsrchr") __attribute__ ((__pure__));
extern "C++" const wchar_t *wcsrchr (const wchar_t *__wcs, wchar_t __wc)
throw () __asm ("wcsrchr") __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__));
extern "C++" wchar_t *wcspbrk (wchar_t *__wcs, const wchar_t *__accept)
throw () __asm ("wcspbrk") __attribute__ ((__pure__));
extern "C++" const wchar_t *wcspbrk (const wchar_t *__wcs,
const wchar_t *__accept)
throw () __asm ("wcspbrk") __attribute__ ((__pure__));
extern "C++" wchar_t *wcsstr (wchar_t *__haystack, const wchar_t *__needle)
throw () __asm ("wcsstr") __attribute__ ((__pure__));
extern "C++" const wchar_t *wcsstr (const wchar_t *__haystack,
const wchar_t *__needle)
throw () __asm ("wcsstr") __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__));
extern "C++" wchar_t *wcswcs (wchar_t *__haystack, const wchar_t *__needle)
throw () __asm ("wcswcs") __attribute__ ((__pure__));
extern "C++" const wchar_t *wcswcs (const wchar_t *__haystack,
const wchar_t *__needle)
throw () __asm ("wcswcs") __attribute__ ((__pure__));
# 306 "/usr/include/wchar.h" 3 4
extern size_t wcsnlen (const wchar_t *__s, size_t __maxlen)
throw () __attribute__ ((__pure__));
extern "C++" wchar_t *wmemchr (wchar_t *__s, wchar_t __c, size_t __n)
throw () __asm ("wmemchr") __attribute__ ((__pure__));
extern "C++" const wchar_t *wmemchr (const wchar_t *__s, wchar_t __c,
size_t __n)
throw () __asm ("wmemchr") __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 ();
# 405 "/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 ();
# 530 "/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 () ;
# 680 "/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 () ;
# 736 "/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);
# 801 "/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);
# 827 "/usr/include/wchar.h" 3 4
extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream);
extern wint_t putwchar_unlocked (wchar_t __wc);
# 837 "/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 ();
# 891 "/usr/include/wchar.h" 3 4
}
# 45 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cwchar" 2 3
# 62 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cwchar" 3
namespace std
{
using ::mbstate_t;
}
# 135 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/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;
# 232 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cwchar" 3
}
namespace __gnu_cxx
{
using ::wcstold;
# 257 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cwchar" 3
using ::wcstoll;
using ::wcstoull;
}
namespace std
{
using ::__gnu_cxx::wcstold;
using ::__gnu_cxx::wcstoll;
using ::__gnu_cxx::wcstoull;
}
# 277 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cwchar" 3
namespace std
{
using std::wcstof;
using std::vfwscanf;
using std::vswscanf;
using std::vwscanf;
using std::wcstold;
using std::wcstoll;
using std::wcstoull;
}
# 41 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/postypes.h" 2 3
# 68 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/postypes.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 88 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/postypes.h" 3
typedef long streamoff;
# 98 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/postypes.h" 3
typedef ptrdiff_t streamsize;
# 111 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/postypes.h" 3
template<typename _StateT>
class fpos
{
private:
streamoff _M_off;
_StateT _M_state;
public:
fpos()
: _M_off(0), _M_state() { }
# 133 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/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;
typedef fpos<mbstate_t> u16streampos;
typedef fpos<mbstate_t> u32streampos;
}
# 41 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iosfwd" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 74 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/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;
namespace __cxx11 {
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;
}
# 39 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ios" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/exception" 1 3
# 33 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/exception" 3
# 34 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/exception" 3
#pragma GCC visibility push(default)
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/atomic_lockfree_defines.h" 1 3
# 33 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/atomic_lockfree_defines.h" 3
# 34 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/atomic_lockfree_defines.h" 3
# 39 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/exception" 2 3
extern "C++" {
namespace std
{
# 60 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/exception" 3
class exception
{
public:
exception() noexcept { }
virtual ~exception() noexcept;
virtual const char*
what() const noexcept;
};
class bad_exception : public exception
{
public:
bad_exception() noexcept { }
virtual ~bad_exception() noexcept;
virtual const char*
what() const noexcept;
};
typedef void (*terminate_handler) ();
typedef void (*unexpected_handler) ();
terminate_handler set_terminate(terminate_handler) noexcept;
terminate_handler get_terminate() noexcept;
void terminate() noexcept __attribute__ ((__noreturn__));
unexpected_handler set_unexpected(unexpected_handler) noexcept;
unexpected_handler get_unexpected() noexcept;
void unexpected() __attribute__ ((__noreturn__));
# 129 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/exception" 3
bool uncaught_exception() noexcept __attribute__ ((__pure__));
int uncaught_exceptions() noexcept __attribute__ ((__pure__));
}
namespace __gnu_cxx
{
# 160 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/exception" 3
void __verbose_terminate_handler();
}
}
#pragma GCC visibility pop
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/exception_ptr.h" 1 3
# 34 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/exception_ptr.h" 3
#pragma GCC visibility push(default)
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/exception_defines.h" 1 3
# 38 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/exception_ptr.h" 2 3
extern "C++" {
namespace std
{
class type_info;
namespace __exception_ptr
{
class exception_ptr;
}
using __exception_ptr::exception_ptr;
exception_ptr current_exception() noexcept;
void rethrow_exception(exception_ptr) __attribute__ ((__noreturn__));
namespace __exception_ptr
{
using std::rethrow_exception;
class exception_ptr
{
void* _M_exception_object;
explicit exception_ptr(void* __e) noexcept;
void _M_addref() noexcept;
void _M_release() noexcept;
void *_M_get() const noexcept __attribute__ ((__pure__));
friend exception_ptr std::current_exception() noexcept;
friend void std::rethrow_exception(exception_ptr);
public:
exception_ptr() noexcept;
exception_ptr(const exception_ptr&) noexcept;
exception_ptr(nullptr_t) noexcept
: _M_exception_object(0)
{ }
exception_ptr(exception_ptr&& __o) noexcept
: _M_exception_object(__o._M_exception_object)
{ __o._M_exception_object = 0; }
# 113 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/exception_ptr.h" 3
exception_ptr&
operator=(const exception_ptr&) noexcept;
exception_ptr&
operator=(exception_ptr&& __o) noexcept
{
exception_ptr(static_cast<exception_ptr&&>(__o)).swap(*this);
return *this;
}
~exception_ptr() noexcept;
void
swap(exception_ptr&) noexcept;
# 140 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/exception_ptr.h" 3
explicit operator bool() const
{ return _M_exception_object; }
friend bool
operator==(const exception_ptr&, const exception_ptr&)
noexcept __attribute__ ((__pure__));
const class std::type_info*
__cxa_exception_type() const noexcept
__attribute__ ((__pure__));
};
bool
operator==(const exception_ptr&, const exception_ptr&)
noexcept __attribute__ ((__pure__));
bool
operator!=(const exception_ptr&, const exception_ptr&)
noexcept __attribute__ ((__pure__));
inline void
swap(exception_ptr& __lhs, exception_ptr& __rhs)
{ __lhs.swap(__rhs); }
}
template<typename _Ex>
exception_ptr
make_exception_ptr(_Ex __ex) noexcept
{
try
{
throw __ex;
}
catch(...)
{
return current_exception();
}
}
template<typename _Ex>
exception_ptr
copy_exception(_Ex __ex) noexcept __attribute__ ((__deprecated__));
template<typename _Ex>
exception_ptr
copy_exception(_Ex __ex) noexcept
{ return std::make_exception_ptr<_Ex>(__ex); }
}
}
#pragma GCC visibility pop
# 171 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/exception" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/nested_exception.h" 1 3
# 33 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/nested_exception.h" 3
#pragma GCC visibility push(default)
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/move.h" 1 3
# 34 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/move.h" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/concept_check.h" 1 3
# 33 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/concept_check.h" 3
# 34 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/concept_check.h" 3
# 35 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/move.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Tp>
inline _Tp*
__addressof(_Tp& __r) noexcept
{
return reinterpret_cast<_Tp*>
(&const_cast<char&>(reinterpret_cast<const volatile char&>(__r)));
}
}
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/type_traits" 1 3
# 32 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/type_traits" 3
# 33 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/type_traits" 3
# 42 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/type_traits" 3
namespace std
{
typedef short unsigned int uint_least16_t;
typedef unsigned int uint_least32_t;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
# 68 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/type_traits" 3
template<typename _Tp, _Tp __v>
struct integral_constant
{
static constexpr _Tp value = __v;
typedef _Tp value_type;
typedef integral_constant<_Tp, __v> type;
constexpr operator value_type() const { return value; }
constexpr value_type operator()() const { return value; }
};
template<typename _Tp, _Tp __v>
constexpr _Tp integral_constant<_Tp, __v>::value;
typedef integral_constant<bool, true> true_type;
typedef integral_constant<bool, false> false_type;
template<bool __v>
using __bool_constant = integral_constant<bool, __v>;
# 103 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/type_traits" 3
template<bool, typename, typename>
struct conditional;
template<typename...>
struct __or_;
template<>
struct __or_<>
: public false_type
{ };
template<typename _B1>
struct __or_<_B1>
: public _B1
{ };
template<typename _B1, typename _B2>
struct __or_<_B1, _B2>
: public conditional<_B1::value, _B1, _B2>::type
{ };
template<typename _B1, typename _B2, typename _B3, typename... _Bn>
struct __or_<_B1, _B2, _B3, _Bn...>
: public conditional<_B1::value, _B1, __or_<_B2, _B3, _Bn...>>::type
{ };
template<typename...>
struct __and_;
template<>
struct __and_<>
: public true_type
{ };
template<typename _B1>
struct __and_<_B1>
: public _B1
{ };
template<typename _B1, typename _B2>
struct __and_<_B1, _B2>
: public conditional<_B1::value, _B2, _B1>::type
{ };
template<typename _B1, typename _B2, typename _B3, typename... _Bn>
struct __and_<_B1, _B2, _B3, _Bn...>
: public conditional<_B1::value, __and_<_B2, _B3, _Bn...>, _B1>::type
{ };
template<typename _Pp>
struct __not_
: public integral_constant<bool, !_Pp::value>
{ };
# 182 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/type_traits" 3
template<typename _Tp>
struct __success_type
{ typedef _Tp type; };
struct __failure_type
{ };
template<typename>
struct remove_cv;
template<typename>
struct __is_void_helper
: public false_type { };
template<>
struct __is_void_helper<void>
: public true_type { };
template<typename _Tp>
struct is_void
: public __is_void_helper<typename remove_cv<_Tp>::type>::type
{ };
template<typename>
struct __is_integral_helper
: public false_type { };
template<>
struct __is_integral_helper<bool>
: public true_type { };
template<>
struct __is_integral_helper<char>
: public true_type { };
template<>
struct __is_integral_helper<signed char>
: public true_type { };
template<>
struct __is_integral_helper<unsigned char>
: public true_type { };
template<>
struct __is_integral_helper<wchar_t>
: public true_type { };
template<>
struct __is_integral_helper<char16_t>
: public true_type { };
template<>
struct __is_integral_helper<char32_t>
: public true_type { };
template<>
struct __is_integral_helper<short>
: public true_type { };
template<>
struct __is_integral_helper<unsigned short>
: public true_type { };
template<>
struct __is_integral_helper<int>
: public true_type { };
template<>
struct __is_integral_helper<unsigned int>
: public true_type { };
template<>
struct __is_integral_helper<long>
: public true_type { };
template<>
struct __is_integral_helper<unsigned long>
: public true_type { };
template<>
struct __is_integral_helper<long long>
: public true_type { };
template<>
struct __is_integral_helper<unsigned long long>
: public true_type { };
template<>
struct __is_integral_helper<__int128>
: public true_type { };
template<>
struct __is_integral_helper<unsigned __int128>
: public true_type { };
# 314 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/type_traits" 3
template<typename _Tp>
struct is_integral
: public __is_integral_helper<typename remove_cv<_Tp>::type>::type
{ };
template<typename>
struct __is_floating_point_helper
: public false_type { };
template<>
struct __is_floating_point_helper<float>
: public true_type { };
template<>
struct __is_floating_point_helper<double>
: public true_type { };
template<>
struct __is_floating_point_helper<long double>
: public true_type { };
template<>
struct __is_floating_point_helper<__float128>
: public true_type { };
template<typename _Tp>
struct is_floating_point
: public __is_floating_point_helper<typename remove_cv<_Tp>::type>::type
{ };
template<typename>
struct is_array
: public false_type { };
template<typename _Tp, std::size_t _Size>
struct is_array<_Tp[_Size]>
: public true_type { };
template<typename _Tp>
struct is_array<_Tp[]>
: public true_type { };
template<typename>
struct __is_pointer_helper
: public false_type { };
template<typename _Tp>
struct __is_pointer_helper<_Tp*>
: public true_type { };
template<typename _Tp>
struct is_pointer
: public __is_pointer_helper<typename remove_cv<_Tp>::type>::type
{ };
template<typename>
struct is_lvalue_reference
: public false_type { };
template<typename _Tp>
struct is_lvalue_reference<_Tp&>
: public true_type { };
template<typename>
struct is_rvalue_reference
: public false_type { };
template<typename _Tp>
struct is_rvalue_reference<_Tp&&>
: public true_type { };
template<typename>
struct is_function;
template<typename>
struct __is_member_object_pointer_helper
: public false_type { };
template<typename _Tp, typename _Cp>
struct __is_member_object_pointer_helper<_Tp _Cp::*>
: public integral_constant<bool, !is_function<_Tp>::value> { };
template<typename _Tp>
struct is_member_object_pointer
: public __is_member_object_pointer_helper<
typename remove_cv<_Tp>::type>::type
{ };
template<typename>
struct __is_member_function_pointer_helper
: public false_type { };
template<typename _Tp, typename _Cp>
struct __is_member_function_pointer_helper<_Tp _Cp::*>
: public integral_constant<bool, is_function<_Tp>::value> { };
template<typename _Tp>
struct is_member_function_pointer
: public __is_member_function_pointer_helper<
typename remove_cv<_Tp>::type>::type
{ };
template<typename _Tp>
struct is_enum
: public integral_constant<bool, __is_enum(_Tp)>
{ };
template<typename _Tp>
struct is_union
: public integral_constant<bool, __is_union(_Tp)>
{ };
template<typename _Tp>
struct is_class
: public integral_constant<bool, __is_class(_Tp)>
{ };
template<typename>
struct is_function
: public false_type { };
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...)>
: public true_type { };
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) &>
: public true_type { };
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) &&>
: public true_type { };
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......)>
: public true_type { };
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) &>
: public true_type { };
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) &&>
: public true_type { };
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) const>
: public true_type { };
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) const &>
: public true_type { };
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) const &&>
: public true_type { };
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) const>
: public true_type { };
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) const &>
: public true_type { };
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) const &&>
: public true_type { };
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) volatile>
: public true_type { };
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) volatile &>
: public true_type { };
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) volatile &&>
: public true_type { };
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) volatile>
: public true_type { };
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) volatile &>
: public true_type { };
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) volatile &&>
: public true_type { };
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) const volatile>
: public true_type { };
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) const volatile &>
: public true_type { };
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) const volatile &&>
: public true_type { };
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) const volatile>
: public true_type { };
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) const volatile &>
: public true_type { };
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) const volatile &&>
: public true_type { };
template<typename>
struct __is_null_pointer_helper
: public false_type { };
template<>
struct __is_null_pointer_helper<std::nullptr_t>
: public true_type { };
template<typename _Tp>
struct is_null_pointer
: public __is_null_pointer_helper<typename remove_cv<_Tp>::type>::type
{ };
template<typename _Tp>
struct __is_nullptr_t
: public is_null_pointer<_Tp>
{ };
template<typename _Tp>
struct is_reference
: public __or_<is_lvalue_reference<_Tp>,
is_rvalue_reference<_Tp>>::type
{ };
template<typename _Tp>
struct is_arithmetic
: public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
{ };
template<typename _Tp>
struct is_fundamental
: public __or_<is_arithmetic<_Tp>, is_void<_Tp>,
is_null_pointer<_Tp>>::type
{ };
template<typename _Tp>
struct is_object
: public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
is_void<_Tp>>>::type
{ };
template<typename>
struct is_member_pointer;
template<typename _Tp>
struct is_scalar
: public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
{ };
template<typename _Tp>
struct is_compound
: public integral_constant<bool, !is_fundamental<_Tp>::value> { };
template<typename _Tp>
struct __is_member_pointer_helper
: public false_type { };
template<typename _Tp, typename _Cp>
struct __is_member_pointer_helper<_Tp _Cp::*>
: public true_type { };
template<typename _Tp>
struct is_member_pointer
: public __is_member_pointer_helper<typename remove_cv<_Tp>::type>::type
{ };
template<typename _Tp>
struct __is_referenceable
: public __or_<is_object<_Tp>, is_reference<_Tp>>::type
{ };
template<typename _Res, typename... _Args>
struct __is_referenceable<_Res(_Args...)>
: public true_type
{ };
template<typename _Res, typename... _Args>
struct __is_referenceable<_Res(_Args......)>
: public true_type
{ };
template<typename>
struct is_const
: public false_type { };
template<typename _Tp>
struct is_const<_Tp const>
: public true_type { };
template<typename>
struct is_volatile
: public false_type { };
template<typename _Tp>
struct is_volatile<_Tp volatile>
: public true_type { };
template<typename _Tp>
struct is_trivial
: public integral_constant<bool, __is_trivial(_Tp)>
{ };
template<typename _Tp>
struct is_trivially_copyable
: public integral_constant<bool, __is_trivially_copyable(_Tp)>
{ };
template<typename _Tp>
struct is_standard_layout
: public integral_constant<bool, __is_standard_layout(_Tp)>
{ };
template<typename _Tp>
struct is_pod
: public integral_constant<bool, __is_pod(_Tp)>
{ };
template<typename _Tp>
struct is_literal_type
: public integral_constant<bool, __is_literal_type(_Tp)>
{ };
template<typename _Tp>
struct is_empty
: public integral_constant<bool, __is_empty(_Tp)>
{ };
template<typename _Tp>
struct is_polymorphic
: public integral_constant<bool, __is_polymorphic(_Tp)>
{ };
template<typename _Tp>
struct is_final
: public integral_constant<bool, __is_final(_Tp)>
{ };
template<typename _Tp>
struct is_abstract
: public integral_constant<bool, __is_abstract(_Tp)>
{ };
template<typename _Tp,
bool = is_arithmetic<_Tp>::value>
struct __is_signed_helper
: public false_type { };
template<typename _Tp>
struct __is_signed_helper<_Tp, true>
: public integral_constant<bool, _Tp(-1) < _Tp(0)>
{ };
template<typename _Tp>
struct is_signed
: public __is_signed_helper<_Tp>::type
{ };
template<typename _Tp>
struct is_unsigned
: public __and_<is_arithmetic<_Tp>, __not_<is_signed<_Tp>>>
{ };
template<typename>
struct add_rvalue_reference;
template<typename _Tp>
typename add_rvalue_reference<_Tp>::type declval() noexcept;
template<typename, unsigned = 0>
struct extent;
template<typename>
struct remove_all_extents;
template<typename _Tp>
struct __is_array_known_bounds
: public integral_constant<bool, (extent<_Tp>::value > 0)>
{ };
template<typename _Tp>
struct __is_array_unknown_bounds
: public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
{ };
struct __do_is_destructible_impl
{
template<typename _Tp, typename = decltype(declval<_Tp&>().~_Tp())>
static true_type __test(int);
template<typename>
static false_type __test(...);
};
template<typename _Tp>
struct __is_destructible_impl
: public __do_is_destructible_impl
{
typedef decltype(__test<_Tp>(0)) type;
};
template<typename _Tp,
bool = __or_<is_void<_Tp>,
__is_array_unknown_bounds<_Tp>,
is_function<_Tp>>::value,
bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value>
struct __is_destructible_safe;
template<typename _Tp>
struct __is_destructible_safe<_Tp, false, false>
: public __is_destructible_impl<typename
remove_all_extents<_Tp>::type>::type
{ };
template<typename _Tp>
struct __is_destructible_safe<_Tp, true, false>
: public false_type { };
template<typename _Tp>
struct __is_destructible_safe<_Tp, false, true>
: public true_type { };
template<typename _Tp>
struct is_destructible
: public __is_destructible_safe<_Tp>::type
{ };
struct __do_is_nt_destructible_impl
{
template<typename _Tp>
static integral_constant<bool, noexcept(declval<_Tp&>().~_Tp())>
__test(int);
template<typename>
static false_type __test(...);
};
template<typename _Tp>
struct __is_nt_destructible_impl
: public __do_is_nt_destructible_impl
{
typedef decltype(__test<_Tp>(0)) type;
};
template<typename _Tp,
bool = __or_<is_void<_Tp>,
__is_array_unknown_bounds<_Tp>,
is_function<_Tp>>::value,
bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value>
struct __is_nt_destructible_safe;
template<typename _Tp>
struct __is_nt_destructible_safe<_Tp, false, false>
: public __is_nt_destructible_impl<typename
remove_all_extents<_Tp>::type>::type
{ };
template<typename _Tp>
struct __is_nt_destructible_safe<_Tp, true, false>
: public false_type { };
template<typename _Tp>
struct __is_nt_destructible_safe<_Tp, false, true>
: public true_type { };
template<typename _Tp>
struct is_nothrow_destructible
: public __is_nt_destructible_safe<_Tp>::type
{ };
struct __do_is_default_constructible_impl
{
template<typename _Tp, typename = decltype(_Tp())>
static true_type __test(int);
template<typename>
static false_type __test(...);
};
template<typename _Tp>
struct __is_default_constructible_impl
: public __do_is_default_constructible_impl
{
typedef decltype(__test<_Tp>(0)) type;
};
template<typename _Tp>
struct __is_default_constructible_atom
: public __and_<__not_<is_void<_Tp>>,
__is_default_constructible_impl<_Tp>>
{ };
template<typename _Tp, bool = is_array<_Tp>::value>
struct __is_default_constructible_safe;
template<typename _Tp>
struct __is_default_constructible_safe<_Tp, true>
: public __and_<__is_array_known_bounds<_Tp>,
__is_default_constructible_atom<typename
remove_all_extents<_Tp>::type>>
{ };
template<typename _Tp>
struct __is_default_constructible_safe<_Tp, false>
: public __is_default_constructible_atom<_Tp>::type
{ };
template<typename _Tp>
struct is_default_constructible
: public __is_default_constructible_safe<_Tp>::type
{ };
# 926 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/type_traits" 3
struct __do_is_static_castable_impl
{
template<typename _From, typename _To, typename
= decltype(static_cast<_To>(declval<_From>()))>
static true_type __test(int);
template<typename, typename>
static false_type __test(...);
};
template<typename _From, typename _To>
struct __is_static_castable_impl
: public __do_is_static_castable_impl
{
typedef decltype(__test<_From, _To>(0)) type;
};
template<typename _From, typename _To>
struct __is_static_castable_safe
: public __is_static_castable_impl<_From, _To>::type
{ };
template<typename _From, typename _To>
struct __is_static_castable
: public integral_constant<bool, (__is_static_castable_safe<
_From, _To>::value)>
{ };
struct __do_is_direct_constructible_impl
{
template<typename _Tp, typename _Arg, typename
= decltype(::new _Tp(declval<_Arg>()))>
static true_type __test(int);
template<typename, typename>
static false_type __test(...);
};
template<typename _Tp, typename _Arg>
struct __is_direct_constructible_impl
: public __do_is_direct_constructible_impl
{
typedef decltype(__test<_Tp, _Arg>(0)) type;
};
template<typename _Tp, typename _Arg>
struct __is_direct_constructible_new_safe
: public __and_<is_destructible<_Tp>,
__is_direct_constructible_impl<_Tp, _Arg>>
{ };
template<typename, typename>
struct is_same;
template<typename, typename>
struct is_base_of;
template<typename>
struct remove_reference;
template<typename _From, typename _To, bool
= __not_<__or_<is_void<_From>,
is_function<_From>>>::value>
struct __is_base_to_derived_ref;
template<typename _From, typename _To>
struct __is_base_to_derived_ref<_From, _To, true>
{
typedef typename remove_cv<typename remove_reference<_From
>::type>::type __src_t;
typedef typename remove_cv<typename remove_reference<_To
>::type>::type __dst_t;
typedef __and_<__not_<is_same<__src_t, __dst_t>>,
is_base_of<__src_t, __dst_t>> type;
static constexpr bool value = type::value;
};
template<typename _From, typename _To>
struct __is_base_to_derived_ref<_From, _To, false>
: public false_type
{ };
template<typename _From, typename _To, bool
= __and_<is_lvalue_reference<_From>,
is_rvalue_reference<_To>>::value>
struct __is_lvalue_to_rvalue_ref;
template<typename _From, typename _To>
struct __is_lvalue_to_rvalue_ref<_From, _To, true>
{
typedef typename remove_cv<typename remove_reference<
_From>::type>::type __src_t;
typedef typename remove_cv<typename remove_reference<
_To>::type>::type __dst_t;
typedef __and_<__not_<is_function<__src_t>>,
__or_<is_same<__src_t, __dst_t>,
is_base_of<__dst_t, __src_t>>> type;
static constexpr bool value = type::value;
};
template<typename _From, typename _To>
struct __is_lvalue_to_rvalue_ref<_From, _To, false>
: public false_type
{ };
template<typename _Tp, typename _Arg>
struct __is_direct_constructible_ref_cast
: public __and_<__is_static_castable<_Arg, _Tp>,
__not_<__or_<__is_base_to_derived_ref<_Arg, _Tp>,
__is_lvalue_to_rvalue_ref<_Arg, _Tp>
>>>
{ };
template<typename _Tp, typename _Arg>
struct __is_direct_constructible_new
: public conditional<is_reference<_Tp>::value,
__is_direct_constructible_ref_cast<_Tp, _Arg>,
__is_direct_constructible_new_safe<_Tp, _Arg>
>::type
{ };
template<typename _Tp, typename _Arg>
struct __is_direct_constructible
: public __is_direct_constructible_new<_Tp, _Arg>::type
{ };
struct __do_is_nary_constructible_impl
{
template<typename _Tp, typename... _Args, typename
= decltype(_Tp(declval<_Args>()...))>
static true_type __test(int);
template<typename, typename...>
static false_type __test(...);
};
template<typename _Tp, typename... _Args>
struct __is_nary_constructible_impl
: public __do_is_nary_constructible_impl
{
typedef decltype(__test<_Tp, _Args...>(0)) type;
};
template<typename _Tp, typename... _Args>
struct __is_nary_constructible
: public __is_nary_constructible_impl<_Tp, _Args...>::type
{
static_assert(sizeof...(_Args) > 1,
"Only useful for > 1 arguments");
};
template<typename _Tp, typename... _Args>
struct __is_constructible_impl
: public __is_nary_constructible<_Tp, _Args...>
{ };
template<typename _Tp, typename _Arg>
struct __is_constructible_impl<_Tp, _Arg>
: public __is_direct_constructible<_Tp, _Arg>
{ };
template<typename _Tp>
struct __is_constructible_impl<_Tp>
: public is_default_constructible<_Tp>
{ };
template<typename _Tp, typename... _Args>
struct is_constructible
: public __is_constructible_impl<_Tp, _Args...>::type
{ };
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_copy_constructible_impl;
template<typename _Tp>
struct __is_copy_constructible_impl<_Tp, false>
: public false_type { };
template<typename _Tp>
struct __is_copy_constructible_impl<_Tp, true>
: public is_constructible<_Tp, const _Tp&>
{ };
template<typename _Tp>
struct is_copy_constructible
: public __is_copy_constructible_impl<_Tp>
{ };
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_move_constructible_impl;
template<typename _Tp>
struct __is_move_constructible_impl<_Tp, false>
: public false_type { };
template<typename _Tp>
struct __is_move_constructible_impl<_Tp, true>
: public is_constructible<_Tp, _Tp&&>
{ };
template<typename _Tp>
struct is_move_constructible
: public __is_move_constructible_impl<_Tp>
{ };
template<typename _Tp>
struct __is_nt_default_constructible_atom
: public integral_constant<bool, noexcept(_Tp())>
{ };
template<typename _Tp, bool = is_array<_Tp>::value>
struct __is_nt_default_constructible_impl;
template<typename _Tp>
struct __is_nt_default_constructible_impl<_Tp, true>
: public __and_<__is_array_known_bounds<_Tp>,
__is_nt_default_constructible_atom<typename
remove_all_extents<_Tp>::type>>
{ };
template<typename _Tp>
struct __is_nt_default_constructible_impl<_Tp, false>
: public __is_nt_default_constructible_atom<_Tp>
{ };
template<typename _Tp>
struct is_nothrow_default_constructible
: public __and_<is_default_constructible<_Tp>,
__is_nt_default_constructible_impl<_Tp>>
{ };
template<typename _Tp, typename... _Args>
struct __is_nt_constructible_impl
: public integral_constant<bool, noexcept(_Tp(declval<_Args>()...))>
{ };
template<typename _Tp, typename _Arg>
struct __is_nt_constructible_impl<_Tp, _Arg>
: public integral_constant<bool,
noexcept(static_cast<_Tp>(declval<_Arg>()))>
{ };
template<typename _Tp>
struct __is_nt_constructible_impl<_Tp>
: public is_nothrow_default_constructible<_Tp>
{ };
template<typename _Tp, typename... _Args>
struct is_nothrow_constructible
: public __and_<is_constructible<_Tp, _Args...>,
__is_nt_constructible_impl<_Tp, _Args...>>
{ };
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_nothrow_copy_constructible_impl;
template<typename _Tp>
struct __is_nothrow_copy_constructible_impl<_Tp, false>
: public false_type { };
template<typename _Tp>
struct __is_nothrow_copy_constructible_impl<_Tp, true>
: public is_nothrow_constructible<_Tp, const _Tp&>
{ };
template<typename _Tp>
struct is_nothrow_copy_constructible
: public __is_nothrow_copy_constructible_impl<_Tp>
{ };
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_nothrow_move_constructible_impl;
template<typename _Tp>
struct __is_nothrow_move_constructible_impl<_Tp, false>
: public false_type { };
template<typename _Tp>
struct __is_nothrow_move_constructible_impl<_Tp, true>
: public is_nothrow_constructible<_Tp, _Tp&&>
{ };
template<typename _Tp>
struct is_nothrow_move_constructible
: public __is_nothrow_move_constructible_impl<_Tp>
{ };
template<typename _Tp, typename _Up>
class __is_assignable_helper
{
template<typename _Tp1, typename _Up1,
typename = decltype(declval<_Tp1>() = declval<_Up1>())>
static true_type
__test(int);
template<typename, typename>
static false_type
__test(...);
public:
typedef decltype(__test<_Tp, _Up>(0)) type;
};
template<typename _Tp, typename _Up>
struct is_assignable
: public __is_assignable_helper<_Tp, _Up>::type
{ };
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_copy_assignable_impl;
template<typename _Tp>
struct __is_copy_assignable_impl<_Tp, false>
: public false_type { };
template<typename _Tp>
struct __is_copy_assignable_impl<_Tp, true>
: public is_assignable<_Tp&, const _Tp&>
{ };
template<typename _Tp>
struct is_copy_assignable
: public __is_copy_assignable_impl<_Tp>
{ };
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_move_assignable_impl;
template<typename _Tp>
struct __is_move_assignable_impl<_Tp, false>
: public false_type { };
template<typename _Tp>
struct __is_move_assignable_impl<_Tp, true>
: public is_assignable<_Tp&, _Tp&&>
{ };
template<typename _Tp>
struct is_move_assignable
: public __is_move_assignable_impl<_Tp>
{ };
template<typename _Tp, typename _Up>
struct __is_nt_assignable_impl
: public integral_constant<bool, noexcept(declval<_Tp>() = declval<_Up>())>
{ };
template<typename _Tp, typename _Up>
struct is_nothrow_assignable
: public __and_<is_assignable<_Tp, _Up>,
__is_nt_assignable_impl<_Tp, _Up>>
{ };
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_nt_copy_assignable_impl;
template<typename _Tp>
struct __is_nt_copy_assignable_impl<_Tp, false>
: public false_type { };
template<typename _Tp>
struct __is_nt_copy_assignable_impl<_Tp, true>
: public is_nothrow_assignable<_Tp&, const _Tp&>
{ };
template<typename _Tp>
struct is_nothrow_copy_assignable
: public __is_nt_copy_assignable_impl<_Tp>
{ };
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_nt_move_assignable_impl;
template<typename _Tp>
struct __is_nt_move_assignable_impl<_Tp, false>
: public false_type { };
template<typename _Tp>
struct __is_nt_move_assignable_impl<_Tp, true>
: public is_nothrow_assignable<_Tp&, _Tp&&>
{ };
template<typename _Tp>
struct is_nothrow_move_assignable
: public __is_nt_move_assignable_impl<_Tp>
{ };
template<typename _Tp, typename... _Args>
struct is_trivially_constructible
: public __and_<is_constructible<_Tp, _Args...>, integral_constant<bool,
__is_trivially_constructible(_Tp, _Args...)>>
{ };
template<typename _Tp>
struct is_trivially_default_constructible
: public is_trivially_constructible<_Tp>::type
{ };
struct __do_is_implicitly_default_constructible_impl
{
template <typename _Tp>
static void __helper(const _Tp&);
template <typename _Tp>
static true_type __test(const _Tp&,
decltype(__helper<const _Tp&>({}))* = 0);
static false_type __test(...);
};
template<typename _Tp>
struct __is_implicitly_default_constructible_impl
: public __do_is_implicitly_default_constructible_impl
{
typedef decltype(__test(declval<_Tp>())) type;
};
template<typename _Tp>
struct __is_implicitly_default_constructible_safe
: public __is_implicitly_default_constructible_impl<_Tp>::type
{ };
template <typename _Tp>
struct __is_implicitly_default_constructible
: public __and_<is_default_constructible<_Tp>,
__is_implicitly_default_constructible_safe<_Tp>>
{ };
template<typename _Tp>
struct is_trivially_copy_constructible
: public __and_<is_copy_constructible<_Tp>,
integral_constant<bool,
__is_trivially_constructible(_Tp, const _Tp&)>>
{ };
template<typename _Tp>
struct is_trivially_move_constructible
: public __and_<is_move_constructible<_Tp>,
integral_constant<bool,
__is_trivially_constructible(_Tp, _Tp&&)>>
{ };
template<typename _Tp, typename _Up>
struct is_trivially_assignable
: public __and_<is_assignable<_Tp, _Up>,
integral_constant<bool,
__is_trivially_assignable(_Tp, _Up)>>
{ };
template<typename _Tp>
struct is_trivially_copy_assignable
: public __and_<is_copy_assignable<_Tp>,
integral_constant<bool,
__is_trivially_assignable(_Tp&, const _Tp&)>>
{ };
template<typename _Tp>
struct is_trivially_move_assignable
: public __and_<is_move_assignable<_Tp>,
integral_constant<bool,
__is_trivially_assignable(_Tp&, _Tp&&)>>
{ };
template<typename _Tp>
struct is_trivially_destructible
: public __and_<is_destructible<_Tp>, integral_constant<bool,
__has_trivial_destructor(_Tp)>>
{ };
template<typename _Tp>
struct has_trivial_default_constructor
: public integral_constant<bool, __has_trivial_constructor(_Tp)>
{ } __attribute__ ((__deprecated__));
template<typename _Tp>
struct has_trivial_copy_constructor
: public integral_constant<bool, __has_trivial_copy(_Tp)>
{ } __attribute__ ((__deprecated__));
template<typename _Tp>
struct has_trivial_copy_assign
: public integral_constant<bool, __has_trivial_assign(_Tp)>
{ } __attribute__ ((__deprecated__));
template<typename _Tp>
struct has_virtual_destructor
: public integral_constant<bool, __has_virtual_destructor(_Tp)>
{ };
template<typename _Tp>
struct alignment_of
: public integral_constant<std::size_t, __alignof__(_Tp)> { };
template<typename>
struct rank
: public integral_constant<std::size_t, 0> { };
template<typename _Tp, std::size_t _Size>
struct rank<_Tp[_Size]>
: public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
template<typename _Tp>
struct rank<_Tp[]>
: public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
template<typename, unsigned _Uint>
struct extent
: public integral_constant<std::size_t, 0> { };
template<typename _Tp, unsigned _Uint, std::size_t _Size>
struct extent<_Tp[_Size], _Uint>
: public integral_constant<std::size_t,
_Uint == 0 ? _Size : extent<_Tp,
_Uint - 1>::value>
{ };
template<typename _Tp, unsigned _Uint>
struct extent<_Tp[], _Uint>
: public integral_constant<std::size_t,
_Uint == 0 ? 0 : extent<_Tp,
_Uint - 1>::value>
{ };
template<typename, typename>
struct is_same
: public false_type { };
template<typename _Tp>
struct is_same<_Tp, _Tp>
: public true_type { };
template<typename _Base, typename _Derived>
struct is_base_of
: public integral_constant<bool, __is_base_of(_Base, _Derived)>
{ };
template<typename _From, typename _To,
bool = __or_<is_void<_From>, is_function<_To>,
is_array<_To>>::value>
struct __is_convertible_helper
{ typedef typename is_void<_To>::type type; };
template<typename _From, typename _To>
class __is_convertible_helper<_From, _To, false>
{
template<typename _To1>
static void __test_aux(_To1);
template<typename _From1, typename _To1,
typename = decltype(__test_aux<_To1>(std::declval<_From1>()))>
static true_type
__test(int);
template<typename, typename>
static false_type
__test(...);
public:
typedef decltype(__test<_From, _To>(0)) type;
};
template<typename _From, typename _To>
struct is_convertible
: public __is_convertible_helper<_From, _To>::type
{ };
template<typename _Tp>
struct remove_const
{ typedef _Tp type; };
template<typename _Tp>
struct remove_const<_Tp const>
{ typedef _Tp type; };
template<typename _Tp>
struct remove_volatile
{ typedef _Tp type; };
template<typename _Tp>
struct remove_volatile<_Tp volatile>
{ typedef _Tp type; };
template<typename _Tp>
struct remove_cv
{
typedef typename
remove_const<typename remove_volatile<_Tp>::type>::type type;
};
template<typename _Tp>
struct add_const
{ typedef _Tp const type; };
template<typename _Tp>
struct add_volatile
{ typedef _Tp volatile type; };
template<typename _Tp>
struct add_cv
{
typedef typename
add_const<typename add_volatile<_Tp>::type>::type type;
};
template<typename _Tp>
using remove_const_t = typename remove_const<_Tp>::type;
template<typename _Tp>
using remove_volatile_t = typename remove_volatile<_Tp>::type;
template<typename _Tp>
using remove_cv_t = typename remove_cv<_Tp>::type;
template<typename _Tp>
using add_const_t = typename add_const<_Tp>::type;
template<typename _Tp>
using add_volatile_t = typename add_volatile<_Tp>::type;
template<typename _Tp>
using add_cv_t = typename add_cv<_Tp>::type;
template<typename _Tp>
struct remove_reference
{ typedef _Tp type; };
template<typename _Tp>
struct remove_reference<_Tp&>
{ typedef _Tp type; };
template<typename _Tp>
struct remove_reference<_Tp&&>
{ typedef _Tp type; };
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __add_lvalue_reference_helper
{ typedef _Tp type; };
template<typename _Tp>
struct __add_lvalue_reference_helper<_Tp, true>
{ typedef _Tp& type; };
template<typename _Tp>
struct add_lvalue_reference
: public __add_lvalue_reference_helper<_Tp>
{ };
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __add_rvalue_reference_helper
{ typedef _Tp type; };
template<typename _Tp>
struct __add_rvalue_reference_helper<_Tp, true>
{ typedef _Tp&& type; };
template<typename _Tp>
struct add_rvalue_reference
: public __add_rvalue_reference_helper<_Tp>
{ };
template<typename _Tp>
using remove_reference_t = typename remove_reference<_Tp>::type;
template<typename _Tp>
using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type;
template<typename _Tp>
using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type;
template<typename _Unqualified, bool _IsConst, bool _IsVol>
struct __cv_selector;
template<typename _Unqualified>
struct __cv_selector<_Unqualified, false, false>
{ typedef _Unqualified __type; };
template<typename _Unqualified>
struct __cv_selector<_Unqualified, false, true>
{ typedef volatile _Unqualified __type; };
template<typename _Unqualified>
struct __cv_selector<_Unqualified, true, false>
{ typedef const _Unqualified __type; };
template<typename _Unqualified>
struct __cv_selector<_Unqualified, true, true>
{ typedef const volatile _Unqualified __type; };
template<typename _Qualified, typename _Unqualified,
bool _IsConst = is_const<_Qualified>::value,
bool _IsVol = is_volatile<_Qualified>::value>
class __match_cv_qualifiers
{
typedef __cv_selector<_Unqualified, _IsConst, _IsVol> __match;
public:
typedef typename __match::__type __type;
};
template<typename _Tp>
struct __make_unsigned
{ typedef _Tp __type; };
template<>
struct __make_unsigned<char>
{ typedef unsigned char __type; };
template<>
struct __make_unsigned<signed char>
{ typedef unsigned char __type; };
template<>
struct __make_unsigned<short>
{ typedef unsigned short __type; };
template<>
struct __make_unsigned<int>
{ typedef unsigned int __type; };
template<>
struct __make_unsigned<long>
{ typedef unsigned long __type; };
template<>
struct __make_unsigned<long long>
{ typedef unsigned long long __type; };
template<>
struct __make_unsigned<wchar_t> : __make_unsigned<int>
{ };
template<>
struct __make_unsigned<__int128>
{ typedef unsigned __int128 __type; };
# 1774 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/type_traits" 3
template<typename _Tp,
bool _IsInt = is_integral<_Tp>::value,
bool _IsEnum = is_enum<_Tp>::value>
class __make_unsigned_selector;
template<typename _Tp>
class __make_unsigned_selector<_Tp, true, false>
{
typedef __make_unsigned<typename remove_cv<_Tp>::type> __unsignedt;
typedef typename __unsignedt::__type __unsigned_type;
typedef __match_cv_qualifiers<_Tp, __unsigned_type> __cv_unsigned;
public:
typedef typename __cv_unsigned::__type __type;
};
template<typename _Tp>
class __make_unsigned_selector<_Tp, false, true>
{
typedef unsigned char __smallest;
static const bool __b0 = sizeof(_Tp) <= sizeof(__smallest);
static const bool __b1 = sizeof(_Tp) <= sizeof(unsigned short);
static const bool __b2 = sizeof(_Tp) <= sizeof(unsigned int);
static const bool __b3 = sizeof(_Tp) <= sizeof(unsigned long);
typedef conditional<__b3, unsigned long, unsigned long long> __cond3;
typedef typename __cond3::type __cond3_type;
typedef conditional<__b2, unsigned int, __cond3_type> __cond2;
typedef typename __cond2::type __cond2_type;
typedef conditional<__b1, unsigned short, __cond2_type> __cond1;
typedef typename __cond1::type __cond1_type;
typedef typename conditional<__b0, __smallest, __cond1_type>::type
__unsigned_type;
typedef __match_cv_qualifiers<_Tp, __unsigned_type> __cv_unsigned;
public:
typedef typename __cv_unsigned::__type __type;
};
template<typename _Tp>
struct make_unsigned
{ typedef typename __make_unsigned_selector<_Tp>::__type type; };
template<>
struct make_unsigned<bool>;
template<typename _Tp>
struct __make_signed
{ typedef _Tp __type; };
template<>
struct __make_signed<char>
{ typedef signed char __type; };
template<>
struct __make_signed<unsigned char>
{ typedef signed char __type; };
template<>
struct __make_signed<unsigned short>
{ typedef signed short __type; };
template<>
struct __make_signed<unsigned int>
{ typedef signed int __type; };
template<>
struct __make_signed<unsigned long>
{ typedef signed long __type; };
template<>
struct __make_signed<unsigned long long>
{ typedef signed long long __type; };
# 1863 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/type_traits" 3
template<>
struct __make_signed<char16_t> : __make_signed<uint_least16_t>
{ };
template<>
struct __make_signed<char32_t> : __make_signed<uint_least32_t>
{ };
template<>
struct __make_signed<unsigned __int128>
{ typedef __int128 __type; };
# 1893 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/type_traits" 3
template<typename _Tp,
bool _IsInt = is_integral<_Tp>::value,
bool _IsEnum = is_enum<_Tp>::value>
class __make_signed_selector;
template<typename _Tp>
class __make_signed_selector<_Tp, true, false>
{
typedef __make_signed<typename remove_cv<_Tp>::type> __signedt;
typedef typename __signedt::__type __signed_type;
typedef __match_cv_qualifiers<_Tp, __signed_type> __cv_signed;
public:
typedef typename __cv_signed::__type __type;
};
template<typename _Tp>
class __make_signed_selector<_Tp, false, true>
{
typedef typename __make_unsigned_selector<_Tp>::__type __unsigned_type;
public:
typedef typename __make_signed_selector<__unsigned_type>::__type __type;
};
template<typename _Tp>
struct make_signed
{ typedef typename __make_signed_selector<_Tp>::__type type; };
template<>
struct make_signed<bool>;
template<typename _Tp>
using make_signed_t = typename make_signed<_Tp>::type;
template<typename _Tp>
using make_unsigned_t = typename make_unsigned<_Tp>::type;
template<typename _Tp>
struct remove_extent
{ typedef _Tp type; };
template<typename _Tp, std::size_t _Size>
struct remove_extent<_Tp[_Size]>
{ typedef _Tp type; };
template<typename _Tp>
struct remove_extent<_Tp[]>
{ typedef _Tp type; };
template<typename _Tp>
struct remove_all_extents
{ typedef _Tp type; };
template<typename _Tp, std::size_t _Size>
struct remove_all_extents<_Tp[_Size]>
{ typedef typename remove_all_extents<_Tp>::type type; };
template<typename _Tp>
struct remove_all_extents<_Tp[]>
{ typedef typename remove_all_extents<_Tp>::type type; };
template<typename _Tp>
using remove_extent_t = typename remove_extent<_Tp>::type;
template<typename _Tp>
using remove_all_extents_t = typename remove_all_extents<_Tp>::type;
template<typename _Tp, typename>
struct __remove_pointer_helper
{ typedef _Tp type; };
template<typename _Tp, typename _Up>
struct __remove_pointer_helper<_Tp, _Up*>
{ typedef _Up type; };
template<typename _Tp>
struct remove_pointer
: public __remove_pointer_helper<_Tp, typename remove_cv<_Tp>::type>
{ };
template<typename _Tp, bool = __or_<__is_referenceable<_Tp>,
is_void<_Tp>>::value>
struct __add_pointer_helper
{ typedef _Tp type; };
template<typename _Tp>
struct __add_pointer_helper<_Tp, true>
{ typedef typename remove_reference<_Tp>::type* type; };
template<typename _Tp>
struct add_pointer
: public __add_pointer_helper<_Tp>
{ };
template<typename _Tp>
using remove_pointer_t = typename remove_pointer<_Tp>::type;
template<typename _Tp>
using add_pointer_t = typename add_pointer<_Tp>::type;
template<std::size_t _Len>
struct __aligned_storage_msa
{
union __type
{
unsigned char __data[_Len];
struct __attribute__((__aligned__)) { } __align;
};
};
# 2039 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/type_traits" 3
template<std::size_t _Len, std::size_t _Align =
__alignof__(typename __aligned_storage_msa<_Len>::__type)>
struct aligned_storage
{
union type
{
unsigned char __data[_Len];
struct __attribute__((__aligned__((_Align)))) { } __align;
};
};
template <typename... _Types>
struct __strictest_alignment
{
static const size_t _S_alignment = 0;
static const size_t _S_size = 0;
};
template <typename _Tp, typename... _Types>
struct __strictest_alignment<_Tp, _Types...>
{
static const size_t _S_alignment =
alignof(_Tp) > __strictest_alignment<_Types...>::_S_alignment
? alignof(_Tp) : __strictest_alignment<_Types...>::_S_alignment;
static const size_t _S_size =
sizeof(_Tp) > __strictest_alignment<_Types...>::_S_size
? sizeof(_Tp) : __strictest_alignment<_Types...>::_S_size;
};
# 2078 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/type_traits" 3
template <size_t _Len, typename... _Types>
struct aligned_union
{
private:
static_assert(sizeof...(_Types) != 0, "At least one type is required");
using __strictest = __strictest_alignment<_Types...>;
static const size_t _S_len = _Len > __strictest::_S_size
? _Len : __strictest::_S_size;
public:
static const size_t alignment_value = __strictest::_S_alignment;
typedef typename aligned_storage<_S_len, alignment_value>::type type;
};
template <size_t _Len, typename... _Types>
const size_t aligned_union<_Len, _Types...>::alignment_value;
template<typename _Up,
bool _IsArray = is_array<_Up>::value,
bool _IsFunction = is_function<_Up>::value>
struct __decay_selector;
template<typename _Up>
struct __decay_selector<_Up, false, false>
{ typedef typename remove_cv<_Up>::type __type; };
template<typename _Up>
struct __decay_selector<_Up, true, false>
{ typedef typename remove_extent<_Up>::type* __type; };
template<typename _Up>
struct __decay_selector<_Up, false, true>
{ typedef typename add_pointer<_Up>::type __type; };
template<typename _Tp>
class decay
{
typedef typename remove_reference<_Tp>::type __remove_type;
public:
typedef typename __decay_selector<__remove_type>::__type type;
};
template<typename _Tp>
class reference_wrapper;
template<typename _Tp>
struct __strip_reference_wrapper
{
typedef _Tp __type;
};
template<typename _Tp>
struct __strip_reference_wrapper<reference_wrapper<_Tp> >
{
typedef _Tp& __type;
};
template<typename _Tp>
struct __decay_and_strip
{
typedef typename __strip_reference_wrapper<
typename decay<_Tp>::type>::__type __type;
};
template<bool, typename _Tp = void>
struct enable_if
{ };
template<typename _Tp>
struct enable_if<true, _Tp>
{ typedef _Tp type; };
template<typename... _Cond>
using _Require = typename enable_if<__and_<_Cond...>::value>::type;
template<bool _Cond, typename _Iftrue, typename _Iffalse>
struct conditional
{ typedef _Iftrue type; };
template<typename _Iftrue, typename _Iffalse>
struct conditional<false, _Iftrue, _Iffalse>
{ typedef _Iffalse type; };
template<typename... _Tp>
struct common_type;
struct __do_common_type_impl
{
template<typename _Tp, typename _Up>
static __success_type<typename decay<decltype
(true ? std::declval<_Tp>()
: std::declval<_Up>())>::type> _S_test(int);
template<typename, typename>
static __failure_type _S_test(...);
};
template<typename _Tp, typename _Up>
struct __common_type_impl
: private __do_common_type_impl
{
typedef decltype(_S_test<_Tp, _Up>(0)) type;
};
struct __do_member_type_wrapper
{
template<typename _Tp>
static __success_type<typename _Tp::type> _S_test(int);
template<typename>
static __failure_type _S_test(...);
};
template<typename _Tp>
struct __member_type_wrapper
: private __do_member_type_wrapper
{
typedef decltype(_S_test<_Tp>(0)) type;
};
template<typename _CTp, typename... _Args>
struct __expanded_common_type_wrapper
{
typedef common_type<typename _CTp::type, _Args...> type;
};
template<typename... _Args>
struct __expanded_common_type_wrapper<__failure_type, _Args...>
{ typedef __failure_type type; };
template<typename _Tp>
struct common_type<_Tp>
{ typedef typename decay<_Tp>::type type; };
template<typename _Tp, typename _Up>
struct common_type<_Tp, _Up>
: public __common_type_impl<_Tp, _Up>::type
{ };
template<typename _Tp, typename _Up, typename... _Vp>
struct common_type<_Tp, _Up, _Vp...>
: public __expanded_common_type_wrapper<typename __member_type_wrapper<
common_type<_Tp, _Up>>::type, _Vp...>::type
{ };
template<typename _Tp>
struct underlying_type
{
typedef __underlying_type(_Tp) type;
};
template<typename _Tp>
struct __declval_protector
{
static const bool __stop = false;
static typename add_rvalue_reference<_Tp>::type __delegate();
};
template<typename _Tp>
inline typename add_rvalue_reference<_Tp>::type
declval() noexcept
{
static_assert(__declval_protector<_Tp>::__stop,
"declval() must not be used!");
return __declval_protector<_Tp>::__delegate();
}
template<typename _Signature>
class result_of;
struct __invoke_memfun_ref { };
struct __invoke_memfun_deref { };
struct __invoke_memobj_ref { };
struct __invoke_memobj_deref { };
struct __invoke_other { };
template<typename _Tp, typename _Tag>
struct __result_of_success : __success_type<_Tp>
{ using __invoke_type = _Tag; };
struct __result_of_memfun_ref_impl
{
template<typename _Fp, typename _Tp1, typename... _Args>
static __result_of_success<decltype(
(std::declval<_Tp1>().*std::declval<_Fp>())(std::declval<_Args>()...)
), __invoke_memfun_ref> _S_test(int);
template<typename...>
static __failure_type _S_test(...);
};
template<typename _MemPtr, typename _Arg, typename... _Args>
struct __result_of_memfun_ref
: private __result_of_memfun_ref_impl
{
typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
};
struct __result_of_memfun_deref_impl
{
template<typename _Fp, typename _Tp1, typename... _Args>
static __result_of_success<decltype(
((*std::declval<_Tp1>()).*std::declval<_Fp>())(std::declval<_Args>()...)
), __invoke_memfun_deref> _S_test(int);
template<typename...>
static __failure_type _S_test(...);
};
template<typename _MemPtr, typename _Arg, typename... _Args>
struct __result_of_memfun_deref
: private __result_of_memfun_deref_impl
{
typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
};
struct __result_of_memobj_ref_impl
{
template<typename _Fp, typename _Tp1>
static __result_of_success<decltype(
std::declval<_Tp1>().*std::declval<_Fp>()
), __invoke_memobj_ref> _S_test(int);
template<typename, typename>
static __failure_type _S_test(...);
};
template<typename _MemPtr, typename _Arg>
struct __result_of_memobj_ref
: private __result_of_memobj_ref_impl
{
typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
};
struct __result_of_memobj_deref_impl
{
template<typename _Fp, typename _Tp1>
static __result_of_success<decltype(
(*std::declval<_Tp1>()).*std::declval<_Fp>()
), __invoke_memobj_deref> _S_test(int);
template<typename, typename>
static __failure_type _S_test(...);
};
template<typename _MemPtr, typename _Arg>
struct __result_of_memobj_deref
: private __result_of_memobj_deref_impl
{
typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
};
template<typename _MemPtr, typename _Arg>
struct __result_of_memobj;
template<typename _Res, typename _Class, typename _Arg>
struct __result_of_memobj<_Res _Class::*, _Arg>
{
typedef typename remove_cv<typename remove_reference<
_Arg>::type>::type _Argval;
typedef _Res _Class::* _MemPtr;
typedef typename conditional<__or_<is_same<_Argval, _Class>,
is_base_of<_Class, _Argval>>::value,
__result_of_memobj_ref<_MemPtr, _Arg>,
__result_of_memobj_deref<_MemPtr, _Arg>
>::type::type type;
};
template<typename _MemPtr, typename _Arg, typename... _Args>
struct __result_of_memfun;
template<typename _Res, typename _Class, typename _Arg, typename... _Args>
struct __result_of_memfun<_Res _Class::*, _Arg, _Args...>
{
typedef typename remove_cv<typename remove_reference<
_Arg>::type>::type _Argval;
typedef _Res _Class::* _MemPtr;
typedef typename conditional<__or_<is_same<_Argval, _Class>,
is_base_of<_Class, _Argval>>::value,
__result_of_memfun_ref<_MemPtr, _Arg, _Args...>,
__result_of_memfun_deref<_MemPtr, _Arg, _Args...>
>::type::type type;
};
template<typename _Res, typename _Class, typename _Arg>
struct __result_of_memobj<_Res _Class::*, reference_wrapper<_Arg>>
: __result_of_memobj_ref<_Res _Class::*, _Arg&>
{ };
template<typename _Res, typename _Class, typename _Arg>
struct __result_of_memobj<_Res _Class::*, reference_wrapper<_Arg>&>
: __result_of_memobj_ref<_Res _Class::*, _Arg&>
{ };
template<typename _Res, typename _Class, typename _Arg>
struct __result_of_memobj<_Res _Class::*, const reference_wrapper<_Arg>&>
: __result_of_memobj_ref<_Res _Class::*, _Arg&>
{ };
template<typename _Res, typename _Class, typename _Arg>
struct __result_of_memobj<_Res _Class::*, reference_wrapper<_Arg>&&>
: __result_of_memobj_ref<_Res _Class::*, _Arg&>
{ };
template<typename _Res, typename _Class, typename _Arg>
struct __result_of_memobj<_Res _Class::*, const reference_wrapper<_Arg>&&>
: __result_of_memobj_ref<_Res _Class::*, _Arg&>
{ };
template<typename _Res, typename _Class, typename _Arg, typename... _Args>
struct __result_of_memfun<_Res _Class::*, reference_wrapper<_Arg>, _Args...>
: __result_of_memfun_ref<_Res _Class::*, _Arg&, _Args...>
{ };
template<typename _Res, typename _Class, typename _Arg, typename... _Args>
struct __result_of_memfun<_Res _Class::*, reference_wrapper<_Arg>&,
_Args...>
: __result_of_memfun_ref<_Res _Class::*, _Arg&, _Args...>
{ };
template<typename _Res, typename _Class, typename _Arg, typename... _Args>
struct __result_of_memfun<_Res _Class::*, const reference_wrapper<_Arg>&,
_Args...>
: __result_of_memfun_ref<_Res _Class::*, _Arg&, _Args...>
{ };
template<typename _Res, typename _Class, typename _Arg, typename... _Args>
struct __result_of_memfun<_Res _Class::*, reference_wrapper<_Arg>&&,
_Args...>
: __result_of_memfun_ref<_Res _Class::*, _Arg&, _Args...>
{ };
template<typename _Res, typename _Class, typename _Arg, typename... _Args>
struct __result_of_memfun<_Res _Class::*, const reference_wrapper<_Arg>&&,
_Args...>
: __result_of_memfun_ref<_Res _Class::*, _Arg&, _Args...>
{ };
template<bool, bool, typename _Functor, typename... _ArgTypes>
struct __result_of_impl
{
typedef __failure_type type;
};
template<typename _MemPtr, typename _Arg>
struct __result_of_impl<true, false, _MemPtr, _Arg>
: public __result_of_memobj<typename decay<_MemPtr>::type, _Arg>
{ };
template<typename _MemPtr, typename _Arg, typename... _Args>
struct __result_of_impl<false, true, _MemPtr, _Arg, _Args...>
: public __result_of_memfun<typename decay<_MemPtr>::type, _Arg, _Args...>
{ };
struct __result_of_other_impl
{
template<typename _Fn, typename... _Args>
static __result_of_success<decltype(
std::declval<_Fn>()(std::declval<_Args>()...)
), __invoke_other> _S_test(int);
template<typename...>
static __failure_type _S_test(...);
};
template<typename _Functor, typename... _ArgTypes>
struct __result_of_impl<false, false, _Functor, _ArgTypes...>
: private __result_of_other_impl
{
typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type;
};
template<typename _Functor, typename... _ArgTypes>
struct result_of<_Functor(_ArgTypes...)>
: public __result_of_impl<
is_member_object_pointer<
typename remove_reference<_Functor>::type
>::value,
is_member_function_pointer<
typename remove_reference<_Functor>::type
>::value,
_Functor, _ArgTypes...
>::type
{ };
template<size_t _Len, size_t _Align =
__alignof__(typename __aligned_storage_msa<_Len>::__type)>
using aligned_storage_t = typename aligned_storage<_Len, _Align>::type;
template <size_t _Len, typename... _Types>
using aligned_union_t = typename aligned_union<_Len, _Types...>::type;
template<typename _Tp>
using decay_t = typename decay<_Tp>::type;
template<bool _Cond, typename _Tp = void>
using enable_if_t = typename enable_if<_Cond, _Tp>::type;
template<bool _Cond, typename _Iftrue, typename _Iffalse>
using conditional_t = typename conditional<_Cond, _Iftrue, _Iffalse>::type;
template<typename... _Tp>
using common_type_t = typename common_type<_Tp...>::type;
template<typename _Tp>
using underlying_type_t = typename underlying_type<_Tp>::type;
template<typename _Tp>
using result_of_t = typename result_of<_Tp>::type;
template<typename...> using __void_t = void;
template<typename...> using void_t = void;
template<typename _Default, typename _AlwaysVoid,
template<typename...> class _Op, typename... _Args>
struct __detector
{
using value_t = false_type;
using type = _Default;
};
template<typename _Default, template<typename...> class _Op,
typename... _Args>
struct __detector<_Default, __void_t<_Op<_Args...>>, _Op, _Args...>
{
using value_t = true_type;
using type = _Op<_Args...>;
};
template<typename _Default, template<typename...> class _Op,
typename... _Args>
using __detected_or = __detector<_Default, void, _Op, _Args...>;
template<typename _Default, template<typename...> class _Op,
typename... _Args>
using __detected_or_t
= typename __detected_or<_Default, _Op, _Args...>::type;
template<template<typename...> class _Default,
template<typename...> class _Op, typename... _Args>
using __detected_or_t_ =
__detected_or_t<_Default<_Args...>, _Op, _Args...>;
# 2590 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/type_traits" 3
template <typename _Tp>
struct __is_swappable;
template <typename _Tp>
struct __is_nothrow_swappable;
template<typename _Tp>
inline
typename enable_if<__and_<is_move_constructible<_Tp>,
is_move_assignable<_Tp>>::value>::type
swap(_Tp&, _Tp&)
noexcept(__and_<is_nothrow_move_constructible<_Tp>,
is_nothrow_move_assignable<_Tp>>::value);
template<typename _Tp, size_t _Nm>
inline
typename enable_if<__is_swappable<_Tp>::value>::type
swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
noexcept(__is_nothrow_swappable<_Tp>::value);
namespace __swappable_details {
using std::swap;
struct __do_is_swappable_impl
{
template<typename _Tp, typename
= decltype(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))>
static true_type __test(int);
template<typename>
static false_type __test(...);
};
struct __do_is_nothrow_swappable_impl
{
template<typename _Tp>
static __bool_constant<
noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))
> __test(int);
template<typename>
static false_type __test(...);
};
}
template<typename _Tp>
struct __is_swappable_impl
: public __swappable_details::__do_is_swappable_impl
{
typedef decltype(__test<_Tp>(0)) type;
};
template<typename _Tp>
struct __is_nothrow_swappable_impl
: public __swappable_details::__do_is_nothrow_swappable_impl
{
typedef decltype(__test<_Tp>(0)) type;
};
template<typename _Tp>
struct __is_swappable
: public __is_swappable_impl<_Tp>::type
{ };
template<typename _Tp>
struct __is_nothrow_swappable
: public __is_nothrow_swappable_impl<_Tp>::type
{ };
}
# 58 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/move.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 74 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/move.h" 3
template<typename _Tp>
constexpr _Tp&&
forward(typename std::remove_reference<_Tp>::type& __t) noexcept
{ return static_cast<_Tp&&>(__t); }
template<typename _Tp>
constexpr _Tp&&
forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
{
static_assert(!std::is_lvalue_reference<_Tp>::value, "template argument"
" substituting _Tp is an lvalue reference type");
return static_cast<_Tp&&>(__t);
}
template<typename _Tp>
constexpr typename std::remove_reference<_Tp>::type&&
move(_Tp&& __t) noexcept
{ return static_cast<typename std::remove_reference<_Tp>::type&&>(__t); }
template<typename _Tp>
struct __move_if_noexcept_cond
: public __and_<__not_<is_nothrow_move_constructible<_Tp>>,
is_copy_constructible<_Tp>>::type { };
# 118 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/move.h" 3
template<typename _Tp>
constexpr typename
conditional<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&>::type
move_if_noexcept(_Tp& __x) noexcept
{ return std::move(__x); }
# 133 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/move.h" 3
template<typename _Tp>
inline _Tp*
addressof(_Tp& __r) noexcept
{ return std::__addressof(__r); }
template <typename _Tp, typename _Up = _Tp>
inline _Tp
__exchange(_Tp& __obj, _Up&& __new_val)
{
_Tp __old_val = std::move(__obj);
__obj = std::forward<_Up>(__new_val);
return __old_val;
}
}
# 159 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/move.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 174 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/move.h" 3
template<typename _Tp>
inline
typename enable_if<__and_<is_move_constructible<_Tp>,
is_move_assignable<_Tp>>::value>::type
swap(_Tp& __a, _Tp& __b)
noexcept(__and_<is_nothrow_move_constructible<_Tp>,
is_nothrow_move_assignable<_Tp>>::value)
{
_Tp __tmp = std::move(__a);
__a = std::move(__b);
__b = std::move(__tmp);
}
template<typename _Tp, size_t _Nm>
inline
typename enable_if<__is_swappable<_Tp>::value>::type
swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
noexcept(__is_nothrow_swappable<_Tp>::value)
{
for (size_t __n = 0; __n < _Nm; ++__n)
swap(__a[__n], __b[__n]);
}
}
# 41 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/nested_exception.h" 2 3
extern "C++" {
namespace std
{
class nested_exception
{
exception_ptr _M_ptr;
public:
nested_exception() noexcept : _M_ptr(current_exception()) { }
nested_exception(const nested_exception&) noexcept = default;
nested_exception& operator=(const nested_exception&) noexcept = default;
virtual ~nested_exception() noexcept;
[[noreturn]]
void
rethrow_nested() const
{
if (_M_ptr)
rethrow_exception(_M_ptr);
std::terminate();
}
exception_ptr
nested_ptr() const noexcept
{ return _M_ptr; }
};
template<typename _Except>
struct _Nested_exception : public _Except, public nested_exception
{
explicit _Nested_exception(const _Except& __ex)
: _Except(__ex)
{ }
explicit _Nested_exception(_Except&& __ex)
: _Except(static_cast<_Except&&>(__ex))
{ }
};
template<typename _Tp,
bool __with_nested = !__is_base_of(nested_exception, _Tp)>
struct _Throw_with_nested_impl
{
template<typename _Up>
static void _S_throw(_Up&& __t)
{ throw _Nested_exception<_Tp>{static_cast<_Up&&>(__t)}; }
};
template<typename _Tp>
struct _Throw_with_nested_impl<_Tp, false>
{
template<typename _Up>
static void _S_throw(_Up&& __t)
{ throw static_cast<_Up&&>(__t); }
};
template<typename _Tp, bool = __is_class(_Tp) && !__is_final(_Tp)>
struct _Throw_with_nested_helper : _Throw_with_nested_impl<_Tp>
{ };
template<typename _Tp>
struct _Throw_with_nested_helper<_Tp, false>
: _Throw_with_nested_impl<_Tp, false>
{ };
template<typename _Tp>
struct _Throw_with_nested_helper<_Tp&, false>
: _Throw_with_nested_helper<_Tp>
{ };
template<typename _Tp>
struct _Throw_with_nested_helper<_Tp&&, false>
: _Throw_with_nested_helper<_Tp>
{ };
template<typename _Tp>
[[noreturn]]
inline void
throw_with_nested(_Tp&& __t)
{
_Throw_with_nested_helper<_Tp>::_S_throw(static_cast<_Tp&&>(__t));
}
template<typename _Tp, bool = __is_polymorphic(_Tp)>
struct _Rethrow_if_nested_impl
{
static void _S_rethrow(const _Tp& __t)
{
if (auto __tp =
dynamic_cast<const nested_exception*>(std::__addressof(__t)))
__tp->rethrow_nested();
}
};
template<typename _Tp>
struct _Rethrow_if_nested_impl<_Tp, false>
{
static void _S_rethrow(const _Tp&) { }
};
template<typename _Ex>
inline void
rethrow_if_nested(const _Ex& __ex)
{
_Rethrow_if_nested_impl<_Ex>::_S_rethrow(__ex);
}
}
}
#pragma GCC visibility pop
# 172 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/exception" 2 3
# 40 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ios" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/char_traits.h" 1 3
# 37 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/char_traits.h" 3
# 38 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/char_traits.h" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 1 3
# 60 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/functexcept.h" 1 3
# 42 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/functexcept.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
void
__throw_bad_exception(void) __attribute__((__noreturn__));
void
__throw_bad_alloc(void) __attribute__((__noreturn__));
void
__throw_bad_cast(void) __attribute__((__noreturn__));
void
__throw_bad_typeid(void) __attribute__((__noreturn__));
void
__throw_logic_error(const char*) __attribute__((__noreturn__));
void
__throw_domain_error(const char*) __attribute__((__noreturn__));
void
__throw_invalid_argument(const char*) __attribute__((__noreturn__));
void
__throw_length_error(const char*) __attribute__((__noreturn__));
void
__throw_out_of_range(const char*) __attribute__((__noreturn__));
void
__throw_out_of_range_fmt(const char*, ...) __attribute__((__noreturn__))
__attribute__((__format__(__gnu_printf__, 1, 2)));
void
__throw_runtime_error(const char*) __attribute__((__noreturn__));
void
__throw_range_error(const char*) __attribute__((__noreturn__));
void
__throw_overflow_error(const char*) __attribute__((__noreturn__));
void
__throw_underflow_error(const char*) __attribute__((__noreturn__));
void
__throw_ios_failure(const char*) __attribute__((__noreturn__));
void
__throw_system_error(int) __attribute__((__noreturn__));
void
__throw_future_error(int) __attribute__((__noreturn__));
void
__throw_bad_function_call() __attribute__((__noreturn__));
}
# 61 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/cpp_type_traits.h" 1 3
# 35 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/cpp_type_traits.h" 3
# 36 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/cpp_type_traits.h" 3
# 67 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/cpp_type_traits.h" 3
extern "C++" {
namespace std __attribute__ ((__visibility__ ("default")))
{
struct __true_type { };
struct __false_type { };
template<bool>
struct __truth_type
{ typedef __false_type __type; };
template<>
struct __truth_type<true>
{ typedef __true_type __type; };
template<class _Sp, class _Tp>
struct __traitor
{
enum { __value = bool(_Sp::__value) || bool(_Tp::__value) };
typedef typename __truth_type<__value>::__type __type;
};
template<typename, typename>
struct __are_same
{
enum { __value = 0 };
typedef __false_type __type;
};
template<typename _Tp>
struct __are_same<_Tp, _Tp>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<typename _Tp>
struct __is_void
{
enum { __value = 0 };
typedef __false_type __type;
};
template<>
struct __is_void<void>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<typename _Tp>
struct __is_integer
{
enum { __value = 0 };
typedef __false_type __type;
};
template<>
struct __is_integer<bool>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<>
struct __is_integer<char>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<>
struct __is_integer<signed char>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<>
struct __is_integer<unsigned char>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<>
struct __is_integer<wchar_t>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<>
struct __is_integer<char16_t>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<>
struct __is_integer<char32_t>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<>
struct __is_integer<short>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<>
struct __is_integer<unsigned short>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<>
struct __is_integer<int>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<>
struct __is_integer<unsigned int>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<>
struct __is_integer<long>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<>
struct __is_integer<unsigned long>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<>
struct __is_integer<long long>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<>
struct __is_integer<unsigned long long>
{
enum { __value = 1 };
typedef __true_type __type;
};
# 261 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/cpp_type_traits.h" 3
template<> struct __is_integer<__int128> { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer<unsigned __int128> { enum { __value = 1 }; typedef __true_type __type; };
# 278 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/cpp_type_traits.h" 3
template<typename _Tp>
struct __is_floating
{
enum { __value = 0 };
typedef __false_type __type;
};
template<>
struct __is_floating<float>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<>
struct __is_floating<double>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<>
struct __is_floating<long double>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<typename _Tp>
struct __is_pointer
{
enum { __value = 0 };
typedef __false_type __type;
};
template<typename _Tp>
struct __is_pointer<_Tp*>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<typename _Tp>
struct __is_arithmetic
: public __traitor<__is_integer<_Tp>, __is_floating<_Tp> >
{ };
template<typename _Tp>
struct __is_scalar
: public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> >
{ };
template<typename _Tp>
struct __is_char
{
enum { __value = 0 };
typedef __false_type __type;
};
template<>
struct __is_char<char>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<>
struct __is_char<wchar_t>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<typename _Tp>
struct __is_byte
{
enum { __value = 0 };
typedef __false_type __type;
};
template<>
struct __is_byte<char>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<>
struct __is_byte<signed char>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<>
struct __is_byte<unsigned char>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<typename _Tp>
struct __is_move_iterator
{
enum { __value = 0 };
typedef __false_type __type;
};
template<typename _Iterator>
inline _Iterator
__miter_base(_Iterator __it)
{ return __it; }
}
}
# 62 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/type_traits.h" 1 3
# 32 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/type_traits.h" 3
# 33 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/type_traits.h" 3
extern "C++" {
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
template<bool, typename>
struct __enable_if
{ };
template<typename _Tp>
struct __enable_if<true, _Tp>
{ typedef _Tp __type; };
template<bool _Cond, typename _Iftrue, typename _Iffalse>
struct __conditional_type
{ typedef _Iftrue __type; };
template<typename _Iftrue, typename _Iffalse>
struct __conditional_type<false, _Iftrue, _Iffalse>
{ typedef _Iffalse __type; };
template<typename _Tp>
struct __add_unsigned
{
private:
typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;
public:
typedef typename __if_type::__type __type;
};
template<>
struct __add_unsigned<char>
{ typedef unsigned char __type; };
template<>
struct __add_unsigned<signed char>
{ typedef unsigned char __type; };
template<>
struct __add_unsigned<short>
{ typedef unsigned short __type; };
template<>
struct __add_unsigned<int>
{ typedef unsigned int __type; };
template<>
struct __add_unsigned<long>
{ typedef unsigned long __type; };
template<>
struct __add_unsigned<long long>
{ typedef unsigned long long __type; };
template<>
struct __add_unsigned<bool>;
template<>
struct __add_unsigned<wchar_t>;
template<typename _Tp>
struct __remove_unsigned
{
private:
typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;
public:
typedef typename __if_type::__type __type;
};
template<>
struct __remove_unsigned<char>
{ typedef signed char __type; };
template<>
struct __remove_unsigned<unsigned char>
{ typedef signed char __type; };
template<>
struct __remove_unsigned<unsigned short>
{ typedef short __type; };
template<>
struct __remove_unsigned<unsigned int>
{ typedef int __type; };
template<>
struct __remove_unsigned<unsigned long>
{ typedef long __type; };
template<>
struct __remove_unsigned<unsigned long long>
{ typedef long long __type; };
template<>
struct __remove_unsigned<bool>;
template<>
struct __remove_unsigned<wchar_t>;
template<typename _Type>
inline bool
__is_null_pointer(_Type* __ptr)
{ return __ptr == 0; }
template<typename _Type>
inline bool
__is_null_pointer(_Type)
{ return false; }
inline bool
__is_null_pointer(std::nullptr_t)
{ return true; }
template<typename _Tp, bool = std::__is_integer<_Tp>::__value>
struct __promote
{ typedef double __type; };
template<typename _Tp>
struct __promote<_Tp, false>
{ };
template<>
struct __promote<long double>
{ typedef long double __type; };
template<>
struct __promote<double>
{ typedef double __type; };
template<>
struct __promote<float>
{ typedef float __type; };
template<typename _Tp, typename _Up,
typename _Tp2 = typename __promote<_Tp>::__type,
typename _Up2 = typename __promote<_Up>::__type>
struct __promote_2
{
typedef __typeof__(_Tp2() + _Up2()) __type;
};
template<typename _Tp, typename _Up, typename _Vp,
typename _Tp2 = typename __promote<_Tp>::__type,
typename _Up2 = typename __promote<_Up>::__type,
typename _Vp2 = typename __promote<_Vp>::__type>
struct __promote_3
{
typedef __typeof__(_Tp2() + _Up2() + _Vp2()) __type;
};
template<typename _Tp, typename _Up, typename _Vp, typename _Wp,
typename _Tp2 = typename __promote<_Tp>::__type,
typename _Up2 = typename __promote<_Up>::__type,
typename _Vp2 = typename __promote<_Vp>::__type,
typename _Wp2 = typename __promote<_Wp>::__type>
struct __promote_4
{
typedef __typeof__(_Tp2() + _Up2() + _Vp2() + _Wp2()) __type;
};
}
}
# 63 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/numeric_traits.h" 1 3
# 32 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/numeric_traits.h" 3
# 33 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/numeric_traits.h" 3
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
# 54 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/numeric_traits.h" 3
template<typename _Value>
struct __numeric_traits_integer
{
static const _Value __min = (((_Value)(-1) < 0) ? (_Value)1 << (sizeof(_Value) * 8 - ((_Value)(-1) < 0)) : (_Value)0);
static const _Value __max = (((_Value)(-1) < 0) ? (((((_Value)1 << ((sizeof(_Value) * 8 - ((_Value)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(_Value)0);
static const bool __is_signed = ((_Value)(-1) < 0);
static const int __digits = (sizeof(_Value) * 8 - ((_Value)(-1) < 0));
};
template<typename _Value>
const _Value __numeric_traits_integer<_Value>::__min;
template<typename _Value>
const _Value __numeric_traits_integer<_Value>::__max;
template<typename _Value>
const bool __numeric_traits_integer<_Value>::__is_signed;
template<typename _Value>
const int __numeric_traits_integer<_Value>::__digits;
# 99 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/numeric_traits.h" 3
template<typename _Value>
struct __numeric_traits_floating
{
static const int __max_digits10 = (2 + (std::__are_same<_Value, float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 64) * 643L / 2136);
static const bool __is_signed = true;
static const int __digits10 = (std::__are_same<_Value, float>::__value ? 6 : std::__are_same<_Value, double>::__value ? 15 : 18);
static const int __max_exponent10 = (std::__are_same<_Value, float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 4932);
};
template<typename _Value>
const int __numeric_traits_floating<_Value>::__max_digits10;
template<typename _Value>
const bool __numeric_traits_floating<_Value>::__is_signed;
template<typename _Value>
const int __numeric_traits_floating<_Value>::__digits10;
template<typename _Value>
const int __numeric_traits_floating<_Value>::__max_exponent10;
template<typename _Value>
struct __numeric_traits
: public __conditional_type<std::__is_integer<_Value>::__value,
__numeric_traits_integer<_Value>,
__numeric_traits_floating<_Value> >::__type
{ };
}
# 64 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_pair.h" 1 3
# 65 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_pair.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 76 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_pair.h" 3
struct piecewise_construct_t { explicit piecewise_construct_t() = default; };
constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
template<typename...>
class tuple;
template<std::size_t...>
struct _Index_tuple;
template <typename _T1, typename _T2, typename _U1, typename _U2>
constexpr bool _ConstructiblePair()
{
return __and_<__or_<is_same<typename decay<_T1>::type,
typename decay<_U1>::type>,
is_constructible<_T1, const _U1&>>,
__or_<is_same<typename decay<_T2>::type,
typename decay<_U2>::type>,
is_constructible<_T2, const _U2&>>>::value;
}
template <typename _T1, typename _T2, typename _U1, typename _U2>
constexpr bool _ImplicitlyConvertiblePair()
{
return __and_<__or_<is_same<typename decay<_T1>::type,
typename decay<_U1>::type>,
is_convertible<const _U1&, _T1>>,
__or_<is_same<typename decay<_T2>::type,
typename decay<_U2>::type>,
is_convertible<const _U2&, _T2>>>::value;
}
template <typename _T1, typename _T2, typename _U1, typename _U2>
constexpr bool _MoveConstructiblePair()
{
return __and_<__or_<is_same<typename decay<_T1>::type,
typename decay<_U1>::type>,
is_constructible<_T1, _U1&&>>,
__or_<is_same<typename decay<_T2>::type,
typename decay<_U2>::type>,
is_constructible<_T2, _U2&&>>>::value;
}
template <typename _T1, typename _T2, typename _U1, typename _U2>
constexpr bool _ImplicitlyMoveConvertiblePair()
{
return __and_<__or_<is_same<typename decay<_T1>::type,
typename decay<_U1>::type>,
is_convertible<_U1&&, _T1>>,
__or_<is_same<typename decay<_T2>::type,
typename decay<_U2>::type>,
is_convertible<_U2&&, _T2>>>::value;
}
# 146 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_pair.h" 3
template<typename _T1, typename _T2>
struct pair
{
typedef _T1 first_type;
typedef _T2 second_type;
_T1 first;
_T2 second;
template <typename _U1 = _T1,
typename _U2 = _T2,
typename enable_if<__and_<
__is_implicitly_default_constructible<_U1>,
__is_implicitly_default_constructible<_U2>>
::value, bool>::type = true>
constexpr pair()
: first(), second() { }
template <typename _U1 = _T1,
typename _U2 = _T2,
typename enable_if<__and_<
is_default_constructible<_U1>,
is_default_constructible<_U2>,
__not_<
__and_<__is_implicitly_default_constructible<_U1>,
__is_implicitly_default_constructible<_U2>>>>
::value, bool>::type = false>
explicit constexpr pair()
: first(), second() { }
template<typename _U1 = _T1, typename _U2=_T2, typename
enable_if<_ConstructiblePair<_T1, _T2, _U1, _U2>()
&& _ImplicitlyConvertiblePair<_T1, _T2, _U1, _U2>(),
bool>::type=true>
constexpr pair(const _T1& __a, const _T2& __b)
: first(__a), second(__b) { }
template<typename _U1 = _T1, typename _U2=_T2, typename
enable_if<_ConstructiblePair<_T1, _T2, _U1, _U2>()
&& !_ImplicitlyConvertiblePair<_T1, _T2, _U1, _U2>(),
bool>::type=false>
explicit constexpr pair(const _T1& __a, const _T2& __b)
: first(__a), second(__b) { }
# 210 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_pair.h" 3
template<typename _U1, typename _U2, typename
enable_if<_ConstructiblePair<_T1, _T2, _U1, _U2>()
&& _ImplicitlyConvertiblePair<_T1, _T2, _U1, _U2>(),
bool>::type=true>
constexpr pair(const pair<_U1, _U2>& __p)
: first(__p.first), second(__p.second) { }
template<typename _U1, typename _U2, typename
enable_if<_ConstructiblePair<_T1, _T2, _U1, _U2>()
&& !_ImplicitlyConvertiblePair<_T1, _T2, _U1, _U2>(),
bool>::type=false>
explicit constexpr pair(const pair<_U1, _U2>& __p)
: first(__p.first), second(__p.second) { }
constexpr pair(const pair&) = default;
constexpr pair(pair&&) = default;
template<typename _U1, typename
enable_if<_ConstructiblePair<_T2, _T2, _T2, _T2>()
&& _MoveConstructiblePair<_T1, _T2, _U1, _T2>()
&& _ImplicitlyConvertiblePair<_T2, _T2, _T2, _T2>()
&& _ImplicitlyMoveConvertiblePair<_T1, _T2,
_U1, _T2>(),
bool>::type=true>
constexpr pair(_U1&& __x, const _T2& __y)
: first(std::forward<_U1>(__x)), second(__y) { }
template<typename _U1, typename
enable_if<_ConstructiblePair<_T2, _T2, _T2, _T2>()
&& _MoveConstructiblePair<_T1, _T2, _U1, _T2>()
&& (!_ImplicitlyConvertiblePair<_T2, _T2, _T2, _T2>()
|| !_ImplicitlyMoveConvertiblePair<_T1, _T2,
_U1, _T2>()),
bool>::type=false>
explicit constexpr pair(_U1&& __x, const _T2& __y)
: first(std::forward<_U1>(__x)), second(__y) { }
template<typename _U2, typename
enable_if<_ConstructiblePair<_T1, _T1, _T1, _T1>()
&& _MoveConstructiblePair<_T1, _T2, _T1, _U2>()
&& _ImplicitlyConvertiblePair<_T1, _T1, _T1, _T1>()
&& _ImplicitlyMoveConvertiblePair<_T1, _T2,
_T1, _U2>(),
bool>::type=true>
constexpr pair(const _T1& __x, _U2&& __y)
: first(__x), second(std::forward<_U2>(__y)) { }
template<typename _U2, typename
enable_if<_ConstructiblePair<_T1, _T1, _T1, _T1>()
&& _MoveConstructiblePair<_T1, _T2, _T1, _U2>()
&& (!_ImplicitlyConvertiblePair<_T1, _T1, _T1, _T1>()
|| !_ImplicitlyMoveConvertiblePair<_T1, _T2,
_T1, _U2>()),
bool>::type=false>
explicit pair(const _T1& __x, _U2&& __y)
: first(__x), second(std::forward<_U2>(__y)) { }
template<typename _U1, typename _U2, typename
enable_if<_MoveConstructiblePair<_T1, _T2, _U1, _U2>()
&& _ImplicitlyMoveConvertiblePair<_T1, _T2,
_U1, _U2>(),
bool>::type=true>
constexpr pair(_U1&& __x, _U2&& __y)
: first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
template<typename _U1, typename _U2, typename
enable_if<_MoveConstructiblePair<_T1, _T2, _U1, _U2>()
&& !_ImplicitlyMoveConvertiblePair<_T1, _T2,
_U1, _U2>(),
bool>::type=false>
explicit constexpr pair(_U1&& __x, _U2&& __y)
: first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
template<typename _U1, typename _U2, typename
enable_if<_MoveConstructiblePair<_T1, _T2, _U1, _U2>()
&& _ImplicitlyMoveConvertiblePair<_T1, _T2,
_U1, _U2>(),
bool>::type=true>
constexpr pair(pair<_U1, _U2>&& __p)
: first(std::forward<_U1>(__p.first)),
second(std::forward<_U2>(__p.second)) { }
template<typename _U1, typename _U2, typename
enable_if<_MoveConstructiblePair<_T1, _T2, _U1, _U2>()
&& !_ImplicitlyMoveConvertiblePair<_T1, _T2,
_U1, _U2>(),
bool>::type=false>
explicit constexpr pair(pair<_U1, _U2>&& __p)
: first(std::forward<_U1>(__p.first)),
second(std::forward<_U2>(__p.second)) { }
template<typename... _Args1, typename... _Args2>
pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>);
pair&
operator=(const pair& __p)
{
first = __p.first;
second = __p.second;
return *this;
}
pair&
operator=(pair&& __p)
noexcept(__and_<is_nothrow_move_assignable<_T1>,
is_nothrow_move_assignable<_T2>>::value)
{
first = std::forward<first_type>(__p.first);
second = std::forward<second_type>(__p.second);
return *this;
}
template<typename _U1, typename _U2>
pair&
operator=(const pair<_U1, _U2>& __p)
{
first = __p.first;
second = __p.second;
return *this;
}
template<typename _U1, typename _U2>
pair&
operator=(pair<_U1, _U2>&& __p)
{
first = std::forward<_U1>(__p.first);
second = std::forward<_U2>(__p.second);
return *this;
}
void
swap(pair& __p)
noexcept(__is_nothrow_swappable<_T1>::value
&& __is_nothrow_swappable<_T2>::value)
{
using std::swap;
swap(first, __p.first);
swap(second, __p.second);
}
private:
template<typename... _Args1, std::size_t... _Indexes1,
typename... _Args2, std::size_t... _Indexes2>
pair(tuple<_Args1...>&, tuple<_Args2...>&,
_Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>);
};
template<typename _T1, typename _T2>
inline constexpr bool
operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return __x.first == __y.first && __x.second == __y.second; }
template<typename _T1, typename _T2>
inline constexpr bool
operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return __x.first < __y.first
|| (!(__y.first < __x.first) && __x.second < __y.second); }
template<typename _T1, typename _T2>
inline constexpr bool
operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return !(__x == __y); }
template<typename _T1, typename _T2>
inline constexpr bool
operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return __y < __x; }
template<typename _T1, typename _T2>
inline constexpr bool
operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return !(__y < __x); }
template<typename _T1, typename _T2>
inline constexpr bool
operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return !(__x < __y); }
template<typename _T1, typename _T2>
inline void
swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
noexcept(noexcept(__x.swap(__y)))
{ __x.swap(__y); }
# 422 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_pair.h" 3
template<typename _T1, typename _T2>
constexpr pair<typename __decay_and_strip<_T1>::__type,
typename __decay_and_strip<_T2>::__type>
make_pair(_T1&& __x, _T2&& __y)
{
typedef typename __decay_and_strip<_T1>::__type __ds_type1;
typedef typename __decay_and_strip<_T2>::__type __ds_type2;
typedef pair<__ds_type1, __ds_type2> __pair_type;
return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y));
}
# 441 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_pair.h" 3
}
# 65 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator_base_types.h" 1 3
# 62 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator_base_types.h" 3
# 63 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator_base_types.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 89 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator_base_types.h" 3
struct input_iterator_tag { };
struct output_iterator_tag { };
struct forward_iterator_tag : public input_iterator_tag { };
struct bidirectional_iterator_tag : public forward_iterator_tag { };
struct random_access_iterator_tag : public bidirectional_iterator_tag { };
# 116 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator_base_types.h" 3
template<typename _Category, typename _Tp, typename _Distance = ptrdiff_t,
typename _Pointer = _Tp*, typename _Reference = _Tp&>
struct iterator
{
typedef _Category iterator_category;
typedef _Tp value_type;
typedef _Distance difference_type;
typedef _Pointer pointer;
typedef _Reference reference;
};
# 143 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator_base_types.h" 3
template<typename _Iterator, typename = __void_t<>>
struct __iterator_traits { };
template<typename _Iterator>
struct __iterator_traits<_Iterator,
__void_t<typename _Iterator::iterator_category,
typename _Iterator::value_type,
typename _Iterator::difference_type,
typename _Iterator::pointer,
typename _Iterator::reference>>
{
typedef typename _Iterator::iterator_category iterator_category;
typedef typename _Iterator::value_type value_type;
typedef typename _Iterator::difference_type difference_type;
typedef typename _Iterator::pointer pointer;
typedef typename _Iterator::reference reference;
};
template<typename _Iterator>
struct iterator_traits
: public __iterator_traits<_Iterator> { };
# 177 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator_base_types.h" 3
template<typename _Tp>
struct iterator_traits<_Tp*>
{
typedef random_access_iterator_tag iterator_category;
typedef _Tp value_type;
typedef ptrdiff_t difference_type;
typedef _Tp* pointer;
typedef _Tp& reference;
};
template<typename _Tp>
struct iterator_traits<const _Tp*>
{
typedef random_access_iterator_tag iterator_category;
typedef _Tp value_type;
typedef ptrdiff_t difference_type;
typedef const _Tp* pointer;
typedef const _Tp& reference;
};
template<typename _Iter>
inline typename iterator_traits<_Iter>::iterator_category
__iterator_category(const _Iter&)
{ return typename iterator_traits<_Iter>::iterator_category(); }
# 230 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator_base_types.h" 3
template<typename _InIter>
using _RequireInputIter = typename
enable_if<is_convertible<typename
iterator_traits<_InIter>::iterator_category,
input_iterator_tag>::value>::type;
}
# 66 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator_base_funcs.h" 1 3
# 62 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator_base_funcs.h" 3
# 63 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator_base_funcs.h" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/debug/assertions.h" 1 3
# 66 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator_base_funcs.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template <typename> struct _List_iterator;
template <typename> struct _List_const_iterator;
template<typename _InputIterator>
inline typename iterator_traits<_InputIterator>::difference_type
__distance(_InputIterator __first, _InputIterator __last,
input_iterator_tag)
{
typename iterator_traits<_InputIterator>::difference_type __n = 0;
while (__first != __last)
{
++__first;
++__n;
}
return __n;
}
template<typename _RandomAccessIterator>
inline typename iterator_traits<_RandomAccessIterator>::difference_type
__distance(_RandomAccessIterator __first, _RandomAccessIterator __last,
random_access_iterator_tag)
{
return __last - __first;
}
template<typename _Tp>
ptrdiff_t
__distance(std::_List_iterator<_Tp>,
std::_List_iterator<_Tp>,
input_iterator_tag);
template<typename _Tp>
ptrdiff_t
__distance(std::_List_const_iterator<_Tp>,
std::_List_const_iterator<_Tp>,
input_iterator_tag);
# 133 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator_base_funcs.h" 3
template<typename _InputIterator>
inline typename iterator_traits<_InputIterator>::difference_type
distance(_InputIterator __first, _InputIterator __last)
{
return std::__distance(__first, __last,
std::__iterator_category(__first));
}
template<typename _InputIterator, typename _Distance>
inline void
__advance(_InputIterator& __i, _Distance __n, input_iterator_tag)
{
;
while (__n--)
++__i;
}
template<typename _BidirectionalIterator, typename _Distance>
inline void
__advance(_BidirectionalIterator& __i, _Distance __n,
bidirectional_iterator_tag)
{
if (__n > 0)
while (__n--)
++__i;
else
while (__n++)
--__i;
}
template<typename _RandomAccessIterator, typename _Distance>
inline void
__advance(_RandomAccessIterator& __i, _Distance __n,
random_access_iterator_tag)
{
__i += __n;
}
# 192 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator_base_funcs.h" 3
template<typename _InputIterator, typename _Distance>
inline void
advance(_InputIterator& __i, _Distance __n)
{
typename iterator_traits<_InputIterator>::difference_type __d = __n;
std::__advance(__i, __d, std::__iterator_category(__i));
}
template<typename _ForwardIterator>
inline _ForwardIterator
next(_ForwardIterator __x, typename
iterator_traits<_ForwardIterator>::difference_type __n = 1)
{
std::advance(__x, __n);
return __x;
}
template<typename _BidirectionalIterator>
inline _BidirectionalIterator
prev(_BidirectionalIterator __x, typename
iterator_traits<_BidirectionalIterator>::difference_type __n = 1)
{
std::advance(__x, -__n);
return __x;
}
}
# 67 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator.h" 1 3
# 66 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator.h" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ptr_traits.h" 1 3
# 37 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ptr_traits.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
class __undefined;
template<typename _Tp>
struct __get_first_arg
{ using type = __undefined; };
template<template<typename, typename...> class _Template, typename _Tp,
typename... _Types>
struct __get_first_arg<_Template<_Tp, _Types...>>
{ using type = _Tp; };
template<typename _Tp>
using __get_first_arg_t = typename __get_first_arg<_Tp>::type;
template<typename _Tp, typename _Up>
struct __replace_first_arg
{ using type = __undefined; };
template<template<typename, typename...> class _Template, typename _Up,
typename _Tp, typename... _Types>
struct __replace_first_arg<_Template<_Tp, _Types...>, _Up>
{ using type = _Template<_Up, _Types...>; };
template<typename _Tp, typename _Up>
using __replace_first_arg_t = typename __replace_first_arg<_Tp, _Up>::type;
template<typename _Tp>
using __make_not_void
= typename conditional<is_void<_Tp>::value, __undefined, _Tp>::type;
template<typename _Ptr>
struct pointer_traits
{
private:
template<typename _Tp>
using __element_type = typename _Tp::element_type;
template<typename _Tp>
using __difference_type = typename _Tp::difference_type;
template<typename _Tp, typename _Up>
using __rebind = typename _Tp::template rebind<_Up>;
public:
using pointer = _Ptr;
using element_type
= __detected_or_t_<__get_first_arg_t, __element_type, _Ptr>;
using difference_type
= __detected_or_t<ptrdiff_t, __difference_type, _Ptr>;
template<typename _Up>
using rebind
= __detected_or_t_<__replace_first_arg_t, __rebind, _Ptr, _Up>;
static _Ptr
pointer_to(__make_not_void<element_type>& __e)
{ return _Ptr::pointer_to(__e); }
static_assert(!is_same<element_type, __undefined>::value,
"pointer type defines element_type or is like SomePointer<T, Args>");
static_assert(!is_same<rebind<element_type>, __undefined>::value,
"pointer type defines rebind<U> or is like SomePointer<T, Args>");
};
template<typename _Tp>
struct pointer_traits<_Tp*>
{
typedef _Tp* pointer;
typedef _Tp element_type;
typedef ptrdiff_t difference_type;
template<typename _Up>
using rebind = _Up*;
static pointer
pointer_to(__make_not_void<element_type>& __r) noexcept
{ return std::addressof(__r); }
};
template<typename _Ptr, typename _Tp>
using __ptr_rebind = typename pointer_traits<_Ptr>::template rebind<_Tp>;
}
# 67 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 96 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator.h" 3
template<typename _Iterator>
class reverse_iterator
: public iterator<typename iterator_traits<_Iterator>::iterator_category,
typename iterator_traits<_Iterator>::value_type,
typename iterator_traits<_Iterator>::difference_type,
typename iterator_traits<_Iterator>::pointer,
typename iterator_traits<_Iterator>::reference>
{
protected:
_Iterator current;
typedef iterator_traits<_Iterator> __traits_type;
public:
typedef _Iterator iterator_type;
typedef typename __traits_type::difference_type difference_type;
typedef typename __traits_type::pointer pointer;
typedef typename __traits_type::reference reference;
reverse_iterator() : current() { }
explicit
reverse_iterator(iterator_type __x) : current(__x) { }
reverse_iterator(const reverse_iterator& __x)
: current(__x.current) { }
template<typename _Iter>
reverse_iterator(const reverse_iterator<_Iter>& __x)
: current(__x.base()) { }
iterator_type
base() const
{ return current; }
# 160 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator.h" 3
reference
operator*() const
{
_Iterator __tmp = current;
return *--__tmp;
}
pointer
operator->() const
{ return &(operator*()); }
reverse_iterator&
operator++()
{
--current;
return *this;
}
reverse_iterator
operator++(int)
{
reverse_iterator __tmp = *this;
--current;
return __tmp;
}
reverse_iterator&
operator--()
{
++current;
return *this;
}
reverse_iterator
operator--(int)
{
reverse_iterator __tmp = *this;
++current;
return __tmp;
}
reverse_iterator
operator+(difference_type __n) const
{ return reverse_iterator(current - __n); }
reverse_iterator&
operator+=(difference_type __n)
{
current -= __n;
return *this;
}
reverse_iterator
operator-(difference_type __n) const
{ return reverse_iterator(current + __n); }
reverse_iterator&
operator-=(difference_type __n)
{
current += __n;
return *this;
}
reference
operator[](difference_type __n) const
{ return *(*this + __n); }
};
# 290 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator.h" 3
template<typename _Iterator>
inline bool
operator==(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
{ return __x.base() == __y.base(); }
template<typename _Iterator>
inline bool
operator<(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
{ return __y.base() < __x.base(); }
template<typename _Iterator>
inline bool
operator!=(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
{ return !(__x == __y); }
template<typename _Iterator>
inline bool
operator>(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
{ return __y < __x; }
template<typename _Iterator>
inline bool
operator<=(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
{ return !(__y < __x); }
template<typename _Iterator>
inline bool
operator>=(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
{ return !(__x < __y); }
template<typename _Iterator>
inline typename reverse_iterator<_Iterator>::difference_type
operator-(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
{ return __y.base() - __x.base(); }
template<typename _Iterator>
inline reverse_iterator<_Iterator>
operator+(typename reverse_iterator<_Iterator>::difference_type __n,
const reverse_iterator<_Iterator>& __x)
{ return reverse_iterator<_Iterator>(__x.base() - __n); }
template<typename _IteratorL, typename _IteratorR>
inline bool
operator==(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
{ return __x.base() == __y.base(); }
template<typename _IteratorL, typename _IteratorR>
inline bool
operator<(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
{ return __y.base() < __x.base(); }
template<typename _IteratorL, typename _IteratorR>
inline bool
operator!=(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
{ return !(__x == __y); }
template<typename _IteratorL, typename _IteratorR>
inline bool
operator>(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
{ return __y < __x; }
template<typename _IteratorL, typename _IteratorR>
inline bool
operator<=(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
{ return !(__y < __x); }
template<typename _IteratorL, typename _IteratorR>
inline bool
operator>=(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
{ return !(__x < __y); }
template<typename _IteratorL, typename _IteratorR>
inline auto
operator-(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
-> decltype(__y.base() - __x.base())
{ return __y.base() - __x.base(); }
template<typename _Iterator>
inline reverse_iterator<_Iterator>
__make_reverse_iterator(_Iterator __i)
{ return reverse_iterator<_Iterator>(__i); }
template<typename _Iterator>
inline reverse_iterator<_Iterator>
make_reverse_iterator(_Iterator __i)
{ return reverse_iterator<_Iterator>(__i); }
template<typename _Iterator>
auto
__niter_base(reverse_iterator<_Iterator> __it)
-> decltype(__make_reverse_iterator(__niter_base(__it.base())))
{ return __make_reverse_iterator(__niter_base(__it.base())); }
template<typename _Iterator>
struct __is_move_iterator<reverse_iterator<_Iterator> >
: __is_move_iterator<_Iterator>
{ };
template<typename _Iterator>
auto
__miter_base(reverse_iterator<_Iterator> __it)
-> decltype(__make_reverse_iterator(__miter_base(__it.base())))
{ return __make_reverse_iterator(__miter_base(__it.base())); }
# 441 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator.h" 3
template<typename _Container>
class back_insert_iterator
: public iterator<output_iterator_tag, void, void, void, void>
{
protected:
_Container* container;
public:
typedef _Container container_type;
explicit
back_insert_iterator(_Container& __x)
: container(std::__addressof(__x)) { }
# 476 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator.h" 3
back_insert_iterator&
operator=(const typename _Container::value_type& __value)
{
container->push_back(__value);
return *this;
}
back_insert_iterator&
operator=(typename _Container::value_type&& __value)
{
container->push_back(std::move(__value));
return *this;
}
back_insert_iterator&
operator*()
{ return *this; }
back_insert_iterator&
operator++()
{ return *this; }
back_insert_iterator
operator++(int)
{ return *this; }
};
# 518 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator.h" 3
template<typename _Container>
inline back_insert_iterator<_Container>
back_inserter(_Container& __x)
{ return back_insert_iterator<_Container>(__x); }
# 533 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator.h" 3
template<typename _Container>
class front_insert_iterator
: public iterator<output_iterator_tag, void, void, void, void>
{
protected:
_Container* container;
public:
typedef _Container container_type;
explicit front_insert_iterator(_Container& __x)
: container(std::__addressof(__x)) { }
# 567 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator.h" 3
front_insert_iterator&
operator=(const typename _Container::value_type& __value)
{
container->push_front(__value);
return *this;
}
front_insert_iterator&
operator=(typename _Container::value_type&& __value)
{
container->push_front(std::move(__value));
return *this;
}
front_insert_iterator&
operator*()
{ return *this; }
front_insert_iterator&
operator++()
{ return *this; }
front_insert_iterator
operator++(int)
{ return *this; }
};
# 609 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator.h" 3
template<typename _Container>
inline front_insert_iterator<_Container>
front_inserter(_Container& __x)
{ return front_insert_iterator<_Container>(__x); }
# 628 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator.h" 3
template<typename _Container>
class insert_iterator
: public iterator<output_iterator_tag, void, void, void, void>
{
protected:
_Container* container;
typename _Container::iterator iter;
public:
typedef _Container container_type;
insert_iterator(_Container& __x, typename _Container::iterator __i)
: container(std::__addressof(__x)), iter(__i) {}
# 679 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator.h" 3
insert_iterator&
operator=(const typename _Container::value_type& __value)
{
iter = container->insert(iter, __value);
++iter;
return *this;
}
insert_iterator&
operator=(typename _Container::value_type&& __value)
{
iter = container->insert(iter, std::move(__value));
++iter;
return *this;
}
insert_iterator&
operator*()
{ return *this; }
insert_iterator&
operator++()
{ return *this; }
insert_iterator&
operator++(int)
{ return *this; }
};
# 723 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator.h" 3
template<typename _Container, typename _Iterator>
inline insert_iterator<_Container>
inserter(_Container& __x, _Iterator __i)
{
return insert_iterator<_Container>(__x,
typename _Container::iterator(__i));
}
}
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
# 747 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator.h" 3
using std::iterator_traits;
using std::iterator;
template<typename _Iterator, typename _Container>
class __normal_iterator
{
protected:
_Iterator _M_current;
typedef iterator_traits<_Iterator> __traits_type;
public:
typedef _Iterator iterator_type;
typedef typename __traits_type::iterator_category iterator_category;
typedef typename __traits_type::value_type value_type;
typedef typename __traits_type::difference_type difference_type;
typedef typename __traits_type::reference reference;
typedef typename __traits_type::pointer pointer;
constexpr __normal_iterator() noexcept
: _M_current(_Iterator()) { }
explicit
__normal_iterator(const _Iterator& __i) noexcept
: _M_current(__i) { }
template<typename _Iter>
__normal_iterator(const __normal_iterator<_Iter,
typename __enable_if<
(std::__are_same<_Iter, typename _Container::pointer>::__value),
_Container>::__type>& __i) noexcept
: _M_current(__i.base()) { }
reference
operator*() const noexcept
{ return *_M_current; }
pointer
operator->() const noexcept
{ return _M_current; }
__normal_iterator&
operator++() noexcept
{
++_M_current;
return *this;
}
__normal_iterator
operator++(int) noexcept
{ return __normal_iterator(_M_current++); }
__normal_iterator&
operator--() noexcept
{
--_M_current;
return *this;
}
__normal_iterator
operator--(int) noexcept
{ return __normal_iterator(_M_current--); }
reference
operator[](difference_type __n) const noexcept
{ return _M_current[__n]; }
__normal_iterator&
operator+=(difference_type __n) noexcept
{ _M_current += __n; return *this; }
__normal_iterator
operator+(difference_type __n) const noexcept
{ return __normal_iterator(_M_current + __n); }
__normal_iterator&
operator-=(difference_type __n) noexcept
{ _M_current -= __n; return *this; }
__normal_iterator
operator-(difference_type __n) const noexcept
{ return __normal_iterator(_M_current - __n); }
const _Iterator&
base() const noexcept
{ return _M_current; }
};
# 847 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator.h" 3
template<typename _IteratorL, typename _IteratorR, typename _Container>
inline bool
operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs)
noexcept
{ return __lhs.base() == __rhs.base(); }
template<typename _Iterator, typename _Container>
inline bool
operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
const __normal_iterator<_Iterator, _Container>& __rhs)
noexcept
{ return __lhs.base() == __rhs.base(); }
template<typename _IteratorL, typename _IteratorR, typename _Container>
inline bool
operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs)
noexcept
{ return __lhs.base() != __rhs.base(); }
template<typename _Iterator, typename _Container>
inline bool
operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
const __normal_iterator<_Iterator, _Container>& __rhs)
noexcept
{ return __lhs.base() != __rhs.base(); }
template<typename _IteratorL, typename _IteratorR, typename _Container>
inline bool
operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs)
noexcept
{ return __lhs.base() < __rhs.base(); }
template<typename _Iterator, typename _Container>
inline bool
operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
const __normal_iterator<_Iterator, _Container>& __rhs)
noexcept
{ return __lhs.base() < __rhs.base(); }
template<typename _IteratorL, typename _IteratorR, typename _Container>
inline bool
operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs)
noexcept
{ return __lhs.base() > __rhs.base(); }
template<typename _Iterator, typename _Container>
inline bool
operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
const __normal_iterator<_Iterator, _Container>& __rhs)
noexcept
{ return __lhs.base() > __rhs.base(); }
template<typename _IteratorL, typename _IteratorR, typename _Container>
inline bool
operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs)
noexcept
{ return __lhs.base() <= __rhs.base(); }
template<typename _Iterator, typename _Container>
inline bool
operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
const __normal_iterator<_Iterator, _Container>& __rhs)
noexcept
{ return __lhs.base() <= __rhs.base(); }
template<typename _IteratorL, typename _IteratorR, typename _Container>
inline bool
operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs)
noexcept
{ return __lhs.base() >= __rhs.base(); }
template<typename _Iterator, typename _Container>
inline bool
operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
const __normal_iterator<_Iterator, _Container>& __rhs)
noexcept
{ return __lhs.base() >= __rhs.base(); }
template<typename _IteratorL, typename _IteratorR, typename _Container>
inline auto
operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept
-> decltype(__lhs.base() - __rhs.base())
{ return __lhs.base() - __rhs.base(); }
template<typename _Iterator, typename _Container>
inline typename __normal_iterator<_Iterator, _Container>::difference_type
operator-(const __normal_iterator<_Iterator, _Container>& __lhs,
const __normal_iterator<_Iterator, _Container>& __rhs)
noexcept
{ return __lhs.base() - __rhs.base(); }
template<typename _Iterator, typename _Container>
inline __normal_iterator<_Iterator, _Container>
operator+(typename __normal_iterator<_Iterator, _Container>::difference_type
__n, const __normal_iterator<_Iterator, _Container>& __i)
noexcept
{ return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Iterator, typename _Container>
_Iterator
__niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it)
{ return __it.base(); }
}
namespace std __attribute__ ((__visibility__ ("default")))
{
# 999 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator.h" 3
template<typename _Iterator>
class move_iterator
{
protected:
_Iterator _M_current;
typedef iterator_traits<_Iterator> __traits_type;
typedef typename __traits_type::reference __base_ref;
public:
typedef _Iterator iterator_type;
typedef typename __traits_type::iterator_category iterator_category;
typedef typename __traits_type::value_type value_type;
typedef typename __traits_type::difference_type difference_type;
typedef _Iterator pointer;
typedef typename conditional<is_reference<__base_ref>::value,
typename remove_reference<__base_ref>::type&&,
__base_ref>::type reference;
move_iterator()
: _M_current() { }
explicit
move_iterator(iterator_type __i)
: _M_current(__i) { }
template<typename _Iter>
move_iterator(const move_iterator<_Iter>& __i)
: _M_current(__i.base()) { }
iterator_type
base() const
{ return _M_current; }
reference
operator*() const
{ return static_cast<reference>(*_M_current); }
pointer
operator->() const
{ return _M_current; }
move_iterator&
operator++()
{
++_M_current;
return *this;
}
move_iterator
operator++(int)
{
move_iterator __tmp = *this;
++_M_current;
return __tmp;
}
move_iterator&
operator--()
{
--_M_current;
return *this;
}
move_iterator
operator--(int)
{
move_iterator __tmp = *this;
--_M_current;
return __tmp;
}
move_iterator
operator+(difference_type __n) const
{ return move_iterator(_M_current + __n); }
move_iterator&
operator+=(difference_type __n)
{
_M_current += __n;
return *this;
}
move_iterator
operator-(difference_type __n) const
{ return move_iterator(_M_current - __n); }
move_iterator&
operator-=(difference_type __n)
{
_M_current -= __n;
return *this;
}
reference
operator[](difference_type __n) const
{ return std::move(_M_current[__n]); }
};
template<typename _IteratorL, typename _IteratorR>
inline bool
operator==(const move_iterator<_IteratorL>& __x,
const move_iterator<_IteratorR>& __y)
{ return __x.base() == __y.base(); }
template<typename _Iterator>
inline bool
operator==(const move_iterator<_Iterator>& __x,
const move_iterator<_Iterator>& __y)
{ return __x.base() == __y.base(); }
template<typename _IteratorL, typename _IteratorR>
inline bool
operator!=(const move_iterator<_IteratorL>& __x,
const move_iterator<_IteratorR>& __y)
{ return !(__x == __y); }
template<typename _Iterator>
inline bool
operator!=(const move_iterator<_Iterator>& __x,
const move_iterator<_Iterator>& __y)
{ return !(__x == __y); }
template<typename _IteratorL, typename _IteratorR>
inline bool
operator<(const move_iterator<_IteratorL>& __x,
const move_iterator<_IteratorR>& __y)
{ return __x.base() < __y.base(); }
template<typename _Iterator>
inline bool
operator<(const move_iterator<_Iterator>& __x,
const move_iterator<_Iterator>& __y)
{ return __x.base() < __y.base(); }
template<typename _IteratorL, typename _IteratorR>
inline bool
operator<=(const move_iterator<_IteratorL>& __x,
const move_iterator<_IteratorR>& __y)
{ return !(__y < __x); }
template<typename _Iterator>
inline bool
operator<=(const move_iterator<_Iterator>& __x,
const move_iterator<_Iterator>& __y)
{ return !(__y < __x); }
template<typename _IteratorL, typename _IteratorR>
inline bool
operator>(const move_iterator<_IteratorL>& __x,
const move_iterator<_IteratorR>& __y)
{ return __y < __x; }
template<typename _Iterator>
inline bool
operator>(const move_iterator<_Iterator>& __x,
const move_iterator<_Iterator>& __y)
{ return __y < __x; }
template<typename _IteratorL, typename _IteratorR>
inline bool
operator>=(const move_iterator<_IteratorL>& __x,
const move_iterator<_IteratorR>& __y)
{ return !(__x < __y); }
template<typename _Iterator>
inline bool
operator>=(const move_iterator<_Iterator>& __x,
const move_iterator<_Iterator>& __y)
{ return !(__x < __y); }
template<typename _IteratorL, typename _IteratorR>
inline auto
operator-(const move_iterator<_IteratorL>& __x,
const move_iterator<_IteratorR>& __y)
-> decltype(__x.base() - __y.base())
{ return __x.base() - __y.base(); }
template<typename _Iterator>
inline auto
operator-(const move_iterator<_Iterator>& __x,
const move_iterator<_Iterator>& __y)
-> decltype(__x.base() - __y.base())
{ return __x.base() - __y.base(); }
template<typename _Iterator>
inline move_iterator<_Iterator>
operator+(typename move_iterator<_Iterator>::difference_type __n,
const move_iterator<_Iterator>& __x)
{ return __x + __n; }
template<typename _Iterator>
inline move_iterator<_Iterator>
make_move_iterator(_Iterator __i)
{ return move_iterator<_Iterator>(__i); }
template<typename _Iterator, typename _ReturnType
= typename conditional<__move_if_noexcept_cond
<typename iterator_traits<_Iterator>::value_type>::value,
_Iterator, move_iterator<_Iterator>>::type>
inline _ReturnType
__make_move_if_noexcept_iterator(_Iterator __i)
{ return _ReturnType(__i); }
template<typename _Tp, typename _ReturnType
= typename conditional<__move_if_noexcept_cond<_Tp>::value,
const _Tp*, move_iterator<_Tp*>>::type>
inline _ReturnType
__make_move_if_noexcept_iterator(_Tp* __i)
{ return _ReturnType(__i); }
template<typename _Iterator>
auto
__niter_base(move_iterator<_Iterator> __it)
-> decltype(make_move_iterator(__niter_base(__it.base())))
{ return make_move_iterator(__niter_base(__it.base())); }
template<typename _Iterator>
struct __is_move_iterator<move_iterator<_Iterator> >
{
enum { __value = 1 };
typedef __true_type __type;
};
template<typename _Iterator>
auto
__miter_base(move_iterator<_Iterator> __it)
-> decltype(__miter_base(__it.base()))
{ return __miter_base(__it.base()); }
}
# 68 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/debug/debug.h" 1 3
# 48 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/debug/debug.h" 3
namespace std
{
namespace __debug { }
}
namespace __gnu_debug
{
using namespace std::__debug;
}
# 70 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/predefined_ops.h" 1 3
# 33 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/predefined_ops.h" 3
namespace __gnu_cxx
{
namespace __ops
{
struct _Iter_less_iter
{
template<typename _Iterator1, typename _Iterator2>
constexpr
bool
operator()(_Iterator1 __it1, _Iterator2 __it2) const
{ return *__it1 < *__it2; }
};
constexpr
inline _Iter_less_iter
__iter_less_iter()
{ return _Iter_less_iter(); }
struct _Iter_less_val
{
template<typename _Iterator, typename _Value>
bool
operator()(_Iterator __it, _Value& __val) const
{ return *__it < __val; }
};
inline _Iter_less_val
__iter_less_val()
{ return _Iter_less_val(); }
inline _Iter_less_val
__iter_comp_val(_Iter_less_iter)
{ return _Iter_less_val(); }
struct _Val_less_iter
{
template<typename _Value, typename _Iterator>
bool
operator()(_Value& __val, _Iterator __it) const
{ return __val < *__it; }
};
inline _Val_less_iter
__val_less_iter()
{ return _Val_less_iter(); }
inline _Val_less_iter
__val_comp_iter(_Iter_less_iter)
{ return _Val_less_iter(); }
struct _Iter_equal_to_iter
{
template<typename _Iterator1, typename _Iterator2>
bool
operator()(_Iterator1 __it1, _Iterator2 __it2) const
{ return *__it1 == *__it2; }
};
inline _Iter_equal_to_iter
__iter_equal_to_iter()
{ return _Iter_equal_to_iter(); }
struct _Iter_equal_to_val
{
template<typename _Iterator, typename _Value>
bool
operator()(_Iterator __it, _Value& __val) const
{ return *__it == __val; }
};
inline _Iter_equal_to_val
__iter_equal_to_val()
{ return _Iter_equal_to_val(); }
inline _Iter_equal_to_val
__iter_comp_val(_Iter_equal_to_iter)
{ return _Iter_equal_to_val(); }
template<typename _Compare>
struct _Iter_comp_iter
{
_Compare _M_comp;
constexpr
_Iter_comp_iter(_Compare __comp)
: _M_comp(__comp)
{ }
template<typename _Iterator1, typename _Iterator2>
constexpr
bool
operator()(_Iterator1 __it1, _Iterator2 __it2)
{ return bool(_M_comp(*__it1, *__it2)); }
};
template<typename _Compare>
constexpr
inline _Iter_comp_iter<_Compare>
__iter_comp_iter(_Compare __comp)
{ return _Iter_comp_iter<_Compare>(__comp); }
template<typename _Compare>
struct _Iter_comp_val
{
_Compare _M_comp;
_Iter_comp_val(_Compare __comp)
: _M_comp(__comp)
{ }
template<typename _Iterator, typename _Value>
bool
operator()(_Iterator __it, _Value& __val)
{ return bool(_M_comp(*__it, __val)); }
};
template<typename _Compare>
inline _Iter_comp_val<_Compare>
__iter_comp_val(_Compare __comp)
{ return _Iter_comp_val<_Compare>(__comp); }
template<typename _Compare>
inline _Iter_comp_val<_Compare>
__iter_comp_val(_Iter_comp_iter<_Compare> __comp)
{ return _Iter_comp_val<_Compare>(__comp._M_comp); }
template<typename _Compare>
struct _Val_comp_iter
{
_Compare _M_comp;
_Val_comp_iter(_Compare __comp)
: _M_comp(__comp)
{ }
template<typename _Value, typename _Iterator>
bool
operator()(_Value& __val, _Iterator __it)
{ return bool(_M_comp(__val, *__it)); }
};
template<typename _Compare>
inline _Val_comp_iter<_Compare>
__val_comp_iter(_Compare __comp)
{ return _Val_comp_iter<_Compare>(__comp); }
template<typename _Compare>
inline _Val_comp_iter<_Compare>
__val_comp_iter(_Iter_comp_iter<_Compare> __comp)
{ return _Val_comp_iter<_Compare>(__comp._M_comp); }
template<typename _Value>
struct _Iter_equals_val
{
_Value& _M_value;
_Iter_equals_val(_Value& __value)
: _M_value(__value)
{ }
template<typename _Iterator>
bool
operator()(_Iterator __it)
{ return *__it == _M_value; }
};
template<typename _Value>
inline _Iter_equals_val<_Value>
__iter_equals_val(_Value& __val)
{ return _Iter_equals_val<_Value>(__val); }
template<typename _Iterator1>
struct _Iter_equals_iter
{
typename std::iterator_traits<_Iterator1>::reference _M_ref;
_Iter_equals_iter(_Iterator1 __it1)
: _M_ref(*__it1)
{ }
template<typename _Iterator2>
bool
operator()(_Iterator2 __it2)
{ return *__it2 == _M_ref; }
};
template<typename _Iterator>
inline _Iter_equals_iter<_Iterator>
__iter_comp_iter(_Iter_equal_to_iter, _Iterator __it)
{ return _Iter_equals_iter<_Iterator>(__it); }
template<typename _Predicate>
struct _Iter_pred
{
_Predicate _M_pred;
_Iter_pred(_Predicate __pred)
: _M_pred(__pred)
{ }
template<typename _Iterator>
bool
operator()(_Iterator __it)
{ return bool(_M_pred(*__it)); }
};
template<typename _Predicate>
inline _Iter_pred<_Predicate>
__pred_iter(_Predicate __pred)
{ return _Iter_pred<_Predicate>(__pred); }
template<typename _Compare, typename _Value>
struct _Iter_comp_to_val
{
_Compare _M_comp;
_Value& _M_value;
_Iter_comp_to_val(_Compare __comp, _Value& __value)
: _M_comp(__comp), _M_value(__value)
{ }
template<typename _Iterator>
bool
operator()(_Iterator __it)
{ return bool(_M_comp(*__it, _M_value)); }
};
template<typename _Compare, typename _Value>
_Iter_comp_to_val<_Compare, _Value>
__iter_comp_val(_Compare __comp, _Value &__val)
{ return _Iter_comp_to_val<_Compare, _Value>(__comp, __val); }
template<typename _Compare, typename _Iterator1>
struct _Iter_comp_to_iter
{
_Compare _M_comp;
typename std::iterator_traits<_Iterator1>::reference _M_ref;
_Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1)
: _M_comp(__comp), _M_ref(*__it1)
{ }
template<typename _Iterator2>
bool
operator()(_Iterator2 __it2)
{ return bool(_M_comp(*__it2, _M_ref)); }
};
template<typename _Compare, typename _Iterator>
inline _Iter_comp_to_iter<_Compare, _Iterator>
__iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it)
{ return _Iter_comp_to_iter<_Compare, _Iterator>(__comp._M_comp, __it); }
template<typename _Predicate>
struct _Iter_negate
{
_Predicate _M_pred;
_Iter_negate(_Predicate __pred)
: _M_pred(__pred)
{ }
template<typename _Iterator>
bool
operator()(_Iterator __it)
{ return !bool(_M_pred(*__it)); }
};
template<typename _Predicate>
inline _Iter_negate<_Predicate>
__negate(_Iter_pred<_Predicate> __pred)
{ return _Iter_negate<_Predicate>(__pred._M_pred); }
}
}
# 72 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 118 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 3
template<typename _ForwardIterator1, typename _ForwardIterator2>
inline void
iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
{
# 148 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 3
swap(*__a, *__b);
}
# 164 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 3
template<typename _ForwardIterator1, typename _ForwardIterator2>
_ForwardIterator2
swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2)
{
;
for (; __first1 != __last1; ++__first1, (void)++__first2)
std::iter_swap(__first1, __first2);
return __first2;
}
# 192 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 3
template<typename _Tp>
constexpr
inline const _Tp&
min(const _Tp& __a, const _Tp& __b)
{
if (__b < __a)
return __b;
return __a;
}
# 216 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 3
template<typename _Tp>
constexpr
inline const _Tp&
max(const _Tp& __a, const _Tp& __b)
{
if (__a < __b)
return __b;
return __a;
}
# 240 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 3
template<typename _Tp, typename _Compare>
constexpr
inline const _Tp&
min(const _Tp& __a, const _Tp& __b, _Compare __comp)
{
if (__comp(__b, __a))
return __b;
return __a;
}
# 262 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 3
template<typename _Tp, typename _Compare>
constexpr
inline const _Tp&
max(const _Tp& __a, const _Tp& __b, _Compare __comp)
{
if (__comp(__a, __b))
return __b;
return __a;
}
template<typename _Iterator>
inline _Iterator
__niter_base(_Iterator __it)
{ return __it; }
template<bool, bool, typename>
struct __copy_move
{
template<typename _II, typename _OI>
static _OI
__copy_m(_II __first, _II __last, _OI __result)
{
for (; __first != __last; ++__result, (void)++__first)
*__result = *__first;
return __result;
}
};
template<typename _Category>
struct __copy_move<true, false, _Category>
{
template<typename _II, typename _OI>
static _OI
__copy_m(_II __first, _II __last, _OI __result)
{
for (; __first != __last; ++__result, (void)++__first)
*__result = std::move(*__first);
return __result;
}
};
template<>
struct __copy_move<false, false, random_access_iterator_tag>
{
template<typename _II, typename _OI>
static _OI
__copy_m(_II __first, _II __last, _OI __result)
{
typedef typename iterator_traits<_II>::difference_type _Distance;
for(_Distance __n = __last - __first; __n > 0; --__n)
{
*__result = *__first;
++__first;
++__result;
}
return __result;
}
};
template<>
struct __copy_move<true, false, random_access_iterator_tag>
{
template<typename _II, typename _OI>
static _OI
__copy_m(_II __first, _II __last, _OI __result)
{
typedef typename iterator_traits<_II>::difference_type _Distance;
for(_Distance __n = __last - __first; __n > 0; --__n)
{
*__result = std::move(*__first);
++__first;
++__result;
}
return __result;
}
};
template<bool _IsMove>
struct __copy_move<_IsMove, true, random_access_iterator_tag>
{
template<typename _Tp>
static _Tp*
__copy_m(const _Tp* __first, const _Tp* __last, _Tp* __result)
{
using __assignable = conditional<_IsMove,
is_move_assignable<_Tp>,
is_copy_assignable<_Tp>>;
static_assert( __assignable::type::value, "type is not assignable" );
const ptrdiff_t _Num = __last - __first;
if (_Num)
__builtin_memmove(__result, __first, sizeof(_Tp) * _Num);
return __result + _Num;
}
};
template<bool _IsMove, typename _II, typename _OI>
inline _OI
__copy_move_a(_II __first, _II __last, _OI __result)
{
typedef typename iterator_traits<_II>::value_type _ValueTypeI;
typedef typename iterator_traits<_OI>::value_type _ValueTypeO;
typedef typename iterator_traits<_II>::iterator_category _Category;
const bool __simple = (__is_trivial(_ValueTypeI)
&& __is_pointer<_II>::__value
&& __is_pointer<_OI>::__value
&& __are_same<_ValueTypeI, _ValueTypeO>::__value);
return std::__copy_move<_IsMove, __simple,
_Category>::__copy_m(__first, __last, __result);
}
template<typename _CharT>
struct char_traits;
template<typename _CharT, typename _Traits>
class istreambuf_iterator;
template<typename _CharT, typename _Traits>
class ostreambuf_iterator;
template<bool _IsMove, typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
__copy_move_a2(_CharT*, _CharT*,
ostreambuf_iterator<_CharT, char_traits<_CharT> >);
template<bool _IsMove, typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
__copy_move_a2(const _CharT*, const _CharT*,
ostreambuf_iterator<_CharT, char_traits<_CharT> >);
template<bool _IsMove, typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
_CharT*>::__type
__copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >,
istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*);
template<bool _IsMove, typename _II, typename _OI>
inline _OI
__copy_move_a2(_II __first, _II __last, _OI __result)
{
return _OI(std::__copy_move_a<_IsMove>(std::__niter_base(__first),
std::__niter_base(__last),
std::__niter_base(__result)));
}
# 444 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 3
template<typename _II, typename _OI>
inline _OI
copy(_II __first, _II __last, _OI __result)
{
;
return (std::__copy_move_a2<__is_move_iterator<_II>::__value>
(std::__miter_base(__first), std::__miter_base(__last),
__result));
}
# 477 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 3
template<typename _II, typename _OI>
inline _OI
move(_II __first, _II __last, _OI __result)
{
;
return std::__copy_move_a2<true>(std::__miter_base(__first),
std::__miter_base(__last), __result);
}
template<bool, bool, typename>
struct __copy_move_backward
{
template<typename _BI1, typename _BI2>
static _BI2
__copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
{
while (__first != __last)
*--__result = *--__last;
return __result;
}
};
template<typename _Category>
struct __copy_move_backward<true, false, _Category>
{
template<typename _BI1, typename _BI2>
static _BI2
__copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
{
while (__first != __last)
*--__result = std::move(*--__last);
return __result;
}
};
template<>
struct __copy_move_backward<false, false, random_access_iterator_tag>
{
template<typename _BI1, typename _BI2>
static _BI2
__copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
{
typename iterator_traits<_BI1>::difference_type __n;
for (__n = __last - __first; __n > 0; --__n)
*--__result = *--__last;
return __result;
}
};
template<>
struct __copy_move_backward<true, false, random_access_iterator_tag>
{
template<typename _BI1, typename _BI2>
static _BI2
__copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
{
typename iterator_traits<_BI1>::difference_type __n;
for (__n = __last - __first; __n > 0; --__n)
*--__result = std::move(*--__last);
return __result;
}
};
template<bool _IsMove>
struct __copy_move_backward<_IsMove, true, random_access_iterator_tag>
{
template<typename _Tp>
static _Tp*
__copy_move_b(const _Tp* __first, const _Tp* __last, _Tp* __result)
{
using __assignable = conditional<_IsMove,
is_move_assignable<_Tp>,
is_copy_assignable<_Tp>>;
static_assert( __assignable::type::value, "type is not assignable" );
const ptrdiff_t _Num = __last - __first;
if (_Num)
__builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num);
return __result - _Num;
}
};
template<bool _IsMove, typename _BI1, typename _BI2>
inline _BI2
__copy_move_backward_a(_BI1 __first, _BI1 __last, _BI2 __result)
{
typedef typename iterator_traits<_BI1>::value_type _ValueType1;
typedef typename iterator_traits<_BI2>::value_type _ValueType2;
typedef typename iterator_traits<_BI1>::iterator_category _Category;
const bool __simple = (__is_trivial(_ValueType1)
&& __is_pointer<_BI1>::__value
&& __is_pointer<_BI2>::__value
&& __are_same<_ValueType1, _ValueType2>::__value);
return std::__copy_move_backward<_IsMove, __simple,
_Category>::__copy_move_b(__first,
__last,
__result);
}
template<bool _IsMove, typename _BI1, typename _BI2>
inline _BI2
__copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result)
{
return _BI2(std::__copy_move_backward_a<_IsMove>
(std::__niter_base(__first), std::__niter_base(__last),
std::__niter_base(__result)));
}
# 620 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 3
template<typename _BI1, typename _BI2>
inline _BI2
copy_backward(_BI1 __first, _BI1 __last, _BI2 __result)
{
;
return (std::__copy_move_backward_a2<__is_move_iterator<_BI1>::__value>
(std::__miter_base(__first), std::__miter_base(__last),
__result));
}
# 656 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 3
template<typename _BI1, typename _BI2>
inline _BI2
move_backward(_BI1 __first, _BI1 __last, _BI2 __result)
{
;
return std::__copy_move_backward_a2<true>(std::__miter_base(__first),
std::__miter_base(__last),
__result);
}
template<typename _ForwardIterator, typename _Tp>
inline typename
__gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, void>::__type
__fill_a(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __value)
{
for (; __first != __last; ++__first)
*__first = __value;
}
template<typename _ForwardIterator, typename _Tp>
inline typename
__gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type
__fill_a(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __value)
{
const _Tp __tmp = __value;
for (; __first != __last; ++__first)
*__first = __tmp;
}
template<typename _Tp>
inline typename
__gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type
__fill_a(_Tp* __first, _Tp* __last, const _Tp& __c)
{
const _Tp __tmp = __c;
if (const size_t __len = __last - __first)
__builtin_memset(__first, static_cast<unsigned char>(__tmp), __len);
}
# 722 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 3
template<typename _ForwardIterator, typename _Tp>
inline void
fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
{
;
std::__fill_a(std::__niter_base(__first), std::__niter_base(__last),
__value);
}
template<typename _OutputIterator, typename _Size, typename _Tp>
inline typename
__gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, _OutputIterator>::__type
__fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
{
for (__decltype(__n + 0) __niter = __n;
__niter > 0; --__niter, ++__first)
*__first = __value;
return __first;
}
template<typename _OutputIterator, typename _Size, typename _Tp>
inline typename
__gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type
__fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
{
const _Tp __tmp = __value;
for (__decltype(__n + 0) __niter = __n;
__niter > 0; --__niter, ++__first)
*__first = __tmp;
return __first;
}
template<typename _Size, typename _Tp>
inline typename
__gnu_cxx::__enable_if<__is_byte<_Tp>::__value, _Tp*>::__type
__fill_n_a(_Tp* __first, _Size __n, const _Tp& __c)
{
std::__fill_a(__first, __first + __n, __c);
return __first + __n;
}
# 782 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 3
template<typename _OI, typename _Size, typename _Tp>
inline _OI
fill_n(_OI __first, _Size __n, const _Tp& __value)
{
return _OI(std::__fill_n_a(std::__niter_base(__first), __n, __value));
}
template<bool _BoolType>
struct __equal
{
template<typename _II1, typename _II2>
static bool
equal(_II1 __first1, _II1 __last1, _II2 __first2)
{
for (; __first1 != __last1; ++__first1, (void)++__first2)
if (!(*__first1 == *__first2))
return false;
return true;
}
};
template<>
struct __equal<true>
{
template<typename _Tp>
static bool
equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2)
{
if (const size_t __len = (__last1 - __first1))
return !__builtin_memcmp(__first1, __first2, sizeof(_Tp) * __len);
return true;
}
};
template<typename _II1, typename _II2>
inline bool
__equal_aux(_II1 __first1, _II1 __last1, _II2 __first2)
{
typedef typename iterator_traits<_II1>::value_type _ValueType1;
typedef typename iterator_traits<_II2>::value_type _ValueType2;
const bool __simple = ((__is_integer<_ValueType1>::__value
|| __is_pointer<_ValueType1>::__value)
&& __is_pointer<_II1>::__value
&& __is_pointer<_II2>::__value
&& __are_same<_ValueType1, _ValueType2>::__value);
return std::__equal<__simple>::equal(__first1, __last1, __first2);
}
template<typename, typename>
struct __lc_rai
{
template<typename _II1, typename _II2>
static _II1
__newlast1(_II1, _II1 __last1, _II2, _II2)
{ return __last1; }
template<typename _II>
static bool
__cnd2(_II __first, _II __last)
{ return __first != __last; }
};
template<>
struct __lc_rai<random_access_iterator_tag, random_access_iterator_tag>
{
template<typename _RAI1, typename _RAI2>
static _RAI1
__newlast1(_RAI1 __first1, _RAI1 __last1,
_RAI2 __first2, _RAI2 __last2)
{
const typename iterator_traits<_RAI1>::difference_type
__diff1 = __last1 - __first1;
const typename iterator_traits<_RAI2>::difference_type
__diff2 = __last2 - __first2;
return __diff2 < __diff1 ? __first1 + __diff2 : __last1;
}
template<typename _RAI>
static bool
__cnd2(_RAI, _RAI)
{ return true; }
};
template<typename _II1, typename _II2, typename _Compare>
bool
__lexicographical_compare_impl(_II1 __first1, _II1 __last1,
_II2 __first2, _II2 __last2,
_Compare __comp)
{
typedef typename iterator_traits<_II1>::iterator_category _Category1;
typedef typename iterator_traits<_II2>::iterator_category _Category2;
typedef std::__lc_rai<_Category1, _Category2> __rai_type;
__last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2);
for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2);
++__first1, (void)++__first2)
{
if (__comp(__first1, __first2))
return true;
if (__comp(__first2, __first1))
return false;
}
return __first1 == __last1 && __first2 != __last2;
}
template<bool _BoolType>
struct __lexicographical_compare
{
template<typename _II1, typename _II2>
static bool __lc(_II1, _II1, _II2, _II2);
};
template<bool _BoolType>
template<typename _II1, typename _II2>
bool
__lexicographical_compare<_BoolType>::
__lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
{
return std::__lexicographical_compare_impl(__first1, __last1,
__first2, __last2,
__gnu_cxx::__ops::__iter_less_iter());
}
template<>
struct __lexicographical_compare<true>
{
template<typename _Tp, typename _Up>
static bool
__lc(const _Tp* __first1, const _Tp* __last1,
const _Up* __first2, const _Up* __last2)
{
const size_t __len1 = __last1 - __first1;
const size_t __len2 = __last2 - __first2;
if (const size_t __len = std::min(__len1, __len2))
if (int __result = __builtin_memcmp(__first1, __first2, __len))
return __result < 0;
return __len1 < __len2;
}
};
template<typename _II1, typename _II2>
inline bool
__lexicographical_compare_aux(_II1 __first1, _II1 __last1,
_II2 __first2, _II2 __last2)
{
typedef typename iterator_traits<_II1>::value_type _ValueType1;
typedef typename iterator_traits<_II2>::value_type _ValueType2;
const bool __simple =
(__is_byte<_ValueType1>::__value && __is_byte<_ValueType2>::__value
&& !__gnu_cxx::__numeric_traits<_ValueType1>::__is_signed
&& !__gnu_cxx::__numeric_traits<_ValueType2>::__is_signed
&& __is_pointer<_II1>::__value
&& __is_pointer<_II2>::__value);
return std::__lexicographical_compare<__simple>::__lc(__first1, __last1,
__first2, __last2);
}
template<typename _ForwardIterator, typename _Tp, typename _Compare>
_ForwardIterator
__lower_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __comp)
{
typedef typename iterator_traits<_ForwardIterator>::difference_type
_DistanceType;
_DistanceType __len = std::distance(__first, __last);
while (__len > 0)
{
_DistanceType __half = __len >> 1;
_ForwardIterator __middle = __first;
std::advance(__middle, __half);
if (__comp(__middle, __val))
{
__first = __middle;
++__first;
__len = __len - __half - 1;
}
else
__len = __half;
}
return __first;
}
# 982 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 3
template<typename _ForwardIterator, typename _Tp>
inline _ForwardIterator
lower_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val)
{
;
return std::__lower_bound(__first, __last, __val,
__gnu_cxx::__ops::__iter_less_val());
}
inline constexpr int
__lg(int __n)
{ return sizeof(int) * 8 - 1 - __builtin_clz(__n); }
inline constexpr unsigned
__lg(unsigned __n)
{ return sizeof(int) * 8 - 1 - __builtin_clz(__n); }
inline constexpr long
__lg(long __n)
{ return sizeof(long) * 8 - 1 - __builtin_clzl(__n); }
inline constexpr unsigned long
__lg(unsigned long __n)
{ return sizeof(long) * 8 - 1 - __builtin_clzl(__n); }
inline constexpr long long
__lg(long long __n)
{ return sizeof(long long) * 8 - 1 - __builtin_clzll(__n); }
inline constexpr unsigned long long
__lg(unsigned long long __n)
{ return sizeof(long long) * 8 - 1 - __builtin_clzll(__n); }
# 1039 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 3
template<typename _II1, typename _II2>
inline bool
equal(_II1 __first1, _II1 __last1, _II2 __first2)
{
;
return std::__equal_aux(std::__niter_base(__first1),
std::__niter_base(__last1),
std::__niter_base(__first2));
}
# 1071 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 3
template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
inline bool
equal(_IIter1 __first1, _IIter1 __last1,
_IIter2 __first2, _BinaryPredicate __binary_pred)
{
;
for (; __first1 != __last1; ++__first1, (void)++__first2)
if (!bool(__binary_pred(*__first1, *__first2)))
return false;
return true;
}
# 1104 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 3
template<typename _II1, typename _II2>
inline bool
equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
{
;
;
using _RATag = random_access_iterator_tag;
using _Cat1 = typename iterator_traits<_II1>::iterator_category;
using _Cat2 = typename iterator_traits<_II2>::iterator_category;
using _RAIters = __and_<is_same<_Cat1, _RATag>, is_same<_Cat2, _RATag>>;
if (_RAIters())
{
auto __d1 = std::distance(__first1, __last1);
auto __d2 = std::distance(__first2, __last2);
if (__d1 != __d2)
return false;
return std::equal(__first1, __last1, __first2);
}
for (; __first1 != __last1 && __first2 != __last2;
++__first1, (void)++__first2)
if (!(*__first1 == *__first2))
return false;
return __first1 == __last1 && __first2 == __last2;
}
# 1153 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 3
template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
inline bool
equal(_IIter1 __first1, _IIter1 __last1,
_IIter2 __first2, _IIter2 __last2, _BinaryPredicate __binary_pred)
{
;
;
using _RATag = random_access_iterator_tag;
using _Cat1 = typename iterator_traits<_IIter1>::iterator_category;
using _Cat2 = typename iterator_traits<_IIter2>::iterator_category;
using _RAIters = __and_<is_same<_Cat1, _RATag>, is_same<_Cat2, _RATag>>;
if (_RAIters())
{
auto __d1 = std::distance(__first1, __last1);
auto __d2 = std::distance(__first2, __last2);
if (__d1 != __d2)
return false;
return std::equal(__first1, __last1, __first2,
__binary_pred);
}
for (; __first1 != __last1 && __first2 != __last2;
++__first1, (void)++__first2)
if (!bool(__binary_pred(*__first1, *__first2)))
return false;
return __first1 == __last1 && __first2 == __last2;
}
# 1201 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 3
template<typename _II1, typename _II2>
inline bool
lexicographical_compare(_II1 __first1, _II1 __last1,
_II2 __first2, _II2 __last2)
{
;
;
return std::__lexicographical_compare_aux(std::__niter_base(__first1),
std::__niter_base(__last1),
std::__niter_base(__first2),
std::__niter_base(__last2));
}
# 1237 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 3
template<typename _II1, typename _II2, typename _Compare>
inline bool
lexicographical_compare(_II1 __first1, _II1 __last1,
_II2 __first2, _II2 __last2, _Compare __comp)
{
;
;
return std::__lexicographical_compare_impl
(__first1, __last1, __first2, __last2,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
template<typename _InputIterator1, typename _InputIterator2,
typename _BinaryPredicate>
pair<_InputIterator1, _InputIterator2>
__mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _BinaryPredicate __binary_pred)
{
while (__first1 != __last1 && __binary_pred(__first1, __first2))
{
++__first1;
++__first2;
}
return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
}
# 1280 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 3
template<typename _InputIterator1, typename _InputIterator2>
inline pair<_InputIterator1, _InputIterator2>
mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2)
{
;
return std::__mismatch(__first1, __last1, __first2,
__gnu_cxx::__ops::__iter_equal_to_iter());
}
# 1313 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 3
template<typename _InputIterator1, typename _InputIterator2,
typename _BinaryPredicate>
inline pair<_InputIterator1, _InputIterator2>
mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _BinaryPredicate __binary_pred)
{
;
return std::__mismatch(__first1, __last1, __first2,
__gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
}
template<typename _InputIterator1, typename _InputIterator2,
typename _BinaryPredicate>
pair<_InputIterator1, _InputIterator2>
__mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_BinaryPredicate __binary_pred)
{
while (__first1 != __last1 && __first2 != __last2
&& __binary_pred(__first1, __first2))
{
++__first1;
++__first2;
}
return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
}
# 1360 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 3
template<typename _InputIterator1, typename _InputIterator2>
inline pair<_InputIterator1, _InputIterator2>
mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2)
{
;
;
return std::__mismatch(__first1, __last1, __first2, __last2,
__gnu_cxx::__ops::__iter_equal_to_iter());
}
# 1395 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 3
template<typename _InputIterator1, typename _InputIterator2,
typename _BinaryPredicate>
inline pair<_InputIterator1, _InputIterator2>
mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_BinaryPredicate __binary_pred)
{
;
;
return std::__mismatch(__first1, __last1, __first2, __last2,
__gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
}
}
# 40 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/char_traits.h" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cwchar" 1 3
# 39 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cwchar" 3
# 40 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cwchar" 3
# 1 "/usr/include/wchar.h" 1 3 4
# 45 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cwchar" 2 3
# 42 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/char_traits.h" 2 3
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
# 57 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/char_traits.h" 3
template<typename _CharT>
struct _Char_types
{
typedef unsigned long int_type;
typedef std::streampos pos_type;
typedef std::streamoff off_type;
typedef std::mbstate_t state_type;
};
# 82 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/char_traits.h" 3
template<typename _CharT>
struct char_traits
{
typedef _CharT char_type;
typedef typename _Char_types<_CharT>::int_type int_type;
typedef typename _Char_types<_CharT>::pos_type pos_type;
typedef typename _Char_types<_CharT>::off_type off_type;
typedef typename _Char_types<_CharT>::state_type state_type;
static void
assign(char_type& __c1, const char_type& __c2)
{ __c1 = __c2; }
static constexpr bool
eq(const char_type& __c1, const char_type& __c2)
{ return __c1 == __c2; }
static constexpr bool
lt(const char_type& __c1, const char_type& __c2)
{ return __c1 < __c2; }
static int
compare(const char_type* __s1, const char_type* __s2, std::size_t __n);
static std::size_t
length(const char_type* __s);
static const char_type*
find(const char_type* __s, std::size_t __n, const char_type& __a);
static char_type*
move(char_type* __s1, const char_type* __s2, std::size_t __n);
static char_type*
copy(char_type* __s1, const char_type* __s2, std::size_t __n);
static char_type*
assign(char_type* __s, std::size_t __n, char_type __a);
static constexpr char_type
to_char_type(const int_type& __c)
{ return static_cast<char_type>(__c); }
static constexpr int_type
to_int_type(const char_type& __c)
{ return static_cast<int_type>(__c); }
static constexpr bool
eq_int_type(const int_type& __c1, const int_type& __c2)
{ return __c1 == __c2; }
static constexpr int_type
eof()
{ return static_cast<int_type>(-1); }
static constexpr int_type
not_eof(const int_type& __c)
{ return !eq_int_type(__c, eof()) ? __c : to_int_type(char_type()); }
};
template<typename _CharT>
int
char_traits<_CharT>::
compare(const char_type* __s1, const char_type* __s2, std::size_t __n)
{
for (std::size_t __i = 0; __i < __n; ++__i)
if (lt(__s1[__i], __s2[__i]))
return -1;
else if (lt(__s2[__i], __s1[__i]))
return 1;
return 0;
}
template<typename _CharT>
std::size_t
char_traits<_CharT>::
length(const char_type* __p)
{
std::size_t __i = 0;
while (!eq(__p[__i], char_type()))
++__i;
return __i;
}
template<typename _CharT>
const typename char_traits<_CharT>::char_type*
char_traits<_CharT>::
find(const char_type* __s, std::size_t __n, const char_type& __a)
{
for (std::size_t __i = 0; __i < __n; ++__i)
if (eq(__s[__i], __a))
return __s + __i;
return 0;
}
template<typename _CharT>
typename char_traits<_CharT>::char_type*
char_traits<_CharT>::
move(char_type* __s1, const char_type* __s2, std::size_t __n)
{
return static_cast<_CharT*>(__builtin_memmove(__s1, __s2,
__n * sizeof(char_type)));
}
template<typename _CharT>
typename char_traits<_CharT>::char_type*
char_traits<_CharT>::
copy(char_type* __s1, const char_type* __s2, std::size_t __n)
{
std::copy(__s2, __s2 + __n, __s1);
return __s1;
}
template<typename _CharT>
typename char_traits<_CharT>::char_type*
char_traits<_CharT>::
assign(char_type* __s, std::size_t __n, char_type __a)
{
std::fill_n(__s, __n, __a);
return __s;
}
}
namespace std __attribute__ ((__visibility__ ("default")))
{
# 226 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/char_traits.h" 3
template<class _CharT>
struct char_traits : public __gnu_cxx::char_traits<_CharT>
{ };
template<>
struct char_traits<char>
{
typedef char char_type;
typedef int int_type;
typedef streampos pos_type;
typedef streamoff off_type;
typedef mbstate_t state_type;
static void
assign(char_type& __c1, const char_type& __c2) noexcept
{ __c1 = __c2; }
static constexpr bool
eq(const char_type& __c1, const char_type& __c2) noexcept
{ return __c1 == __c2; }
static constexpr bool
lt(const char_type& __c1, const char_type& __c2) noexcept
{
return (static_cast<unsigned char>(__c1)
< static_cast<unsigned char>(__c2));
}
static int
compare(const char_type* __s1, const char_type* __s2, size_t __n)
{
if (__n == 0)
return 0;
return __builtin_memcmp(__s1, __s2, __n);
}
static size_t
length(const char_type* __s)
{ return __builtin_strlen(__s); }
static const char_type*
find(const char_type* __s, size_t __n, const char_type& __a)
{
if (__n == 0)
return 0;
return static_cast<const char_type*>(__builtin_memchr(__s, __a, __n));
}
static char_type*
move(char_type* __s1, const char_type* __s2, size_t __n)
{
if (__n == 0)
return __s1;
return static_cast<char_type*>(__builtin_memmove(__s1, __s2, __n));
}
static char_type*
copy(char_type* __s1, const char_type* __s2, size_t __n)
{
if (__n == 0)
return __s1;
return static_cast<char_type*>(__builtin_memcpy(__s1, __s2, __n));
}
static char_type*
assign(char_type* __s, size_t __n, char_type __a)
{
if (__n == 0)
return __s;
return static_cast<char_type*>(__builtin_memset(__s, __a, __n));
}
static constexpr char_type
to_char_type(const int_type& __c) noexcept
{ return static_cast<char_type>(__c); }
static constexpr int_type
to_int_type(const char_type& __c) noexcept
{ return static_cast<int_type>(static_cast<unsigned char>(__c)); }
static constexpr bool
eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
{ return __c1 == __c2; }
static constexpr int_type
eof() noexcept
{ return static_cast<int_type>(-1); }
static constexpr int_type
not_eof(const int_type& __c) noexcept
{ return (__c == eof()) ? 0 : __c; }
};
template<>
struct char_traits<wchar_t>
{
typedef wchar_t char_type;
typedef wint_t int_type;
typedef streamoff off_type;
typedef wstreampos pos_type;
typedef mbstate_t state_type;
static void
assign(char_type& __c1, const char_type& __c2) noexcept
{ __c1 = __c2; }
static constexpr bool
eq(const char_type& __c1, const char_type& __c2) noexcept
{ return __c1 == __c2; }
static constexpr bool
lt(const char_type& __c1, const char_type& __c2) noexcept
{ return __c1 < __c2; }
static int
compare(const char_type* __s1, const char_type* __s2, size_t __n)
{
if (__n == 0)
return 0;
return wmemcmp(__s1, __s2, __n);
}
static size_t
length(const char_type* __s)
{ return wcslen(__s); }
static const char_type*
find(const char_type* __s, size_t __n, const char_type& __a)
{
if (__n == 0)
return 0;
return wmemchr(__s, __a, __n);
}
static char_type*
move(char_type* __s1, const char_type* __s2, size_t __n)
{
if (__n == 0)
return __s1;
return wmemmove(__s1, __s2, __n);
}
static char_type*
copy(char_type* __s1, const char_type* __s2, size_t __n)
{
if (__n == 0)
return __s1;
return wmemcpy(__s1, __s2, __n);
}
static char_type*
assign(char_type* __s, size_t __n, char_type __a)
{
if (__n == 0)
return __s;
return wmemset(__s, __a, __n);
}
static constexpr char_type
to_char_type(const int_type& __c) noexcept
{ return char_type(__c); }
static constexpr int_type
to_int_type(const char_type& __c) noexcept
{ return int_type(__c); }
static constexpr bool
eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
{ return __c1 == __c2; }
static constexpr int_type
eof() noexcept
{ return static_cast<int_type>((0xffffffffu)); }
static constexpr int_type
not_eof(const int_type& __c) noexcept
{ return eq_int_type(__c, eof()) ? 0 : __c; }
};
}
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdint" 1 3
# 32 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdint" 3
# 33 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdint" 3
# 41 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdint" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include/stdint.h" 1 3 4
# 9 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include/stdint.h" 3 4
# 1 "/usr/include/stdint.h" 1 3 4
# 27 "/usr/include/stdint.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 28 "/usr/include/stdint.h" 2 3 4
# 36 "/usr/include/stdint.h" 3 4
typedef signed char int8_t;
typedef short int int16_t;
typedef int int32_t;
typedef long int int64_t;
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;
# 10 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include/stdint.h" 2 3 4
# 42 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdint" 2 3
namespace std
{
using ::int8_t;
using ::int16_t;
using ::int32_t;
using ::int64_t;
using ::int_fast8_t;
using ::int_fast16_t;
using ::int_fast32_t;
using ::int_fast64_t;
using ::int_least8_t;
using ::int_least16_t;
using ::int_least32_t;
using ::int_least64_t;
using ::intmax_t;
using ::intptr_t;
using ::uint8_t;
using ::uint16_t;
using ::uint32_t;
using ::uint64_t;
using ::uint_fast8_t;
using ::uint_fast16_t;
using ::uint_fast32_t;
using ::uint_fast64_t;
using ::uint_least8_t;
using ::uint_least16_t;
using ::uint_least32_t;
using ::uint_least64_t;
using ::uintmax_t;
using ::uintptr_t;
}
# 421 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/char_traits.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<>
struct char_traits<char16_t>
{
typedef char16_t char_type;
typedef uint_least16_t int_type;
typedef streamoff off_type;
typedef u16streampos pos_type;
typedef mbstate_t state_type;
static void
assign(char_type& __c1, const char_type& __c2) noexcept
{ __c1 = __c2; }
static constexpr bool
eq(const char_type& __c1, const char_type& __c2) noexcept
{ return __c1 == __c2; }
static constexpr bool
lt(const char_type& __c1, const char_type& __c2) noexcept
{ return __c1 < __c2; }
static int
compare(const char_type* __s1, const char_type* __s2, size_t __n)
{
for (size_t __i = 0; __i < __n; ++__i)
if (lt(__s1[__i], __s2[__i]))
return -1;
else if (lt(__s2[__i], __s1[__i]))
return 1;
return 0;
}
static size_t
length(const char_type* __s)
{
size_t __i = 0;
while (!eq(__s[__i], char_type()))
++__i;
return __i;
}
static const char_type*
find(const char_type* __s, size_t __n, const char_type& __a)
{
for (size_t __i = 0; __i < __n; ++__i)
if (eq(__s[__i], __a))
return __s + __i;
return 0;
}
static char_type*
move(char_type* __s1, const char_type* __s2, size_t __n)
{
if (__n == 0)
return __s1;
return (static_cast<char_type*>
(__builtin_memmove(__s1, __s2, __n * sizeof(char_type))));
}
static char_type*
copy(char_type* __s1, const char_type* __s2, size_t __n)
{
if (__n == 0)
return __s1;
return (static_cast<char_type*>
(__builtin_memcpy(__s1, __s2, __n * sizeof(char_type))));
}
static char_type*
assign(char_type* __s, size_t __n, char_type __a)
{
for (size_t __i = 0; __i < __n; ++__i)
assign(__s[__i], __a);
return __s;
}
static constexpr char_type
to_char_type(const int_type& __c) noexcept
{ return char_type(__c); }
static constexpr int_type
to_int_type(const char_type& __c) noexcept
{ return int_type(__c); }
static constexpr bool
eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
{ return __c1 == __c2; }
static constexpr int_type
eof() noexcept
{ return static_cast<int_type>(-1); }
static constexpr int_type
not_eof(const int_type& __c) noexcept
{ return eq_int_type(__c, eof()) ? 0 : __c; }
};
template<>
struct char_traits<char32_t>
{
typedef char32_t char_type;
typedef uint_least32_t int_type;
typedef streamoff off_type;
typedef u32streampos pos_type;
typedef mbstate_t state_type;
static void
assign(char_type& __c1, const char_type& __c2) noexcept
{ __c1 = __c2; }
static constexpr bool
eq(const char_type& __c1, const char_type& __c2) noexcept
{ return __c1 == __c2; }
static constexpr bool
lt(const char_type& __c1, const char_type& __c2) noexcept
{ return __c1 < __c2; }
static int
compare(const char_type* __s1, const char_type* __s2, size_t __n)
{
for (size_t __i = 0; __i < __n; ++__i)
if (lt(__s1[__i], __s2[__i]))
return -1;
else if (lt(__s2[__i], __s1[__i]))
return 1;
return 0;
}
static size_t
length(const char_type* __s)
{
size_t __i = 0;
while (!eq(__s[__i], char_type()))
++__i;
return __i;
}
static const char_type*
find(const char_type* __s, size_t __n, const char_type& __a)
{
for (size_t __i = 0; __i < __n; ++__i)
if (eq(__s[__i], __a))
return __s + __i;
return 0;
}
static char_type*
move(char_type* __s1, const char_type* __s2, size_t __n)
{
if (__n == 0)
return __s1;
return (static_cast<char_type*>
(__builtin_memmove(__s1, __s2, __n * sizeof(char_type))));
}
static char_type*
copy(char_type* __s1, const char_type* __s2, size_t __n)
{
if (__n == 0)
return __s1;
return (static_cast<char_type*>
(__builtin_memcpy(__s1, __s2, __n * sizeof(char_type))));
}
static char_type*
assign(char_type* __s, size_t __n, char_type __a)
{
for (size_t __i = 0; __i < __n; ++__i)
assign(__s[__i], __a);
return __s;
}
static constexpr char_type
to_char_type(const int_type& __c) noexcept
{ return char_type(__c); }
static constexpr int_type
to_int_type(const char_type& __c) noexcept
{ return int_type(__c); }
static constexpr bool
eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
{ return __c1 == __c2; }
static constexpr int_type
eof() noexcept
{ return static_cast<int_type>(-1); }
static constexpr int_type
not_eof(const int_type& __c) noexcept
{ return eq_int_type(__c, eof()) ? 0 : __c; }
};
}
# 41 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ios" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/localefwd.h" 1 3
# 37 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/localefwd.h" 3
# 38 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/localefwd.h" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/c++locale.h" 1 3
# 39 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/c++locale.h" 3
# 40 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/c++locale.h" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/clocale" 1 3
# 39 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/clocale" 3
# 40 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/clocale" 3
# 1 "/usr/include/locale.h" 1 3 4
# 29 "/usr/include/locale.h" 3 4
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include/stddef.h" 1 3 4
# 30 "/usr/include/locale.h" 2 3 4
# 1 "/usr/include/bits/locale.h" 1 3 4
# 31 "/usr/include/locale.h" 2 3 4
extern "C" {
# 51 "/usr/include/locale.h" 3 4
struct lconv
{
char *decimal_point;
char *thousands_sep;
char *grouping;
char *int_curr_symbol;
char *currency_symbol;
char *mon_decimal_point;
char *mon_thousands_sep;
char *mon_grouping;
char *positive_sign;
char *negative_sign;
char int_frac_digits;
char frac_digits;
char p_cs_precedes;
char p_sep_by_space;
char n_cs_precedes;
char n_sep_by_space;
char p_sign_posn;
char n_sign_posn;
char int_p_cs_precedes;
char int_p_sep_by_space;
char int_n_cs_precedes;
char int_n_sep_by_space;
char int_p_sign_posn;
char int_n_sign_posn;
# 121 "/usr/include/locale.h" 3 4
};
extern char *setlocale (int __category, const char *__locale) throw ();
extern struct lconv *localeconv (void) throw ();
# 152 "/usr/include/locale.h" 3 4
extern __locale_t newlocale (int __category_mask, const char *__locale,
__locale_t __base) throw ();
# 187 "/usr/include/locale.h" 3 4
extern __locale_t duplocale (__locale_t __dataset) throw ();
extern void freelocale (__locale_t __dataset) throw ();
extern __locale_t uselocale (__locale_t __dataset) throw ();
}
# 43 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/clocale" 2 3
# 51 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/clocale" 3
namespace std
{
using ::lconv;
using ::setlocale;
using ::localeconv;
}
# 42 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/c++locale.h" 2 3
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
extern "C" __typeof(uselocale) __uselocale;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
typedef __locale_t __c_locale;
inline int
__convert_from_v(const __c_locale& __cloc __attribute__ ((__unused__)),
char* __out,
const int __size __attribute__ ((__unused__)),
const char* __fmt, ...)
{
__c_locale __old = __gnu_cxx::__uselocale(__cloc);
# 88 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/c++locale.h" 3
__builtin_va_list __args;
__builtin_va_start(__args, __fmt);
const int __ret = __builtin_vsnprintf(__out, __size, __fmt, __args);
__builtin_va_end(__args);
__gnu_cxx::__uselocale(__old);
return __ret;
}
}
# 41 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/localefwd.h" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cctype" 1 3
# 39 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cctype" 3
# 40 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cctype" 3
# 1 "/usr/include/ctype.h" 1 3 4
# 27 "/usr/include/ctype.h" 3 4
# 1 "/usr/include/bits/types.h" 1 3 4
# 27 "/usr/include/bits/types.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 28 "/usr/include/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;
# 130 "/usr/include/bits/types.h" 3 4
# 1 "/usr/include/bits/typesizes.h" 1 3 4
# 131 "/usr/include/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;
# 28 "/usr/include/ctype.h" 2 3 4
extern "C" {
# 40 "/usr/include/ctype.h" 3 4
# 1 "/usr/include/endian.h" 1 3 4
# 36 "/usr/include/endian.h" 3 4
# 1 "/usr/include/bits/endian.h" 1 3 4
# 37 "/usr/include/endian.h" 2 3 4
# 60 "/usr/include/endian.h" 3 4
# 1 "/usr/include/bits/byteswap.h" 1 3 4
# 28 "/usr/include/bits/byteswap.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 29 "/usr/include/bits/byteswap.h" 2 3 4
# 1 "/usr/include/bits/byteswap-16.h" 1 3 4
# 36 "/usr/include/bits/byteswap.h" 2 3 4
# 44 "/usr/include/bits/byteswap.h" 3 4
static __inline unsigned int
__bswap_32 (unsigned int __bsx)
{
return __builtin_bswap32 (__bsx);
}
# 108 "/usr/include/bits/byteswap.h" 3 4
static __inline __uint64_t
__bswap_64 (__uint64_t __bsx)
{
return __builtin_bswap64 (__bsx);
}
# 61 "/usr/include/endian.h" 2 3 4
# 41 "/usr/include/ctype.h" 2 3 4
enum
{
_ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)),
_ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)),
_ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)),
_ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)),
_ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)),
_ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)),
_ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)),
_ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)),
_ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)),
_IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)),
_ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)),
_ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8))
};
# 80 "/usr/include/ctype.h" 3 4
extern const unsigned short int **__ctype_b_loc (void)
throw () __attribute__ ((__const__));
extern const __int32_t **__ctype_tolower_loc (void)
throw () __attribute__ ((__const__));
extern const __int32_t **__ctype_toupper_loc (void)
throw () __attribute__ ((__const__));
# 105 "/usr/include/ctype.h" 3 4
extern int isalnum (int) throw ();
extern int isalpha (int) throw ();
extern int iscntrl (int) throw ();
extern int isdigit (int) throw ();
extern int islower (int) throw ();
extern int isgraph (int) throw ();
extern int isprint (int) throw ();
extern int ispunct (int) throw ();
extern int isspace (int) throw ();
extern int isupper (int) throw ();
extern int isxdigit (int) throw ();
extern int tolower (int __c) throw ();
extern int toupper (int __c) throw ();
extern int isblank (int) throw ();
extern int isctype (int __c, int __mask) throw ();
extern int isascii (int __c) throw ();
extern int toascii (int __c) throw ();
extern int _toupper (int) throw ();
extern int _tolower (int) throw ();
# 272 "/usr/include/ctype.h" 3 4
extern int isalnum_l (int, __locale_t) throw ();
extern int isalpha_l (int, __locale_t) throw ();
extern int iscntrl_l (int, __locale_t) throw ();
extern int isdigit_l (int, __locale_t) throw ();
extern int islower_l (int, __locale_t) throw ();
extern int isgraph_l (int, __locale_t) throw ();
extern int isprint_l (int, __locale_t) throw ();
extern int ispunct_l (int, __locale_t) throw ();
extern int isspace_l (int, __locale_t) throw ();
extern int isupper_l (int, __locale_t) throw ();
extern int isxdigit_l (int, __locale_t) throw ();
extern int isblank_l (int, __locale_t) throw ();
extern int __tolower_l (int __c, __locale_t __l) throw ();
extern int tolower_l (int __c, __locale_t __l) throw ();
extern int __toupper_l (int __c, __locale_t __l) throw ();
extern int toupper_l (int __c, __locale_t __l) throw ();
# 348 "/usr/include/ctype.h" 3 4
}
# 43 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cctype" 2 3
# 62 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cctype" 3
namespace std
{
using ::isalnum;
using ::isalpha;
using ::iscntrl;
using ::isdigit;
using ::isgraph;
using ::islower;
using ::isprint;
using ::ispunct;
using ::isspace;
using ::isupper;
using ::isxdigit;
using ::tolower;
using ::toupper;
}
namespace std
{
using ::isblank;
}
# 43 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/localefwd.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 55 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/localefwd.h" 3
class locale;
template<typename _Facet>
bool
has_facet(const locale&) throw();
template<typename _Facet>
const _Facet&
use_facet(const locale&);
template<typename _CharT>
bool
isspace(_CharT, const locale&);
template<typename _CharT>
bool
isprint(_CharT, const locale&);
template<typename _CharT>
bool
iscntrl(_CharT, const locale&);
template<typename _CharT>
bool
isupper(_CharT, const locale&);
template<typename _CharT>
bool
islower(_CharT, const locale&);
template<typename _CharT>
bool
isalpha(_CharT, const locale&);
template<typename _CharT>
bool
isdigit(_CharT, const locale&);
template<typename _CharT>
bool
ispunct(_CharT, const locale&);
template<typename _CharT>
bool
isxdigit(_CharT, const locale&);
template<typename _CharT>
bool
isalnum(_CharT, const locale&);
template<typename _CharT>
bool
isgraph(_CharT, const locale&);
template<typename _CharT>
bool
isblank(_CharT, const locale&);
template<typename _CharT>
_CharT
toupper(_CharT, const locale&);
template<typename _CharT>
_CharT
tolower(_CharT, const locale&);
class ctype_base;
template<typename _CharT>
class ctype;
template<> class ctype<char>;
template<> class ctype<wchar_t>;
template<typename _CharT>
class ctype_byname;
class codecvt_base;
template<typename _InternT, typename _ExternT, typename _StateT>
class codecvt;
template<> class codecvt<char, char, mbstate_t>;
template<> class codecvt<wchar_t, char, mbstate_t>;
template<typename _InternT, typename _ExternT, typename _StateT>
class codecvt_byname;
template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
class num_get;
template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
class num_put;
namespace __cxx11 {
template<typename _CharT> class numpunct;
template<typename _CharT> class numpunct_byname;
}
namespace __cxx11 {
template<typename _CharT>
class collate;
template<typename _CharT>
class collate_byname;
}
class time_base;
namespace __cxx11 {
template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
class time_get;
template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
class time_get_byname;
}
template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
class time_put;
template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
class time_put_byname;
class money_base;
namespace __cxx11 {
template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
class money_get;
template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
class money_put;
}
namespace __cxx11 {
template<typename _CharT, bool _Intl = false>
class moneypunct;
template<typename _CharT, bool _Intl = false>
class moneypunct_byname;
}
class messages_base;
namespace __cxx11 {
template<typename _CharT>
class messages;
template<typename _CharT>
class messages_byname;
}
}
# 42 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ios" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 1 3
# 37 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 3
# 38 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/atomicity.h" 1 3
# 32 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/atomicity.h" 3
# 33 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/atomicity.h" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/gthr.h" 1 3
# 30 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/gthr.h" 3
#pragma GCC visibility push(default)
# 148 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/gthr.h" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/gthr-default.h" 1 3
# 35 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/gthr-default.h" 3
# 1 "/usr/include/pthread.h" 1 3 4
# 23 "/usr/include/pthread.h" 3 4
# 1 "/usr/include/sched.h" 1 3 4
# 29 "/usr/include/sched.h" 3 4
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include/stddef.h" 1 3 4
# 30 "/usr/include/sched.h" 2 3 4
# 1 "/usr/include/time.h" 1 3 4
# 73 "/usr/include/time.h" 3 4
typedef __time_t time_t;
# 120 "/usr/include/time.h" 3 4
struct timespec
{
__time_t tv_sec;
__syscall_slong_t tv_nsec;
};
# 34 "/usr/include/sched.h" 2 3 4
typedef __pid_t pid_t;
# 1 "/usr/include/bits/sched.h" 1 3 4
# 73 "/usr/include/bits/sched.h" 3 4
struct sched_param
{
int __sched_priority;
};
extern "C" {
extern int clone (int (*__fn) (void *__arg), void *__child_stack,
int __flags, void *__arg, ...) throw ();
extern int unshare (int __flags) throw ();
extern int sched_getcpu (void) throw ();
extern int setns (int __fd, int __nstype) throw ();
}
struct __sched_param
{
int __sched_priority;
};
# 119 "/usr/include/bits/sched.h" 3 4
typedef unsigned long int __cpu_mask;
typedef struct
{
__cpu_mask __bits[1024 / (8 * sizeof (__cpu_mask))];
} cpu_set_t;
# 202 "/usr/include/bits/sched.h" 3 4
extern "C" {
extern int __sched_cpucount (size_t __setsize, const cpu_set_t *__setp)
throw ();
extern cpu_set_t *__sched_cpualloc (size_t __count) throw () ;
extern void __sched_cpufree (cpu_set_t *__set) throw ();
}
# 43 "/usr/include/sched.h" 2 3 4
extern "C" {
extern int sched_setparam (__pid_t __pid, const struct sched_param *__param)
throw ();
extern int sched_getparam (__pid_t __pid, struct sched_param *__param) throw ();
extern int sched_setscheduler (__pid_t __pid, int __policy,
const struct sched_param *__param) throw ();
extern int sched_getscheduler (__pid_t __pid) throw ();
extern int sched_yield (void) throw ();
extern int sched_get_priority_max (int __algorithm) throw ();
extern int sched_get_priority_min (int __algorithm) throw ();
extern int sched_rr_get_interval (__pid_t __pid, struct timespec *__t) throw ();
# 117 "/usr/include/sched.h" 3 4
extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize,
const cpu_set_t *__cpuset) throw ();
extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize,
cpu_set_t *__cpuset) throw ();
}
# 24 "/usr/include/pthread.h" 2 3 4
# 1 "/usr/include/time.h" 1 3 4
# 29 "/usr/include/time.h" 3 4
extern "C" {
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include/stddef.h" 1 3 4
# 38 "/usr/include/time.h" 2 3 4
# 1 "/usr/include/bits/time.h" 1 3 4
# 30 "/usr/include/bits/time.h" 3 4
struct timeval
{
__time_t tv_sec;
__suseconds_t tv_usec;
};
# 88 "/usr/include/bits/time.h" 3 4
# 1 "/usr/include/bits/timex.h" 1 3 4
# 25 "/usr/include/bits/timex.h" 3 4
struct timex
{
unsigned int modes;
__syscall_slong_t offset;
__syscall_slong_t freq;
__syscall_slong_t maxerror;
__syscall_slong_t esterror;
int status;
__syscall_slong_t constant;
__syscall_slong_t precision;
__syscall_slong_t tolerance;
struct timeval time;
__syscall_slong_t tick;
__syscall_slong_t ppsfreq;
__syscall_slong_t jitter;
int shift;
__syscall_slong_t stabil;
__syscall_slong_t jitcnt;
__syscall_slong_t calcnt;
__syscall_slong_t errcnt;
__syscall_slong_t stbcnt;
int tai;
int :32; int :32; int :32; int :32;
int :32; int :32; int :32; int :32;
int :32; int :32; int :32;
};
# 89 "/usr/include/bits/time.h" 2 3 4
extern "C" {
extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) throw ();
}
# 42 "/usr/include/time.h" 2 3 4
# 57 "/usr/include/time.h" 3 4
typedef __clock_t clock_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;
# 131 "/usr/include/time.h" 3 4
struct tm
{
int tm_sec;
int tm_min;
int tm_hour;
int tm_mday;
int tm_mon;
int tm_year;
int tm_wday;
int tm_yday;
int tm_isdst;
long int tm_gmtoff;
const char *tm_zone;
};
struct itimerspec
{
struct timespec it_interval;
struct timespec it_value;
};
struct sigevent;
# 186 "/usr/include/time.h" 3 4
extern clock_t clock (void) throw ();
extern time_t time (time_t *__timer) throw ();
extern double difftime (time_t __time1, time_t __time0)
throw () __attribute__ ((__const__));
extern time_t mktime (struct tm *__tp) throw ();
extern size_t strftime (char *__restrict __s, size_t __maxsize,
const char *__restrict __format,
const struct tm *__restrict __tp) throw ();
extern char *strptime (const char *__restrict __s,
const char *__restrict __fmt, struct tm *__tp)
throw ();
extern size_t strftime_l (char *__restrict __s, size_t __maxsize,
const char *__restrict __format,
const struct tm *__restrict __tp,
__locale_t __loc) throw ();
extern char *strptime_l (const char *__restrict __s,
const char *__restrict __fmt, struct tm *__tp,
__locale_t __loc) throw ();
extern struct tm *gmtime (const time_t *__timer) throw ();
extern struct tm *localtime (const time_t *__timer) throw ();
extern struct tm *gmtime_r (const time_t *__restrict __timer,
struct tm *__restrict __tp) throw ();
extern struct tm *localtime_r (const time_t *__restrict __timer,
struct tm *__restrict __tp) throw ();
extern char *asctime (const struct tm *__tp) throw ();
extern char *ctime (const time_t *__timer) throw ();
extern char *asctime_r (const struct tm *__restrict __tp,
char *__restrict __buf) throw ();
extern char *ctime_r (const time_t *__restrict __timer,
char *__restrict __buf) throw ();
extern char *__tzname[2];
extern int __daylight;
extern long int __timezone;
extern char *tzname[2];
extern void tzset (void) throw ();
extern int daylight;
extern long int timezone;
extern int stime (const time_t *__when) throw ();
# 319 "/usr/include/time.h" 3 4
extern time_t timegm (struct tm *__tp) throw ();
extern time_t timelocal (struct tm *__tp) throw ();
extern int dysize (int __year) throw () __attribute__ ((__const__));
# 334 "/usr/include/time.h" 3 4
extern int nanosleep (const struct timespec *__requested_time,
struct timespec *__remaining);
extern int clock_getres (clockid_t __clock_id, struct timespec *__res) throw ();
extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) throw ();
extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp)
throw ();
extern int clock_nanosleep (clockid_t __clock_id, int __flags,
const struct timespec *__req,
struct timespec *__rem);
extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) throw ();
extern int timer_create (clockid_t __clock_id,
struct sigevent *__restrict __evp,
timer_t *__restrict __timerid) throw ();
extern int timer_delete (timer_t __timerid) throw ();
extern int timer_settime (timer_t __timerid, int __flags,
const struct itimerspec *__restrict __value,
struct itimerspec *__restrict __ovalue) throw ();
extern int timer_gettime (timer_t __timerid, struct itimerspec *__value)
throw ();
extern int timer_getoverrun (timer_t __timerid) throw ();
extern int timespec_get (struct timespec *__ts, int __base)
throw () __attribute__ ((__nonnull__ (1)));
# 403 "/usr/include/time.h" 3 4
extern int getdate_err;
# 412 "/usr/include/time.h" 3 4
extern struct tm *getdate (const char *__string);
# 426 "/usr/include/time.h" 3 4
extern int getdate_r (const char *__restrict __string,
struct tm *__restrict __resbufp);
}
# 25 "/usr/include/pthread.h" 2 3 4
# 1 "/usr/include/bits/pthreadtypes.h" 1 3 4
# 21 "/usr/include/bits/pthreadtypes.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 22 "/usr/include/bits/pthreadtypes.h" 2 3 4
# 60 "/usr/include/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/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/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;
unsigned long int __pad1;
unsigned long int __pad2;
unsigned int __flags;
} __data;
# 212 "/usr/include/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;
# 27 "/usr/include/pthread.h" 2 3 4
# 1 "/usr/include/bits/setjmp.h" 1 3 4
# 26 "/usr/include/bits/setjmp.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 27 "/usr/include/bits/setjmp.h" 2 3 4
typedef long int __jmp_buf[8];
# 28 "/usr/include/pthread.h" 2 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 29 "/usr/include/pthread.h" 2 3 4
enum
{
PTHREAD_CREATE_JOINABLE,
PTHREAD_CREATE_DETACHED
};
enum
{
PTHREAD_MUTEX_TIMED_NP,
PTHREAD_MUTEX_RECURSIVE_NP,
PTHREAD_MUTEX_ERRORCHECK_NP,
PTHREAD_MUTEX_ADAPTIVE_NP
,
PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_TIMED_NP,
PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP,
PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP,
PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL
, PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_TIMED_NP
};
enum
{
PTHREAD_MUTEX_STALLED,
PTHREAD_MUTEX_STALLED_NP = PTHREAD_MUTEX_STALLED,
PTHREAD_MUTEX_ROBUST,
PTHREAD_MUTEX_ROBUST_NP = PTHREAD_MUTEX_ROBUST
};
enum
{
PTHREAD_PRIO_NONE,
PTHREAD_PRIO_INHERIT,
PTHREAD_PRIO_PROTECT
};
# 116 "/usr/include/pthread.h" 3 4
enum
{
PTHREAD_RWLOCK_PREFER_READER_NP,
PTHREAD_RWLOCK_PREFER_WRITER_NP,
PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP,
PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_READER_NP
};
# 157 "/usr/include/pthread.h" 3 4
enum
{
PTHREAD_INHERIT_SCHED,
PTHREAD_EXPLICIT_SCHED
};
enum
{
PTHREAD_SCOPE_SYSTEM,
PTHREAD_SCOPE_PROCESS
};
enum
{
PTHREAD_PROCESS_PRIVATE,
PTHREAD_PROCESS_SHARED
};
# 192 "/usr/include/pthread.h" 3 4
struct _pthread_cleanup_buffer
{
void (*__routine) (void *);
void *__arg;
int __canceltype;
struct _pthread_cleanup_buffer *__prev;
};
enum
{
PTHREAD_CANCEL_ENABLE,
PTHREAD_CANCEL_DISABLE
};
enum
{
PTHREAD_CANCEL_DEFERRED,
PTHREAD_CANCEL_ASYNCHRONOUS
};
# 230 "/usr/include/pthread.h" 3 4
extern "C" {
extern int pthread_create (pthread_t *__restrict __newthread,
const pthread_attr_t *__restrict __attr,
void *(*__start_routine) (void *),
void *__restrict __arg) throw () __attribute__ ((__nonnull__ (1, 3)));
extern void pthread_exit (void *__retval) __attribute__ ((__noreturn__));
extern int pthread_join (pthread_t __th, void **__thread_return);
extern int pthread_tryjoin_np (pthread_t __th, void **__thread_return) throw ();
extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return,
const struct timespec *__abstime);
extern int pthread_detach (pthread_t __th) throw ();
extern pthread_t pthread_self (void) throw () __attribute__ ((__const__));
extern int pthread_equal (pthread_t __thread1, pthread_t __thread2)
throw () __attribute__ ((__const__));
extern int pthread_attr_init (pthread_attr_t *__attr) throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_destroy (pthread_attr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_getdetachstate (const pthread_attr_t *__attr,
int *__detachstate)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_attr_setdetachstate (pthread_attr_t *__attr,
int __detachstate)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_getguardsize (const pthread_attr_t *__attr,
size_t *__guardsize)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_attr_setguardsize (pthread_attr_t *__attr,
size_t __guardsize)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict __attr,
struct sched_param *__restrict __param)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr,
const struct sched_param *__restrict
__param) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_attr_getschedpolicy (const pthread_attr_t *__restrict
__attr, int *__restrict __policy)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_getinheritsched (const pthread_attr_t *__restrict
__attr, int *__restrict __inherit)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_attr_setinheritsched (pthread_attr_t *__attr,
int __inherit)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_getscope (const pthread_attr_t *__restrict __attr,
int *__restrict __scope)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_getstackaddr (const pthread_attr_t *__restrict
__attr, void **__restrict __stackaddr)
throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__deprecated__));
extern int pthread_attr_setstackaddr (pthread_attr_t *__attr,
void *__stackaddr)
throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__));
extern int pthread_attr_getstacksize (const pthread_attr_t *__restrict
__attr, size_t *__restrict __stacksize)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_attr_setstacksize (pthread_attr_t *__attr,
size_t __stacksize)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_getstack (const pthread_attr_t *__restrict __attr,
void **__restrict __stackaddr,
size_t *__restrict __stacksize)
throw () __attribute__ ((__nonnull__ (1, 2, 3)));
extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr,
size_t __stacksize) throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_setaffinity_np (pthread_attr_t *__attr,
size_t __cpusetsize,
const cpu_set_t *__cpuset)
throw () __attribute__ ((__nonnull__ (1, 3)));
extern int pthread_attr_getaffinity_np (const pthread_attr_t *__attr,
size_t __cpusetsize,
cpu_set_t *__cpuset)
throw () __attribute__ ((__nonnull__ (1, 3)));
extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr)
throw () __attribute__ ((__nonnull__ (2)));
extern int pthread_setschedparam (pthread_t __target_thread, int __policy,
const struct sched_param *__param)
throw () __attribute__ ((__nonnull__ (3)));
extern int pthread_getschedparam (pthread_t __target_thread,
int *__restrict __policy,
struct sched_param *__restrict __param)
throw () __attribute__ ((__nonnull__ (2, 3)));
extern int pthread_setschedprio (pthread_t __target_thread, int __prio)
throw ();
extern int pthread_getname_np (pthread_t __target_thread, char *__buf,
size_t __buflen)
throw () __attribute__ ((__nonnull__ (2)));
extern int pthread_setname_np (pthread_t __target_thread, const char *__name)
throw () __attribute__ ((__nonnull__ (2)));
extern int pthread_getconcurrency (void) throw ();
extern int pthread_setconcurrency (int __level) throw ();
extern int pthread_yield (void) throw ();
extern int pthread_setaffinity_np (pthread_t __th, size_t __cpusetsize,
const cpu_set_t *__cpuset)
throw () __attribute__ ((__nonnull__ (3)));
extern int pthread_getaffinity_np (pthread_t __th, size_t __cpusetsize,
cpu_set_t *__cpuset)
throw () __attribute__ ((__nonnull__ (3)));
# 488 "/usr/include/pthread.h" 3 4
extern int pthread_once (pthread_once_t *__once_control,
void (*__init_routine) (void)) __attribute__ ((__nonnull__ (1, 2)));
# 500 "/usr/include/pthread.h" 3 4
extern int pthread_setcancelstate (int __state, int *__oldstate);
extern int pthread_setcanceltype (int __type, int *__oldtype);
extern int pthread_cancel (pthread_t __th);
extern void pthread_testcancel (void);
typedef struct
{
struct
{
__jmp_buf __cancel_jmp_buf;
int __mask_was_saved;
} __cancel_jmp_buf[1];
void *__pad[4];
} __pthread_unwind_buf_t __attribute__ ((__aligned__));
# 534 "/usr/include/pthread.h" 3 4
struct __pthread_cleanup_frame
{
void (*__cancel_routine) (void *);
void *__cancel_arg;
int __do_it;
int __cancel_type;
};
class __pthread_cleanup_class
{
void (*__cancel_routine) (void *);
void *__cancel_arg;
int __do_it;
int __cancel_type;
public:
__pthread_cleanup_class (void (*__fct) (void *), void *__arg)
: __cancel_routine (__fct), __cancel_arg (__arg), __do_it (1) { }
~__pthread_cleanup_class () { if (__do_it) __cancel_routine (__cancel_arg); }
void __setdoit (int __newval) { __do_it = __newval; }
void __defer () { pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED,
&__cancel_type); }
void __restore () const { pthread_setcanceltype (__cancel_type, 0); }
};
# 736 "/usr/include/pthread.h" 3 4
struct __jmp_buf_tag;
extern int __sigsetjmp (struct __jmp_buf_tag *__env, int __savemask) throw ();
extern int pthread_mutex_init (pthread_mutex_t *__mutex,
const pthread_mutexattr_t *__mutexattr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutex_destroy (pthread_mutex_t *__mutex)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutex_trylock (pthread_mutex_t *__mutex)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutex_lock (pthread_mutex_t *__mutex)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex,
const struct timespec *__restrict
__abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_mutex_unlock (pthread_mutex_t *__mutex)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutex_getprioceiling (const pthread_mutex_t *
__restrict __mutex,
int *__restrict __prioceiling)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex,
int __prioceiling,
int *__restrict __old_ceiling)
throw () __attribute__ ((__nonnull__ (1, 3)));
extern int pthread_mutex_consistent (pthread_mutex_t *__mutex)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutex_consistent_np (pthread_mutex_t *__mutex)
throw () __attribute__ ((__nonnull__ (1)));
# 800 "/usr/include/pthread.h" 3 4
extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutexattr_getpshared (const pthread_mutexattr_t *
__restrict __attr,
int *__restrict __pshared)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr,
int __pshared)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutexattr_gettype (const pthread_mutexattr_t *__restrict
__attr, int *__restrict __kind)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutexattr_getprotocol (const pthread_mutexattr_t *
__restrict __attr,
int *__restrict __protocol)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_mutexattr_setprotocol (pthread_mutexattr_t *__attr,
int __protocol)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutexattr_getprioceiling (const pthread_mutexattr_t *
__restrict __attr,
int *__restrict __prioceiling)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_mutexattr_setprioceiling (pthread_mutexattr_t *__attr,
int __prioceiling)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutexattr_getrobust (const pthread_mutexattr_t *__attr,
int *__robustness)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_mutexattr_getrobust_np (const pthread_mutexattr_t *__attr,
int *__robustness)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_mutexattr_setrobust (pthread_mutexattr_t *__attr,
int __robustness)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutexattr_setrobust_np (pthread_mutexattr_t *__attr,
int __robustness)
throw () __attribute__ ((__nonnull__ (1)));
# 882 "/usr/include/pthread.h" 3 4
extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock,
const pthread_rwlockattr_t *__restrict
__attr) throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock,
const struct timespec *__restrict
__abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock,
const struct timespec *__restrict
__abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *
__restrict __attr,
int *__restrict __pshared)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr,
int __pshared)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t *
__restrict __attr,
int *__restrict __pref)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr,
int __pref) throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_cond_init (pthread_cond_t *__restrict __cond,
const pthread_condattr_t *__restrict __cond_attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_cond_destroy (pthread_cond_t *__cond)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_cond_signal (pthread_cond_t *__cond)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_cond_broadcast (pthread_cond_t *__cond)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_cond_wait (pthread_cond_t *__restrict __cond,
pthread_mutex_t *__restrict __mutex)
__attribute__ ((__nonnull__ (1, 2)));
# 994 "/usr/include/pthread.h" 3 4
extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond,
pthread_mutex_t *__restrict __mutex,
const struct timespec *__restrict __abstime)
__attribute__ ((__nonnull__ (1, 2, 3)));
extern int pthread_condattr_init (pthread_condattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_condattr_destroy (pthread_condattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_condattr_getpshared (const pthread_condattr_t *
__restrict __attr,
int *__restrict __pshared)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_condattr_setpshared (pthread_condattr_t *__attr,
int __pshared) throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_condattr_getclock (const pthread_condattr_t *
__restrict __attr,
__clockid_t *__restrict __clock_id)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_condattr_setclock (pthread_condattr_t *__attr,
__clockid_t __clock_id)
throw () __attribute__ ((__nonnull__ (1)));
# 1038 "/usr/include/pthread.h" 3 4
extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_spin_destroy (pthread_spinlock_t *__lock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_spin_lock (pthread_spinlock_t *__lock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_spin_trylock (pthread_spinlock_t *__lock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_spin_unlock (pthread_spinlock_t *__lock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier,
const pthread_barrierattr_t *__restrict
__attr, unsigned int __count)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_barrier_destroy (pthread_barrier_t *__barrier)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_barrier_wait (pthread_barrier_t *__barrier)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t *
__restrict __attr,
int *__restrict __pshared)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr,
int __pshared)
throw () __attribute__ ((__nonnull__ (1)));
# 1105 "/usr/include/pthread.h" 3 4
extern int pthread_key_create (pthread_key_t *__key,
void (*__destr_function) (void *))
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_key_delete (pthread_key_t __key) throw ();
extern void *pthread_getspecific (pthread_key_t __key) throw ();
extern int pthread_setspecific (pthread_key_t __key,
const void *__pointer) throw () ;
extern int pthread_getcpuclockid (pthread_t __thread_id,
__clockid_t *__clock_id)
throw () __attribute__ ((__nonnull__ (2)));
# 1139 "/usr/include/pthread.h" 3 4
extern int pthread_atfork (void (*__prepare) (void),
void (*__parent) (void),
void (*__child) (void)) throw ();
# 1153 "/usr/include/pthread.h" 3 4
}
# 36 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/gthr-default.h" 2 3
# 47 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/gthr-default.h" 3
typedef pthread_t __gthread_t;
typedef pthread_key_t __gthread_key_t;
typedef pthread_once_t __gthread_once_t;
typedef pthread_mutex_t __gthread_mutex_t;
typedef pthread_mutex_t __gthread_recursive_mutex_t;
typedef pthread_cond_t __gthread_cond_t;
typedef struct timespec __gthread_time_t;
# 101 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/gthr-default.h" 3
static __typeof(pthread_once) __gthrw_pthread_once __attribute__ ((__weakref__("pthread_once")));
static __typeof(pthread_getspecific) __gthrw_pthread_getspecific __attribute__ ((__weakref__("pthread_getspecific")));
static __typeof(pthread_setspecific) __gthrw_pthread_setspecific __attribute__ ((__weakref__("pthread_setspecific")));
static __typeof(pthread_create) __gthrw_pthread_create __attribute__ ((__weakref__("pthread_create")));
static __typeof(pthread_join) __gthrw_pthread_join __attribute__ ((__weakref__("pthread_join")));
static __typeof(pthread_equal) __gthrw_pthread_equal __attribute__ ((__weakref__("pthread_equal")));
static __typeof(pthread_self) __gthrw_pthread_self __attribute__ ((__weakref__("pthread_self")));
static __typeof(pthread_detach) __gthrw_pthread_detach __attribute__ ((__weakref__("pthread_detach")));
static __typeof(pthread_cancel) __gthrw_pthread_cancel __attribute__ ((__weakref__("pthread_cancel")));
static __typeof(sched_yield) __gthrw_sched_yield __attribute__ ((__weakref__("sched_yield")));
static __typeof(pthread_mutex_lock) __gthrw_pthread_mutex_lock __attribute__ ((__weakref__("pthread_mutex_lock")));
static __typeof(pthread_mutex_trylock) __gthrw_pthread_mutex_trylock __attribute__ ((__weakref__("pthread_mutex_trylock")));
static __typeof(pthread_mutex_timedlock) __gthrw_pthread_mutex_timedlock __attribute__ ((__weakref__("pthread_mutex_timedlock")));
static __typeof(pthread_mutex_unlock) __gthrw_pthread_mutex_unlock __attribute__ ((__weakref__("pthread_mutex_unlock")));
static __typeof(pthread_mutex_init) __gthrw_pthread_mutex_init __attribute__ ((__weakref__("pthread_mutex_init")));
static __typeof(pthread_mutex_destroy) __gthrw_pthread_mutex_destroy __attribute__ ((__weakref__("pthread_mutex_destroy")));
static __typeof(pthread_cond_init) __gthrw_pthread_cond_init __attribute__ ((__weakref__("pthread_cond_init")));
static __typeof(pthread_cond_broadcast) __gthrw_pthread_cond_broadcast __attribute__ ((__weakref__("pthread_cond_broadcast")));
static __typeof(pthread_cond_signal) __gthrw_pthread_cond_signal __attribute__ ((__weakref__("pthread_cond_signal")));
static __typeof(pthread_cond_wait) __gthrw_pthread_cond_wait __attribute__ ((__weakref__("pthread_cond_wait")));
static __typeof(pthread_cond_timedwait) __gthrw_pthread_cond_timedwait __attribute__ ((__weakref__("pthread_cond_timedwait")));
static __typeof(pthread_cond_destroy) __gthrw_pthread_cond_destroy __attribute__ ((__weakref__("pthread_cond_destroy")));
static __typeof(pthread_key_create) __gthrw_pthread_key_create __attribute__ ((__weakref__("pthread_key_create")));
static __typeof(pthread_key_delete) __gthrw_pthread_key_delete __attribute__ ((__weakref__("pthread_key_delete")));
static __typeof(pthread_mutexattr_init) __gthrw_pthread_mutexattr_init __attribute__ ((__weakref__("pthread_mutexattr_init")));
static __typeof(pthread_mutexattr_settype) __gthrw_pthread_mutexattr_settype __attribute__ ((__weakref__("pthread_mutexattr_settype")));
static __typeof(pthread_mutexattr_destroy) __gthrw_pthread_mutexattr_destroy __attribute__ ((__weakref__("pthread_mutexattr_destroy")));
# 236 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/gthr-default.h" 3
static __typeof(pthread_key_create) __gthrw___pthread_key_create __attribute__ ((__weakref__("__pthread_key_create")));
# 246 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/gthr-default.h" 3
static inline int
__gthread_active_p (void)
{
static void *const __gthread_active_ptr
= __extension__ (void *) &__gthrw___pthread_key_create;
return __gthread_active_ptr != 0;
}
# 658 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/gthr-default.h" 3
static inline int
__gthread_create (__gthread_t *__threadid, void *(*__func) (void*),
void *__args)
{
return __gthrw_pthread_create (__threadid, __null, __func, __args);
}
static inline int
__gthread_join (__gthread_t __threadid, void **__value_ptr)
{
return __gthrw_pthread_join (__threadid, __value_ptr);
}
static inline int
__gthread_detach (__gthread_t __threadid)
{
return __gthrw_pthread_detach (__threadid);
}
static inline int
__gthread_equal (__gthread_t __t1, __gthread_t __t2)
{
return __gthrw_pthread_equal (__t1, __t2);
}
static inline __gthread_t
__gthread_self (void)
{
return __gthrw_pthread_self ();
}
static inline int
__gthread_yield (void)
{
return __gthrw_sched_yield ();
}
static inline int
__gthread_once (__gthread_once_t *__once, void (*__func) (void))
{
if (__gthread_active_p ())
return __gthrw_pthread_once (__once, __func);
else
return -1;
}
static inline int
__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *))
{
return __gthrw_pthread_key_create (__key, __dtor);
}
static inline int
__gthread_key_delete (__gthread_key_t __key)
{
return __gthrw_pthread_key_delete (__key);
}
static inline void *
__gthread_getspecific (__gthread_key_t __key)
{
return __gthrw_pthread_getspecific (__key);
}
static inline int
__gthread_setspecific (__gthread_key_t __key, const void *__ptr)
{
return __gthrw_pthread_setspecific (__key, __ptr);
}
static inline void
__gthread_mutex_init_function (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
__gthrw_pthread_mutex_init (__mutex, __null);
}
static inline int
__gthread_mutex_destroy (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
return __gthrw_pthread_mutex_destroy (__mutex);
else
return 0;
}
static inline int
__gthread_mutex_lock (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
return __gthrw_pthread_mutex_lock (__mutex);
else
return 0;
}
static inline int
__gthread_mutex_trylock (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
return __gthrw_pthread_mutex_trylock (__mutex);
else
return 0;
}
static inline int
__gthread_mutex_timedlock (__gthread_mutex_t *__mutex,
const __gthread_time_t *__abs_timeout)
{
if (__gthread_active_p ())
return __gthrw_pthread_mutex_timedlock (__mutex, __abs_timeout);
else
return 0;
}
static inline int
__gthread_mutex_unlock (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
return __gthrw_pthread_mutex_unlock (__mutex);
else
return 0;
}
# 807 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/gthr-default.h" 3
static inline int
__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)
{
return __gthread_mutex_lock (__mutex);
}
static inline int
__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)
{
return __gthread_mutex_trylock (__mutex);
}
static inline int
__gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *__mutex,
const __gthread_time_t *__abs_timeout)
{
return __gthread_mutex_timedlock (__mutex, __abs_timeout);
}
static inline int
__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
{
return __gthread_mutex_unlock (__mutex);
}
static inline int
__gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t *__mutex)
{
return __gthread_mutex_destroy (__mutex);
}
# 849 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/gthr-default.h" 3
static inline int
__gthread_cond_broadcast (__gthread_cond_t *__cond)
{
return __gthrw_pthread_cond_broadcast (__cond);
}
static inline int
__gthread_cond_signal (__gthread_cond_t *__cond)
{
return __gthrw_pthread_cond_signal (__cond);
}
static inline int
__gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex)
{
return __gthrw_pthread_cond_wait (__cond, __mutex);
}
static inline int
__gthread_cond_timedwait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex,
const __gthread_time_t *__abs_timeout)
{
return __gthrw_pthread_cond_timedwait (__cond, __mutex, __abs_timeout);
}
static inline int
__gthread_cond_wait_recursive (__gthread_cond_t *__cond,
__gthread_recursive_mutex_t *__mutex)
{
return __gthread_cond_wait (__cond, __mutex);
}
static inline int
__gthread_cond_destroy (__gthread_cond_t* __cond)
{
return __gthrw_pthread_cond_destroy (__cond);
}
# 149 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/gthr.h" 2 3
#pragma GCC visibility pop
# 36 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/atomicity.h" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/atomic_word.h" 1 3
# 32 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/atomic_word.h" 3
typedef int _Atomic_word;
# 37 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/atomicity.h" 2 3
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
static inline _Atomic_word
__exchange_and_add(volatile _Atomic_word* __mem, int __val)
{ return __atomic_fetch_add(__mem, __val, 4); }
static inline void
__atomic_add(volatile _Atomic_word* __mem, int __val)
{ __atomic_fetch_add(__mem, __val, 4); }
# 64 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/atomicity.h" 3
static inline _Atomic_word
__exchange_and_add_single(_Atomic_word* __mem, int __val)
{
_Atomic_word __result = *__mem;
*__mem += __val;
return __result;
}
static inline void
__atomic_add_single(_Atomic_word* __mem, int __val)
{ *__mem += __val; }
static inline _Atomic_word
__attribute__ ((__unused__))
__exchange_and_add_dispatch(_Atomic_word* __mem, int __val)
{
if (__gthread_active_p())
return __exchange_and_add(__mem, __val);
else
return __exchange_and_add_single(__mem, __val);
}
static inline void
__attribute__ ((__unused__))
__atomic_add_dispatch(_Atomic_word* __mem, int __val)
{
if (__gthread_active_p())
__atomic_add(__mem, __val);
else
__atomic_add_single(__mem, __val);
}
}
# 40 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 1 3
# 37 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 3
# 38 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/string" 1 3
# 36 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/string" 3
# 37 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/string" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/allocator.h" 1 3
# 46 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/allocator.h" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/c++allocator.h" 1 3
# 33 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/c++allocator.h" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/new_allocator.h" 1 3
# 33 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/new_allocator.h" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/new" 1 3
# 37 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/new" 3
# 38 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/new" 3
#pragma GCC visibility push(default)
extern "C++" {
namespace std
{
class bad_alloc : public exception
{
public:
bad_alloc() throw() { }
virtual ~bad_alloc() throw();
virtual const char* what() const throw();
};
class bad_array_new_length : public bad_alloc
{
public:
bad_array_new_length() throw() { };
virtual ~bad_array_new_length() throw();
virtual const char* what() const throw();
};
struct nothrow_t
{
explicit nothrow_t() = default;
};
extern const nothrow_t nothrow;
typedef void (*new_handler)();
new_handler set_new_handler(new_handler) throw();
new_handler get_new_handler() noexcept;
}
# 116 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/new" 3
void* operator new(std::size_t)
__attribute__((__externally_visible__));
void* operator new[](std::size_t)
__attribute__((__externally_visible__));
void operator delete(void*) noexcept
__attribute__((__externally_visible__));
void operator delete[](void*) noexcept
__attribute__((__externally_visible__));
void operator delete(void*, std::size_t) noexcept
__attribute__((__externally_visible__));
void operator delete[](void*, std::size_t) noexcept
__attribute__((__externally_visible__));
void* operator new(std::size_t, const std::nothrow_t&) noexcept
__attribute__((__externally_visible__));
void* operator new[](std::size_t, const std::nothrow_t&) noexcept
__attribute__((__externally_visible__));
void operator delete(void*, const std::nothrow_t&) noexcept
__attribute__((__externally_visible__));
void operator delete[](void*, const std::nothrow_t&) noexcept
__attribute__((__externally_visible__));
void operator delete(void*, std::size_t, const std::nothrow_t&) noexcept
__attribute__((__externally_visible__));
void operator delete[](void*, std::size_t, const std::nothrow_t&) noexcept
__attribute__((__externally_visible__));
inline void* operator new(std::size_t, void* __p) noexcept
{ return __p; }
inline void* operator new[](std::size_t, void* __p) noexcept
{ return __p; }
inline void operator delete (void*, void*) noexcept { }
inline void operator delete[](void*, void*) noexcept { }
}
#pragma GCC visibility pop
# 34 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/new_allocator.h" 2 3
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
using std::size_t;
using std::ptrdiff_t;
# 57 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/new_allocator.h" 3
template<typename _Tp>
class new_allocator
{
public:
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef _Tp* pointer;
typedef const _Tp* const_pointer;
typedef _Tp& reference;
typedef const _Tp& const_reference;
typedef _Tp value_type;
template<typename _Tp1>
struct rebind
{ typedef new_allocator<_Tp1> other; };
typedef std::true_type propagate_on_container_move_assignment;
new_allocator() noexcept { }
new_allocator(const new_allocator&) noexcept { }
template<typename _Tp1>
new_allocator(const new_allocator<_Tp1>&) noexcept { }
~new_allocator() noexcept { }
pointer
address(reference __x) const noexcept
{ return std::__addressof(__x); }
const_pointer
address(const_reference __x) const noexcept
{ return std::__addressof(__x); }
pointer
allocate(size_type __n, const void* = 0)
{
if (__n > this->max_size())
std::__throw_bad_alloc();
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
}
void
deallocate(pointer __p, size_type)
{ ::operator delete(__p); }
size_type
max_size() const noexcept
{ return size_t(-1) / sizeof(_Tp); }
template<typename _Up, typename... _Args>
void
construct(_Up* __p, _Args&&... __args)
{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
template<typename _Up>
void
destroy(_Up* __p) { __p->~_Up(); }
# 135 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/new_allocator.h" 3
};
template<typename _Tp>
inline bool
operator==(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
{ return true; }
template<typename _Tp>
inline bool
operator!=(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
{ return false; }
}
# 34 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/c++allocator.h" 2 3
namespace std
{
# 47 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/c++allocator.h" 3
template<typename _Tp>
using __allocator_base = __gnu_cxx::new_allocator<_Tp>;
}
# 47 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/allocator.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<>
class allocator<void>
{
public:
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef void* pointer;
typedef const void* const_pointer;
typedef void value_type;
template<typename _Tp1>
struct rebind
{ typedef allocator<_Tp1> other; };
typedef true_type propagate_on_container_move_assignment;
typedef true_type is_always_equal;
};
# 96 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/allocator.h" 3
template<typename _Tp>
class allocator: public __allocator_base<_Tp>
{
public:
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef _Tp* pointer;
typedef const _Tp* const_pointer;
typedef _Tp& reference;
typedef const _Tp& const_reference;
typedef _Tp value_type;
template<typename _Tp1>
struct rebind
{ typedef allocator<_Tp1> other; };
typedef true_type propagate_on_container_move_assignment;
allocator() throw() { }
allocator(const allocator& __a) throw()
: __allocator_base<_Tp>(__a) { }
template<typename _Tp1>
allocator(const allocator<_Tp1>&) throw() { }
~allocator() throw() { }
};
template<typename _T1, typename _T2>
inline bool
operator==(const allocator<_T1>&, const allocator<_T2>&)
noexcept
{ return true; }
template<typename _Tp>
inline bool
operator==(const allocator<_Tp>&, const allocator<_Tp>&)
noexcept
{ return true; }
template<typename _T1, typename _T2>
inline bool
operator!=(const allocator<_T1>&, const allocator<_T2>&)
noexcept
{ return false; }
template<typename _Tp>
inline bool
operator!=(const allocator<_Tp>&, const allocator<_Tp>&)
noexcept
{ return false; }
extern template class allocator<char>;
extern template class allocator<wchar_t>;
template<typename _Alloc, bool = __is_empty(_Alloc)>
struct __alloc_swap
{ static void _S_do_it(_Alloc&, _Alloc&) noexcept { } };
template<typename _Alloc>
struct __alloc_swap<_Alloc, false>
{
static void
_S_do_it(_Alloc& __one, _Alloc& __two) noexcept
{
if (__one != __two)
swap(__one, __two);
}
};
template<typename _Alloc, bool = __is_empty(_Alloc)>
struct __alloc_neq
{
static bool
_S_do_it(const _Alloc&, const _Alloc&)
{ return false; }
};
template<typename _Alloc>
struct __alloc_neq<_Alloc, false>
{
static bool
_S_do_it(const _Alloc& __one, const _Alloc& __two)
{ return __one != __two; }
};
template<typename _Tp, bool
= __or_<is_copy_constructible<typename _Tp::value_type>,
is_nothrow_move_constructible<typename _Tp::value_type>>::value>
struct __shrink_to_fit_aux
{ static bool _S_do_it(_Tp&) noexcept { return false; } };
template<typename _Tp>
struct __shrink_to_fit_aux<_Tp, true>
{
static bool
_S_do_it(_Tp& __c) noexcept
{
try
{
_Tp(__make_move_if_noexcept_iterator(__c.begin()),
__make_move_if_noexcept_iterator(__c.end()),
__c.get_allocator()).swap(__c);
return true;
}
catch(...)
{ return false; }
}
};
}
# 42 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/string" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ostream_insert.h" 1 3
# 33 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ostream_insert.h" 3
# 34 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ostream_insert.h" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/cxxabi_forced.h" 1 3
# 34 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/cxxabi_forced.h" 3
# 35 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/cxxabi_forced.h" 3
#pragma GCC visibility push(default)
namespace __cxxabiv1
{
class __forced_unwind
{
virtual ~__forced_unwind() throw();
virtual void __pure_dummy() = 0;
};
}
#pragma GCC visibility pop
# 37 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ostream_insert.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits>
inline void
__ostream_write(basic_ostream<_CharT, _Traits>& __out,
const _CharT* __s, streamsize __n)
{
typedef basic_ostream<_CharT, _Traits> __ostream_type;
typedef typename __ostream_type::ios_base __ios_base;
const streamsize __put = __out.rdbuf()->sputn(__s, __n);
if (__put != __n)
__out.setstate(__ios_base::badbit);
}
template<typename _CharT, typename _Traits>
inline void
__ostream_fill(basic_ostream<_CharT, _Traits>& __out, streamsize __n)
{
typedef basic_ostream<_CharT, _Traits> __ostream_type;
typedef typename __ostream_type::ios_base __ios_base;
const _CharT __c = __out.fill();
for (; __n > 0; --__n)
{
const typename _Traits::int_type __put = __out.rdbuf()->sputc(__c);
if (_Traits::eq_int_type(__put, _Traits::eof()))
{
__out.setstate(__ios_base::badbit);
break;
}
}
}
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
__ostream_insert(basic_ostream<_CharT, _Traits>& __out,
const _CharT* __s, streamsize __n)
{
typedef basic_ostream<_CharT, _Traits> __ostream_type;
typedef typename __ostream_type::ios_base __ios_base;
typename __ostream_type::sentry __cerb(__out);
if (__cerb)
{
try
{
const streamsize __w = __out.width();
if (__w > __n)
{
const bool __left = ((__out.flags()
& __ios_base::adjustfield)
== __ios_base::left);
if (!__left)
__ostream_fill(__out, __w - __n);
if (__out.good())
__ostream_write(__out, __s, __n);
if (__left && __out.good())
__ostream_fill(__out, __w - __n);
}
else
__ostream_write(__out, __s, __n);
__out.width(0);
}
catch(__cxxabiv1::__forced_unwind&)
{
__out._M_setstate(__ios_base::badbit);
throw;
}
catch(...)
{ __out._M_setstate(__ios_base::badbit); }
}
return __out;
}
extern template ostream& __ostream_insert(ostream&, const char*, streamsize);
extern template wostream& __ostream_insert(wostream&, const wchar_t*,
streamsize);
}
# 45 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/string" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_function.h" 1 3
# 63 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_function.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 104 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_function.h" 3
template<typename _Arg, typename _Result>
struct unary_function
{
typedef _Arg argument_type;
typedef _Result result_type;
};
template<typename _Arg1, typename _Arg2, typename _Result>
struct binary_function
{
typedef _Arg1 first_argument_type;
typedef _Arg2 second_argument_type;
typedef _Result result_type;
};
# 144 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_function.h" 3
struct __is_transparent;
template<typename _Tp = void>
struct plus;
template<typename _Tp = void>
struct minus;
template<typename _Tp = void>
struct multiplies;
template<typename _Tp = void>
struct divides;
template<typename _Tp = void>
struct modulus;
template<typename _Tp = void>
struct negate;
template<typename _Tp>
struct plus : public binary_function<_Tp, _Tp, _Tp>
{
constexpr
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x + __y; }
};
template<typename _Tp>
struct minus : public binary_function<_Tp, _Tp, _Tp>
{
constexpr
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x - __y; }
};
template<typename _Tp>
struct multiplies : public binary_function<_Tp, _Tp, _Tp>
{
constexpr
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x * __y; }
};
template<typename _Tp>
struct divides : public binary_function<_Tp, _Tp, _Tp>
{
constexpr
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x / __y; }
};
template<typename _Tp>
struct modulus : public binary_function<_Tp, _Tp, _Tp>
{
constexpr
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x % __y; }
};
template<typename _Tp>
struct negate : public unary_function<_Tp, _Tp>
{
constexpr
_Tp
operator()(const _Tp& __x) const
{ return -__x; }
};
template<>
struct plus<void>
{
template <typename _Tp, typename _Up>
constexpr
auto
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::forward<_Tp>(__t) + std::forward<_Up>(__u)))
-> decltype(std::forward<_Tp>(__t) + std::forward<_Up>(__u))
{ return std::forward<_Tp>(__t) + std::forward<_Up>(__u); }
typedef __is_transparent is_transparent;
};
template<>
struct minus<void>
{
template <typename _Tp, typename _Up>
constexpr
auto
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::forward<_Tp>(__t) - std::forward<_Up>(__u)))
-> decltype(std::forward<_Tp>(__t) - std::forward<_Up>(__u))
{ return std::forward<_Tp>(__t) - std::forward<_Up>(__u); }
typedef __is_transparent is_transparent;
};
template<>
struct multiplies<void>
{
template <typename _Tp, typename _Up>
constexpr
auto
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::forward<_Tp>(__t) * std::forward<_Up>(__u)))
-> decltype(std::forward<_Tp>(__t) * std::forward<_Up>(__u))
{ return std::forward<_Tp>(__t) * std::forward<_Up>(__u); }
typedef __is_transparent is_transparent;
};
template<>
struct divides<void>
{
template <typename _Tp, typename _Up>
constexpr
auto
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::forward<_Tp>(__t) / std::forward<_Up>(__u)))
-> decltype(std::forward<_Tp>(__t) / std::forward<_Up>(__u))
{ return std::forward<_Tp>(__t) / std::forward<_Up>(__u); }
typedef __is_transparent is_transparent;
};
template<>
struct modulus<void>
{
template <typename _Tp, typename _Up>
constexpr
auto
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::forward<_Tp>(__t) % std::forward<_Up>(__u)))
-> decltype(std::forward<_Tp>(__t) % std::forward<_Up>(__u))
{ return std::forward<_Tp>(__t) % std::forward<_Up>(__u); }
typedef __is_transparent is_transparent;
};
template<>
struct negate<void>
{
template <typename _Tp>
constexpr
auto
operator()(_Tp&& __t) const
noexcept(noexcept(-std::forward<_Tp>(__t)))
-> decltype(-std::forward<_Tp>(__t))
{ return -std::forward<_Tp>(__t); }
typedef __is_transparent is_transparent;
};
# 330 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_function.h" 3
template<typename _Tp = void>
struct equal_to;
template<typename _Tp = void>
struct not_equal_to;
template<typename _Tp = void>
struct greater;
template<typename _Tp = void>
struct less;
template<typename _Tp = void>
struct greater_equal;
template<typename _Tp = void>
struct less_equal;
template<typename _Tp>
struct equal_to : public binary_function<_Tp, _Tp, bool>
{
constexpr
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x == __y; }
};
template<typename _Tp>
struct not_equal_to : public binary_function<_Tp, _Tp, bool>
{
constexpr
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x != __y; }
};
template<typename _Tp>
struct greater : public binary_function<_Tp, _Tp, bool>
{
constexpr
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x > __y; }
};
template<typename _Tp>
struct less : public binary_function<_Tp, _Tp, bool>
{
constexpr
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x < __y; }
};
template<typename _Tp>
struct greater_equal : public binary_function<_Tp, _Tp, bool>
{
constexpr
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x >= __y; }
};
template<typename _Tp>
struct less_equal : public binary_function<_Tp, _Tp, bool>
{
constexpr
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x <= __y; }
};
template<>
struct equal_to<void>
{
template <typename _Tp, typename _Up>
constexpr
auto
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::forward<_Tp>(__t) == std::forward<_Up>(__u)))
-> decltype(std::forward<_Tp>(__t) == std::forward<_Up>(__u))
{ return std::forward<_Tp>(__t) == std::forward<_Up>(__u); }
typedef __is_transparent is_transparent;
};
template<>
struct not_equal_to<void>
{
template <typename _Tp, typename _Up>
constexpr
auto
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::forward<_Tp>(__t) != std::forward<_Up>(__u)))
-> decltype(std::forward<_Tp>(__t) != std::forward<_Up>(__u))
{ return std::forward<_Tp>(__t) != std::forward<_Up>(__u); }
typedef __is_transparent is_transparent;
};
template<>
struct greater<void>
{
template <typename _Tp, typename _Up>
constexpr
auto
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::forward<_Tp>(__t) > std::forward<_Up>(__u)))
-> decltype(std::forward<_Tp>(__t) > std::forward<_Up>(__u))
{ return std::forward<_Tp>(__t) > std::forward<_Up>(__u); }
typedef __is_transparent is_transparent;
};
template<>
struct less<void>
{
template <typename _Tp, typename _Up>
constexpr
auto
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::forward<_Tp>(__t) < std::forward<_Up>(__u)))
-> decltype(std::forward<_Tp>(__t) < std::forward<_Up>(__u))
{ return std::forward<_Tp>(__t) < std::forward<_Up>(__u); }
typedef __is_transparent is_transparent;
};
template<>
struct greater_equal<void>
{
template <typename _Tp, typename _Up>
constexpr
auto
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::forward<_Tp>(__t) >= std::forward<_Up>(__u)))
-> decltype(std::forward<_Tp>(__t) >= std::forward<_Up>(__u))
{ return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); }
typedef __is_transparent is_transparent;
};
template<>
struct less_equal<void>
{
template <typename _Tp, typename _Up>
constexpr
auto
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::forward<_Tp>(__t) <= std::forward<_Up>(__u)))
-> decltype(std::forward<_Tp>(__t) <= std::forward<_Up>(__u))
{ return std::forward<_Tp>(__t) <= std::forward<_Up>(__u); }
typedef __is_transparent is_transparent;
};
# 512 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_function.h" 3
template<typename _Tp = void>
struct logical_and;
template<typename _Tp = void>
struct logical_or;
template<typename _Tp = void>
struct logical_not;
template<typename _Tp>
struct logical_and : public binary_function<_Tp, _Tp, bool>
{
constexpr
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x && __y; }
};
template<typename _Tp>
struct logical_or : public binary_function<_Tp, _Tp, bool>
{
constexpr
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x || __y; }
};
template<typename _Tp>
struct logical_not : public unary_function<_Tp, bool>
{
constexpr
bool
operator()(const _Tp& __x) const
{ return !__x; }
};
template<>
struct logical_and<void>
{
template <typename _Tp, typename _Up>
constexpr
auto
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::forward<_Tp>(__t) && std::forward<_Up>(__u)))
-> decltype(std::forward<_Tp>(__t) && std::forward<_Up>(__u))
{ return std::forward<_Tp>(__t) && std::forward<_Up>(__u); }
typedef __is_transparent is_transparent;
};
template<>
struct logical_or<void>
{
template <typename _Tp, typename _Up>
constexpr
auto
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::forward<_Tp>(__t) || std::forward<_Up>(__u)))
-> decltype(std::forward<_Tp>(__t) || std::forward<_Up>(__u))
{ return std::forward<_Tp>(__t) || std::forward<_Up>(__u); }
typedef __is_transparent is_transparent;
};
template<>
struct logical_not<void>
{
template <typename _Tp>
constexpr
auto
operator()(_Tp&& __t) const
noexcept(noexcept(!std::forward<_Tp>(__t)))
-> decltype(!std::forward<_Tp>(__t))
{ return !std::forward<_Tp>(__t); }
typedef __is_transparent is_transparent;
};
template<typename _Tp = void>
struct bit_and;
template<typename _Tp = void>
struct bit_or;
template<typename _Tp = void>
struct bit_xor;
template<typename _Tp = void>
struct bit_not;
template<typename _Tp>
struct bit_and : public binary_function<_Tp, _Tp, _Tp>
{
constexpr
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x & __y; }
};
template<typename _Tp>
struct bit_or : public binary_function<_Tp, _Tp, _Tp>
{
constexpr
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x | __y; }
};
template<typename _Tp>
struct bit_xor : public binary_function<_Tp, _Tp, _Tp>
{
constexpr
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x ^ __y; }
};
template<typename _Tp>
struct bit_not : public unary_function<_Tp, _Tp>
{
constexpr
_Tp
operator()(const _Tp& __x) const
{ return ~__x; }
};
template <>
struct bit_and<void>
{
template <typename _Tp, typename _Up>
constexpr
auto
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::forward<_Tp>(__t) & std::forward<_Up>(__u)))
-> decltype(std::forward<_Tp>(__t) & std::forward<_Up>(__u))
{ return std::forward<_Tp>(__t) & std::forward<_Up>(__u); }
typedef __is_transparent is_transparent;
};
template <>
struct bit_or<void>
{
template <typename _Tp, typename _Up>
constexpr
auto
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::forward<_Tp>(__t) | std::forward<_Up>(__u)))
-> decltype(std::forward<_Tp>(__t) | std::forward<_Up>(__u))
{ return std::forward<_Tp>(__t) | std::forward<_Up>(__u); }
typedef __is_transparent is_transparent;
};
template <>
struct bit_xor<void>
{
template <typename _Tp, typename _Up>
constexpr
auto
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u)))
-> decltype(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u))
{ return std::forward<_Tp>(__t) ^ std::forward<_Up>(__u); }
typedef __is_transparent is_transparent;
};
template <>
struct bit_not<void>
{
template <typename _Tp>
constexpr
auto
operator()(_Tp&& __t) const
noexcept(noexcept(~std::forward<_Tp>(__t)))
-> decltype(~std::forward<_Tp>(__t))
{ return ~std::forward<_Tp>(__t); }
typedef __is_transparent is_transparent;
};
# 740 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_function.h" 3
template<typename _Predicate>
class unary_negate
: public unary_function<typename _Predicate::argument_type, bool>
{
protected:
_Predicate _M_pred;
public:
constexpr
explicit
unary_negate(const _Predicate& __x) : _M_pred(__x) { }
constexpr
bool
operator()(const typename _Predicate::argument_type& __x) const
{ return !_M_pred(__x); }
};
template<typename _Predicate>
constexpr
inline unary_negate<_Predicate>
not1(const _Predicate& __pred)
{ return unary_negate<_Predicate>(__pred); }
template<typename _Predicate>
class binary_negate
: public binary_function<typename _Predicate::first_argument_type,
typename _Predicate::second_argument_type, bool>
{
protected:
_Predicate _M_pred;
public:
constexpr
explicit
binary_negate(const _Predicate& __x) : _M_pred(__x) { }
constexpr
bool
operator()(const typename _Predicate::first_argument_type& __x,
const typename _Predicate::second_argument_type& __y) const
{ return !_M_pred(__x, __y); }
};
template<typename _Predicate>
constexpr
inline binary_negate<_Predicate>
not2(const _Predicate& __pred)
{ return binary_negate<_Predicate>(__pred); }
# 817 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_function.h" 3
template<typename _Arg, typename _Result>
class pointer_to_unary_function : public unary_function<_Arg, _Result>
{
protected:
_Result (*_M_ptr)(_Arg);
public:
pointer_to_unary_function() { }
explicit
pointer_to_unary_function(_Result (*__x)(_Arg))
: _M_ptr(__x) { }
_Result
operator()(_Arg __x) const
{ return _M_ptr(__x); }
};
template<typename _Arg, typename _Result>
inline pointer_to_unary_function<_Arg, _Result>
ptr_fun(_Result (*__x)(_Arg))
{ return pointer_to_unary_function<_Arg, _Result>(__x); }
template<typename _Arg1, typename _Arg2, typename _Result>
class pointer_to_binary_function
: public binary_function<_Arg1, _Arg2, _Result>
{
protected:
_Result (*_M_ptr)(_Arg1, _Arg2);
public:
pointer_to_binary_function() { }
explicit
pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
: _M_ptr(__x) { }
_Result
operator()(_Arg1 __x, _Arg2 __y) const
{ return _M_ptr(__x, __y); }
};
template<typename _Arg1, typename _Arg2, typename _Result>
inline pointer_to_binary_function<_Arg1, _Arg2, _Result>
ptr_fun(_Result (*__x)(_Arg1, _Arg2))
{ return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); }
template<typename _Tp>
struct _Identity
: public unary_function<_Tp,_Tp>
{
_Tp&
operator()(_Tp& __x) const
{ return __x; }
const _Tp&
operator()(const _Tp& __x) const
{ return __x; }
};
template<typename _Pair>
struct _Select1st
: public unary_function<_Pair, typename _Pair::first_type>
{
typename _Pair::first_type&
operator()(_Pair& __x) const
{ return __x.first; }
const typename _Pair::first_type&
operator()(const _Pair& __x) const
{ return __x.first; }
template<typename _Pair2>
typename _Pair2::first_type&
operator()(_Pair2& __x) const
{ return __x.first; }
template<typename _Pair2>
const typename _Pair2::first_type&
operator()(const _Pair2& __x) const
{ return __x.first; }
};
template<typename _Pair>
struct _Select2nd
: public unary_function<_Pair, typename _Pair::second_type>
{
typename _Pair::second_type&
operator()(_Pair& __x) const
{ return __x.second; }
const typename _Pair::second_type&
operator()(const _Pair& __x) const
{ return __x.second; }
};
# 937 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_function.h" 3
template<typename _Ret, typename _Tp>
class mem_fun_t : public unary_function<_Tp*, _Ret>
{
public:
explicit
mem_fun_t(_Ret (_Tp::*__pf)())
: _M_f(__pf) { }
_Ret
operator()(_Tp* __p) const
{ return (__p->*_M_f)(); }
private:
_Ret (_Tp::*_M_f)();
};
template<typename _Ret, typename _Tp>
class const_mem_fun_t : public unary_function<const _Tp*, _Ret>
{
public:
explicit
const_mem_fun_t(_Ret (_Tp::*__pf)() const)
: _M_f(__pf) { }
_Ret
operator()(const _Tp* __p) const
{ return (__p->*_M_f)(); }
private:
_Ret (_Tp::*_M_f)() const;
};
template<typename _Ret, typename _Tp>
class mem_fun_ref_t : public unary_function<_Tp, _Ret>
{
public:
explicit
mem_fun_ref_t(_Ret (_Tp::*__pf)())
: _M_f(__pf) { }
_Ret
operator()(_Tp& __r) const
{ return (__r.*_M_f)(); }
private:
_Ret (_Tp::*_M_f)();
};
template<typename _Ret, typename _Tp>
class const_mem_fun_ref_t : public unary_function<_Tp, _Ret>
{
public:
explicit
const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const)
: _M_f(__pf) { }
_Ret
operator()(const _Tp& __r) const
{ return (__r.*_M_f)(); }
private:
_Ret (_Tp::*_M_f)() const;
};
template<typename _Ret, typename _Tp, typename _Arg>
class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret>
{
public:
explicit
mem_fun1_t(_Ret (_Tp::*__pf)(_Arg))
: _M_f(__pf) { }
_Ret
operator()(_Tp* __p, _Arg __x) const
{ return (__p->*_M_f)(__x); }
private:
_Ret (_Tp::*_M_f)(_Arg);
};
template<typename _Ret, typename _Tp, typename _Arg>
class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret>
{
public:
explicit
const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const)
: _M_f(__pf) { }
_Ret
operator()(const _Tp* __p, _Arg __x) const
{ return (__p->*_M_f)(__x); }
private:
_Ret (_Tp::*_M_f)(_Arg) const;
};
template<typename _Ret, typename _Tp, typename _Arg>
class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
{
public:
explicit
mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg))
: _M_f(__pf) { }
_Ret
operator()(_Tp& __r, _Arg __x) const
{ return (__r.*_M_f)(__x); }
private:
_Ret (_Tp::*_M_f)(_Arg);
};
template<typename _Ret, typename _Tp, typename _Arg>
class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
{
public:
explicit
const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const)
: _M_f(__pf) { }
_Ret
operator()(const _Tp& __r, _Arg __x) const
{ return (__r.*_M_f)(__x); }
private:
_Ret (_Tp::*_M_f)(_Arg) const;
};
template<typename _Ret, typename _Tp>
inline mem_fun_t<_Ret, _Tp>
mem_fun(_Ret (_Tp::*__f)())
{ return mem_fun_t<_Ret, _Tp>(__f); }
template<typename _Ret, typename _Tp>
inline const_mem_fun_t<_Ret, _Tp>
mem_fun(_Ret (_Tp::*__f)() const)
{ return const_mem_fun_t<_Ret, _Tp>(__f); }
template<typename _Ret, typename _Tp>
inline mem_fun_ref_t<_Ret, _Tp>
mem_fun_ref(_Ret (_Tp::*__f)())
{ return mem_fun_ref_t<_Ret, _Tp>(__f); }
template<typename _Ret, typename _Tp>
inline const_mem_fun_ref_t<_Ret, _Tp>
mem_fun_ref(_Ret (_Tp::*__f)() const)
{ return const_mem_fun_ref_t<_Ret, _Tp>(__f); }
template<typename _Ret, typename _Tp, typename _Arg>
inline mem_fun1_t<_Ret, _Tp, _Arg>
mem_fun(_Ret (_Tp::*__f)(_Arg))
{ return mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
template<typename _Ret, typename _Tp, typename _Arg>
inline const_mem_fun1_t<_Ret, _Tp, _Arg>
mem_fun(_Ret (_Tp::*__f)(_Arg) const)
{ return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
template<typename _Ret, typename _Tp, typename _Arg>
inline mem_fun1_ref_t<_Ret, _Tp, _Arg>
mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
{ return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
template<typename _Ret, typename _Tp, typename _Arg>
inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg>
mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
{ return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
}
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/backward/binders.h" 1 3
# 60 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/backward/binders.h" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
namespace std __attribute__ ((__visibility__ ("default")))
{
# 107 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/backward/binders.h" 3
template<typename _Operation>
class binder1st
: public unary_function<typename _Operation::second_argument_type,
typename _Operation::result_type>
{
protected:
_Operation op;
typename _Operation::first_argument_type value;
public:
binder1st(const _Operation& __x,
const typename _Operation::first_argument_type& __y)
: op(__x), value(__y) { }
typename _Operation::result_type
operator()(const typename _Operation::second_argument_type& __x) const
{ return op(value, __x); }
typename _Operation::result_type
operator()(typename _Operation::second_argument_type& __x) const
{ return op(value, __x); }
} __attribute__ ((__deprecated__));
template<typename _Operation, typename _Tp>
inline binder1st<_Operation>
bind1st(const _Operation& __fn, const _Tp& __x)
{
typedef typename _Operation::first_argument_type _Arg1_type;
return binder1st<_Operation>(__fn, _Arg1_type(__x));
}
template<typename _Operation>
class binder2nd
: public unary_function<typename _Operation::first_argument_type,
typename _Operation::result_type>
{
protected:
_Operation op;
typename _Operation::second_argument_type value;
public:
binder2nd(const _Operation& __x,
const typename _Operation::second_argument_type& __y)
: op(__x), value(__y) { }
typename _Operation::result_type
operator()(const typename _Operation::first_argument_type& __x) const
{ return op(__x, value); }
typename _Operation::result_type
operator()(typename _Operation::first_argument_type& __x) const
{ return op(__x, value); }
} __attribute__ ((__deprecated__));
template<typename _Operation, typename _Tp>
inline binder2nd<_Operation>
bind2nd(const _Operation& __fn, const _Tp& __x)
{
typedef typename _Operation::second_argument_type _Arg2_type;
return binder2nd<_Operation>(__fn, _Arg2_type(__x));
}
}
#pragma GCC diagnostic pop
# 1128 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_function.h" 2 3
# 49 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/string" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/range_access.h" 1 3
# 33 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/range_access.h" 3
# 34 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/range_access.h" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/initializer_list" 1 3
# 33 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/initializer_list" 3
# 34 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/initializer_list" 3
#pragma GCC visibility push(default)
namespace std
{
template<class _E>
class initializer_list
{
public:
typedef _E value_type;
typedef const _E& reference;
typedef const _E& const_reference;
typedef size_t size_type;
typedef const _E* iterator;
typedef const _E* const_iterator;
private:
iterator _M_array;
size_type _M_len;
constexpr initializer_list(const_iterator __a, size_type __l)
: _M_array(__a), _M_len(__l) { }
public:
constexpr initializer_list() noexcept
: _M_array(0), _M_len(0) { }
constexpr size_type
size() const noexcept { return _M_len; }
constexpr const_iterator
begin() const noexcept { return _M_array; }
constexpr const_iterator
end() const noexcept { return begin() + size(); }
};
template<class _Tp>
constexpr const _Tp*
begin(initializer_list<_Tp> __ils) noexcept
{ return __ils.begin(); }
template<class _Tp>
constexpr const _Tp*
end(initializer_list<_Tp> __ils) noexcept
{ return __ils.end(); }
}
#pragma GCC visibility pop
# 37 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/range_access.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Container>
inline auto
begin(_Container& __cont) -> decltype(__cont.begin())
{ return __cont.begin(); }
template<typename _Container>
inline auto
begin(const _Container& __cont) -> decltype(__cont.begin())
{ return __cont.begin(); }
template<typename _Container>
inline auto
end(_Container& __cont) -> decltype(__cont.end())
{ return __cont.end(); }
template<typename _Container>
inline auto
end(const _Container& __cont) -> decltype(__cont.end())
{ return __cont.end(); }
template<typename _Tp, size_t _Nm>
inline constexpr _Tp*
begin(_Tp (&__arr)[_Nm])
{ return __arr; }
template<typename _Tp, size_t _Nm>
inline constexpr _Tp*
end(_Tp (&__arr)[_Nm])
{ return __arr + _Nm; }
template<typename _Tp> class valarray;
template<typename _Tp> _Tp* begin(valarray<_Tp>&);
template<typename _Tp> const _Tp* begin(const valarray<_Tp>&);
template<typename _Tp> _Tp* end(valarray<_Tp>&);
template<typename _Tp> const _Tp* end(const valarray<_Tp>&);
template<typename _Container>
inline constexpr auto
cbegin(const _Container& __cont) noexcept(noexcept(std::begin(__cont)))
-> decltype(std::begin(__cont))
{ return std::begin(__cont); }
template<typename _Container>
inline constexpr auto
cend(const _Container& __cont) noexcept(noexcept(std::end(__cont)))
-> decltype(std::end(__cont))
{ return std::end(__cont); }
template<typename _Container>
inline auto
rbegin(_Container& __cont) -> decltype(__cont.rbegin())
{ return __cont.rbegin(); }
template<typename _Container>
inline auto
rbegin(const _Container& __cont) -> decltype(__cont.rbegin())
{ return __cont.rbegin(); }
template<typename _Container>
inline auto
rend(_Container& __cont) -> decltype(__cont.rend())
{ return __cont.rend(); }
template<typename _Container>
inline auto
rend(const _Container& __cont) -> decltype(__cont.rend())
{ return __cont.rend(); }
template<typename _Tp, size_t _Nm>
inline reverse_iterator<_Tp*>
rbegin(_Tp (&__arr)[_Nm])
{ return reverse_iterator<_Tp*>(__arr + _Nm); }
template<typename _Tp, size_t _Nm>
inline reverse_iterator<_Tp*>
rend(_Tp (&__arr)[_Nm])
{ return reverse_iterator<_Tp*>(__arr); }
template<typename _Tp>
inline reverse_iterator<const _Tp*>
rbegin(initializer_list<_Tp> __il)
{ return reverse_iterator<const _Tp*>(__il.end()); }
template<typename _Tp>
inline reverse_iterator<const _Tp*>
rend(initializer_list<_Tp> __il)
{ return reverse_iterator<const _Tp*>(__il.begin()); }
template<typename _Container>
inline auto
crbegin(const _Container& __cont) -> decltype(std::rbegin(__cont))
{ return std::rbegin(__cont); }
template<typename _Container>
inline auto
crend(const _Container& __cont) -> decltype(std::rend(__cont))
{ return std::rend(__cont); }
# 319 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/range_access.h" 3
}
# 52 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/string" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 1 3
# 37 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
# 38 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/alloc_traits.h" 1 3
# 32 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/alloc_traits.h" 3
# 33 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/alloc_traits.h" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/alloc_traits.h" 1 3
# 41 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/alloc_traits.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
struct __allocator_traits_base
{
template<typename _Alloc, typename _Up>
using __rebind = typename _Alloc::template rebind<_Up>::other;
protected:
template<typename _Tp>
using __pointer = typename _Tp::pointer;
template<typename _Tp>
using __c_pointer = typename _Tp::const_pointer;
template<typename _Tp>
using __v_pointer = typename _Tp::void_pointer;
template<typename _Tp>
using __cv_pointer = typename _Tp::const_void_pointer;
template<typename _Tp>
using __diff_type = typename _Tp::difference_type;
template<typename _Tp>
using __size_type = typename _Tp::size_type;
template<typename _Tp>
using __pocca = typename _Tp::propagate_on_container_copy_assignment;
template<typename _Tp>
using __pocma = typename _Tp::propagate_on_container_move_assignment;
template<typename _Tp>
using __pocs = typename _Tp::propagate_on_container_swap;
template<typename _Tp>
using __equal = typename _Tp::is_always_equal;
};
template<typename _Alloc, typename _Up>
using __alloc_rebind = __detected_or_t_<__replace_first_arg_t,
__allocator_traits_base::__rebind,
_Alloc, _Up>;
template<typename _Alloc>
struct allocator_traits : __allocator_traits_base
{
typedef _Alloc allocator_type;
typedef typename _Alloc::value_type value_type;
using pointer = __detected_or_t<value_type*, __pointer, _Alloc>;
using const_pointer
= __detected_or_t<__ptr_rebind<pointer, const value_type>,
__c_pointer, _Alloc>;
using void_pointer
= __detected_or_t<__ptr_rebind<pointer, void>, __v_pointer, _Alloc>;
using const_void_pointer
= __detected_or_t<__ptr_rebind<pointer, const void>, __cv_pointer,
_Alloc>;
using difference_type
= __detected_or_t<typename pointer_traits<pointer>::difference_type,
__diff_type, _Alloc>;
using size_type
= __detected_or_t<typename make_unsigned<difference_type>::type,
__size_type, _Alloc>;
using propagate_on_container_copy_assignment
= __detected_or_t<false_type, __pocca, _Alloc>;
using propagate_on_container_move_assignment
= __detected_or_t<false_type, __pocma, _Alloc>;
using propagate_on_container_swap
= __detected_or_t<false_type, __pocs, _Alloc>;
using is_always_equal
= __detected_or_t<typename is_empty<_Alloc>::type, __equal, _Alloc>;
template<typename _Tp>
using rebind_alloc = __alloc_rebind<_Alloc, _Tp>;
template<typename _Tp>
using rebind_traits = allocator_traits<rebind_alloc<_Tp>>;
static_assert(!is_same<rebind_alloc<value_type>, __undefined>::value,
"allocator defines rebind or is like Alloc<T, Args>");
private:
template<typename _Alloc2>
static auto
_S_allocate(_Alloc2& __a, size_type __n, const_void_pointer __hint, int)
-> decltype(__a.allocate(__n, __hint))
{ return __a.allocate(__n, __hint); }
template<typename _Alloc2>
static pointer
_S_allocate(_Alloc2& __a, size_type __n, const_void_pointer, ...)
{ return __a.allocate(__n); }
template<typename _Tp, typename... _Args>
struct __construct_helper
{
template<typename _Alloc2,
typename = decltype(std::declval<_Alloc2*>()->construct(
std::declval<_Tp*>(), std::declval<_Args>()...))>
static true_type __test(int);
template<typename>
static false_type __test(...);
using type = decltype(__test<_Alloc>(0));
};
template<typename _Tp, typename... _Args>
using __has_construct
= typename __construct_helper<_Tp, _Args...>::type;
template<typename _Tp, typename... _Args>
static _Require<__has_construct<_Tp, _Args...>>
_S_construct(_Alloc& __a, _Tp* __p, _Args&&... __args)
{ __a.construct(__p, std::forward<_Args>(__args)...); }
template<typename _Tp, typename... _Args>
static
_Require<__and_<__not_<__has_construct<_Tp, _Args...>>,
is_constructible<_Tp, _Args...>>>
_S_construct(_Alloc&, _Tp* __p, _Args&&... __args)
{ ::new((void*)__p) _Tp(std::forward<_Args>(__args)...); }
template<typename _Alloc2, typename _Tp>
static auto
_S_destroy(_Alloc2& __a, _Tp* __p, int)
-> decltype(__a.destroy(__p))
{ __a.destroy(__p); }
template<typename _Alloc2, typename _Tp>
static void
_S_destroy(_Alloc2&, _Tp* __p, ...)
{ __p->~_Tp(); }
template<typename _Alloc2>
static auto
_S_max_size(_Alloc2& __a, int)
-> decltype(__a.max_size())
{ return __a.max_size(); }
template<typename _Alloc2>
static size_type
_S_max_size(_Alloc2&, ...)
{
return __gnu_cxx::__numeric_traits<size_type>::__max
/ sizeof(value_type);
}
template<typename _Alloc2>
static auto
_S_select(_Alloc2& __a, int)
-> decltype(__a.select_on_container_copy_construction())
{ return __a.select_on_container_copy_construction(); }
template<typename _Alloc2>
static _Alloc2
_S_select(_Alloc2& __a, ...)
{ return __a; }
public:
# 279 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/alloc_traits.h" 3
static pointer
allocate(_Alloc& __a, size_type __n)
{ return __a.allocate(__n); }
# 294 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/alloc_traits.h" 3
static pointer
allocate(_Alloc& __a, size_type __n, const_void_pointer __hint)
{ return _S_allocate(__a, __n, __hint, 0); }
# 306 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/alloc_traits.h" 3
static void
deallocate(_Alloc& __a, pointer __p, size_type __n)
{ __a.deallocate(__p, __n); }
# 321 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/alloc_traits.h" 3
template<typename _Tp, typename... _Args>
static auto construct(_Alloc& __a, _Tp* __p, _Args&&... __args)
-> decltype(_S_construct(__a, __p, std::forward<_Args>(__args)...))
{ _S_construct(__a, __p, std::forward<_Args>(__args)...); }
# 334 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/alloc_traits.h" 3
template<typename _Tp>
static void destroy(_Alloc& __a, _Tp* __p)
{ _S_destroy(__a, __p, 0); }
# 346 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/alloc_traits.h" 3
static size_type max_size(const _Alloc& __a) noexcept
{ return _S_max_size(__a, 0); }
# 357 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/alloc_traits.h" 3
static _Alloc
select_on_container_copy_construction(const _Alloc& __rhs)
{ return _S_select(__rhs, 0); }
};
template<typename _Tp>
struct allocator_traits<allocator<_Tp>>
{
using allocator_type = allocator<_Tp>;
using value_type = _Tp;
using pointer = _Tp*;
using const_pointer = const _Tp*;
using void_pointer = void*;
using const_void_pointer = const void*;
using difference_type = std::ptrdiff_t;
using size_type = std::size_t;
using propagate_on_container_copy_assignment = false_type;
using propagate_on_container_move_assignment = true_type;
using propagate_on_container_swap = false_type;
using is_always_equal = true_type;
template<typename _Up>
using rebind_alloc = allocator<_Up>;
template<typename _Up>
using rebind_traits = allocator_traits<allocator<_Up>>;
# 414 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/alloc_traits.h" 3
static pointer
allocate(allocator_type& __a, size_type __n)
{ return __a.allocate(__n); }
# 428 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/alloc_traits.h" 3
static pointer
allocate(allocator_type& __a, size_type __n, const_void_pointer __hint)
{ return __a.allocate(__n, __hint); }
# 440 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/alloc_traits.h" 3
static void
deallocate(allocator_type& __a, pointer __p, size_type __n)
{ __a.deallocate(__p, __n); }
# 452 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/alloc_traits.h" 3
template<typename _Up, typename... _Args>
static void
construct(allocator_type& __a, _Up* __p, _Args&&... __args)
{ __a.construct(__p, std::forward<_Args>(__args)...); }
# 464 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/alloc_traits.h" 3
template<typename _Up>
static void
destroy(allocator_type& __a, _Up* __p)
{ __a.destroy(__p); }
static size_type
max_size(const allocator_type& __a) noexcept
{ return __a.max_size(); }
static allocator_type
select_on_container_copy_construction(const allocator_type& __rhs)
{ return __rhs; }
};
template<typename _Alloc>
inline void
__do_alloc_on_copy(_Alloc& __one, const _Alloc& __two, true_type)
{ __one = __two; }
template<typename _Alloc>
inline void
__do_alloc_on_copy(_Alloc&, const _Alloc&, false_type)
{ }
template<typename _Alloc>
inline void __alloc_on_copy(_Alloc& __one, const _Alloc& __two)
{
typedef allocator_traits<_Alloc> __traits;
typedef typename __traits::propagate_on_container_copy_assignment __pocca;
__do_alloc_on_copy(__one, __two, __pocca());
}
template<typename _Alloc>
inline _Alloc __alloc_on_copy(const _Alloc& __a)
{
typedef allocator_traits<_Alloc> __traits;
return __traits::select_on_container_copy_construction(__a);
}
template<typename _Alloc>
inline void __do_alloc_on_move(_Alloc& __one, _Alloc& __two, true_type)
{ __one = std::move(__two); }
template<typename _Alloc>
inline void __do_alloc_on_move(_Alloc&, _Alloc&, false_type)
{ }
template<typename _Alloc>
inline void __alloc_on_move(_Alloc& __one, _Alloc& __two)
{
typedef allocator_traits<_Alloc> __traits;
typedef typename __traits::propagate_on_container_move_assignment __pocma;
__do_alloc_on_move(__one, __two, __pocma());
}
template<typename _Alloc>
inline void __do_alloc_on_swap(_Alloc& __one, _Alloc& __two, true_type)
{
using std::swap;
swap(__one, __two);
}
template<typename _Alloc>
inline void __do_alloc_on_swap(_Alloc&, _Alloc&, false_type)
{ }
template<typename _Alloc>
inline void __alloc_on_swap(_Alloc& __one, _Alloc& __two)
{
typedef allocator_traits<_Alloc> __traits;
typedef typename __traits::propagate_on_container_swap __pocs;
__do_alloc_on_swap(__one, __two, __pocs());
}
template<typename _Alloc>
class __is_copy_insertable_impl
{
typedef allocator_traits<_Alloc> _Traits;
template<typename _Up, typename
= decltype(_Traits::construct(std::declval<_Alloc&>(),
std::declval<_Up*>(),
std::declval<const _Up&>()))>
static true_type
_M_select(int);
template<typename _Up>
static false_type
_M_select(...);
public:
typedef decltype(_M_select<typename _Alloc::value_type>(0)) type;
};
template<typename _Alloc>
struct __is_copy_insertable
: __is_copy_insertable_impl<_Alloc>::type
{ };
template<typename _Tp>
struct __is_copy_insertable<allocator<_Tp>>
: is_copy_constructible<_Tp>
{ };
}
# 37 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/alloc_traits.h" 2 3
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
template<typename _Alloc>
struct __alloc_traits
: std::allocator_traits<_Alloc>
{
typedef _Alloc allocator_type;
typedef std::allocator_traits<_Alloc> _Base_type;
typedef typename _Base_type::value_type value_type;
typedef typename _Base_type::pointer pointer;
typedef typename _Base_type::const_pointer const_pointer;
typedef typename _Base_type::size_type size_type;
typedef typename _Base_type::difference_type difference_type;
typedef value_type& reference;
typedef const value_type& const_reference;
using _Base_type::allocate;
using _Base_type::deallocate;
using _Base_type::construct;
using _Base_type::destroy;
using _Base_type::max_size;
private:
template<typename _Ptr>
using __is_custom_pointer
= std::__and_<std::is_same<pointer, _Ptr>,
std::__not_<std::is_pointer<_Ptr>>>;
public:
template<typename _Ptr, typename... _Args>
static typename std::enable_if<__is_custom_pointer<_Ptr>::value>::type
construct(_Alloc& __a, _Ptr __p, _Args&&... __args)
{
_Base_type::construct(__a, std::addressof(*__p),
std::forward<_Args>(__args)...);
}
template<typename _Ptr>
static typename std::enable_if<__is_custom_pointer<_Ptr>::value>::type
destroy(_Alloc& __a, _Ptr __p)
{ _Base_type::destroy(__a, std::addressof(*__p)); }
static _Alloc _S_select_on_copy(const _Alloc& __a)
{ return _Base_type::select_on_container_copy_construction(__a); }
static void _S_on_swap(_Alloc& __a, _Alloc& __b)
{ std::__alloc_on_swap(__a, __b); }
static constexpr bool _S_propagate_on_copy_assign()
{ return _Base_type::propagate_on_container_copy_assignment::value; }
static constexpr bool _S_propagate_on_move_assign()
{ return _Base_type::propagate_on_container_move_assignment::value; }
static constexpr bool _S_propagate_on_swap()
{ return _Base_type::propagate_on_container_swap::value; }
static constexpr bool _S_always_equal()
{ return _Base_type::is_always_equal::value; }
static constexpr bool _S_nothrow_move()
{ return _S_propagate_on_move_assign() || _S_always_equal(); }
template<typename _Tp>
struct rebind
{ typedef typename _Base_type::template rebind_alloc<_Tp> other; };
# 158 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/alloc_traits.h" 3
};
}
# 41 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
namespace __cxx11 {
# 71 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
template<typename _CharT, typename _Traits, typename _Alloc>
class basic_string
{
typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
rebind<_CharT>::other _Char_alloc_type;
typedef __gnu_cxx::__alloc_traits<_Char_alloc_type> _Alloc_traits;
public:
typedef _Traits traits_type;
typedef typename _Traits::char_type value_type;
typedef _Char_alloc_type allocator_type;
typedef typename _Alloc_traits::size_type size_type;
typedef typename _Alloc_traits::difference_type difference_type;
typedef typename _Alloc_traits::reference reference;
typedef typename _Alloc_traits::const_reference const_reference;
typedef typename _Alloc_traits::pointer pointer;
typedef typename _Alloc_traits::const_pointer const_pointer;
typedef __gnu_cxx::__normal_iterator<pointer, basic_string> iterator;
typedef __gnu_cxx::__normal_iterator<const_pointer, basic_string>
const_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
typedef std::reverse_iterator<iterator> reverse_iterator;
static const size_type npos = static_cast<size_type>(-1);
private:
typedef const_iterator __const_iterator;
struct _Alloc_hider : allocator_type
{
_Alloc_hider(pointer __dat, const _Alloc& __a = _Alloc())
: allocator_type(__a), _M_p(__dat) { }
pointer _M_p;
};
_Alloc_hider _M_dataplus;
size_type _M_string_length;
enum { _S_local_capacity = 15 / sizeof(_CharT) };
union
{
_CharT _M_local_buf[_S_local_capacity + 1];
size_type _M_allocated_capacity;
};
void
_M_data(pointer __p)
{ _M_dataplus._M_p = __p; }
void
_M_length(size_type __length)
{ _M_string_length = __length; }
pointer
_M_data() const
{ return _M_dataplus._M_p; }
pointer
_M_local_data()
{
return std::pointer_traits<pointer>::pointer_to(*_M_local_buf);
}
const_pointer
_M_local_data() const
{
return std::pointer_traits<const_pointer>::pointer_to(*_M_local_buf);
}
void
_M_capacity(size_type __capacity)
{ _M_allocated_capacity = __capacity; }
void
_M_set_length(size_type __n)
{
_M_length(__n);
traits_type::assign(_M_data()[__n], _CharT());
}
bool
_M_is_local() const
{ return _M_data() == _M_local_data(); }
pointer
_M_create(size_type&, size_type);
void
_M_dispose()
{
if (!_M_is_local())
_M_destroy(_M_allocated_capacity);
}
void
_M_destroy(size_type __size) throw()
{ _Alloc_traits::deallocate(_M_get_allocator(), _M_data(), __size + 1); }
template<typename _InIterator>
void
_M_construct_aux(_InIterator __beg, _InIterator __end,
std::__false_type)
{
typedef typename iterator_traits<_InIterator>::iterator_category _Tag;
_M_construct(__beg, __end, _Tag());
}
template<typename _Integer>
void
_M_construct_aux(_Integer __beg, _Integer __end, std::__true_type)
{ _M_construct_aux_2(static_cast<size_type>(__beg), __end); }
void
_M_construct_aux_2(size_type __req, _CharT __c)
{ _M_construct(__req, __c); }
template<typename _InIterator>
void
_M_construct(_InIterator __beg, _InIterator __end)
{
typedef typename std::__is_integer<_InIterator>::__type _Integral;
_M_construct_aux(__beg, __end, _Integral());
}
template<typename _InIterator>
void
_M_construct(_InIterator __beg, _InIterator __end,
std::input_iterator_tag);
template<typename _FwdIterator>
void
_M_construct(_FwdIterator __beg, _FwdIterator __end,
std::forward_iterator_tag);
void
_M_construct(size_type __req, _CharT __c);
allocator_type&
_M_get_allocator()
{ return _M_dataplus; }
const allocator_type&
_M_get_allocator() const
{ return _M_dataplus; }
private:
# 258 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
size_type
_M_check(size_type __pos, const char* __s) const
{
if (__pos > this->size())
__throw_out_of_range_fmt(("%s: __pos (which is %zu) > " "this->size() (which is %zu)")
,
__s, __pos, this->size());
return __pos;
}
void
_M_check_length(size_type __n1, size_type __n2, const char* __s) const
{
if (this->max_size() - (this->size() - __n1) < __n2)
__throw_length_error((__s));
}
size_type
_M_limit(size_type __pos, size_type __off) const noexcept
{
const bool __testoff = __off < this->size() - __pos;
return __testoff ? __off : this->size() - __pos;
}
bool
_M_disjunct(const _CharT* __s) const noexcept
{
return (less<const _CharT*>()(__s, _M_data())
|| less<const _CharT*>()(_M_data() + this->size(), __s));
}
static void
_S_copy(_CharT* __d, const _CharT* __s, size_type __n)
{
if (__n == 1)
traits_type::assign(*__d, *__s);
else
traits_type::copy(__d, __s, __n);
}
static void
_S_move(_CharT* __d, const _CharT* __s, size_type __n)
{
if (__n == 1)
traits_type::assign(*__d, *__s);
else
traits_type::move(__d, __s, __n);
}
static void
_S_assign(_CharT* __d, size_type __n, _CharT __c)
{
if (__n == 1)
traits_type::assign(*__d, __c);
else
traits_type::assign(__d, __n, __c);
}
template<class _Iterator>
static void
_S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2)
{
for (; __k1 != __k2; ++__k1, (void)++__p)
traits_type::assign(*__p, *__k1);
}
static void
_S_copy_chars(_CharT* __p, iterator __k1, iterator __k2) noexcept
{ _S_copy_chars(__p, __k1.base(), __k2.base()); }
static void
_S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2)
noexcept
{ _S_copy_chars(__p, __k1.base(), __k2.base()); }
static void
_S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2) noexcept
{ _S_copy(__p, __k1, __k2 - __k1); }
static void
_S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
noexcept
{ _S_copy(__p, __k1, __k2 - __k1); }
static int
_S_compare(size_type __n1, size_type __n2) noexcept
{
const difference_type __d = difference_type(__n1 - __n2);
if (__d > __gnu_cxx::__numeric_traits<int>::__max)
return __gnu_cxx::__numeric_traits<int>::__max;
else if (__d < __gnu_cxx::__numeric_traits<int>::__min)
return __gnu_cxx::__numeric_traits<int>::__min;
else
return int(__d);
}
void
_M_assign(const basic_string& __rcs);
void
_M_mutate(size_type __pos, size_type __len1, const _CharT* __s,
size_type __len2);
void
_M_erase(size_type __pos, size_type __n);
public:
basic_string()
noexcept(is_nothrow_default_constructible<_Alloc>::value)
: _M_dataplus(_M_local_data())
{ _M_set_length(0); }
explicit
basic_string(const _Alloc& __a) noexcept
: _M_dataplus(_M_local_data(), __a)
{ _M_set_length(0); }
basic_string(const basic_string& __str)
: _M_dataplus(_M_local_data(),
_Alloc_traits::_S_select_on_copy(__str._M_get_allocator()))
{ _M_construct(__str._M_data(), __str._M_data() + __str.length()); }
# 410 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
basic_string(const basic_string& __str, size_type __pos,
size_type __n = npos)
: _M_dataplus(_M_local_data())
{
const _CharT* __start = __str._M_data()
+ __str._M_check(__pos, "basic_string::basic_string");
_M_construct(__start, __start + __str._M_limit(__pos, __n));
}
# 426 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
basic_string(const basic_string& __str, size_type __pos,
size_type __n, const _Alloc& __a)
: _M_dataplus(_M_local_data(), __a)
{
const _CharT* __start
= __str._M_data() + __str._M_check(__pos, "string::string");
_M_construct(__start, __start + __str._M_limit(__pos, __n));
}
# 444 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
basic_string(const _CharT* __s, size_type __n,
const _Alloc& __a = _Alloc())
: _M_dataplus(_M_local_data(), __a)
{ _M_construct(__s, __s + __n); }
basic_string(const _CharT* __s, const _Alloc& __a = _Alloc())
: _M_dataplus(_M_local_data(), __a)
{ _M_construct(__s, __s ? __s + traits_type::length(__s) : __s+npos); }
basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc())
: _M_dataplus(_M_local_data(), __a)
{ _M_construct(__n, __c); }
# 476 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
basic_string(basic_string&& __str) noexcept
: _M_dataplus(_M_local_data(), std::move(__str._M_get_allocator()))
{
if (__str._M_is_local())
{
traits_type::copy(_M_local_buf, __str._M_local_buf,
_S_local_capacity + 1);
}
else
{
_M_data(__str._M_data());
_M_capacity(__str._M_allocated_capacity);
}
_M_length(__str.length());
__str._M_data(__str._M_local_data());
__str._M_set_length(0);
}
basic_string(initializer_list<_CharT> __l, const _Alloc& __a = _Alloc())
: _M_dataplus(_M_local_data(), __a)
{ _M_construct(__l.begin(), __l.end()); }
basic_string(const basic_string& __str, const _Alloc& __a)
: _M_dataplus(_M_local_data(), __a)
{ _M_construct(__str.begin(), __str.end()); }
basic_string(basic_string&& __str, const _Alloc& __a)
noexcept(_Alloc_traits::_S_always_equal())
: _M_dataplus(_M_local_data(), __a)
{
if (__str._M_is_local())
{
traits_type::copy(_M_local_buf, __str._M_local_buf,
_S_local_capacity + 1);
_M_length(__str.length());
__str._M_set_length(0);
}
else if (_Alloc_traits::_S_always_equal()
|| __str.get_allocator() == __a)
{
_M_data(__str._M_data());
_M_length(__str.length());
_M_capacity(__str._M_allocated_capacity);
__str._M_data(__str._M_local_buf);
__str._M_set_length(0);
}
else
_M_construct(__str.begin(), __str.end());
}
# 544 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
template<typename _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
basic_string(_InputIterator __beg, _InputIterator __end,
const _Alloc& __a = _Alloc())
: _M_dataplus(_M_local_data(), __a)
{ _M_construct(__beg, __end); }
~basic_string()
{ _M_dispose(); }
basic_string&
operator=(const basic_string& __str)
{
if (_Alloc_traits::_S_propagate_on_copy_assign())
{
if (!_Alloc_traits::_S_always_equal() && !_M_is_local()
&& _M_get_allocator() != __str._M_get_allocator())
{
_M_destroy(_M_allocated_capacity);
_M_data(_M_local_data());
_M_set_length(0);
}
std::__alloc_on_copy(_M_get_allocator(), __str._M_get_allocator());
}
return this->assign(__str);
}
basic_string&
operator=(const _CharT* __s)
{ return this->assign(__s); }
# 599 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
basic_string&
operator=(_CharT __c)
{
this->assign(1, __c);
return *this;
}
# 617 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
basic_string&
operator=(basic_string&& __str)
noexcept(_Alloc_traits::_S_nothrow_move())
{
if (!_M_is_local() && _Alloc_traits::_S_propagate_on_move_assign()
&& !_Alloc_traits::_S_always_equal()
&& _M_get_allocator() != __str._M_get_allocator())
{
_M_destroy(_M_allocated_capacity);
_M_data(_M_local_data());
_M_set_length(0);
}
std::__alloc_on_move(_M_get_allocator(), __str._M_get_allocator());
if (!__str._M_is_local()
&& (_Alloc_traits::_S_propagate_on_move_assign()
|| _Alloc_traits::_S_always_equal()))
{
pointer __data = nullptr;
size_type __capacity;
if (!_M_is_local())
{
if (_Alloc_traits::_S_always_equal())
{
__data = _M_data();
__capacity = _M_allocated_capacity;
}
else
_M_destroy(_M_allocated_capacity);
}
_M_data(__str._M_data());
_M_length(__str.length());
_M_capacity(__str._M_allocated_capacity);
if (__data)
{
__str._M_data(__data);
__str._M_capacity(__capacity);
}
else
__str._M_data(__str._M_local_buf);
}
else
assign(__str);
__str.clear();
return *this;
}
basic_string&
operator=(initializer_list<_CharT> __l)
{
this->assign(__l.begin(), __l.size());
return *this;
}
iterator
begin() noexcept
{ return iterator(_M_data()); }
const_iterator
begin() const noexcept
{ return const_iterator(_M_data()); }
iterator
end() noexcept
{ return iterator(_M_data() + this->size()); }
const_iterator
end() const noexcept
{ return const_iterator(_M_data() + this->size()); }
reverse_iterator
rbegin() noexcept
{ return reverse_iterator(this->end()); }
const_reverse_iterator
rbegin() const noexcept
{ return const_reverse_iterator(this->end()); }
reverse_iterator
rend() noexcept
{ return reverse_iterator(this->begin()); }
const_reverse_iterator
rend() const noexcept
{ return const_reverse_iterator(this->begin()); }
const_iterator
cbegin() const noexcept
{ return const_iterator(this->_M_data()); }
const_iterator
cend() const noexcept
{ return const_iterator(this->_M_data() + this->size()); }
const_reverse_iterator
crbegin() const noexcept
{ return const_reverse_iterator(this->end()); }
const_reverse_iterator
crend() const noexcept
{ return const_reverse_iterator(this->begin()); }
public:
size_type
size() const noexcept
{ return _M_string_length; }
size_type
length() const noexcept
{ return _M_string_length; }
size_type
max_size() const noexcept
{ return (_Alloc_traits::max_size(_M_get_allocator()) - 1) / 2; }
# 813 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
void
resize(size_type __n, _CharT __c);
# 826 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
void
resize(size_type __n)
{ this->resize(__n, _CharT()); }
void
shrink_to_fit() noexcept
{
if (capacity() > size())
{
try
{ reserve(0); }
catch(...)
{ }
}
}
size_type
capacity() const noexcept
{
return _M_is_local() ? size_type(_S_local_capacity)
: _M_allocated_capacity;
}
# 875 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
void
reserve(size_type __res_arg = 0);
void
clear() noexcept
{ _M_set_length(0); }
bool
empty() const noexcept
{ return this->size() == 0; }
# 904 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
const_reference
operator[] (size_type __pos) const noexcept
{
;
return _M_data()[__pos];
}
# 921 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
reference
operator[](size_type __pos)
{
;
;
return _M_data()[__pos];
}
# 942 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
const_reference
at(size_type __n) const
{
if (__n >= this->size())
__throw_out_of_range_fmt(("basic_string::at: __n " "(which is %zu) >= this->size() " "(which is %zu)")
,
__n, this->size());
return _M_data()[__n];
}
# 963 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
reference
at(size_type __n)
{
if (__n >= size())
__throw_out_of_range_fmt(("basic_string::at: __n " "(which is %zu) >= this->size() " "(which is %zu)")
,
__n, this->size());
return _M_data()[__n];
}
reference
front() noexcept
{
;
return operator[](0);
}
const_reference
front() const noexcept
{
;
return operator[](0);
}
reference
back() noexcept
{
;
return operator[](this->size() - 1);
}
const_reference
back() const noexcept
{
;
return operator[](this->size() - 1);
}
# 1026 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
basic_string&
operator+=(const basic_string& __str)
{ return this->append(__str); }
basic_string&
operator+=(const _CharT* __s)
{ return this->append(__s); }
basic_string&
operator+=(_CharT __c)
{
this->push_back(__c);
return *this;
}
basic_string&
operator+=(initializer_list<_CharT> __l)
{ return this->append(__l.begin(), __l.size()); }
basic_string&
append(const basic_string& __str)
{ return _M_append(__str._M_data(), __str.size()); }
# 1084 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
basic_string&
append(const basic_string& __str, size_type __pos, size_type __n)
{ return _M_append(__str._M_data()
+ __str._M_check(__pos, "basic_string::append"),
__str._M_limit(__pos, __n)); }
basic_string&
append(const _CharT* __s, size_type __n)
{
;
_M_check_length(size_type(0), __n, "basic_string::append");
return _M_append(__s, __n);
}
basic_string&
append(const _CharT* __s)
{
;
const size_type __n = traits_type::length(__s);
_M_check_length(size_type(0), __n, "basic_string::append");
return _M_append(__s, __n);
}
# 1126 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
basic_string&
append(size_type __n, _CharT __c)
{ return _M_replace_aux(this->size(), size_type(0), __n, __c); }
basic_string&
append(initializer_list<_CharT> __l)
{ return this->append(__l.begin(), __l.size()); }
# 1150 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
template<class _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
basic_string&
append(_InputIterator __first, _InputIterator __last)
{ return this->replace(end(), end(), __first, __last); }
void
push_back(_CharT __c)
{
const size_type __size = this->size();
if (__size + 1 > this->capacity())
this->_M_mutate(__size, size_type(0), 0, size_type(1));
traits_type::assign(this->_M_data()[__size], __c);
this->_M_set_length(__size + 1);
}
basic_string&
assign(const basic_string& __str)
{
this->_M_assign(__str);
return *this;
}
# 1194 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
basic_string&
assign(basic_string&& __str)
noexcept(_Alloc_traits::_S_nothrow_move())
{
return *this = std::move(__str);
}
# 1217 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
basic_string&
assign(const basic_string& __str, size_type __pos, size_type __n)
{ return _M_replace(size_type(0), this->size(), __str._M_data()
+ __str._M_check(__pos, "basic_string::assign"),
__str._M_limit(__pos, __n)); }
# 1233 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
basic_string&
assign(const _CharT* __s, size_type __n)
{
;
return _M_replace(size_type(0), this->size(), __s, __n);
}
# 1249 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
basic_string&
assign(const _CharT* __s)
{
;
return _M_replace(size_type(0), this->size(), __s,
traits_type::length(__s));
}
# 1266 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
basic_string&
assign(size_type __n, _CharT __c)
{ return _M_replace_aux(size_type(0), this->size(), __n, __c); }
# 1279 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
template<class _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
basic_string&
assign(_InputIterator __first, _InputIterator __last)
{ return this->replace(begin(), end(), __first, __last); }
basic_string&
assign(initializer_list<_CharT> __l)
{ return this->assign(__l.begin(), __l.size()); }
# 1315 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
iterator
insert(const_iterator __p, size_type __n, _CharT __c)
{
;
const size_type __pos = __p - begin();
this->replace(__p, __p, __n, __c);
return iterator(this->_M_data() + __pos);
}
# 1357 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
template<class _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
iterator
insert(const_iterator __p, _InputIterator __beg, _InputIterator __end)
{
;
const size_type __pos = __p - begin();
this->replace(__p, __p, __beg, __end);
return iterator(this->_M_data() + __pos);
}
# 1393 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
void
insert(iterator __p, initializer_list<_CharT> __l)
{
;
this->insert(__p - begin(), __l.begin(), __l.size());
}
# 1413 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
basic_string&
insert(size_type __pos1, const basic_string& __str)
{ return this->replace(__pos1, size_type(0),
__str._M_data(), __str.size()); }
# 1436 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
basic_string&
insert(size_type __pos1, const basic_string& __str,
size_type __pos2, size_type __n)
{ return this->replace(__pos1, size_type(0), __str._M_data()
+ __str._M_check(__pos2, "basic_string::insert"),
__str._M_limit(__pos2, __n)); }
# 1459 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
basic_string&
insert(size_type __pos, const _CharT* __s, size_type __n)
{ return this->replace(__pos, size_type(0), __s, __n); }
# 1478 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
basic_string&
insert(size_type __pos, const _CharT* __s)
{
;
return this->replace(__pos, size_type(0), __s,
traits_type::length(__s));
}
# 1502 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
basic_string&
insert(size_type __pos, size_type __n, _CharT __c)
{ return _M_replace_aux(_M_check(__pos, "basic_string::insert"),
size_type(0), __n, __c); }
# 1520 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
iterator
insert(__const_iterator __p, _CharT __c)
{
;
const size_type __pos = __p - begin();
_M_replace_aux(__pos, size_type(0), size_type(1), __c);
return iterator(_M_data() + __pos);
}
# 1544 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
basic_string&
erase(size_type __pos = 0, size_type __n = npos)
{
this->_M_erase(_M_check(__pos, "basic_string::erase"),
_M_limit(__pos, __n));
return *this;
}
# 1560 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
iterator
erase(__const_iterator __position)
{
;
const size_type __pos = __position - begin();
this->_M_erase(__pos, size_type(1));
return iterator(_M_data() + __pos);
}
# 1579 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
iterator
erase(__const_iterator __first, __const_iterator __last)
{
;
const size_type __pos = __first - begin();
this->_M_erase(__pos, __last - __first);
return iterator(this->_M_data() + __pos);
}
void
pop_back() noexcept
{
;
_M_erase(size() - 1, 1);
}
# 1620 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
basic_string&
replace(size_type __pos, size_type __n, const basic_string& __str)
{ return this->replace(__pos, __n, __str._M_data(), __str.size()); }
# 1642 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
basic_string&
replace(size_type __pos1, size_type __n1, const basic_string& __str,
size_type __pos2, size_type __n2)
{ return this->replace(__pos1, __n1, __str._M_data()
+ __str._M_check(__pos2, "basic_string::replace"),
__str._M_limit(__pos2, __n2)); }
# 1667 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
basic_string&
replace(size_type __pos, size_type __n1, const _CharT* __s,
size_type __n2)
{
;
return _M_replace(_M_check(__pos, "basic_string::replace"),
_M_limit(__pos, __n1), __s, __n2);
}
# 1692 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
basic_string&
replace(size_type __pos, size_type __n1, const _CharT* __s)
{
;
return this->replace(__pos, __n1, __s, traits_type::length(__s));
}
# 1716 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
basic_string&
replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
{ return _M_replace_aux(_M_check(__pos, "basic_string::replace"),
_M_limit(__pos, __n1), __n2, __c); }
# 1734 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
basic_string&
replace(__const_iterator __i1, __const_iterator __i2,
const basic_string& __str)
{ return this->replace(__i1, __i2, __str._M_data(), __str.size()); }
# 1754 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
basic_string&
replace(__const_iterator __i1, __const_iterator __i2,
const _CharT* __s, size_type __n)
{
;
return this->replace(__i1 - begin(), __i2 - __i1, __s, __n);
}
# 1776 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
basic_string&
replace(__const_iterator __i1, __const_iterator __i2, const _CharT* __s)
{
;
return this->replace(__i1, __i2, __s, traits_type::length(__s));
}
# 1797 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
basic_string&
replace(__const_iterator __i1, __const_iterator __i2, size_type __n,
_CharT __c)
{
;
return _M_replace_aux(__i1 - begin(), __i2 - __i1, __n, __c);
}
# 1822 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
template<class _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
basic_string&
replace(const_iterator __i1, const_iterator __i2,
_InputIterator __k1, _InputIterator __k2)
{
;
;
return this->_M_replace_dispatch(__i1, __i2, __k1, __k2,
std::__false_type());
}
# 1854 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
basic_string&
replace(__const_iterator __i1, __const_iterator __i2,
_CharT* __k1, _CharT* __k2)
{
;
;
return this->replace(__i1 - begin(), __i2 - __i1,
__k1, __k2 - __k1);
}
basic_string&
replace(__const_iterator __i1, __const_iterator __i2,
const _CharT* __k1, const _CharT* __k2)
{
;
;
return this->replace(__i1 - begin(), __i2 - __i1,
__k1, __k2 - __k1);
}
basic_string&
replace(__const_iterator __i1, __const_iterator __i2,
iterator __k1, iterator __k2)
{
;
;
return this->replace(__i1 - begin(), __i2 - __i1,
__k1.base(), __k2 - __k1);
}
basic_string&
replace(__const_iterator __i1, __const_iterator __i2,
const_iterator __k1, const_iterator __k2)
{
;
;
return this->replace(__i1 - begin(), __i2 - __i1,
__k1.base(), __k2 - __k1);
}
# 1913 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
basic_string& replace(const_iterator __i1, const_iterator __i2,
initializer_list<_CharT> __l)
{ return this->replace(__i1, __i2, __l.begin(), __l.end()); }
private:
template<class _Integer>
basic_string&
_M_replace_dispatch(const_iterator __i1, const_iterator __i2,
_Integer __n, _Integer __val, __true_type)
{ return _M_replace_aux(__i1 - begin(), __i2 - __i1, __n, __val); }
template<class _InputIterator>
basic_string&
_M_replace_dispatch(const_iterator __i1, const_iterator __i2,
_InputIterator __k1, _InputIterator __k2,
__false_type);
basic_string&
_M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
_CharT __c);
basic_string&
_M_replace(size_type __pos, size_type __len1, const _CharT* __s,
const size_type __len2);
basic_string&
_M_append(const _CharT* __s, size_type __n);
public:
# 1956 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
size_type
copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
# 1966 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
void
swap(basic_string& __s) noexcept;
# 1976 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
const _CharT*
c_str() const noexcept
{ return _M_data(); }
const _CharT*
data() const noexcept
{ return _M_data(); }
allocator_type
get_allocator() const noexcept
{ return _M_get_allocator(); }
# 2009 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
size_type
find(const _CharT* __s, size_type __pos, size_type __n) const;
# 2022 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
size_type
find(const basic_string& __str, size_type __pos = 0) const
noexcept
{ return this->find(__str.data(), __pos, __str.size()); }
# 2037 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
size_type
find(const _CharT* __s, size_type __pos = 0) const
{
;
return this->find(__s, __pos, traits_type::length(__s));
}
# 2054 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
size_type
find(_CharT __c, size_type __pos = 0) const noexcept;
# 2067 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
size_type
rfind(const basic_string& __str, size_type __pos = npos) const
noexcept
{ return this->rfind(__str.data(), __pos, __str.size()); }
# 2084 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
size_type
rfind(const _CharT* __s, size_type __pos, size_type __n) const;
# 2097 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
size_type
rfind(const _CharT* __s, size_type __pos = npos) const
{
;
return this->rfind(__s, __pos, traits_type::length(__s));
}
# 2114 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
size_type
rfind(_CharT __c, size_type __pos = npos) const noexcept;
# 2128 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
size_type
find_first_of(const basic_string& __str, size_type __pos = 0) const
noexcept
{ return this->find_first_of(__str.data(), __pos, __str.size()); }
# 2145 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
size_type
find_first_of(const _CharT* __s, size_type __pos, size_type __n) const;
# 2158 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
size_type
find_first_of(const _CharT* __s, size_type __pos = 0) const
{
;
return this->find_first_of(__s, __pos, traits_type::length(__s));
}
# 2177 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
size_type
find_first_of(_CharT __c, size_type __pos = 0) const noexcept
{ return this->find(__c, __pos); }
# 2192 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
size_type
find_last_of(const basic_string& __str, size_type __pos = npos) const
noexcept
{ return this->find_last_of(__str.data(), __pos, __str.size()); }
# 2209 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
size_type
find_last_of(const _CharT* __s, size_type __pos, size_type __n) const;
# 2222 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
size_type
find_last_of(const _CharT* __s, size_type __pos = npos) const
{
;
return this->find_last_of(__s, __pos, traits_type::length(__s));
}
# 2241 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
size_type
find_last_of(_CharT __c, size_type __pos = npos) const noexcept
{ return this->rfind(__c, __pos); }
# 2255 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
size_type
find_first_not_of(const basic_string& __str, size_type __pos = 0) const
noexcept
{ return this->find_first_not_of(__str.data(), __pos, __str.size()); }
# 2272 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
size_type
find_first_not_of(const _CharT* __s, size_type __pos,
size_type __n) const;
# 2286 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
size_type
find_first_not_of(const _CharT* __s, size_type __pos = 0) const
{
;
return this->find_first_not_of(__s, __pos, traits_type::length(__s));
}
# 2303 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
size_type
find_first_not_of(_CharT __c, size_type __pos = 0) const
noexcept;
# 2318 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
size_type
find_last_not_of(const basic_string& __str, size_type __pos = npos) const
noexcept
{ return this->find_last_not_of(__str.data(), __pos, __str.size()); }
# 2335 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
size_type
find_last_not_of(const _CharT* __s, size_type __pos,
size_type __n) const;
# 2349 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
size_type
find_last_not_of(const _CharT* __s, size_type __pos = npos) const
{
;
return this->find_last_not_of(__s, __pos, traits_type::length(__s));
}
# 2366 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
size_type
find_last_not_of(_CharT __c, size_type __pos = npos) const
noexcept;
# 2382 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
basic_string
substr(size_type __pos = 0, size_type __n = npos) const
{ return basic_string(*this,
_M_check(__pos, "basic_string::substr"), __n); }
# 2401 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
int
compare(const basic_string& __str) const
{
const size_type __size = this->size();
const size_type __osize = __str.size();
const size_type __len = std::min(__size, __osize);
int __r = traits_type::compare(_M_data(), __str.data(), __len);
if (!__r)
__r = _S_compare(__size, __osize);
return __r;
}
# 2433 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
int
compare(size_type __pos, size_type __n, const basic_string& __str) const;
# 2459 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
int
compare(size_type __pos1, size_type __n1, const basic_string& __str,
size_type __pos2, size_type __n2) const;
# 2477 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
int
compare(const _CharT* __s) const;
# 2501 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
int
compare(size_type __pos, size_type __n1, const _CharT* __s) const;
# 2528 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
int
compare(size_type __pos, size_type __n1, const _CharT* __s,
size_type __n2) const;
};
}
# 4927 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>
operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{
basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
__str.append(__rhs);
return __str;
}
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT,_Traits,_Alloc>
operator+(const _CharT* __lhs,
const basic_string<_CharT,_Traits,_Alloc>& __rhs);
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT,_Traits,_Alloc>
operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs);
template<typename _CharT, typename _Traits, typename _Alloc>
inline basic_string<_CharT, _Traits, _Alloc>
operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
{
basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
__str.append(__rhs);
return __str;
}
template<typename _CharT, typename _Traits, typename _Alloc>
inline basic_string<_CharT, _Traits, _Alloc>
operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs)
{
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
typedef typename __string_type::size_type __size_type;
__string_type __str(__lhs);
__str.append(__size_type(1), __rhs);
return __str;
}
template<typename _CharT, typename _Traits, typename _Alloc>
inline basic_string<_CharT, _Traits, _Alloc>
operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ return std::move(__lhs.append(__rhs)); }
template<typename _CharT, typename _Traits, typename _Alloc>
inline basic_string<_CharT, _Traits, _Alloc>
operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
basic_string<_CharT, _Traits, _Alloc>&& __rhs)
{ return std::move(__rhs.insert(0, __lhs)); }
template<typename _CharT, typename _Traits, typename _Alloc>
inline basic_string<_CharT, _Traits, _Alloc>
operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
basic_string<_CharT, _Traits, _Alloc>&& __rhs)
{
const auto __size = __lhs.size() + __rhs.size();
const bool __cond = (__size > __lhs.capacity()
&& __size <= __rhs.capacity());
return __cond ? std::move(__rhs.insert(0, __lhs))
: std::move(__lhs.append(__rhs));
}
template<typename _CharT, typename _Traits, typename _Alloc>
inline basic_string<_CharT, _Traits, _Alloc>
operator+(const _CharT* __lhs,
basic_string<_CharT, _Traits, _Alloc>&& __rhs)
{ return std::move(__rhs.insert(0, __lhs)); }
template<typename _CharT, typename _Traits, typename _Alloc>
inline basic_string<_CharT, _Traits, _Alloc>
operator+(_CharT __lhs,
basic_string<_CharT, _Traits, _Alloc>&& __rhs)
{ return std::move(__rhs.insert(0, 1, __lhs)); }
template<typename _CharT, typename _Traits, typename _Alloc>
inline basic_string<_CharT, _Traits, _Alloc>
operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
const _CharT* __rhs)
{ return std::move(__lhs.append(__rhs)); }
template<typename _CharT, typename _Traits, typename _Alloc>
inline basic_string<_CharT, _Traits, _Alloc>
operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
_CharT __rhs)
{ return std::move(__lhs.append(1, __rhs)); }
# 5048 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
noexcept
{ return __lhs.compare(__rhs) == 0; }
template<typename _CharT>
inline
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, bool>::__type
operator==(const basic_string<_CharT>& __lhs,
const basic_string<_CharT>& __rhs) noexcept
{ return (__lhs.size() == __rhs.size()
&& !std::char_traits<_CharT>::compare(__lhs.data(), __rhs.data(),
__lhs.size())); }
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator==(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ return __rhs.compare(__lhs) == 0; }
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
{ return __lhs.compare(__rhs) == 0; }
# 5095 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
noexcept
{ return !(__lhs == __rhs); }
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator!=(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ return !(__lhs == __rhs); }
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
{ return !(__lhs == __rhs); }
# 5133 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
noexcept
{ return __lhs.compare(__rhs) < 0; }
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
{ return __lhs.compare(__rhs) < 0; }
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator<(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ return __rhs.compare(__lhs) > 0; }
# 5171 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
noexcept
{ return __lhs.compare(__rhs) > 0; }
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
{ return __lhs.compare(__rhs) > 0; }
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator>(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ return __rhs.compare(__lhs) < 0; }
# 5209 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
noexcept
{ return __lhs.compare(__rhs) <= 0; }
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
{ return __lhs.compare(__rhs) <= 0; }
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator<=(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ return __rhs.compare(__lhs) >= 0; }
# 5247 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
noexcept
{ return __lhs.compare(__rhs) >= 0; }
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
{ return __lhs.compare(__rhs) >= 0; }
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator>=(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ return __rhs.compare(__lhs) <= 0; }
# 5285 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
template<typename _CharT, typename _Traits, typename _Alloc>
inline void
swap(basic_string<_CharT, _Traits, _Alloc>& __lhs,
basic_string<_CharT, _Traits, _Alloc>& __rhs)
noexcept(noexcept(__lhs.swap(__rhs)))
{ __lhs.swap(__rhs); }
# 5305 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
template<typename _CharT, typename _Traits, typename _Alloc>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is,
basic_string<_CharT, _Traits, _Alloc>& __str);
template<>
basic_istream<char>&
operator>>(basic_istream<char>& __is, basic_string<char>& __str);
# 5323 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
template<typename _CharT, typename _Traits, typename _Alloc>
inline basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os,
const basic_string<_CharT, _Traits, _Alloc>& __str)
{
return __ostream_insert(__os, __str.data(), __str.size());
}
# 5346 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
template<typename _CharT, typename _Traits, typename _Alloc>
basic_istream<_CharT, _Traits>&
getline(basic_istream<_CharT, _Traits>& __is,
basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim);
# 5363 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
template<typename _CharT, typename _Traits, typename _Alloc>
inline basic_istream<_CharT, _Traits>&
getline(basic_istream<_CharT, _Traits>& __is,
basic_string<_CharT, _Traits, _Alloc>& __str)
{ return std::getline(__is, __str, __is.widen('\n')); }
template<typename _CharT, typename _Traits, typename _Alloc>
inline basic_istream<_CharT, _Traits>&
getline(basic_istream<_CharT, _Traits>&& __is,
basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
{ return std::getline(__is, __str, __delim); }
template<typename _CharT, typename _Traits, typename _Alloc>
inline basic_istream<_CharT, _Traits>&
getline(basic_istream<_CharT, _Traits>&& __is,
basic_string<_CharT, _Traits, _Alloc>& __str)
{ return std::getline(__is, __str); }
template<>
basic_istream<char>&
getline(basic_istream<char>& __in, basic_string<char>& __str,
char __delim);
template<>
basic_istream<wchar_t>&
getline(basic_istream<wchar_t>& __in, basic_string<wchar_t>& __str,
wchar_t __delim);
}
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/string_conversions.h" 1 3
# 32 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/string_conversions.h" 3
# 33 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/string_conversions.h" 3
# 41 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/string_conversions.h" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 1 3
# 39 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 3
# 40 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 3
# 75 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 3
# 1 "/usr/include/stdlib.h" 1 3 4
# 32 "/usr/include/stdlib.h" 3 4
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include/stddef.h" 1 3 4
# 33 "/usr/include/stdlib.h" 2 3 4
extern "C" {
# 1 "/usr/include/bits/waitflags.h" 1 3 4
# 42 "/usr/include/stdlib.h" 2 3 4
# 1 "/usr/include/bits/waitstatus.h" 1 3 4
# 66 "/usr/include/bits/waitstatus.h" 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
# 95 "/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/sys/types.h" 1 3 4
# 27 "/usr/include/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;
typedef __off_t off_t;
typedef __off64_t off64_t;
# 104 "/usr/include/sys/types.h" 3 4
typedef __id_t id_t;
typedef __ssize_t ssize_t;
typedef __daddr_t daddr_t;
typedef __caddr_t caddr_t;
typedef __key_t key_t;
# 136 "/usr/include/sys/types.h" 3 4
typedef __useconds_t useconds_t;
typedef __suseconds_t suseconds_t;
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include/stddef.h" 1 3 4
# 147 "/usr/include/sys/types.h" 2 3 4
typedef unsigned long int ulong;
typedef unsigned short int ushort;
typedef unsigned int uint;
# 200 "/usr/include/sys/types.h" 3 4
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/sys/types.h" 3 4
# 1 "/usr/include/sys/select.h" 1 3 4
# 30 "/usr/include/sys/select.h" 3 4
# 1 "/usr/include/bits/select.h" 1 3 4
# 22 "/usr/include/bits/select.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 23 "/usr/include/bits/select.h" 2 3 4
# 31 "/usr/include/sys/select.h" 2 3 4
# 1 "/usr/include/bits/sigset.h" 1 3 4
# 23 "/usr/include/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/sys/select.h" 2 3 4
typedef __sigset_t sigset_t;
# 1 "/usr/include/bits/time.h" 1 3 4
# 46 "/usr/include/sys/select.h" 2 3 4
# 54 "/usr/include/sys/select.h" 3 4
typedef long int __fd_mask;
# 64 "/usr/include/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/sys/select.h" 3 4
extern "C" {
# 106 "/usr/include/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/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/sys/select.h" 3 4
}
# 220 "/usr/include/sys/types.h" 2 3 4
# 1 "/usr/include/sys/sysmacros.h" 1 3 4
# 29 "/usr/include/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__));
# 63 "/usr/include/sys/sysmacros.h" 3 4
}
# 223 "/usr/include/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/sys/types.h" 3 4
typedef __blkcnt64_t blkcnt64_t;
typedef __fsblkcnt64_t fsblkcnt64_t;
typedef __fsfilcnt64_t fsfilcnt64_t;
# 273 "/usr/include/sys/types.h" 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;
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)));
extern void *malloc (size_t __size) throw () __attribute__ ((__malloc__)) ;
extern void *calloc (size_t __nmemb, size_t __size)
throw () __attribute__ ((__malloc__)) ;
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 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include/stddef.h" 1 3 4
# 25 "/usr/include/alloca.h" 2 3 4
extern "C" {
extern void *alloca (size_t __size) throw ();
}
# 492 "/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__, __alloc_size__ (2)));
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)));
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 ();
# 605 "/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))) ;
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__)) ;
# 807 "/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 ();
extern int rpmatch (const char *__response) throw () __attribute__ ((__nonnull__ (1))) ;
# 895 "/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/bits/stdlib-float.h" 1 3 4
# 952 "/usr/include/stdlib.h" 2 3 4
# 964 "/usr/include/stdlib.h" 3 4
}
# 76 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 2 3
# 118 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 3
extern "C++"
{
namespace std __attribute__ ((__visibility__ ("default")))
{
using ::div_t;
using ::ldiv_t;
using ::abort;
using ::abs;
using ::atexit;
using ::at_quick_exit;
using ::atof;
using ::atoi;
using ::atol;
using ::bsearch;
using ::calloc;
using ::div;
using ::exit;
using ::free;
using ::getenv;
using ::labs;
using ::ldiv;
using ::malloc;
using ::mblen;
using ::mbstowcs;
using ::mbtowc;
using ::qsort;
using ::quick_exit;
using ::rand;
using ::realloc;
using ::srand;
using ::strtod;
using ::strtol;
using ::strtoul;
using ::system;
using ::wcstombs;
using ::wctomb;
inline long
abs(long __i) { return __builtin_labs(__i); }
inline ldiv_t
div(long __i, long __j) { return ldiv(__i, __j); }
inline long long
abs(long long __x) { return __builtin_llabs (__x); }
inline __int128
abs(__int128 __x) { return __x >= 0 ? __x : -__x; }
# 201 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 3
}
# 215 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 3
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
using ::lldiv_t;
using ::_Exit;
using ::llabs;
inline lldiv_t
div(long long __n, long long __d)
{ lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; }
using ::lldiv;
# 247 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 3
using ::atoll;
using ::strtoll;
using ::strtoull;
using ::strtof;
using ::strtold;
}
namespace std
{
using ::__gnu_cxx::lldiv_t;
using ::__gnu_cxx::_Exit;
using ::__gnu_cxx::llabs;
using ::__gnu_cxx::div;
using ::__gnu_cxx::lldiv;
using ::__gnu_cxx::atoll;
using ::__gnu_cxx::strtof;
using ::__gnu_cxx::strtoll;
using ::__gnu_cxx::strtoull;
using ::__gnu_cxx::strtold;
}
}
# 42 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/string_conversions.h" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cwchar" 1 3
# 39 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cwchar" 3
# 40 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cwchar" 3
# 1 "/usr/include/wchar.h" 1 3 4
# 45 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cwchar" 2 3
# 43 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/string_conversions.h" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdio" 1 3
# 39 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdio" 3
# 40 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdio" 3
# 1 "/usr/include/stdio.h" 1 3 4
# 29 "/usr/include/stdio.h" 3 4
extern "C" {
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include/stddef.h" 1 3 4
# 34 "/usr/include/stdio.h" 2 3 4
# 74 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/libio.h" 1 3 4
# 32 "/usr/include/libio.h" 3 4
# 1 "/usr/include/_G_config.h" 1 3 4
# 15 "/usr/include/_G_config.h" 3 4
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/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;
# 33 "/usr/include/libio.h" 2 3 4
# 50 "/usr/include/libio.h" 3 4
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include/stdarg.h" 1 3 4
# 51 "/usr/include/libio.h" 2 3 4
# 145 "/usr/include/libio.h" 3 4
struct _IO_jump_t; struct _IO_FILE;
# 155 "/usr/include/libio.h" 3 4
typedef void _IO_lock_t;
struct _IO_marker {
struct _IO_marker *_next;
struct _IO_FILE *_sbuf;
int _pos;
# 178 "/usr/include/libio.h" 3 4
};
enum __codecvt_result
{
__codecvt_ok,
__codecvt_partial,
__codecvt_error,
__codecvt_noconv
};
# 246 "/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;
# 294 "/usr/include/libio.h" 3 4
__off64_t _offset;
# 303 "/usr/include/libio.h" 3 4
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_;
# 339 "/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);
# 435 "/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 ();
# 465 "/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 ();
# 527 "/usr/include/libio.h" 3 4
}
# 75 "/usr/include/stdio.h" 2 3 4
typedef __gnuc_va_list va_list;
# 108 "/usr/include/stdio.h" 3 4
typedef _G_fpos_t fpos_t;
typedef _G_fpos64_t fpos64_t;
# 164 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/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 ();
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__)) ;
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);
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) ;
# 295 "/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 ();
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)));
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 ();
# 463 "/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)));
# 522 "/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);
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);
extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
;
# 640 "/usr/include/stdio.h" 3 4
# 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) ;
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);
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) ;
# 792 "/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);
# 815 "/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 () ;
extern void perror (const char *__s);
# 1 "/usr/include/bits/sys_errlist.h" 1 3 4
# 26 "/usr/include/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 () ;
# 873 "/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 ();
# 943 "/usr/include/stdio.h" 3 4
}
# 43 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdio" 2 3
# 96 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/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 ::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;
}
# 157 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdio" 3
namespace __gnu_cxx
{
# 175 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/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;
}
# 44 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/string_conversions.h" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cerrno" 1 3
# 39 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cerrno" 3
# 40 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cerrno" 3
# 1 "/usr/include/errno.h" 1 3 4
# 31 "/usr/include/errno.h" 3 4
extern "C" {
# 1 "/usr/include/bits/errno.h" 1 3 4
# 24 "/usr/include/bits/errno.h" 3 4
# 1 "/usr/include/linux/errno.h" 1 3 4
# 1 "/usr/include/asm/errno.h" 1 3 4
# 1 "/usr/include/asm-generic/errno.h" 1 3 4
# 1 "/usr/include/asm-generic/errno-base.h" 1 3 4
# 5 "/usr/include/asm-generic/errno.h" 2 3 4
# 1 "/usr/include/asm/errno.h" 2 3 4
# 1 "/usr/include/linux/errno.h" 2 3 4
# 25 "/usr/include/bits/errno.h" 2 3 4
# 50 "/usr/include/bits/errno.h" 3 4
extern int *__errno_location (void) throw () __attribute__ ((__const__));
# 36 "/usr/include/errno.h" 2 3 4
# 54 "/usr/include/errno.h" 3 4
extern char *program_invocation_name, *program_invocation_short_name;
}
# 68 "/usr/include/errno.h" 3 4
typedef int error_t;
# 43 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cerrno" 2 3
# 45 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/string_conversions.h" 2 3
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
template<typename _TRet, typename _Ret = _TRet, typename _CharT,
typename... _Base>
_Ret
__stoa(_TRet (*__convf) (const _CharT*, _CharT**, _Base...),
const char* __name, const _CharT* __str, std::size_t* __idx,
_Base... __base)
{
_Ret __ret;
_CharT* __endptr;
struct _Save_errno {
_Save_errno() : _M_errno((*__errno_location ())) { (*__errno_location ()) = 0; }
~_Save_errno() { if ((*__errno_location ()) == 0) (*__errno_location ()) = _M_errno; }
int _M_errno;
} const __save_errno;
const _TRet __tmp = __convf(__str, &__endptr, __base...);
if (__endptr == __str)
std::__throw_invalid_argument(__name);
else if ((*__errno_location ()) == 34
|| (std::__are_same<_Ret, int>::__value
&& (__tmp < __numeric_traits<int>::__min
|| __tmp > __numeric_traits<int>::__max)))
std::__throw_out_of_range(__name);
else
__ret = __tmp;
if (__idx)
*__idx = __endptr - __str;
return __ret;
}
template<typename _String, typename _CharT = typename _String::value_type>
_String
__to_xstring(int (*__convf) (_CharT*, std::size_t, const _CharT*,
__builtin_va_list), std::size_t __n,
const _CharT* __fmt, ...)
{
_CharT* __s = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
* __n));
__builtin_va_list __args;
__builtin_va_start(__args, __fmt);
const int __len = __convf(__s, __n, __fmt, __args);
__builtin_va_end(__args);
return _String(__s, __s + __len);
}
}
# 5403 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
namespace __cxx11 {
inline int
stoi(const string& __str, size_t* __idx = 0, int __base = 10)
{ return __gnu_cxx::__stoa<long, int>(&std::strtol, "stoi", __str.c_str(),
__idx, __base); }
inline long
stol(const string& __str, size_t* __idx = 0, int __base = 10)
{ return __gnu_cxx::__stoa(&std::strtol, "stol", __str.c_str(),
__idx, __base); }
inline unsigned long
stoul(const string& __str, size_t* __idx = 0, int __base = 10)
{ return __gnu_cxx::__stoa(&std::strtoul, "stoul", __str.c_str(),
__idx, __base); }
inline long long
stoll(const string& __str, size_t* __idx = 0, int __base = 10)
{ return __gnu_cxx::__stoa(&std::strtoll, "stoll", __str.c_str(),
__idx, __base); }
inline unsigned long long
stoull(const string& __str, size_t* __idx = 0, int __base = 10)
{ return __gnu_cxx::__stoa(&std::strtoull, "stoull", __str.c_str(),
__idx, __base); }
inline float
stof(const string& __str, size_t* __idx = 0)
{ return __gnu_cxx::__stoa(&std::strtof, "stof", __str.c_str(), __idx); }
inline double
stod(const string& __str, size_t* __idx = 0)
{ return __gnu_cxx::__stoa(&std::strtod, "stod", __str.c_str(), __idx); }
inline long double
stold(const string& __str, size_t* __idx = 0)
{ return __gnu_cxx::__stoa(&std::strtold, "stold", __str.c_str(), __idx); }
inline string
to_string(int __val)
{ return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, 4 * sizeof(int),
"%d", __val); }
inline string
to_string(unsigned __val)
{ return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
4 * sizeof(unsigned),
"%u", __val); }
inline string
to_string(long __val)
{ return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, 4 * sizeof(long),
"%ld", __val); }
inline string
to_string(unsigned long __val)
{ return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
4 * sizeof(unsigned long),
"%lu", __val); }
inline string
to_string(long long __val)
{ return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
4 * sizeof(long long),
"%lld", __val); }
inline string
to_string(unsigned long long __val)
{ return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
4 * sizeof(unsigned long long),
"%llu", __val); }
inline string
to_string(float __val)
{
const int __n =
__gnu_cxx::__numeric_traits<float>::__max_exponent10 + 20;
return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
"%f", __val);
}
inline string
to_string(double __val)
{
const int __n =
__gnu_cxx::__numeric_traits<double>::__max_exponent10 + 20;
return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
"%f", __val);
}
inline string
to_string(long double __val)
{
const int __n =
__gnu_cxx::__numeric_traits<long double>::__max_exponent10 + 20;
return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
"%Lf", __val);
}
inline int
stoi(const wstring& __str, size_t* __idx = 0, int __base = 10)
{ return __gnu_cxx::__stoa<long, int>(&std::wcstol, "stoi", __str.c_str(),
__idx, __base); }
inline long
stol(const wstring& __str, size_t* __idx = 0, int __base = 10)
{ return __gnu_cxx::__stoa(&std::wcstol, "stol", __str.c_str(),
__idx, __base); }
inline unsigned long
stoul(const wstring& __str, size_t* __idx = 0, int __base = 10)
{ return __gnu_cxx::__stoa(&std::wcstoul, "stoul", __str.c_str(),
__idx, __base); }
inline long long
stoll(const wstring& __str, size_t* __idx = 0, int __base = 10)
{ return __gnu_cxx::__stoa(&std::wcstoll, "stoll", __str.c_str(),
__idx, __base); }
inline unsigned long long
stoull(const wstring& __str, size_t* __idx = 0, int __base = 10)
{ return __gnu_cxx::__stoa(&std::wcstoull, "stoull", __str.c_str(),
__idx, __base); }
inline float
stof(const wstring& __str, size_t* __idx = 0)
{ return __gnu_cxx::__stoa(&std::wcstof, "stof", __str.c_str(), __idx); }
inline double
stod(const wstring& __str, size_t* __idx = 0)
{ return __gnu_cxx::__stoa(&std::wcstod, "stod", __str.c_str(), __idx); }
inline long double
stold(const wstring& __str, size_t* __idx = 0)
{ return __gnu_cxx::__stoa(&std::wcstold, "stold", __str.c_str(), __idx); }
inline wstring
to_wstring(int __val)
{ return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, 4 * sizeof(int),
L"%d", __val); }
inline wstring
to_wstring(unsigned __val)
{ return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
4 * sizeof(unsigned),
L"%u", __val); }
inline wstring
to_wstring(long __val)
{ return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, 4 * sizeof(long),
L"%ld", __val); }
inline wstring
to_wstring(unsigned long __val)
{ return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
4 * sizeof(unsigned long),
L"%lu", __val); }
inline wstring
to_wstring(long long __val)
{ return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
4 * sizeof(long long),
L"%lld", __val); }
inline wstring
to_wstring(unsigned long long __val)
{ return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
4 * sizeof(unsigned long long),
L"%llu", __val); }
inline wstring
to_wstring(float __val)
{
const int __n =
__gnu_cxx::__numeric_traits<float>::__max_exponent10 + 20;
return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
L"%f", __val);
}
inline wstring
to_wstring(double __val)
{
const int __n =
__gnu_cxx::__numeric_traits<double>::__max_exponent10 + 20;
return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
L"%f", __val);
}
inline wstring
to_wstring(long double __val)
{
const int __n =
__gnu_cxx::__numeric_traits<long double>::__max_exponent10 + 20;
return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
L"%Lf", __val);
}
}
}
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/functional_hash.h" 1 3
# 33 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/functional_hash.h" 3
# 34 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/functional_hash.h" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/hash_bytes.h" 1 3
# 33 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/hash_bytes.h" 3
# 34 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/hash_bytes.h" 3
namespace std
{
size_t
_Hash_bytes(const void* __ptr, size_t __len, size_t __seed);
size_t
_Fnv_hash_bytes(const void* __ptr, size_t __len, size_t __seed);
}
# 36 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/functional_hash.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 49 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/functional_hash.h" 3
template<typename _Result, typename _Arg>
struct __hash_base
{
typedef _Result result_type;
typedef _Arg argument_type;
};
template<typename _Tp>
struct hash;
template<typename _Tp, bool = is_enum<_Tp>::value>
struct __hash_enum
{
private:
__hash_enum(__hash_enum&&);
~__hash_enum();
};
template<typename _Tp>
struct __hash_enum<_Tp, true> : public __hash_base<size_t, _Tp>
{
size_t
operator()(_Tp __val) const noexcept
{
using __type = typename underlying_type<_Tp>::type;
return hash<__type>{}(static_cast<__type>(__val));
}
};
template<typename _Tp>
struct hash : __hash_enum<_Tp>
{ };
template<typename _Tp>
struct hash<_Tp*> : public __hash_base<size_t, _Tp*>
{
size_t
operator()(_Tp* __p) const noexcept
{ return reinterpret_cast<size_t>(__p); }
};
# 108 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/functional_hash.h" 3
template<> struct hash<bool> : public __hash_base<size_t, bool> { size_t operator()(bool __val) const noexcept { return static_cast<size_t>(__val); } };
template<> struct hash<char> : public __hash_base<size_t, char> { size_t operator()(char __val) const noexcept { return static_cast<size_t>(__val); } };
template<> struct hash<signed char> : public __hash_base<size_t, signed char> { size_t operator()(signed char __val) const noexcept { return static_cast<size_t>(__val); } };
template<> struct hash<unsigned char> : public __hash_base<size_t, unsigned char> { size_t operator()(unsigned char __val) const noexcept { return static_cast<size_t>(__val); } };
template<> struct hash<wchar_t> : public __hash_base<size_t, wchar_t> { size_t operator()(wchar_t __val) const noexcept { return static_cast<size_t>(__val); } };
template<> struct hash<char16_t> : public __hash_base<size_t, char16_t> { size_t operator()(char16_t __val) const noexcept { return static_cast<size_t>(__val); } };
template<> struct hash<char32_t> : public __hash_base<size_t, char32_t> { size_t operator()(char32_t __val) const noexcept { return static_cast<size_t>(__val); } };
template<> struct hash<short> : public __hash_base<size_t, short> { size_t operator()(short __val) const noexcept { return static_cast<size_t>(__val); } };
template<> struct hash<int> : public __hash_base<size_t, int> { size_t operator()(int __val) const noexcept { return static_cast<size_t>(__val); } };
template<> struct hash<long> : public __hash_base<size_t, long> { size_t operator()(long __val) const noexcept { return static_cast<size_t>(__val); } };
template<> struct hash<long long> : public __hash_base<size_t, long long> { size_t operator()(long long __val) const noexcept { return static_cast<size_t>(__val); } };
template<> struct hash<unsigned short> : public __hash_base<size_t, unsigned short> { size_t operator()(unsigned short __val) const noexcept { return static_cast<size_t>(__val); } };
template<> struct hash<unsigned int> : public __hash_base<size_t, unsigned int> { size_t operator()(unsigned int __val) const noexcept { return static_cast<size_t>(__val); } };
template<> struct hash<unsigned long> : public __hash_base<size_t, unsigned long> { size_t operator()(unsigned long __val) const noexcept { return static_cast<size_t>(__val); } };
template<> struct hash<unsigned long long> : public __hash_base<size_t, unsigned long long> { size_t operator()(unsigned long long __val) const noexcept { return static_cast<size_t>(__val); } };
template<> struct hash<__int128> : public __hash_base<size_t, __int128> { size_t operator()(__int128 __val) const noexcept { return static_cast<size_t>(__val); } };
template<> struct hash<__int128 unsigned> : public __hash_base<size_t, __int128 unsigned> { size_t operator()(__int128 unsigned __val) const noexcept { return static_cast<size_t>(__val); } };
# 171 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/functional_hash.h" 3
struct _Hash_impl
{
static size_t
hash(const void* __ptr, size_t __clength,
size_t __seed = static_cast<size_t>(0xc70f6907UL))
{ return _Hash_bytes(__ptr, __clength, __seed); }
template<typename _Tp>
static size_t
hash(const _Tp& __val)
{ return hash(&__val, sizeof(__val)); }
template<typename _Tp>
static size_t
__hash_combine(const _Tp& __val, size_t __hash)
{ return hash(&__val, sizeof(__val), __hash); }
};
struct _Fnv_hash_impl
{
static size_t
hash(const void* __ptr, size_t __clength,
size_t __seed = static_cast<size_t>(2166136261UL))
{ return _Fnv_hash_bytes(__ptr, __clength, __seed); }
template<typename _Tp>
static size_t
hash(const _Tp& __val)
{ return hash(&__val, sizeof(__val)); }
template<typename _Tp>
static size_t
__hash_combine(const _Tp& __val, size_t __hash)
{ return hash(&__val, sizeof(__val), __hash); }
};
template<>
struct hash<float> : public __hash_base<size_t, float>
{
size_t
operator()(float __val) const noexcept
{
return __val != 0.0f ? std::_Hash_impl::hash(__val) : 0;
}
};
template<>
struct hash<double> : public __hash_base<size_t, double>
{
size_t
operator()(double __val) const noexcept
{
return __val != 0.0 ? std::_Hash_impl::hash(__val) : 0;
}
};
template<>
struct hash<long double>
: public __hash_base<size_t, long double>
{
__attribute__ ((__pure__)) size_t
operator()(long double __val) const noexcept;
};
template<typename _Hash>
struct __is_fast_hash : public std::true_type
{ };
template<>
struct __is_fast_hash<hash<long double>> : public std::false_type
{ };
}
# 5629 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<>
struct hash<string>
: public __hash_base<size_t, string>
{
size_t
operator()(const string& __s) const noexcept
{ return std::_Hash_impl::hash(__s.data(), __s.length()); }
};
template<>
struct __is_fast_hash<hash<string>> : std::false_type
{ };
template<>
struct hash<wstring>
: public __hash_base<size_t, wstring>
{
size_t
operator()(const wstring& __s) const noexcept
{ return std::_Hash_impl::hash(__s.data(),
__s.length() * sizeof(wchar_t)); }
};
template<>
struct __is_fast_hash<hash<wstring>> : std::false_type
{ };
template<>
struct hash<u16string>
: public __hash_base<size_t, u16string>
{
size_t
operator()(const u16string& __s) const noexcept
{ return std::_Hash_impl::hash(__s.data(),
__s.length() * sizeof(char16_t)); }
};
template<>
struct __is_fast_hash<hash<u16string>> : std::false_type
{ };
template<>
struct hash<u32string>
: public __hash_base<size_t, u32string>
{
size_t
operator()(const u32string& __s) const noexcept
{ return std::_Hash_impl::hash(__s.data(),
__s.length() * sizeof(char32_t)); }
};
template<>
struct __is_fast_hash<hash<u32string>> : std::false_type
{ };
inline namespace literals
{
inline namespace string_literals
{
__attribute ((__abi_tag__ ("cxx11")))
inline basic_string<char>
operator""s(const char* __str, size_t __len)
{ return basic_string<char>{__str, __len}; }
__attribute ((__abi_tag__ ("cxx11")))
inline basic_string<wchar_t>
operator""s(const wchar_t* __str, size_t __len)
{ return basic_string<wchar_t>{__str, __len}; }
__attribute ((__abi_tag__ ("cxx11")))
inline basic_string<char16_t>
operator""s(const char16_t* __str, size_t __len)
{ return basic_string<char16_t>{__str, __len}; }
__attribute ((__abi_tag__ ("cxx11")))
inline basic_string<char32_t>
operator""s(const char32_t* __str, size_t __len)
{ return basic_string<char32_t>{__str, __len}; }
}
}
}
# 53 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/string" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.tcc" 1 3
# 42 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.tcc" 3
# 43 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits, typename _Alloc>
const typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::npos;
template<typename _CharT, typename _Traits, typename _Alloc>
void
basic_string<_CharT, _Traits, _Alloc>::
swap(basic_string& __s) noexcept
{
if (this == &__s)
return;
_Alloc_traits::_S_on_swap(_M_get_allocator(), __s._M_get_allocator());
if (_M_is_local())
if (__s._M_is_local())
{
if (length() && __s.length())
{
_CharT __tmp_data[_S_local_capacity + 1];
traits_type::copy(__tmp_data, __s._M_local_buf,
_S_local_capacity + 1);
traits_type::copy(__s._M_local_buf, _M_local_buf,
_S_local_capacity + 1);
traits_type::copy(_M_local_buf, __tmp_data,
_S_local_capacity + 1);
}
else if (__s.length())
{
traits_type::copy(_M_local_buf, __s._M_local_buf,
_S_local_capacity + 1);
_M_length(__s.length());
__s._M_set_length(0);
return;
}
else if (length())
{
traits_type::copy(__s._M_local_buf, _M_local_buf,
_S_local_capacity + 1);
__s._M_length(length());
_M_set_length(0);
return;
}
}
else
{
const size_type __tmp_capacity = __s._M_allocated_capacity;
traits_type::copy(__s._M_local_buf, _M_local_buf,
_S_local_capacity + 1);
_M_data(__s._M_data());
__s._M_data(__s._M_local_buf);
_M_capacity(__tmp_capacity);
}
else
{
const size_type __tmp_capacity = _M_allocated_capacity;
if (__s._M_is_local())
{
traits_type::copy(_M_local_buf, __s._M_local_buf,
_S_local_capacity + 1);
__s._M_data(_M_data());
_M_data(_M_local_buf);
}
else
{
pointer __tmp_ptr = _M_data();
_M_data(__s._M_data());
__s._M_data(__tmp_ptr);
_M_capacity(__s._M_allocated_capacity);
}
__s._M_capacity(__tmp_capacity);
}
const size_type __tmp_length = length();
_M_length(__s.length());
__s._M_length(__tmp_length);
}
template<typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::pointer
basic_string<_CharT, _Traits, _Alloc>::
_M_create(size_type& __capacity, size_type __old_capacity)
{
if (__capacity > max_size())
std::__throw_length_error(("basic_string::_M_create"));
if (__capacity > __old_capacity && __capacity < 2 * __old_capacity)
{
__capacity = 2 * __old_capacity;
if (__capacity > max_size())
__capacity = max_size();
}
return _Alloc_traits::allocate(_M_get_allocator(), __capacity + 1);
}
template<typename _CharT, typename _Traits, typename _Alloc>
template<typename _InIterator>
void
basic_string<_CharT, _Traits, _Alloc>::
_M_construct(_InIterator __beg, _InIterator __end,
std::input_iterator_tag)
{
size_type __len = 0;
size_type __capacity = size_type(_S_local_capacity);
while (__beg != __end && __len < __capacity)
{
_M_data()[__len++] = *__beg;
++__beg;
}
try
{
while (__beg != __end)
{
if (__len == __capacity)
{
__capacity = __len + 1;
pointer __another = _M_create(__capacity, __len);
this->_S_copy(__another, _M_data(), __len);
_M_dispose();
_M_data(__another);
_M_capacity(__capacity);
}
_M_data()[__len++] = *__beg;
++__beg;
}
}
catch(...)
{
_M_dispose();
throw;
}
_M_set_length(__len);
}
template<typename _CharT, typename _Traits, typename _Alloc>
template<typename _InIterator>
void
basic_string<_CharT, _Traits, _Alloc>::
_M_construct(_InIterator __beg, _InIterator __end,
std::forward_iterator_tag)
{
if (__gnu_cxx::__is_null_pointer(__beg) && __beg != __end)
std::__throw_logic_error(("basic_string::" "_M_construct null not valid")
);
size_type __dnew = static_cast<size_type>(std::distance(__beg, __end));
if (__dnew > size_type(_S_local_capacity))
{
_M_data(_M_create(__dnew, size_type(0)));
_M_capacity(__dnew);
}
try
{ this->_S_copy_chars(_M_data(), __beg, __end); }
catch(...)
{
_M_dispose();
throw;
}
_M_set_length(__dnew);
}
template<typename _CharT, typename _Traits, typename _Alloc>
void
basic_string<_CharT, _Traits, _Alloc>::
_M_construct(size_type __n, _CharT __c)
{
if (__n > size_type(_S_local_capacity))
{
_M_data(_M_create(__n, size_type(0)));
_M_capacity(__n);
}
if (__n)
this->_S_assign(_M_data(), __n, __c);
_M_set_length(__n);
}
template<typename _CharT, typename _Traits, typename _Alloc>
void
basic_string<_CharT, _Traits, _Alloc>::
_M_assign(const basic_string& __str)
{
if (this != &__str)
{
const size_type __rsize = __str.length();
const size_type __capacity = capacity();
if (__rsize > __capacity)
{
size_type __new_capacity = __rsize;
pointer __tmp = _M_create(__new_capacity, __capacity);
_M_dispose();
_M_data(__tmp);
_M_capacity(__new_capacity);
}
if (__rsize)
this->_S_copy(_M_data(), __str._M_data(), __rsize);
_M_set_length(__rsize);
}
}
template<typename _CharT, typename _Traits, typename _Alloc>
void
basic_string<_CharT, _Traits, _Alloc>::
reserve(size_type __res)
{
if (__res < length())
__res = length();
const size_type __capacity = capacity();
if (__res != __capacity)
{
if (__res > __capacity
|| __res > size_type(_S_local_capacity))
{
pointer __tmp = _M_create(__res, __capacity);
this->_S_copy(__tmp, _M_data(), length() + 1);
_M_dispose();
_M_data(__tmp);
_M_capacity(__res);
}
else if (!_M_is_local())
{
this->_S_copy(_M_local_data(), _M_data(), length() + 1);
_M_destroy(__capacity);
_M_data(_M_local_data());
}
}
}
template<typename _CharT, typename _Traits, typename _Alloc>
void
basic_string<_CharT, _Traits, _Alloc>::
_M_mutate(size_type __pos, size_type __len1, const _CharT* __s,
size_type __len2)
{
const size_type __how_much = length() - __pos - __len1;
size_type __new_capacity = length() + __len2 - __len1;
pointer __r = _M_create(__new_capacity, capacity());
if (__pos)
this->_S_copy(__r, _M_data(), __pos);
if (__s && __len2)
this->_S_copy(__r + __pos, __s, __len2);
if (__how_much)
this->_S_copy(__r + __pos + __len2,
_M_data() + __pos + __len1, __how_much);
_M_dispose();
_M_data(__r);
_M_capacity(__new_capacity);
}
template<typename _CharT, typename _Traits, typename _Alloc>
void
basic_string<_CharT, _Traits, _Alloc>::
_M_erase(size_type __pos, size_type __n)
{
const size_type __how_much = length() - __pos - __n;
if (__how_much && __n)
this->_S_move(_M_data() + __pos, _M_data() + __pos + __n, __how_much);
_M_set_length(length() - __n);
}
template<typename _CharT, typename _Traits, typename _Alloc>
void
basic_string<_CharT, _Traits, _Alloc>::
resize(size_type __n, _CharT __c)
{
const size_type __size = this->size();
if (__size < __n)
this->append(__n - __size, __c);
else if (__n < __size)
this->_M_erase(__n, __size - __n);
}
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>&
basic_string<_CharT, _Traits, _Alloc>::
_M_append(const _CharT* __s, size_type __n)
{
const size_type __len = __n + this->size();
if (__len <= this->capacity())
{
if (__n)
this->_S_copy(this->_M_data() + this->size(), __s, __n);
}
else
this->_M_mutate(this->size(), size_type(0), __s, __n);
this->_M_set_length(__len);
return *this;
}
template<typename _CharT, typename _Traits, typename _Alloc>
template<typename _InputIterator>
basic_string<_CharT, _Traits, _Alloc>&
basic_string<_CharT, _Traits, _Alloc>::
_M_replace_dispatch(const_iterator __i1, const_iterator __i2,
_InputIterator __k1, _InputIterator __k2,
std::__false_type)
{
const basic_string __s(__k1, __k2);
const size_type __n1 = __i2 - __i1;
return _M_replace(__i1 - begin(), __n1, __s._M_data(),
__s.size());
}
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>&
basic_string<_CharT, _Traits, _Alloc>::
_M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
_CharT __c)
{
_M_check_length(__n1, __n2, "basic_string::_M_replace_aux");
const size_type __old_size = this->size();
const size_type __new_size = __old_size + __n2 - __n1;
if (__new_size <= this->capacity())
{
pointer __p = this->_M_data() + __pos1;
const size_type __how_much = __old_size - __pos1 - __n1;
if (__how_much && __n1 != __n2)
this->_S_move(__p + __n2, __p + __n1, __how_much);
}
else
this->_M_mutate(__pos1, __n1, 0, __n2);
if (__n2)
this->_S_assign(this->_M_data() + __pos1, __n2, __c);
this->_M_set_length(__new_size);
return *this;
}
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>&
basic_string<_CharT, _Traits, _Alloc>::
_M_replace(size_type __pos, size_type __len1, const _CharT* __s,
const size_type __len2)
{
_M_check_length(__len1, __len2, "basic_string::_M_replace");
const size_type __old_size = this->size();
const size_type __new_size = __old_size + __len2 - __len1;
if (__new_size <= this->capacity())
{
pointer __p = this->_M_data() + __pos;
const size_type __how_much = __old_size - __pos - __len1;
if (_M_disjunct(__s))
{
if (__how_much && __len1 != __len2)
this->_S_move(__p + __len2, __p + __len1, __how_much);
if (__len2)
this->_S_copy(__p, __s, __len2);
}
else
{
if (__len2 && __len2 <= __len1)
this->_S_move(__p, __s, __len2);
if (__how_much && __len1 != __len2)
this->_S_move(__p + __len2, __p + __len1, __how_much);
if (__len2 > __len1)
{
if (__s + __len2 <= __p + __len1)
this->_S_move(__p, __s, __len2);
else if (__s >= __p + __len1)
this->_S_copy(__p, __s + __len2 - __len1, __len2);
else
{
const size_type __nleft = (__p + __len1) - __s;
this->_S_move(__p, __s, __nleft);
this->_S_copy(__p + __nleft, __p + __len2,
__len2 - __nleft);
}
}
}
}
else
this->_M_mutate(__pos, __len1, __s, __len2);
this->_M_set_length(__new_size);
return *this;
}
template<typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
copy(_CharT* __s, size_type __n, size_type __pos) const
{
_M_check(__pos, "basic_string::copy");
__n = _M_limit(__pos, __n);
;
if (__n)
_S_copy(__s, _M_data() + __pos, __n);
return __n;
}
# 1145 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.tcc" 3
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>
operator+(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{
;
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
typedef typename __string_type::size_type __size_type;
const __size_type __len = _Traits::length(__lhs);
__string_type __str;
__str.reserve(__len + __rhs.size());
__str.append(__lhs, __len);
__str.append(__rhs);
return __str;
}
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>
operator+(_CharT __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
typedef typename __string_type::size_type __size_type;
__string_type __str;
const __size_type __len = __rhs.size();
__str.reserve(__len + 1);
__str.append(__size_type(1), __lhs);
__str.append(__rhs);
return __str;
}
template<typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
find(const _CharT* __s, size_type __pos, size_type __n) const
{
;
const size_type __size = this->size();
const _CharT* __data = _M_data();
if (__n == 0)
return __pos <= __size ? __pos : npos;
if (__n <= __size)
{
for (; __pos <= __size - __n; ++__pos)
if (traits_type::eq(__data[__pos], __s[0])
&& traits_type::compare(__data + __pos + 1,
__s + 1, __n - 1) == 0)
return __pos;
}
return npos;
}
template<typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
find(_CharT __c, size_type __pos) const noexcept
{
size_type __ret = npos;
const size_type __size = this->size();
if (__pos < __size)
{
const _CharT* __data = _M_data();
const size_type __n = __size - __pos;
const _CharT* __p = traits_type::find(__data + __pos, __n, __c);
if (__p)
__ret = __p - __data;
}
return __ret;
}
template<typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
rfind(const _CharT* __s, size_type __pos, size_type __n) const
{
;
const size_type __size = this->size();
if (__n <= __size)
{
__pos = std::min(size_type(__size - __n), __pos);
const _CharT* __data = _M_data();
do
{
if (traits_type::compare(__data + __pos, __s, __n) == 0)
return __pos;
}
while (__pos-- > 0);
}
return npos;
}
template<typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
rfind(_CharT __c, size_type __pos) const noexcept
{
size_type __size = this->size();
if (__size)
{
if (--__size > __pos)
__size = __pos;
for (++__size; __size-- > 0; )
if (traits_type::eq(_M_data()[__size], __c))
return __size;
}
return npos;
}
template<typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
{
;
for (; __n && __pos < this->size(); ++__pos)
{
const _CharT* __p = traits_type::find(__s, __n, _M_data()[__pos]);
if (__p)
return __pos;
}
return npos;
}
template<typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
{
;
size_type __size = this->size();
if (__size && __n)
{
if (--__size > __pos)
__size = __pos;
do
{
if (traits_type::find(__s, __n, _M_data()[__size]))
return __size;
}
while (__size-- != 0);
}
return npos;
}
template<typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const
{
;
for (; __pos < this->size(); ++__pos)
if (!traits_type::find(__s, __n, _M_data()[__pos]))
return __pos;
return npos;
}
template<typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
find_first_not_of(_CharT __c, size_type __pos) const noexcept
{
for (; __pos < this->size(); ++__pos)
if (!traits_type::eq(_M_data()[__pos], __c))
return __pos;
return npos;
}
template<typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const
{
;
size_type __size = this->size();
if (__size)
{
if (--__size > __pos)
__size = __pos;
do
{
if (!traits_type::find(__s, __n, _M_data()[__size]))
return __size;
}
while (__size--);
}
return npos;
}
template<typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
find_last_not_of(_CharT __c, size_type __pos) const noexcept
{
size_type __size = this->size();
if (__size)
{
if (--__size > __pos)
__size = __pos;
do
{
if (!traits_type::eq(_M_data()[__size], __c))
return __size;
}
while (__size--);
}
return npos;
}
template<typename _CharT, typename _Traits, typename _Alloc>
int
basic_string<_CharT, _Traits, _Alloc>::
compare(size_type __pos, size_type __n, const basic_string& __str) const
{
_M_check(__pos, "basic_string::compare");
__n = _M_limit(__pos, __n);
const size_type __osize = __str.size();
const size_type __len = std::min(__n, __osize);
int __r = traits_type::compare(_M_data() + __pos, __str.data(), __len);
if (!__r)
__r = _S_compare(__n, __osize);
return __r;
}
template<typename _CharT, typename _Traits, typename _Alloc>
int
basic_string<_CharT, _Traits, _Alloc>::
compare(size_type __pos1, size_type __n1, const basic_string& __str,
size_type __pos2, size_type __n2) const
{
_M_check(__pos1, "basic_string::compare");
__str._M_check(__pos2, "basic_string::compare");
__n1 = _M_limit(__pos1, __n1);
__n2 = __str._M_limit(__pos2, __n2);
const size_type __len = std::min(__n1, __n2);
int __r = traits_type::compare(_M_data() + __pos1,
__str.data() + __pos2, __len);
if (!__r)
__r = _S_compare(__n1, __n2);
return __r;
}
template<typename _CharT, typename _Traits, typename _Alloc>
int
basic_string<_CharT, _Traits, _Alloc>::
compare(const _CharT* __s) const
{
;
const size_type __size = this->size();
const size_type __osize = traits_type::length(__s);
const size_type __len = std::min(__size, __osize);
int __r = traits_type::compare(_M_data(), __s, __len);
if (!__r)
__r = _S_compare(__size, __osize);
return __r;
}
template<typename _CharT, typename _Traits, typename _Alloc>
int
basic_string <_CharT, _Traits, _Alloc>::
compare(size_type __pos, size_type __n1, const _CharT* __s) const
{
;
_M_check(__pos, "basic_string::compare");
__n1 = _M_limit(__pos, __n1);
const size_type __osize = traits_type::length(__s);
const size_type __len = std::min(__n1, __osize);
int __r = traits_type::compare(_M_data() + __pos, __s, __len);
if (!__r)
__r = _S_compare(__n1, __osize);
return __r;
}
template<typename _CharT, typename _Traits, typename _Alloc>
int
basic_string <_CharT, _Traits, _Alloc>::
compare(size_type __pos, size_type __n1, const _CharT* __s,
size_type __n2) const
{
;
_M_check(__pos, "basic_string::compare");
__n1 = _M_limit(__pos, __n1);
const size_type __len = std::min(__n1, __n2);
int __r = traits_type::compare(_M_data() + __pos, __s, __len);
if (!__r)
__r = _S_compare(__n1, __n2);
return __r;
}
template<typename _CharT, typename _Traits, typename _Alloc>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __in,
basic_string<_CharT, _Traits, _Alloc>& __str)
{
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
typedef typename __istream_type::ios_base __ios_base;
typedef typename __istream_type::int_type __int_type;
typedef typename __string_type::size_type __size_type;
typedef ctype<_CharT> __ctype_type;
typedef typename __ctype_type::ctype_base __ctype_base;
__size_type __extracted = 0;
typename __ios_base::iostate __err = __ios_base::goodbit;
typename __istream_type::sentry __cerb(__in, false);
if (__cerb)
{
try
{
__str.erase();
_CharT __buf[128];
__size_type __len = 0;
const streamsize __w = __in.width();
const __size_type __n = __w > 0 ? static_cast<__size_type>(__w)
: __str.max_size();
const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
const __int_type __eof = _Traits::eof();
__int_type __c = __in.rdbuf()->sgetc();
while (__extracted < __n
&& !_Traits::eq_int_type(__c, __eof)
&& !__ct.is(__ctype_base::space,
_Traits::to_char_type(__c)))
{
if (__len == sizeof(__buf) / sizeof(_CharT))
{
__str.append(__buf, sizeof(__buf) / sizeof(_CharT));
__len = 0;
}
__buf[__len++] = _Traits::to_char_type(__c);
++__extracted;
__c = __in.rdbuf()->snextc();
}
__str.append(__buf, __len);
if (_Traits::eq_int_type(__c, __eof))
__err |= __ios_base::eofbit;
__in.width(0);
}
catch(__cxxabiv1::__forced_unwind&)
{
__in._M_setstate(__ios_base::badbit);
throw;
}
catch(...)
{
__in._M_setstate(__ios_base::badbit);
}
}
if (!__extracted)
__err |= __ios_base::failbit;
if (__err)
__in.setstate(__err);
return __in;
}
template<typename _CharT, typename _Traits, typename _Alloc>
basic_istream<_CharT, _Traits>&
getline(basic_istream<_CharT, _Traits>& __in,
basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
{
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
typedef typename __istream_type::ios_base __ios_base;
typedef typename __istream_type::int_type __int_type;
typedef typename __string_type::size_type __size_type;
__size_type __extracted = 0;
const __size_type __n = __str.max_size();
typename __ios_base::iostate __err = __ios_base::goodbit;
typename __istream_type::sentry __cerb(__in, true);
if (__cerb)
{
try
{
__str.erase();
const __int_type __idelim = _Traits::to_int_type(__delim);
const __int_type __eof = _Traits::eof();
__int_type __c = __in.rdbuf()->sgetc();
while (__extracted < __n
&& !_Traits::eq_int_type(__c, __eof)
&& !_Traits::eq_int_type(__c, __idelim))
{
__str += _Traits::to_char_type(__c);
++__extracted;
__c = __in.rdbuf()->snextc();
}
if (_Traits::eq_int_type(__c, __eof))
__err |= __ios_base::eofbit;
else if (_Traits::eq_int_type(__c, __idelim))
{
++__extracted;
__in.rdbuf()->sbumpc();
}
else
__err |= __ios_base::failbit;
}
catch(__cxxabiv1::__forced_unwind&)
{
__in._M_setstate(__ios_base::badbit);
throw;
}
catch(...)
{
__in._M_setstate(__ios_base::badbit);
}
}
if (!__extracted)
__err |= __ios_base::failbit;
if (__err)
__in.setstate(__err);
return __in;
}
extern template class basic_string<char>;
extern template
basic_istream<char>&
operator>>(basic_istream<char>&, string&);
extern template
basic_ostream<char>&
operator<<(basic_ostream<char>&, const string&);
extern template
basic_istream<char>&
getline(basic_istream<char>&, string&, char);
extern template
basic_istream<char>&
getline(basic_istream<char>&, string&);
extern template class basic_string<wchar_t>;
extern template
basic_istream<wchar_t>&
operator>>(basic_istream<wchar_t>&, wstring&);
extern template
basic_ostream<wchar_t>&
operator<<(basic_ostream<wchar_t>&, const wstring&);
extern template
basic_istream<wchar_t>&
getline(basic_istream<wchar_t>&, wstring&, wchar_t);
extern template
basic_istream<wchar_t>&
getline(basic_istream<wchar_t>&, wstring&);
}
# 54 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/string" 2 3
# 41 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 62 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 3
class locale
{
public:
typedef int category;
class facet;
class id;
class _Impl;
friend class facet;
friend class _Impl;
template<typename _Facet>
friend bool
has_facet(const locale&) throw();
template<typename _Facet>
friend const _Facet&
use_facet(const locale&);
template<typename _Cache>
friend struct __use_cache;
# 98 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 3
static const category none = 0;
static const category ctype = 1L << 0;
static const category numeric = 1L << 1;
static const category collate = 1L << 2;
static const category time = 1L << 3;
static const category monetary = 1L << 4;
static const category messages = 1L << 5;
static const category all = (ctype | numeric | collate |
time | monetary | messages);
# 117 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 3
locale() throw();
# 126 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 3
locale(const locale& __other) throw();
# 136 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 3
explicit
locale(const char* __s);
# 151 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 3
locale(const locale& __base, const char* __s, category __cat);
# 162 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 3
explicit
locale(const std::string& __s) : locale(__s.c_str()) { }
# 177 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 3
locale(const locale& __base, const std::string& __s, category __cat)
: locale(__base, __s.c_str(), __cat) { }
# 192 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 3
locale(const locale& __base, const locale& __add, category __cat);
# 205 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 3
template<typename _Facet>
locale(const locale& __other, _Facet* __f);
~locale() throw();
# 219 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 3
const locale&
operator=(const locale& __other) throw();
# 234 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 3
template<typename _Facet>
locale
combine(const locale& __other) const;
__attribute ((__abi_tag__ ("cxx11")))
string
name() const;
# 254 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 3
bool
operator==(const locale& __other) const throw();
bool
operator!=(const locale& __other) const throw()
{ return !(this->operator==(__other)); }
# 282 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 3
template<typename _Char, typename _Traits, typename _Alloc>
bool
operator()(const basic_string<_Char, _Traits, _Alloc>& __s1,
const basic_string<_Char, _Traits, _Alloc>& __s2) const;
# 298 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 3
static locale
global(const locale& __loc);
static const locale&
classic();
private:
_Impl* _M_impl;
static _Impl* _S_classic;
static _Impl* _S_global;
static const char* const* const _S_categories;
# 333 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 3
enum { _S_categories_size = 6 + 6 };
static __gthread_once_t _S_once;
explicit
locale(_Impl*) throw();
static void
_S_initialize();
static void
_S_initialize_once() throw();
static category
_S_normalize_category(category);
void
_M_coalesce(const locale& __base, const locale& __add, category __cat);
static const id* const _S_twinned_facets[];
};
# 371 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 3
class locale::facet
{
private:
friend class locale;
friend class locale::_Impl;
mutable _Atomic_word _M_refcount;
static __c_locale _S_c_locale;
static const char _S_c_name[2];
static __gthread_once_t _S_once;
static void
_S_initialize_once();
protected:
# 402 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 3
explicit
facet(size_t __refs = 0) throw() : _M_refcount(__refs ? 1 : 0)
{ }
virtual
~facet();
static void
_S_create_c_locale(__c_locale& __cloc, const char* __s,
__c_locale __old = 0);
static __c_locale
_S_clone_c_locale(__c_locale& __cloc) throw();
static void
_S_destroy_c_locale(__c_locale& __cloc);
static __c_locale
_S_lc_ctype_c_locale(__c_locale __cloc, const char* __s);
static __c_locale
_S_get_c_locale();
__attribute__ ((__const__)) static const char*
_S_get_c_name() throw();
# 438 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 3
facet(const facet&) = delete;
facet&
operator=(const facet&) = delete;
private:
void
_M_add_reference() const throw()
{ __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
void
_M_remove_reference() const throw()
{
;
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
{
;
try
{ delete this; }
catch(...)
{ }
}
}
class __shim;
const facet* _M_sso_shim(const id*) const;
const facet* _M_cow_shim(const id*) const;
};
# 482 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 3
class locale::id
{
private:
friend class locale;
friend class locale::_Impl;
template<typename _Facet>
friend const _Facet&
use_facet(const locale&);
template<typename _Facet>
friend bool
has_facet(const locale&) throw();
mutable size_t _M_index;
static _Atomic_word _S_refcount;
void
operator=(const id&);
id(const id&);
public:
id() { }
size_t
_M_id() const throw();
};
class locale::_Impl
{
public:
friend class locale;
friend class locale::facet;
template<typename _Facet>
friend bool
has_facet(const locale&) throw();
template<typename _Facet>
friend const _Facet&
use_facet(const locale&);
template<typename _Cache>
friend struct __use_cache;
private:
_Atomic_word _M_refcount;
const facet** _M_facets;
size_t _M_facets_size;
const facet** _M_caches;
char** _M_names;
static const locale::id* const _S_id_ctype[];
static const locale::id* const _S_id_numeric[];
static const locale::id* const _S_id_collate[];
static const locale::id* const _S_id_time[];
static const locale::id* const _S_id_monetary[];
static const locale::id* const _S_id_messages[];
static const locale::id* const* const _S_facet_categories[];
void
_M_add_reference() throw()
{ __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
void
_M_remove_reference() throw()
{
;
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
{
;
try
{ delete this; }
catch(...)
{ }
}
}
_Impl(const _Impl&, size_t);
_Impl(const char*, size_t);
_Impl(size_t) throw();
~_Impl() throw();
_Impl(const _Impl&);
void
operator=(const _Impl&);
bool
_M_check_same_name()
{
bool __ret = true;
if (_M_names[1])
for (size_t __i = 0; __ret && __i < _S_categories_size - 1; ++__i)
__ret = __builtin_strcmp(_M_names[__i], _M_names[__i + 1]) == 0;
return __ret;
}
void
_M_replace_categories(const _Impl*, category);
void
_M_replace_category(const _Impl*, const locale::id* const*);
void
_M_replace_facet(const _Impl*, const locale::id*);
void
_M_install_facet(const locale::id*, const facet*);
template<typename _Facet>
void
_M_init_facet(_Facet* __facet)
{ _M_install_facet(&_Facet::id, __facet); }
template<typename _Facet>
void
_M_init_facet_unchecked(_Facet* __facet)
{
__facet->_M_add_reference();
_M_facets[_Facet::id._M_id()] = __facet;
}
void
_M_install_cache(const facet*, size_t);
void _M_init_extra(facet**);
void _M_init_extra(void*, void*, const char*, const char*);
};
# 640 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 3
template<typename _CharT>
class __cxx11:: collate : public locale::facet
{
public:
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;
protected:
__c_locale _M_c_locale_collate;
public:
static locale::id id;
# 667 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 3
explicit
collate(size_t __refs = 0)
: facet(__refs), _M_c_locale_collate(_S_get_c_locale())
{ }
# 681 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 3
explicit
collate(__c_locale __cloc, size_t __refs = 0)
: facet(__refs), _M_c_locale_collate(_S_clone_c_locale(__cloc))
{ }
# 698 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 3
int
compare(const _CharT* __lo1, const _CharT* __hi1,
const _CharT* __lo2, const _CharT* __hi2) const
{ return this->do_compare(__lo1, __hi1, __lo2, __hi2); }
# 717 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 3
string_type
transform(const _CharT* __lo, const _CharT* __hi) const
{ return this->do_transform(__lo, __hi); }
# 731 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 3
long
hash(const _CharT* __lo, const _CharT* __hi) const
{ return this->do_hash(__lo, __hi); }
int
_M_compare(const _CharT*, const _CharT*) const throw();
size_t
_M_transform(_CharT*, const _CharT*, size_t) const throw();
protected:
virtual
~collate()
{ _S_destroy_c_locale(_M_c_locale_collate); }
# 760 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 3
virtual int
do_compare(const _CharT* __lo1, const _CharT* __hi1,
const _CharT* __lo2, const _CharT* __hi2) const;
# 774 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 3
virtual string_type
do_transform(const _CharT* __lo, const _CharT* __hi) const;
# 787 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 3
virtual long
do_hash(const _CharT* __lo, const _CharT* __hi) const;
};
template<typename _CharT>
locale::id collate<_CharT>::id;
template<>
int
collate<char>::_M_compare(const char*, const char*) const throw();
template<>
size_t
collate<char>::_M_transform(char*, const char*, size_t) const throw();
template<>
int
collate<wchar_t>::_M_compare(const wchar_t*, const wchar_t*) const throw();
template<>
size_t
collate<wchar_t>::_M_transform(wchar_t*, const wchar_t*, size_t) const throw();
template<typename _CharT>
class __cxx11:: collate_byname : public collate<_CharT>
{
public:
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;
explicit
collate_byname(const char* __s, size_t __refs = 0)
: collate<_CharT>(__refs)
{
if (__builtin_strcmp(__s, "C") != 0
&& __builtin_strcmp(__s, "POSIX") != 0)
{
this->_S_destroy_c_locale(this->_M_c_locale_collate);
this->_S_create_c_locale(this->_M_c_locale_collate, __s);
}
}
explicit
collate_byname(const string& __s, size_t __refs = 0)
: collate_byname(__s.c_str(), __refs) { }
protected:
virtual
~collate_byname() { }
};
}
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.tcc" 1 3
# 37 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.tcc" 3
# 38 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Facet>
locale::
locale(const locale& __other, _Facet* __f)
{
_M_impl = new _Impl(*__other._M_impl, 1);
try
{ _M_impl->_M_install_facet(&_Facet::id, __f); }
catch(...)
{
_M_impl->_M_remove_reference();
throw;
}
delete [] _M_impl->_M_names[0];
_M_impl->_M_names[0] = 0;
}
template<typename _Facet>
locale
locale::
combine(const locale& __other) const
{
_Impl* __tmp = new _Impl(*_M_impl, 1);
try
{
__tmp->_M_replace_facet(__other._M_impl, &_Facet::id);
}
catch(...)
{
__tmp->_M_remove_reference();
throw;
}
return locale(__tmp);
}
template<typename _CharT, typename _Traits, typename _Alloc>
bool
locale::
operator()(const basic_string<_CharT, _Traits, _Alloc>& __s1,
const basic_string<_CharT, _Traits, _Alloc>& __s2) const
{
typedef std::collate<_CharT> __collate_type;
const __collate_type& __collate = use_facet<__collate_type>(*this);
return (__collate.compare(__s1.data(), __s1.data() + __s1.length(),
__s2.data(), __s2.data() + __s2.length()) < 0);
}
# 102 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.tcc" 3
template<typename _Facet>
bool
has_facet(const locale& __loc) throw()
{
const size_t __i = _Facet::id._M_id();
const locale::facet** __facets = __loc._M_impl->_M_facets;
return (__i < __loc._M_impl->_M_facets_size
&& dynamic_cast<const _Facet*>(__facets[__i]));
}
# 130 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.tcc" 3
template<typename _Facet>
const _Facet&
use_facet(const locale& __loc)
{
const size_t __i = _Facet::id._M_id();
const locale::facet** __facets = __loc._M_impl->_M_facets;
if (__i >= __loc._M_impl->_M_facets_size || !__facets[__i])
__throw_bad_cast();
return dynamic_cast<const _Facet&>(*__facets[__i]);
}
template<typename _CharT>
int
collate<_CharT>::_M_compare(const _CharT*, const _CharT*) const throw ()
{ return 0; }
template<typename _CharT>
size_t
collate<_CharT>::_M_transform(_CharT*, const _CharT*, size_t) const throw ()
{ return 0; }
template<typename _CharT>
int
collate<_CharT>::
do_compare(const _CharT* __lo1, const _CharT* __hi1,
const _CharT* __lo2, const _CharT* __hi2) const
{
const string_type __one(__lo1, __hi1);
const string_type __two(__lo2, __hi2);
const _CharT* __p = __one.c_str();
const _CharT* __pend = __one.data() + __one.length();
const _CharT* __q = __two.c_str();
const _CharT* __qend = __two.data() + __two.length();
for (;;)
{
const int __res = _M_compare(__p, __q);
if (__res)
return __res;
__p += char_traits<_CharT>::length(__p);
__q += char_traits<_CharT>::length(__q);
if (__p == __pend && __q == __qend)
return 0;
else if (__p == __pend)
return -1;
else if (__q == __qend)
return 1;
__p++;
__q++;
}
}
template<typename _CharT>
typename collate<_CharT>::string_type
collate<_CharT>::
do_transform(const _CharT* __lo, const _CharT* __hi) const
{
string_type __ret;
const string_type __str(__lo, __hi);
const _CharT* __p = __str.c_str();
const _CharT* __pend = __str.data() + __str.length();
size_t __len = (__hi - __lo) * 2;
_CharT* __c = new _CharT[__len];
try
{
for (;;)
{
size_t __res = _M_transform(__c, __p, __len);
if (__res >= __len)
{
__len = __res + 1;
delete [] __c, __c = 0;
__c = new _CharT[__len];
__res = _M_transform(__c, __p, __len);
}
__ret.append(__c, __res);
__p += char_traits<_CharT>::length(__p);
if (__p == __pend)
break;
__p++;
__ret.push_back(_CharT());
}
}
catch(...)
{
delete [] __c;
throw;
}
delete [] __c;
return __ret;
}
template<typename _CharT>
long
collate<_CharT>::
do_hash(const _CharT* __lo, const _CharT* __hi) const
{
unsigned long __val = 0;
for (; __lo < __hi; ++__lo)
__val =
*__lo + ((__val << 7)
| (__val >> (__gnu_cxx::__numeric_traits<unsigned long>::
__digits - 7)));
return static_cast<long>(__val);
}
extern template class collate<char>;
extern template class collate_byname<char>;
extern template
const collate<char>&
use_facet<collate<char> >(const locale&);
extern template
bool
has_facet<collate<char> >(const locale&);
extern template class collate<wchar_t>;
extern template class collate_byname<wchar_t>;
extern template
const collate<wchar_t>&
use_facet<collate<wchar_t> >(const locale&);
extern template
bool
has_facet<collate<wchar_t> >(const locale&);
}
# 851 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 2 3
# 42 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/system_error" 1 3
# 32 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/system_error" 3
# 33 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/system_error" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/error_constants.h" 1 3
# 34 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/error_constants.h" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cerrno" 1 3
# 39 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cerrno" 3
# 40 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cerrno" 3
# 1 "/usr/include/errno.h" 1 3 4
# 43 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cerrno" 2 3
# 35 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/error_constants.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
enum class errc
{
address_family_not_supported = 97,
address_in_use = 98,
address_not_available = 99,
already_connected = 106,
argument_list_too_long = 7,
argument_out_of_domain = 33,
bad_address = 14,
bad_file_descriptor = 9,
bad_message = 74,
broken_pipe = 32,
connection_aborted = 103,
connection_already_in_progress = 114,
connection_refused = 111,
connection_reset = 104,
cross_device_link = 18,
destination_address_required = 89,
device_or_resource_busy = 16,
directory_not_empty = 39,
executable_format_error = 8,
file_exists = 17,
file_too_large = 27,
filename_too_long = 36,
function_not_supported = 38,
host_unreachable = 113,
identifier_removed = 43,
illegal_byte_sequence = 84,
inappropriate_io_control_operation = 25,
interrupted = 4,
invalid_argument = 22,
invalid_seek = 29,
io_error = 5,
is_a_directory = 21,
message_size = 90,
network_down = 100,
network_reset = 102,
network_unreachable = 101,
no_buffer_space = 105,
no_child_process = 10,
no_link = 67,
no_lock_available = 37,
no_message_available = 61,
no_message = 42,
no_protocol_option = 92,
no_space_on_device = 28,
no_stream_resources = 63,
no_such_device_or_address = 6,
no_such_device = 19,
no_such_file_or_directory = 2,
no_such_process = 3,
not_a_directory = 20,
not_a_socket = 88,
not_a_stream = 60,
not_connected = 107,
not_enough_memory = 12,
not_supported = 95,
operation_canceled = 125,
operation_in_progress = 115,
operation_not_permitted = 1,
operation_not_supported = 95,
operation_would_block = 11,
owner_dead = 130,
permission_denied = 13,
protocol_error = 71,
protocol_not_supported = 93,
read_only_file_system = 30,
resource_deadlock_would_occur = 35,
resource_unavailable_try_again = 11,
result_out_of_range = 34,
state_not_recoverable = 131,
stream_timeout = 62,
text_file_busy = 26,
timed_out = 110,
too_many_files_open_in_system = 23,
too_many_files_open = 24,
too_many_links = 31,
too_many_symbolic_link_levels = 40,
value_too_large = 75,
wrong_protocol_type = 91
};
}
# 40 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/system_error" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/stdexcept" 1 3
# 36 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/stdexcept" 3
# 37 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/stdexcept" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
struct __cow_string
{
union {
const char* _M_p;
char _M_bytes[sizeof(const char*)];
};
__cow_string();
__cow_string(const std::string&);
__cow_string(const char*, size_t);
__cow_string(const __cow_string&) noexcept;
__cow_string& operator=(const __cow_string&) noexcept;
~__cow_string();
__cow_string(__cow_string&&) noexcept;
__cow_string& operator=(__cow_string&&) noexcept;
};
typedef basic_string<char> __sso_string;
# 113 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/stdexcept" 3
class logic_error : public exception
{
__cow_string _M_msg;
public:
explicit
logic_error(const string& __arg) ;
explicit
logic_error(const char*) ;
logic_error(const logic_error&) noexcept;
logic_error& operator=(const logic_error&) noexcept;
virtual ~logic_error() noexcept;
virtual const char*
what() const noexcept;
};
class domain_error : public logic_error
{
public:
explicit domain_error(const string& __arg) ;
explicit domain_error(const char*) ;
virtual ~domain_error() noexcept;
};
class invalid_argument : public logic_error
{
public:
explicit invalid_argument(const string& __arg) ;
explicit invalid_argument(const char*) ;
virtual ~invalid_argument() noexcept;
};
class length_error : public logic_error
{
public:
explicit length_error(const string& __arg) ;
explicit length_error(const char*) ;
virtual ~length_error() noexcept;
};
class out_of_range : public logic_error
{
public:
explicit out_of_range(const string& __arg) ;
explicit out_of_range(const char*) ;
virtual ~out_of_range() noexcept;
};
class runtime_error : public exception
{
__cow_string _M_msg;
public:
explicit
runtime_error(const string& __arg) ;
explicit
runtime_error(const char*) ;
runtime_error(const runtime_error&) noexcept;
runtime_error& operator=(const runtime_error&) noexcept;
virtual ~runtime_error() noexcept;
virtual const char*
what() const noexcept;
};
class range_error : public runtime_error
{
public:
explicit range_error(const string& __arg) ;
explicit range_error(const char*) ;
virtual ~range_error() noexcept;
};
class overflow_error : public runtime_error
{
public:
explicit overflow_error(const string& __arg) ;
explicit overflow_error(const char*) ;
virtual ~overflow_error() noexcept;
};
class underflow_error : public runtime_error
{
public:
explicit underflow_error(const string& __arg) ;
explicit underflow_error(const char*) ;
virtual ~underflow_error() noexcept;
};
}
# 42 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/system_error" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
class error_code;
class error_condition;
class system_error;
template<typename _Tp>
struct is_error_code_enum : public false_type { };
template<typename _Tp>
struct is_error_condition_enum : public false_type { };
template<>
struct is_error_condition_enum<errc>
: public true_type { };
inline namespace _V2 {
class error_category
{
public:
constexpr error_category() noexcept = default;
virtual ~error_category();
error_category(const error_category&) = delete;
error_category& operator=(const error_category&) = delete;
virtual const char*
name() const noexcept = 0;
private:
__attribute ((__abi_tag__ ("cxx11")))
virtual __cow_string
_M_message(int) const;
public:
__attribute ((__abi_tag__ ("cxx11")))
virtual string
message(int) const = 0;
# 102 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/system_error" 3
public:
virtual error_condition
default_error_condition(int __i) const noexcept;
virtual bool
equivalent(int __i, const error_condition& __cond) const noexcept;
virtual bool
equivalent(const error_code& __code, int __i) const noexcept;
bool
operator<(const error_category& __other) const noexcept
{ return less<const error_category*>()(this, &__other); }
bool
operator==(const error_category& __other) const noexcept
{ return this == &__other; }
bool
operator!=(const error_category& __other) const noexcept
{ return this != &__other; }
};
__attribute__ ((__const__)) const error_category& system_category() noexcept;
__attribute__ ((__const__)) const error_category& generic_category() noexcept;
}
error_code make_error_code(errc) noexcept;
template<typename _Tp>
struct hash;
struct error_code
{
error_code() noexcept
: _M_value(0), _M_cat(&system_category()) { }
error_code(int __v, const error_category& __cat) noexcept
: _M_value(__v), _M_cat(&__cat) { }
template<typename _ErrorCodeEnum, typename = typename
enable_if<is_error_code_enum<_ErrorCodeEnum>::value>::type>
error_code(_ErrorCodeEnum __e) noexcept
{ *this = make_error_code(__e); }
void
assign(int __v, const error_category& __cat) noexcept
{
_M_value = __v;
_M_cat = &__cat;
}
void
clear() noexcept
{ assign(0, system_category()); }
template<typename _ErrorCodeEnum>
typename enable_if<is_error_code_enum<_ErrorCodeEnum>::value,
error_code&>::type
operator=(_ErrorCodeEnum __e) noexcept
{ return *this = make_error_code(__e); }
int
value() const noexcept { return _M_value; }
const error_category&
category() const noexcept { return *_M_cat; }
error_condition
default_error_condition() const noexcept;
__attribute ((__abi_tag__ ("cxx11")))
string
message() const
{ return category().message(value()); }
explicit operator bool() const noexcept
{ return _M_value != 0; }
private:
friend class hash<error_code>;
int _M_value;
const error_category* _M_cat;
};
inline error_code
make_error_code(errc __e) noexcept
{ return error_code(static_cast<int>(__e), generic_category()); }
inline bool
operator<(const error_code& __lhs, const error_code& __rhs) noexcept
{
return (__lhs.category() < __rhs.category()
|| (__lhs.category() == __rhs.category()
&& __lhs.value() < __rhs.value()));
}
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, const error_code& __e)
{ return (__os << __e.category().name() << ':' << __e.value()); }
error_condition make_error_condition(errc) noexcept;
struct error_condition
{
error_condition() noexcept
: _M_value(0), _M_cat(&generic_category()) { }
error_condition(int __v, const error_category& __cat) noexcept
: _M_value(__v), _M_cat(&__cat) { }
template<typename _ErrorConditionEnum, typename = typename
enable_if<is_error_condition_enum<_ErrorConditionEnum>::value>::type>
error_condition(_ErrorConditionEnum __e) noexcept
{ *this = make_error_condition(__e); }
void
assign(int __v, const error_category& __cat) noexcept
{
_M_value = __v;
_M_cat = &__cat;
}
template<typename _ErrorConditionEnum>
typename enable_if<is_error_condition_enum
<_ErrorConditionEnum>::value, error_condition&>::type
operator=(_ErrorConditionEnum __e) noexcept
{ return *this = make_error_condition(__e); }
void
clear() noexcept
{ assign(0, generic_category()); }
int
value() const noexcept { return _M_value; }
const error_category&
category() const noexcept { return *_M_cat; }
__attribute ((__abi_tag__ ("cxx11")))
string
message() const
{ return category().message(value()); }
explicit operator bool() const noexcept
{ return _M_value != 0; }
private:
int _M_value;
const error_category* _M_cat;
};
inline error_condition
make_error_condition(errc __e) noexcept
{ return error_condition(static_cast<int>(__e), generic_category()); }
inline bool
operator<(const error_condition& __lhs,
const error_condition& __rhs) noexcept
{
return (__lhs.category() < __rhs.category()
|| (__lhs.category() == __rhs.category()
&& __lhs.value() < __rhs.value()));
}
inline bool
operator==(const error_code& __lhs, const error_code& __rhs) noexcept
{ return (__lhs.category() == __rhs.category()
&& __lhs.value() == __rhs.value()); }
inline bool
operator==(const error_code& __lhs, const error_condition& __rhs) noexcept
{
return (__lhs.category().equivalent(__lhs.value(), __rhs)
|| __rhs.category().equivalent(__lhs, __rhs.value()));
}
inline bool
operator==(const error_condition& __lhs, const error_code& __rhs) noexcept
{
return (__rhs.category().equivalent(__rhs.value(), __lhs)
|| __lhs.category().equivalent(__rhs, __lhs.value()));
}
inline bool
operator==(const error_condition& __lhs,
const error_condition& __rhs) noexcept
{
return (__lhs.category() == __rhs.category()
&& __lhs.value() == __rhs.value());
}
inline bool
operator!=(const error_code& __lhs, const error_code& __rhs) noexcept
{ return !(__lhs == __rhs); }
inline bool
operator!=(const error_code& __lhs, const error_condition& __rhs) noexcept
{ return !(__lhs == __rhs); }
inline bool
operator!=(const error_condition& __lhs, const error_code& __rhs) noexcept
{ return !(__lhs == __rhs); }
inline bool
operator!=(const error_condition& __lhs,
const error_condition& __rhs) noexcept
{ return !(__lhs == __rhs); }
class system_error : public std::runtime_error
{
private:
error_code _M_code;
public:
system_error(error_code __ec = error_code())
: runtime_error(__ec.message()), _M_code(__ec) { }
system_error(error_code __ec, const string& __what)
: runtime_error(__what + ": " + __ec.message()), _M_code(__ec) { }
system_error(error_code __ec, const char* __what)
: runtime_error(__what + (": " + __ec.message())), _M_code(__ec) { }
system_error(int __v, const error_category& __ecat, const char* __what)
: system_error(error_code(__v, __ecat), __what) { }
system_error(int __v, const error_category& __ecat)
: runtime_error(error_code(__v, __ecat).message()),
_M_code(__v, __ecat) { }
system_error(int __v, const error_category& __ecat, const string& __what)
: runtime_error(__what + ": " + error_code(__v, __ecat).message()),
_M_code(__v, __ecat) { }
virtual ~system_error() noexcept;
const error_code&
code() const noexcept { return _M_code; }
};
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<>
struct hash<error_code>
: public __hash_base<size_t, error_code>
{
size_t
operator()(const error_code& __e) const noexcept
{
const size_t __tmp = std::_Hash_impl::hash(__e._M_value);
return std::_Hash_impl::__hash_combine(__e._M_cat, __tmp);
}
};
}
# 47 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
enum _Ios_Fmtflags
{
_S_boolalpha = 1L << 0,
_S_dec = 1L << 1,
_S_fixed = 1L << 2,
_S_hex = 1L << 3,
_S_internal = 1L << 4,
_S_left = 1L << 5,
_S_oct = 1L << 6,
_S_right = 1L << 7,
_S_scientific = 1L << 8,
_S_showbase = 1L << 9,
_S_showpoint = 1L << 10,
_S_showpos = 1L << 11,
_S_skipws = 1L << 12,
_S_unitbuf = 1L << 13,
_S_uppercase = 1L << 14,
_S_adjustfield = _S_left | _S_right | _S_internal,
_S_basefield = _S_dec | _S_oct | _S_hex,
_S_floatfield = _S_scientific | _S_fixed,
_S_ios_fmtflags_end = 1L << 16,
_S_ios_fmtflags_max = 0x7fffffff,
_S_ios_fmtflags_min = ~0x7fffffff
};
inline constexpr _Ios_Fmtflags
operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
{ return _Ios_Fmtflags(static_cast<int>(__a) & static_cast<int>(__b)); }
inline constexpr _Ios_Fmtflags
operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
{ return _Ios_Fmtflags(static_cast<int>(__a) | static_cast<int>(__b)); }
inline constexpr _Ios_Fmtflags
operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
{ return _Ios_Fmtflags(static_cast<int>(__a) ^ static_cast<int>(__b)); }
inline constexpr _Ios_Fmtflags
operator~(_Ios_Fmtflags __a)
{ return _Ios_Fmtflags(~static_cast<int>(__a)); }
inline const _Ios_Fmtflags&
operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
{ return __a = __a | __b; }
inline const _Ios_Fmtflags&
operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
{ return __a = __a & __b; }
inline const _Ios_Fmtflags&
operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
{ return __a = __a ^ __b; }
enum _Ios_Openmode
{
_S_app = 1L << 0,
_S_ate = 1L << 1,
_S_bin = 1L << 2,
_S_in = 1L << 3,
_S_out = 1L << 4,
_S_trunc = 1L << 5,
_S_ios_openmode_end = 1L << 16,
_S_ios_openmode_max = 0x7fffffff,
_S_ios_openmode_min = ~0x7fffffff
};
inline constexpr _Ios_Openmode
operator&(_Ios_Openmode __a, _Ios_Openmode __b)
{ return _Ios_Openmode(static_cast<int>(__a) & static_cast<int>(__b)); }
inline constexpr _Ios_Openmode
operator|(_Ios_Openmode __a, _Ios_Openmode __b)
{ return _Ios_Openmode(static_cast<int>(__a) | static_cast<int>(__b)); }
inline constexpr _Ios_Openmode
operator^(_Ios_Openmode __a, _Ios_Openmode __b)
{ return _Ios_Openmode(static_cast<int>(__a) ^ static_cast<int>(__b)); }
inline constexpr _Ios_Openmode
operator~(_Ios_Openmode __a)
{ return _Ios_Openmode(~static_cast<int>(__a)); }
inline const _Ios_Openmode&
operator|=(_Ios_Openmode& __a, _Ios_Openmode __b)
{ return __a = __a | __b; }
inline const _Ios_Openmode&
operator&=(_Ios_Openmode& __a, _Ios_Openmode __b)
{ return __a = __a & __b; }
inline const _Ios_Openmode&
operator^=(_Ios_Openmode& __a, _Ios_Openmode __b)
{ return __a = __a ^ __b; }
enum _Ios_Iostate
{
_S_goodbit = 0,
_S_badbit = 1L << 0,
_S_eofbit = 1L << 1,
_S_failbit = 1L << 2,
_S_ios_iostate_end = 1L << 16,
_S_ios_iostate_max = 0x7fffffff,
_S_ios_iostate_min = ~0x7fffffff
};
inline constexpr _Ios_Iostate
operator&(_Ios_Iostate __a, _Ios_Iostate __b)
{ return _Ios_Iostate(static_cast<int>(__a) & static_cast<int>(__b)); }
inline constexpr _Ios_Iostate
operator|(_Ios_Iostate __a, _Ios_Iostate __b)
{ return _Ios_Iostate(static_cast<int>(__a) | static_cast<int>(__b)); }
inline constexpr _Ios_Iostate
operator^(_Ios_Iostate __a, _Ios_Iostate __b)
{ return _Ios_Iostate(static_cast<int>(__a) ^ static_cast<int>(__b)); }
inline constexpr _Ios_Iostate
operator~(_Ios_Iostate __a)
{ return _Ios_Iostate(~static_cast<int>(__a)); }
inline const _Ios_Iostate&
operator|=(_Ios_Iostate& __a, _Ios_Iostate __b)
{ return __a = __a | __b; }
inline const _Ios_Iostate&
operator&=(_Ios_Iostate& __a, _Ios_Iostate __b)
{ return __a = __a & __b; }
inline const _Ios_Iostate&
operator^=(_Ios_Iostate& __a, _Ios_Iostate __b)
{ return __a = __a ^ __b; }
enum _Ios_Seekdir
{
_S_beg = 0,
_S_cur = 1,
_S_end = 2,
_S_ios_seekdir_end = 1L << 16
};
enum class io_errc { stream = 1 };
template <> struct is_error_code_enum<io_errc> : public true_type { };
const error_category& iostream_category() noexcept;
inline error_code
make_error_code(io_errc e) noexcept
{ return error_code(static_cast<int>(e), iostream_category()); }
inline error_condition
make_error_condition(io_errc e) noexcept
{ return error_condition(static_cast<int>(e), iostream_category()); }
# 228 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 3
class ios_base
{
# 246 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 3
public:
# 255 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 3
class __attribute ((__abi_tag__ ("cxx11"))) failure : public system_error
{
public:
explicit
failure(const string& __str);
explicit
failure(const string&, const error_code&);
explicit
failure(const char*, const error_code& = io_errc::stream);
virtual
~failure() throw();
virtual const char*
what() const throw();
};
# 323 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 3
typedef _Ios_Fmtflags fmtflags;
static const fmtflags boolalpha = _S_boolalpha;
static const fmtflags dec = _S_dec;
static const fmtflags fixed = _S_fixed;
static const fmtflags hex = _S_hex;
static const fmtflags internal = _S_internal;
static const fmtflags left = _S_left;
static const fmtflags oct = _S_oct;
static const fmtflags right = _S_right;
static const fmtflags scientific = _S_scientific;
static const fmtflags showbase = _S_showbase;
static const fmtflags showpoint = _S_showpoint;
static const fmtflags showpos = _S_showpos;
static const fmtflags skipws = _S_skipws;
static const fmtflags unitbuf = _S_unitbuf;
static const fmtflags uppercase = _S_uppercase;
static const fmtflags adjustfield = _S_adjustfield;
static const fmtflags basefield = _S_basefield;
static const fmtflags floatfield = _S_floatfield;
# 398 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 3
typedef _Ios_Iostate iostate;
static const iostate badbit = _S_badbit;
static const iostate eofbit = _S_eofbit;
static const iostate failbit = _S_failbit;
static const iostate goodbit = _S_goodbit;
# 429 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 3
typedef _Ios_Openmode openmode;
static const openmode app = _S_app;
static const openmode ate = _S_ate;
static const openmode binary = _S_bin;
static const openmode in = _S_in;
static const openmode out = _S_out;
static const openmode trunc = _S_trunc;
# 461 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 3
typedef _Ios_Seekdir seekdir;
static const seekdir beg = _S_beg;
static const seekdir cur = _S_cur;
static const seekdir end = _S_end;
typedef int io_state;
typedef int open_mode;
typedef int seek_dir;
typedef std::streampos streampos;
typedef std::streamoff streamoff;
# 487 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 3
enum event
{
erase_event,
imbue_event,
copyfmt_event
};
# 504 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 3
typedef void (*event_callback) (event __e, ios_base& __b, int __i);
# 516 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 3
void
register_callback(event_callback __fn, int __index);
protected:
streamsize _M_precision;
streamsize _M_width;
fmtflags _M_flags;
iostate _M_exception;
iostate _M_streambuf_state;
struct _Callback_list
{
_Callback_list* _M_next;
ios_base::event_callback _M_fn;
int _M_index;
_Atomic_word _M_refcount;
_Callback_list(ios_base::event_callback __fn, int __index,
_Callback_list* __cb)
: _M_next(__cb), _M_fn(__fn), _M_index(__index), _M_refcount(0) { }
void
_M_add_reference() { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
int
_M_remove_reference()
{
;
int __res = __gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1);
if (__res == 0)
{
;
}
return __res;
}
};
_Callback_list* _M_callbacks;
void
_M_call_callbacks(event __ev) throw();
void
_M_dispose_callbacks(void) throw();
struct _Words
{
void* _M_pword;
long _M_iword;
_Words() : _M_pword(0), _M_iword(0) { }
};
_Words _M_word_zero;
enum { _S_local_word_size = 8 };
_Words _M_local_word[_S_local_word_size];
int _M_word_size;
_Words* _M_word;
_Words&
_M_grow_words(int __index, bool __iword);
locale _M_ios_locale;
void
_M_init() throw();
public:
class Init
{
friend class ios_base;
public:
Init();
~Init();
private:
static _Atomic_word _S_refcount;
static bool _S_synced_with_stdio;
};
fmtflags
flags() const
{ return _M_flags; }
# 629 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 3
fmtflags
flags(fmtflags __fmtfl)
{
fmtflags __old = _M_flags;
_M_flags = __fmtfl;
return __old;
}
# 645 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 3
fmtflags
setf(fmtflags __fmtfl)
{
fmtflags __old = _M_flags;
_M_flags |= __fmtfl;
return __old;
}
# 662 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 3
fmtflags
setf(fmtflags __fmtfl, fmtflags __mask)
{
fmtflags __old = _M_flags;
_M_flags &= ~__mask;
_M_flags |= (__fmtfl & __mask);
return __old;
}
void
unsetf(fmtflags __mask)
{ _M_flags &= ~__mask; }
# 688 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 3
streamsize
precision() const
{ return _M_precision; }
streamsize
precision(streamsize __prec)
{
streamsize __old = _M_precision;
_M_precision = __prec;
return __old;
}
streamsize
width() const
{ return _M_width; }
streamsize
width(streamsize __wide)
{
streamsize __old = _M_width;
_M_width = __wide;
return __old;
}
# 739 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 3
static bool
sync_with_stdio(bool __sync = true);
# 751 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 3
locale
imbue(const locale& __loc) throw();
# 762 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 3
locale
getloc() const
{ return _M_ios_locale; }
# 773 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 3
const locale&
_M_getloc() const
{ return _M_ios_locale; }
# 792 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 3
static int
xalloc() throw();
# 808 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 3
long&
iword(int __ix)
{
_Words& __word = (__ix < _M_word_size)
? _M_word[__ix] : _M_grow_words(__ix, true);
return __word._M_iword;
}
# 829 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 3
void*&
pword(int __ix)
{
_Words& __word = (__ix < _M_word_size)
? _M_word[__ix] : _M_grow_words(__ix, false);
return __word._M_pword;
}
# 846 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 3
virtual ~ios_base();
protected:
ios_base() throw ();
# 860 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 3
public:
ios_base(const ios_base&) = delete;
ios_base&
operator=(const ios_base&) = delete;
protected:
void
_M_move(ios_base&) noexcept;
void
_M_swap(ios_base& __rhs) noexcept;
};
inline ios_base&
boolalpha(ios_base& __base)
{
__base.setf(ios_base::boolalpha);
return __base;
}
inline ios_base&
noboolalpha(ios_base& __base)
{
__base.unsetf(ios_base::boolalpha);
return __base;
}
inline ios_base&
showbase(ios_base& __base)
{
__base.setf(ios_base::showbase);
return __base;
}
inline ios_base&
noshowbase(ios_base& __base)
{
__base.unsetf(ios_base::showbase);
return __base;
}
inline ios_base&
showpoint(ios_base& __base)
{
__base.setf(ios_base::showpoint);
return __base;
}
inline ios_base&
noshowpoint(ios_base& __base)
{
__base.unsetf(ios_base::showpoint);
return __base;
}
inline ios_base&
showpos(ios_base& __base)
{
__base.setf(ios_base::showpos);
return __base;
}
inline ios_base&
noshowpos(ios_base& __base)
{
__base.unsetf(ios_base::showpos);
return __base;
}
inline ios_base&
skipws(ios_base& __base)
{
__base.setf(ios_base::skipws);
return __base;
}
inline ios_base&
noskipws(ios_base& __base)
{
__base.unsetf(ios_base::skipws);
return __base;
}
inline ios_base&
uppercase(ios_base& __base)
{
__base.setf(ios_base::uppercase);
return __base;
}
inline ios_base&
nouppercase(ios_base& __base)
{
__base.unsetf(ios_base::uppercase);
return __base;
}
inline ios_base&
unitbuf(ios_base& __base)
{
__base.setf(ios_base::unitbuf);
return __base;
}
inline ios_base&
nounitbuf(ios_base& __base)
{
__base.unsetf(ios_base::unitbuf);
return __base;
}
inline ios_base&
internal(ios_base& __base)
{
__base.setf(ios_base::internal, ios_base::adjustfield);
return __base;
}
inline ios_base&
left(ios_base& __base)
{
__base.setf(ios_base::left, ios_base::adjustfield);
return __base;
}
inline ios_base&
right(ios_base& __base)
{
__base.setf(ios_base::right, ios_base::adjustfield);
return __base;
}
inline ios_base&
dec(ios_base& __base)
{
__base.setf(ios_base::dec, ios_base::basefield);
return __base;
}
inline ios_base&
hex(ios_base& __base)
{
__base.setf(ios_base::hex, ios_base::basefield);
return __base;
}
inline ios_base&
oct(ios_base& __base)
{
__base.setf(ios_base::oct, ios_base::basefield);
return __base;
}
inline ios_base&
fixed(ios_base& __base)
{
__base.setf(ios_base::fixed, ios_base::floatfield);
return __base;
}
inline ios_base&
scientific(ios_base& __base)
{
__base.setf(ios_base::scientific, ios_base::floatfield);
return __base;
}
inline ios_base&
hexfloat(ios_base& __base)
{
__base.setf(ios_base::fixed | ios_base::scientific, ios_base::floatfield);
return __base;
}
inline ios_base&
defaultfloat(ios_base& __base)
{
__base.unsetf(ios_base::floatfield);
return __base;
}
}
# 43 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ios" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 1 3
# 36 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
# 37 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
# 45 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits>
streamsize
__copy_streambufs_eof(basic_streambuf<_CharT, _Traits>*,
basic_streambuf<_CharT, _Traits>*, bool&);
# 119 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
template<typename _CharT, typename _Traits>
class basic_streambuf
{
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type;
typedef basic_streambuf<char_type, traits_type> __streambuf_type;
friend class basic_ios<char_type, traits_type>;
friend class basic_istream<char_type, traits_type>;
friend class basic_ostream<char_type, traits_type>;
friend class istreambuf_iterator<char_type, traits_type>;
friend class ostreambuf_iterator<char_type, traits_type>;
friend streamsize
__copy_streambufs_eof<>(basic_streambuf*, basic_streambuf*, bool&);
template<bool _IsMove, typename _CharT2>
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
_CharT2*>::__type
__copy_move_a2(istreambuf_iterator<_CharT2>,
istreambuf_iterator<_CharT2>, _CharT2*);
template<typename _CharT2>
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
istreambuf_iterator<_CharT2> >::__type
find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
const _CharT2&);
template<typename _CharT2, typename _Traits2>
friend basic_istream<_CharT2, _Traits2>&
operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2*);
template<typename _CharT2, typename _Traits2, typename _Alloc>
friend basic_istream<_CharT2, _Traits2>&
operator>>(basic_istream<_CharT2, _Traits2>&,
basic_string<_CharT2, _Traits2, _Alloc>&);
template<typename _CharT2, typename _Traits2, typename _Alloc>
friend basic_istream<_CharT2, _Traits2>&
getline(basic_istream<_CharT2, _Traits2>&,
basic_string<_CharT2, _Traits2, _Alloc>&, _CharT2);
protected:
char_type* _M_in_beg;
char_type* _M_in_cur;
char_type* _M_in_end;
char_type* _M_out_beg;
char_type* _M_out_cur;
char_type* _M_out_end;
locale _M_buf_locale;
public:
virtual
~basic_streambuf()
{ }
# 208 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
locale
pubimbue(const locale& __loc)
{
locale __tmp(this->getloc());
this->imbue(__loc);
_M_buf_locale = __loc;
return __tmp;
}
# 225 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
locale
getloc() const
{ return _M_buf_locale; }
# 238 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
basic_streambuf*
pubsetbuf(char_type* __s, streamsize __n)
{ return this->setbuf(__s, __n); }
# 250 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
pos_type
pubseekoff(off_type __off, ios_base::seekdir __way,
ios_base::openmode __mode = ios_base::in | ios_base::out)
{ return this->seekoff(__off, __way, __mode); }
# 262 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
pos_type
pubseekpos(pos_type __sp,
ios_base::openmode __mode = ios_base::in | ios_base::out)
{ return this->seekpos(__sp, __mode); }
int
pubsync() { return this->sync(); }
# 283 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
streamsize
in_avail()
{
const streamsize __ret = this->egptr() - this->gptr();
return __ret ? __ret : this->showmanyc();
}
# 297 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
int_type
snextc()
{
int_type __ret = traits_type::eof();
if (__builtin_expect(!traits_type::eq_int_type(this->sbumpc(),
__ret), true))
__ret = this->sgetc();
return __ret;
}
# 315 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
int_type
sbumpc()
{
int_type __ret;
if (__builtin_expect(this->gptr() < this->egptr(), true))
{
__ret = traits_type::to_int_type(*this->gptr());
this->gbump(1);
}
else
__ret = this->uflow();
return __ret;
}
# 337 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
int_type
sgetc()
{
int_type __ret;
if (__builtin_expect(this->gptr() < this->egptr(), true))
__ret = traits_type::to_int_type(*this->gptr());
else
__ret = this->underflow();
return __ret;
}
# 356 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
streamsize
sgetn(char_type* __s, streamsize __n)
{ return this->xsgetn(__s, __n); }
# 371 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
int_type
sputbackc(char_type __c)
{
int_type __ret;
const bool __testpos = this->eback() < this->gptr();
if (__builtin_expect(!__testpos ||
!traits_type::eq(__c, this->gptr()[-1]), false))
__ret = this->pbackfail(traits_type::to_int_type(__c));
else
{
this->gbump(-1);
__ret = traits_type::to_int_type(*this->gptr());
}
return __ret;
}
# 396 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
int_type
sungetc()
{
int_type __ret;
if (__builtin_expect(this->eback() < this->gptr(), true))
{
this->gbump(-1);
__ret = traits_type::to_int_type(*this->gptr());
}
else
__ret = this->pbackfail();
return __ret;
}
# 423 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
int_type
sputc(char_type __c)
{
int_type __ret;
if (__builtin_expect(this->pptr() < this->epptr(), true))
{
*this->pptr() = __c;
this->pbump(1);
__ret = traits_type::to_int_type(__c);
}
else
__ret = this->overflow(traits_type::to_int_type(__c));
return __ret;
}
# 449 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
streamsize
sputn(const char_type* __s, streamsize __n)
{ return this->xsputn(__s, __n); }
protected:
# 463 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
basic_streambuf()
: _M_in_beg(0), _M_in_cur(0), _M_in_end(0),
_M_out_beg(0), _M_out_cur(0), _M_out_end(0),
_M_buf_locale(locale())
{ }
# 481 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
char_type*
eback() const { return _M_in_beg; }
char_type*
gptr() const { return _M_in_cur; }
char_type*
egptr() const { return _M_in_end; }
# 497 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
void
gbump(int __n) { _M_in_cur += __n; }
# 508 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
void
setg(char_type* __gbeg, char_type* __gnext, char_type* __gend)
{
_M_in_beg = __gbeg;
_M_in_cur = __gnext;
_M_in_end = __gend;
}
# 528 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
char_type*
pbase() const { return _M_out_beg; }
char_type*
pptr() const { return _M_out_cur; }
char_type*
epptr() const { return _M_out_end; }
# 544 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
void
pbump(int __n) { _M_out_cur += __n; }
# 554 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
void
setp(char_type* __pbeg, char_type* __pend)
{
_M_out_beg = _M_out_cur = __pbeg;
_M_out_end = __pend;
}
# 575 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
virtual void
imbue(const locale& __loc)
{ }
# 590 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
virtual basic_streambuf<char_type,_Traits>*
setbuf(char_type*, streamsize)
{ return this; }
# 601 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
virtual pos_type
seekoff(off_type, ios_base::seekdir,
ios_base::openmode = ios_base::in | ios_base::out)
{ return pos_type(off_type(-1)); }
# 613 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
virtual pos_type
seekpos(pos_type,
ios_base::openmode = ios_base::in | ios_base::out)
{ return pos_type(off_type(-1)); }
# 626 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
virtual int
sync() { return 0; }
# 648 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
virtual streamsize
showmanyc() { return 0; }
# 664 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
virtual streamsize
xsgetn(char_type* __s, streamsize __n);
# 686 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
virtual int_type
underflow()
{ return traits_type::eof(); }
# 699 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
virtual int_type
uflow()
{
int_type __ret = traits_type::eof();
const bool __testeof = traits_type::eq_int_type(this->underflow(),
__ret);
if (!__testeof)
{
__ret = traits_type::to_int_type(*this->gptr());
this->gbump(1);
}
return __ret;
}
# 723 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
virtual int_type
pbackfail(int_type __c = traits_type::eof())
{ return traits_type::eof(); }
# 741 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
virtual streamsize
xsputn(const char_type* __s, streamsize __n);
# 767 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
virtual int_type
overflow(int_type __c = traits_type::eof())
{ return traits_type::eof(); }
public:
# 782 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
void
stossc()
{
if (this->gptr() < this->egptr())
this->gbump(1);
else
this->uflow();
}
void
__safe_gbump(streamsize __n) { _M_in_cur += __n; }
void
__safe_pbump(streamsize __n) { _M_out_cur += __n; }
protected:
basic_streambuf(const basic_streambuf&);
basic_streambuf&
operator=(const basic_streambuf&);
void
swap(basic_streambuf& __sb)
{
std::swap(_M_in_beg, __sb._M_in_beg);
std::swap(_M_in_cur, __sb._M_in_cur);
std::swap(_M_in_end, __sb._M_in_end);
std::swap(_M_out_beg, __sb._M_out_beg);
std::swap(_M_out_cur, __sb._M_out_cur);
std::swap(_M_out_end, __sb._M_out_end);
std::swap(_M_buf_locale, __sb._M_buf_locale);
}
};
template<typename _CharT, typename _Traits>
std::basic_streambuf<_CharT, _Traits>::
basic_streambuf(const basic_streambuf&) = default;
template<typename _CharT, typename _Traits>
std::basic_streambuf<_CharT, _Traits>&
std::basic_streambuf<_CharT, _Traits>::
operator=(const basic_streambuf&) = default;
template<>
streamsize
__copy_streambufs_eof(basic_streambuf<char>* __sbin,
basic_streambuf<char>* __sbout, bool& __ineof);
template<>
streamsize
__copy_streambufs_eof(basic_streambuf<wchar_t>* __sbin,
basic_streambuf<wchar_t>* __sbout, bool& __ineof);
}
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/streambuf.tcc" 1 3
# 37 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/streambuf.tcc" 3
# 38 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/streambuf.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits>
streamsize
basic_streambuf<_CharT, _Traits>::
xsgetn(char_type* __s, streamsize __n)
{
streamsize __ret = 0;
while (__ret < __n)
{
const streamsize __buf_len = this->egptr() - this->gptr();
if (__buf_len)
{
const streamsize __remaining = __n - __ret;
const streamsize __len = std::min(__buf_len, __remaining);
traits_type::copy(__s, this->gptr(), __len);
__ret += __len;
__s += __len;
this->__safe_gbump(__len);
}
if (__ret < __n)
{
const int_type __c = this->uflow();
if (!traits_type::eq_int_type(__c, traits_type::eof()))
{
traits_type::assign(*__s++, traits_type::to_char_type(__c));
++__ret;
}
else
break;
}
}
return __ret;
}
template<typename _CharT, typename _Traits>
streamsize
basic_streambuf<_CharT, _Traits>::
xsputn(const char_type* __s, streamsize __n)
{
streamsize __ret = 0;
while (__ret < __n)
{
const streamsize __buf_len = this->epptr() - this->pptr();
if (__buf_len)
{
const streamsize __remaining = __n - __ret;
const streamsize __len = std::min(__buf_len, __remaining);
traits_type::copy(this->pptr(), __s, __len);
__ret += __len;
__s += __len;
this->__safe_pbump(__len);
}
if (__ret < __n)
{
int_type __c = this->overflow(traits_type::to_int_type(*__s));
if (!traits_type::eq_int_type(__c, traits_type::eof()))
{
++__ret;
++__s;
}
else
break;
}
}
return __ret;
}
template<typename _CharT, typename _Traits>
streamsize
__copy_streambufs_eof(basic_streambuf<_CharT, _Traits>* __sbin,
basic_streambuf<_CharT, _Traits>* __sbout,
bool& __ineof)
{
streamsize __ret = 0;
__ineof = true;
typename _Traits::int_type __c = __sbin->sgetc();
while (!_Traits::eq_int_type(__c, _Traits::eof()))
{
__c = __sbout->sputc(_Traits::to_char_type(__c));
if (_Traits::eq_int_type(__c, _Traits::eof()))
{
__ineof = false;
break;
}
++__ret;
__c = __sbin->snextc();
}
return __ret;
}
template<typename _CharT, typename _Traits>
inline streamsize
__copy_streambufs(basic_streambuf<_CharT, _Traits>* __sbin,
basic_streambuf<_CharT, _Traits>* __sbout)
{
bool __ineof;
return __copy_streambufs_eof(__sbin, __sbout, __ineof);
}
extern template class basic_streambuf<char>;
extern template
streamsize
__copy_streambufs(basic_streambuf<char>*,
basic_streambuf<char>*);
extern template
streamsize
__copy_streambufs_eof(basic_streambuf<char>*,
basic_streambuf<char>*, bool&);
extern template class basic_streambuf<wchar_t>;
extern template
streamsize
__copy_streambufs(basic_streambuf<wchar_t>*,
basic_streambuf<wchar_t>*);
extern template
streamsize
__copy_streambufs_eof(basic_streambuf<wchar_t>*,
basic_streambuf<wchar_t>*, bool&);
}
# 851 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 2 3
# 44 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ios" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_ios.h" 1 3
# 33 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_ios.h" 3
# 34 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_ios.h" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 1 3
# 37 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
# 38 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cwctype" 1 3
# 39 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cwctype" 3
# 40 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cwctype" 3
# 50 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cwctype" 3
# 1 "/usr/include/wctype.h" 1 3 4
# 33 "/usr/include/wctype.h" 3 4
# 1 "/usr/include/wchar.h" 1 3 4
# 34 "/usr/include/wctype.h" 2 3 4
# 49 "/usr/include/wctype.h" 3 4
typedef unsigned long int wctype_t;
# 71 "/usr/include/wctype.h" 3 4
enum
{
__ISwupper = 0,
__ISwlower = 1,
__ISwalpha = 2,
__ISwdigit = 3,
__ISwxdigit = 4,
__ISwspace = 5,
__ISwprint = 6,
__ISwgraph = 7,
__ISwblank = 8,
__ISwcntrl = 9,
__ISwpunct = 10,
__ISwalnum = 11,
_ISwupper = ((__ISwupper) < 8 ? (int) ((1UL << (__ISwupper)) << 24) : ((__ISwupper) < 16 ? (int) ((1UL << (__ISwupper)) << 8) : ((__ISwupper) < 24 ? (int) ((1UL << (__ISwupper)) >> 8) : (int) ((1UL << (__ISwupper)) >> 24)))),
_ISwlower = ((__ISwlower) < 8 ? (int) ((1UL << (__ISwlower)) << 24) : ((__ISwlower) < 16 ? (int) ((1UL << (__ISwlower)) << 8) : ((__ISwlower) < 24 ? (int) ((1UL << (__ISwlower)) >> 8) : (int) ((1UL << (__ISwlower)) >> 24)))),
_ISwalpha = ((__ISwalpha) < 8 ? (int) ((1UL << (__ISwalpha)) << 24) : ((__ISwalpha) < 16 ? (int) ((1UL << (__ISwalpha)) << 8) : ((__ISwalpha) < 24 ? (int) ((1UL << (__ISwalpha)) >> 8) : (int) ((1UL << (__ISwalpha)) >> 24)))),
_ISwdigit = ((__ISwdigit) < 8 ? (int) ((1UL << (__ISwdigit)) << 24) : ((__ISwdigit) < 16 ? (int) ((1UL << (__ISwdigit)) << 8) : ((__ISwdigit) < 24 ? (int) ((1UL << (__ISwdigit)) >> 8) : (int) ((1UL << (__ISwdigit)) >> 24)))),
_ISwxdigit = ((__ISwxdigit) < 8 ? (int) ((1UL << (__ISwxdigit)) << 24) : ((__ISwxdigit) < 16 ? (int) ((1UL << (__ISwxdigit)) << 8) : ((__ISwxdigit) < 24 ? (int) ((1UL << (__ISwxdigit)) >> 8) : (int) ((1UL << (__ISwxdigit)) >> 24)))),
_ISwspace = ((__ISwspace) < 8 ? (int) ((1UL << (__ISwspace)) << 24) : ((__ISwspace) < 16 ? (int) ((1UL << (__ISwspace)) << 8) : ((__ISwspace) < 24 ? (int) ((1UL << (__ISwspace)) >> 8) : (int) ((1UL << (__ISwspace)) >> 24)))),
_ISwprint = ((__ISwprint) < 8 ? (int) ((1UL << (__ISwprint)) << 24) : ((__ISwprint) < 16 ? (int) ((1UL << (__ISwprint)) << 8) : ((__ISwprint) < 24 ? (int) ((1UL << (__ISwprint)) >> 8) : (int) ((1UL << (__ISwprint)) >> 24)))),
_ISwgraph = ((__ISwgraph) < 8 ? (int) ((1UL << (__ISwgraph)) << 24) : ((__ISwgraph) < 16 ? (int) ((1UL << (__ISwgraph)) << 8) : ((__ISwgraph) < 24 ? (int) ((1UL << (__ISwgraph)) >> 8) : (int) ((1UL << (__ISwgraph)) >> 24)))),
_ISwblank = ((__ISwblank) < 8 ? (int) ((1UL << (__ISwblank)) << 24) : ((__ISwblank) < 16 ? (int) ((1UL << (__ISwblank)) << 8) : ((__ISwblank) < 24 ? (int) ((1UL << (__ISwblank)) >> 8) : (int) ((1UL << (__ISwblank)) >> 24)))),
_ISwcntrl = ((__ISwcntrl) < 8 ? (int) ((1UL << (__ISwcntrl)) << 24) : ((__ISwcntrl) < 16 ? (int) ((1UL << (__ISwcntrl)) << 8) : ((__ISwcntrl) < 24 ? (int) ((1UL << (__ISwcntrl)) >> 8) : (int) ((1UL << (__ISwcntrl)) >> 24)))),
_ISwpunct = ((__ISwpunct) < 8 ? (int) ((1UL << (__ISwpunct)) << 24) : ((__ISwpunct) < 16 ? (int) ((1UL << (__ISwpunct)) << 8) : ((__ISwpunct) < 24 ? (int) ((1UL << (__ISwpunct)) >> 8) : (int) ((1UL << (__ISwpunct)) >> 24)))),
_ISwalnum = ((__ISwalnum) < 8 ? (int) ((1UL << (__ISwalnum)) << 24) : ((__ISwalnum) < 16 ? (int) ((1UL << (__ISwalnum)) << 8) : ((__ISwalnum) < 24 ? (int) ((1UL << (__ISwalnum)) >> 8) : (int) ((1UL << (__ISwalnum)) >> 24))))
};
extern "C" {
extern int iswalnum (wint_t __wc) throw ();
extern int iswalpha (wint_t __wc) throw ();
extern int iswcntrl (wint_t __wc) throw ();
extern int iswdigit (wint_t __wc) throw ();
extern int iswgraph (wint_t __wc) throw ();
extern int iswlower (wint_t __wc) throw ();
extern int iswprint (wint_t __wc) throw ();
extern int iswpunct (wint_t __wc) throw ();
extern int iswspace (wint_t __wc) throw ();
extern int iswupper (wint_t __wc) throw ();
extern int iswxdigit (wint_t __wc) throw ();
extern int iswblank (wint_t __wc) throw ();
# 171 "/usr/include/wctype.h" 3 4
extern wctype_t wctype (const char *__property) throw ();
extern int iswctype (wint_t __wc, wctype_t __desc) throw ();
typedef const __int32_t *wctrans_t;
extern wint_t towlower (wint_t __wc) throw ();
extern wint_t towupper (wint_t __wc) throw ();
}
# 213 "/usr/include/wctype.h" 3 4
extern "C" {
extern wctrans_t wctrans (const char *__property) throw ();
extern wint_t towctrans (wint_t __wc, wctrans_t __desc) throw ();
extern int iswalnum_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswalpha_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswcntrl_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswdigit_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswgraph_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswlower_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswprint_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswpunct_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswspace_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswupper_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswxdigit_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswblank_l (wint_t __wc, __locale_t __locale) throw ();
extern wctype_t wctype_l (const char *__property, __locale_t __locale)
throw ();
extern int iswctype_l (wint_t __wc, wctype_t __desc, __locale_t __locale)
throw ();
extern wint_t towlower_l (wint_t __wc, __locale_t __locale) throw ();
extern wint_t towupper_l (wint_t __wc, __locale_t __locale) throw ();
extern wctrans_t wctrans_l (const char *__property, __locale_t __locale)
throw ();
extern wint_t towctrans_l (wint_t __wc, wctrans_t __desc,
__locale_t __locale) throw ();
}
# 51 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cwctype" 2 3
# 80 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cwctype" 3
namespace std
{
using ::wctrans_t;
using ::wctype_t;
using ::wint_t;
using ::iswalnum;
using ::iswalpha;
using ::iswblank;
using ::iswcntrl;
using ::iswctype;
using ::iswdigit;
using ::iswgraph;
using ::iswlower;
using ::iswprint;
using ::iswpunct;
using ::iswspace;
using ::iswupper;
using ::iswxdigit;
using ::towctrans;
using ::towlower;
using ::towupper;
using ::wctrans;
using ::wctype;
}
# 40 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cctype" 1 3
# 39 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cctype" 3
# 40 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cctype" 3
# 41 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/ctype_base.h" 1 3
# 36 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/ctype_base.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
struct ctype_base
{
typedef const int* __to_type;
typedef unsigned short mask;
static const mask upper = _ISupper;
static const mask lower = _ISlower;
static const mask alpha = _ISalpha;
static const mask digit = _ISdigit;
static const mask xdigit = _ISxdigit;
static const mask space = _ISspace;
static const mask print = _ISprint;
static const mask graph = _ISalpha | _ISdigit | _ISpunct;
static const mask cntrl = _IScntrl;
static const mask punct = _ISpunct;
static const mask alnum = _ISalpha | _ISdigit;
static const mask blank = _ISblank;
};
}
# 42 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/streambuf_iterator.h" 1 3
# 33 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/streambuf_iterator.h" 3
# 34 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/streambuf_iterator.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 49 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/streambuf_iterator.h" 3
template<typename _CharT, typename _Traits>
class istreambuf_iterator
: public iterator<input_iterator_tag, _CharT, typename _Traits::off_type,
_CharT*,
_CharT>
{
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef typename _Traits::int_type int_type;
typedef basic_streambuf<_CharT, _Traits> streambuf_type;
typedef basic_istream<_CharT, _Traits> istream_type;
template<typename _CharT2>
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
ostreambuf_iterator<_CharT2> >::__type
copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
ostreambuf_iterator<_CharT2>);
template<bool _IsMove, typename _CharT2>
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
_CharT2*>::__type
__copy_move_a2(istreambuf_iterator<_CharT2>,
istreambuf_iterator<_CharT2>, _CharT2*);
template<typename _CharT2>
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
istreambuf_iterator<_CharT2> >::__type
find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
const _CharT2&);
private:
mutable streambuf_type* _M_sbuf;
mutable int_type _M_c;
public:
constexpr istreambuf_iterator() noexcept
: _M_sbuf(0), _M_c(traits_type::eof()) { }
istreambuf_iterator(const istreambuf_iterator&) noexcept = default;
~istreambuf_iterator() = default;
istreambuf_iterator(istream_type& __s) noexcept
: _M_sbuf(__s.rdbuf()), _M_c(traits_type::eof()) { }
istreambuf_iterator(streambuf_type* __s) noexcept
: _M_sbuf(__s), _M_c(traits_type::eof()) { }
char_type
operator*() const
{
return traits_type::to_char_type(_M_get());
}
istreambuf_iterator&
operator++()
{
;
if (_M_sbuf)
{
_M_sbuf->sbumpc();
_M_c = traits_type::eof();
}
return *this;
}
istreambuf_iterator
operator++(int)
{
;
istreambuf_iterator __old = *this;
if (_M_sbuf)
{
__old._M_c = _M_sbuf->sbumpc();
_M_c = traits_type::eof();
}
return __old;
}
bool
equal(const istreambuf_iterator& __b) const
{ return _M_at_eof() == __b._M_at_eof(); }
private:
int_type
_M_get() const
{
const int_type __eof = traits_type::eof();
int_type __ret = __eof;
if (_M_sbuf)
{
if (!traits_type::eq_int_type(_M_c, __eof))
__ret = _M_c;
else if (!traits_type::eq_int_type((__ret = _M_sbuf->sgetc()),
__eof))
_M_c = __ret;
else
_M_sbuf = 0;
}
return __ret;
}
bool
_M_at_eof() const
{
const int_type __eof = traits_type::eof();
return traits_type::eq_int_type(_M_get(), __eof);
}
};
template<typename _CharT, typename _Traits>
inline bool
operator==(const istreambuf_iterator<_CharT, _Traits>& __a,
const istreambuf_iterator<_CharT, _Traits>& __b)
{ return __a.equal(__b); }
template<typename _CharT, typename _Traits>
inline bool
operator!=(const istreambuf_iterator<_CharT, _Traits>& __a,
const istreambuf_iterator<_CharT, _Traits>& __b)
{ return !__a.equal(__b); }
template<typename _CharT, typename _Traits>
class ostreambuf_iterator
: public iterator<output_iterator_tag, void, void, void, void>
{
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef basic_streambuf<_CharT, _Traits> streambuf_type;
typedef basic_ostream<_CharT, _Traits> ostream_type;
template<typename _CharT2>
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
ostreambuf_iterator<_CharT2> >::__type
copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
ostreambuf_iterator<_CharT2>);
private:
streambuf_type* _M_sbuf;
bool _M_failed;
public:
ostreambuf_iterator(ostream_type& __s) noexcept
: _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { }
ostreambuf_iterator(streambuf_type* __s) noexcept
: _M_sbuf(__s), _M_failed(!_M_sbuf) { }
ostreambuf_iterator&
operator=(_CharT __c)
{
if (!_M_failed &&
_Traits::eq_int_type(_M_sbuf->sputc(__c), _Traits::eof()))
_M_failed = true;
return *this;
}
ostreambuf_iterator&
operator*()
{ return *this; }
ostreambuf_iterator&
operator++(int)
{ return *this; }
ostreambuf_iterator&
operator++()
{ return *this; }
bool
failed() const noexcept
{ return _M_failed; }
ostreambuf_iterator&
_M_put(const _CharT* __ws, streamsize __len)
{
if (__builtin_expect(!_M_failed, true)
&& __builtin_expect(this->_M_sbuf->sputn(__ws, __len) != __len,
false))
_M_failed = true;
return *this;
}
};
template<typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
ostreambuf_iterator<_CharT> >::__type
copy(istreambuf_iterator<_CharT> __first,
istreambuf_iterator<_CharT> __last,
ostreambuf_iterator<_CharT> __result)
{
if (__first._M_sbuf && !__last._M_sbuf && !__result._M_failed)
{
bool __ineof;
__copy_streambufs_eof(__first._M_sbuf, __result._M_sbuf, __ineof);
if (!__ineof)
__result._M_failed = true;
}
return __result;
}
template<bool _IsMove, typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
ostreambuf_iterator<_CharT> >::__type
__copy_move_a2(_CharT* __first, _CharT* __last,
ostreambuf_iterator<_CharT> __result)
{
const streamsize __num = __last - __first;
if (__num > 0)
__result._M_put(__first, __num);
return __result;
}
template<bool _IsMove, typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
ostreambuf_iterator<_CharT> >::__type
__copy_move_a2(const _CharT* __first, const _CharT* __last,
ostreambuf_iterator<_CharT> __result)
{
const streamsize __num = __last - __first;
if (__num > 0)
__result._M_put(__first, __num);
return __result;
}
template<bool _IsMove, typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
_CharT*>::__type
__copy_move_a2(istreambuf_iterator<_CharT> __first,
istreambuf_iterator<_CharT> __last, _CharT* __result)
{
typedef istreambuf_iterator<_CharT> __is_iterator_type;
typedef typename __is_iterator_type::traits_type traits_type;
typedef typename __is_iterator_type::streambuf_type streambuf_type;
typedef typename traits_type::int_type int_type;
if (__first._M_sbuf && !__last._M_sbuf)
{
streambuf_type* __sb = __first._M_sbuf;
int_type __c = __sb->sgetc();
while (!traits_type::eq_int_type(__c, traits_type::eof()))
{
const streamsize __n = __sb->egptr() - __sb->gptr();
if (__n > 1)
{
traits_type::copy(__result, __sb->gptr(), __n);
__sb->__safe_gbump(__n);
__result += __n;
__c = __sb->underflow();
}
else
{
*__result++ = traits_type::to_char_type(__c);
__c = __sb->snextc();
}
}
}
return __result;
}
template<typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
istreambuf_iterator<_CharT> >::__type
find(istreambuf_iterator<_CharT> __first,
istreambuf_iterator<_CharT> __last, const _CharT& __val)
{
typedef istreambuf_iterator<_CharT> __is_iterator_type;
typedef typename __is_iterator_type::traits_type traits_type;
typedef typename __is_iterator_type::streambuf_type streambuf_type;
typedef typename traits_type::int_type int_type;
if (__first._M_sbuf && !__last._M_sbuf)
{
const int_type __ival = traits_type::to_int_type(__val);
streambuf_type* __sb = __first._M_sbuf;
int_type __c = __sb->sgetc();
while (!traits_type::eq_int_type(__c, traits_type::eof())
&& !traits_type::eq_int_type(__c, __ival))
{
streamsize __n = __sb->egptr() - __sb->gptr();
if (__n > 1)
{
const _CharT* __p = traits_type::find(__sb->gptr(),
__n, __val);
if (__p)
__n = __p - __sb->gptr();
__sb->__safe_gbump(__n);
__c = __sb->sgetc();
}
else
__c = __sb->snextc();
}
if (!traits_type::eq_int_type(__c, traits_type::eof()))
__first._M_c = __c;
else
__first._M_sbuf = 0;
}
return __first;
}
}
# 49 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 71 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
template<typename _Tp>
void
__convert_to_v(const char*, _Tp&, ios_base::iostate&,
const __c_locale&) throw();
template<>
void
__convert_to_v(const char*, float&, ios_base::iostate&,
const __c_locale&) throw();
template<>
void
__convert_to_v(const char*, double&, ios_base::iostate&,
const __c_locale&) throw();
template<>
void
__convert_to_v(const char*, long double&, ios_base::iostate&,
const __c_locale&) throw();
template<typename _CharT, typename _Traits>
struct __pad
{
static void
_S_pad(ios_base& __io, _CharT __fill, _CharT* __news,
const _CharT* __olds, streamsize __newlen, streamsize __oldlen);
};
template<typename _CharT>
_CharT*
__add_grouping(_CharT* __s, _CharT __sep,
const char* __gbeg, size_t __gsize,
const _CharT* __first, const _CharT* __last);
template<typename _CharT>
inline
ostreambuf_iterator<_CharT>
__write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len)
{
__s._M_put(__ws, __len);
return __s;
}
template<typename _CharT, typename _OutIter>
inline
_OutIter
__write(_OutIter __s, const _CharT* __ws, int __len)
{
for (int __j = 0; __j < __len; __j++, ++__s)
*__s = __ws[__j];
return __s;
}
# 149 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
template<typename _CharT>
class __ctype_abstract_base : public locale::facet, public ctype_base
{
public:
typedef _CharT char_type;
# 168 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
bool
is(mask __m, char_type __c) const
{ return this->do_is(__m, __c); }
# 185 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
const char_type*
is(const char_type *__lo, const char_type *__hi, mask *__vec) const
{ return this->do_is(__lo, __hi, __vec); }
# 201 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
const char_type*
scan_is(mask __m, const char_type* __lo, const char_type* __hi) const
{ return this->do_scan_is(__m, __lo, __hi); }
# 217 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
const char_type*
scan_not(mask __m, const char_type* __lo, const char_type* __hi) const
{ return this->do_scan_not(__m, __lo, __hi); }
# 231 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
char_type
toupper(char_type __c) const
{ return this->do_toupper(__c); }
# 246 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
const char_type*
toupper(char_type *__lo, const char_type* __hi) const
{ return this->do_toupper(__lo, __hi); }
# 260 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
char_type
tolower(char_type __c) const
{ return this->do_tolower(__c); }
# 275 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
const char_type*
tolower(char_type* __lo, const char_type* __hi) const
{ return this->do_tolower(__lo, __hi); }
# 292 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
char_type
widen(char __c) const
{ return this->do_widen(__c); }
# 311 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
const char*
widen(const char* __lo, const char* __hi, char_type* __to) const
{ return this->do_widen(__lo, __hi, __to); }
# 330 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
char
narrow(char_type __c, char __dfault) const
{ return this->do_narrow(__c, __dfault); }
# 352 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
const char_type*
narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char* __to) const
{ return this->do_narrow(__lo, __hi, __dfault, __to); }
protected:
explicit
__ctype_abstract_base(size_t __refs = 0): facet(__refs) { }
virtual
~__ctype_abstract_base() { }
# 377 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
virtual bool
do_is(mask __m, char_type __c) const = 0;
# 396 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
virtual const char_type*
do_is(const char_type* __lo, const char_type* __hi,
mask* __vec) const = 0;
# 415 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
virtual const char_type*
do_scan_is(mask __m, const char_type* __lo,
const char_type* __hi) const = 0;
# 434 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
virtual const char_type*
do_scan_not(mask __m, const char_type* __lo,
const char_type* __hi) const = 0;
# 452 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
virtual char_type
do_toupper(char_type __c) const = 0;
# 469 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
virtual const char_type*
do_toupper(char_type* __lo, const char_type* __hi) const = 0;
# 485 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
virtual char_type
do_tolower(char_type __c) const = 0;
# 502 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
virtual const char_type*
do_tolower(char_type* __lo, const char_type* __hi) const = 0;
# 521 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
virtual char_type
do_widen(char __c) const = 0;
# 542 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
virtual const char*
do_widen(const char* __lo, const char* __hi, char_type* __to) const = 0;
# 563 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
virtual char
do_narrow(char_type __c, char __dfault) const = 0;
# 588 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
virtual const char_type*
do_narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char* __to) const = 0;
};
# 611 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
template<typename _CharT>
class ctype : public __ctype_abstract_base<_CharT>
{
public:
typedef _CharT char_type;
typedef typename __ctype_abstract_base<_CharT>::mask mask;
static locale::id id;
explicit
ctype(size_t __refs = 0) : __ctype_abstract_base<_CharT>(__refs) { }
protected:
virtual
~ctype();
virtual bool
do_is(mask __m, char_type __c) const;
virtual const char_type*
do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
virtual const char_type*
do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
virtual const char_type*
do_scan_not(mask __m, const char_type* __lo,
const char_type* __hi) const;
virtual char_type
do_toupper(char_type __c) const;
virtual const char_type*
do_toupper(char_type* __lo, const char_type* __hi) const;
virtual char_type
do_tolower(char_type __c) const;
virtual const char_type*
do_tolower(char_type* __lo, const char_type* __hi) const;
virtual char_type
do_widen(char __c) const;
virtual const char*
do_widen(const char* __lo, const char* __hi, char_type* __dest) const;
virtual char
do_narrow(char_type, char __dfault) const;
virtual const char_type*
do_narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char* __to) const;
};
template<typename _CharT>
locale::id ctype<_CharT>::id;
# 680 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
template<>
class ctype<char> : public locale::facet, public ctype_base
{
public:
typedef char char_type;
protected:
__c_locale _M_c_locale_ctype;
bool _M_del;
__to_type _M_toupper;
__to_type _M_tolower;
const mask* _M_table;
mutable char _M_widen_ok;
mutable char _M_widen[1 + static_cast<unsigned char>(-1)];
mutable char _M_narrow[1 + static_cast<unsigned char>(-1)];
mutable char _M_narrow_ok;
public:
static locale::id id;
static const size_t table_size = 1 + static_cast<unsigned char>(-1);
# 717 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
explicit
ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0);
# 730 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
explicit
ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false,
size_t __refs = 0);
# 743 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
inline bool
is(mask __m, char __c) const;
# 758 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
inline const char*
is(const char* __lo, const char* __hi, mask* __vec) const;
# 772 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
inline const char*
scan_is(mask __m, const char* __lo, const char* __hi) const;
# 786 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
inline const char*
scan_not(mask __m, const char* __lo, const char* __hi) const;
# 801 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
char_type
toupper(char_type __c) const
{ return this->do_toupper(__c); }
# 818 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
const char_type*
toupper(char_type *__lo, const char_type* __hi) const
{ return this->do_toupper(__lo, __hi); }
# 834 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
char_type
tolower(char_type __c) const
{ return this->do_tolower(__c); }
# 851 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
const char_type*
tolower(char_type* __lo, const char_type* __hi) const
{ return this->do_tolower(__lo, __hi); }
# 871 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
char_type
widen(char __c) const
{
if (_M_widen_ok)
return _M_widen[static_cast<unsigned char>(__c)];
this->_M_widen_init();
return this->do_widen(__c);
}
# 898 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
const char*
widen(const char* __lo, const char* __hi, char_type* __to) const
{
if (_M_widen_ok == 1)
{
__builtin_memcpy(__to, __lo, __hi - __lo);
return __hi;
}
if (!_M_widen_ok)
_M_widen_init();
return this->do_widen(__lo, __hi, __to);
}
# 929 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
char
narrow(char_type __c, char __dfault) const
{
if (_M_narrow[static_cast<unsigned char>(__c)])
return _M_narrow[static_cast<unsigned char>(__c)];
const char __t = do_narrow(__c, __dfault);
if (__t != __dfault)
_M_narrow[static_cast<unsigned char>(__c)] = __t;
return __t;
}
# 962 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
const char_type*
narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char* __to) const
{
if (__builtin_expect(_M_narrow_ok == 1, true))
{
__builtin_memcpy(__to, __lo, __hi - __lo);
return __hi;
}
if (!_M_narrow_ok)
_M_narrow_init();
return this->do_narrow(__lo, __hi, __dfault, __to);
}
const mask*
table() const throw()
{ return _M_table; }
static const mask*
classic_table() throw();
protected:
virtual
~ctype();
# 1011 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
virtual char_type
do_toupper(char_type __c) const;
# 1028 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
virtual const char_type*
do_toupper(char_type* __lo, const char_type* __hi) const;
# 1044 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
virtual char_type
do_tolower(char_type __c) const;
# 1061 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
virtual const char_type*
do_tolower(char_type* __lo, const char_type* __hi) const;
# 1081 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
virtual char_type
do_widen(char __c) const
{ return __c; }
# 1104 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
virtual const char*
do_widen(const char* __lo, const char* __hi, char_type* __to) const
{
__builtin_memcpy(__to, __lo, __hi - __lo);
return __hi;
}
# 1130 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
virtual char
do_narrow(char_type __c, char __dfault) const
{ return __c; }
# 1156 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
virtual const char_type*
do_narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char* __to) const
{
__builtin_memcpy(__to, __lo, __hi - __lo);
return __hi;
}
private:
void _M_narrow_init() const;
void _M_widen_init() const;
};
# 1181 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
template<>
class ctype<wchar_t> : public __ctype_abstract_base<wchar_t>
{
public:
typedef wchar_t char_type;
typedef wctype_t __wmask_type;
protected:
__c_locale _M_c_locale_ctype;
bool _M_narrow_ok;
char _M_narrow[128];
wint_t _M_widen[1 + static_cast<unsigned char>(-1)];
mask _M_bit[16];
__wmask_type _M_wmask[16];
public:
static locale::id id;
# 1214 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
explicit
ctype(size_t __refs = 0);
# 1225 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
explicit
ctype(__c_locale __cloc, size_t __refs = 0);
protected:
__wmask_type
_M_convert_to_wmask(const mask __m) const throw();
virtual
~ctype();
# 1249 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
virtual bool
do_is(mask __m, char_type __c) const;
# 1268 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
virtual const char_type*
do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
# 1286 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
virtual const char_type*
do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
# 1304 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
virtual const char_type*
do_scan_not(mask __m, const char_type* __lo,
const char_type* __hi) const;
# 1321 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
virtual char_type
do_toupper(char_type __c) const;
# 1338 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
virtual const char_type*
do_toupper(char_type* __lo, const char_type* __hi) const;
# 1354 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
virtual char_type
do_tolower(char_type __c) const;
# 1371 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
virtual const char_type*
do_tolower(char_type* __lo, const char_type* __hi) const;
# 1391 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
virtual char_type
do_widen(char __c) const;
# 1413 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
virtual const char*
do_widen(const char* __lo, const char* __hi, char_type* __to) const;
# 1436 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
virtual char
do_narrow(char_type __c, char __dfault) const;
# 1462 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
virtual const char_type*
do_narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char* __to) const;
void
_M_initialize_ctype() throw();
};
template<typename _CharT>
class ctype_byname : public ctype<_CharT>
{
public:
typedef typename ctype<_CharT>::mask mask;
explicit
ctype_byname(const char* __s, size_t __refs = 0);
explicit
ctype_byname(const string& __s, size_t __refs = 0)
: ctype_byname(__s.c_str(), __refs) { }
protected:
virtual
~ctype_byname() { };
};
template<>
class ctype_byname<char> : public ctype<char>
{
public:
explicit
ctype_byname(const char* __s, size_t __refs = 0);
explicit
ctype_byname(const string& __s, size_t __refs = 0);
protected:
virtual
~ctype_byname();
};
template<>
class ctype_byname<wchar_t> : public ctype<wchar_t>
{
public:
explicit
ctype_byname(const char* __s, size_t __refs = 0);
explicit
ctype_byname(const string& __s, size_t __refs = 0);
protected:
virtual
~ctype_byname();
};
}
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/ctype_inline.h" 1 3
# 37 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/ctype_inline.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
bool
ctype<char>::
is(mask __m, char __c) const
{ return _M_table[static_cast<unsigned char>(__c)] & __m; }
const char*
ctype<char>::
is(const char* __low, const char* __high, mask* __vec) const
{
while (__low < __high)
*__vec++ = _M_table[static_cast<unsigned char>(*__low++)];
return __high;
}
const char*
ctype<char>::
scan_is(mask __m, const char* __low, const char* __high) const
{
while (__low < __high
&& !(_M_table[static_cast<unsigned char>(*__low)] & __m))
++__low;
return __low;
}
const char*
ctype<char>::
scan_not(mask __m, const char* __low, const char* __high) const
{
while (__low < __high
&& (_M_table[static_cast<unsigned char>(*__low)] & __m) != 0)
++__low;
return __low;
}
}
# 1535 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
class __num_base
{
public:
enum
{
_S_ominus,
_S_oplus,
_S_ox,
_S_oX,
_S_odigits,
_S_odigits_end = _S_odigits + 16,
_S_oudigits = _S_odigits_end,
_S_oudigits_end = _S_oudigits + 16,
_S_oe = _S_odigits + 14,
_S_oE = _S_oudigits + 14,
_S_oend = _S_oudigits_end
};
static const char* _S_atoms_out;
static const char* _S_atoms_in;
enum
{
_S_iminus,
_S_iplus,
_S_ix,
_S_iX,
_S_izero,
_S_ie = _S_izero + 14,
_S_iE = _S_izero + 20,
_S_iend = 26
};
static void
_S_format_float(const ios_base& __io, char* __fptr, char __mod) throw();
};
template<typename _CharT>
struct __numpunct_cache : public locale::facet
{
const char* _M_grouping;
size_t _M_grouping_size;
bool _M_use_grouping;
const _CharT* _M_truename;
size_t _M_truename_size;
const _CharT* _M_falsename;
size_t _M_falsename_size;
_CharT _M_decimal_point;
_CharT _M_thousands_sep;
_CharT _M_atoms_out[__num_base::_S_oend];
_CharT _M_atoms_in[__num_base::_S_iend];
bool _M_allocated;
__numpunct_cache(size_t __refs = 0)
: facet(__refs), _M_grouping(0), _M_grouping_size(0),
_M_use_grouping(false),
_M_truename(0), _M_truename_size(0), _M_falsename(0),
_M_falsename_size(0), _M_decimal_point(_CharT()),
_M_thousands_sep(_CharT()), _M_allocated(false)
{ }
~__numpunct_cache();
void
_M_cache(const locale& __loc);
private:
__numpunct_cache&
operator=(const __numpunct_cache&);
explicit
__numpunct_cache(const __numpunct_cache&);
};
template<typename _CharT>
__numpunct_cache<_CharT>::~__numpunct_cache()
{
if (_M_allocated)
{
delete [] _M_grouping;
delete [] _M_truename;
delete [] _M_falsename;
}
}
namespace __cxx11 {
# 1665 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
template<typename _CharT>
class numpunct : public locale::facet
{
public:
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;
typedef __numpunct_cache<_CharT> __cache_type;
protected:
__cache_type* _M_data;
public:
static locale::id id;
explicit
numpunct(size_t __refs = 0)
: facet(__refs), _M_data(0)
{ _M_initialize_numpunct(); }
# 1703 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
explicit
numpunct(__cache_type* __cache, size_t __refs = 0)
: facet(__refs), _M_data(__cache)
{ _M_initialize_numpunct(); }
# 1717 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
explicit
numpunct(__c_locale __cloc, size_t __refs = 0)
: facet(__refs), _M_data(0)
{ _M_initialize_numpunct(__cloc); }
# 1731 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
char_type
decimal_point() const
{ return this->do_decimal_point(); }
# 1744 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
char_type
thousands_sep() const
{ return this->do_thousands_sep(); }
# 1775 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
string
grouping() const
{ return this->do_grouping(); }
# 1788 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
string_type
truename() const
{ return this->do_truename(); }
# 1801 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
string_type
falsename() const
{ return this->do_falsename(); }
protected:
virtual
~numpunct();
# 1818 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
virtual char_type
do_decimal_point() const
{ return _M_data->_M_decimal_point; }
# 1830 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
virtual char_type
do_thousands_sep() const
{ return _M_data->_M_thousands_sep; }
# 1843 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
virtual string
do_grouping() const
{ return _M_data->_M_grouping; }
# 1856 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
virtual string_type
do_truename() const
{ return _M_data->_M_truename; }
# 1869 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
virtual string_type
do_falsename() const
{ return _M_data->_M_falsename; }
void
_M_initialize_numpunct(__c_locale __cloc = 0);
};
template<typename _CharT>
locale::id numpunct<_CharT>::id;
template<>
numpunct<char>::~numpunct();
template<>
void
numpunct<char>::_M_initialize_numpunct(__c_locale __cloc);
template<>
numpunct<wchar_t>::~numpunct();
template<>
void
numpunct<wchar_t>::_M_initialize_numpunct(__c_locale __cloc);
template<typename _CharT>
class numpunct_byname : public numpunct<_CharT>
{
public:
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;
explicit
numpunct_byname(const char* __s, size_t __refs = 0)
: numpunct<_CharT>(__refs)
{
if (__builtin_strcmp(__s, "C") != 0
&& __builtin_strcmp(__s, "POSIX") != 0)
{
__c_locale __tmp;
this->_S_create_c_locale(__tmp, __s);
this->_M_initialize_numpunct(__tmp);
this->_S_destroy_c_locale(__tmp);
}
}
explicit
numpunct_byname(const string& __s, size_t __refs = 0)
: numpunct_byname(__s.c_str(), __refs) { }
protected:
virtual
~numpunct_byname() { }
};
}
# 1947 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
template<typename _CharT, typename _InIter>
class num_get : public locale::facet
{
public:
typedef _CharT char_type;
typedef _InIter iter_type;
static locale::id id;
# 1968 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
explicit
num_get(size_t __refs = 0) : facet(__refs) { }
# 1994 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, bool& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }
# 2031 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned short& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned int& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned long& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long long& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned long long& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }
# 2091 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, float& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, double& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long double& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }
# 2134 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, void*& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }
protected:
virtual ~num_get() { }
__attribute ((__abi_tag__ ("cxx11")))
iter_type
_M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&,
string&) const;
template<typename _ValueT>
__attribute ((__abi_tag__ ("cxx11")))
iter_type
_M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&,
_ValueT&) const;
template<typename _CharT2>
typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, int>::__type
_M_find(const _CharT2*, size_t __len, _CharT2 __c) const
{
int __ret = -1;
if (__len <= 10)
{
if (__c >= _CharT2('0') && __c < _CharT2(_CharT2('0') + __len))
__ret = __c - _CharT2('0');
}
else
{
if (__c >= _CharT2('0') && __c <= _CharT2('9'))
__ret = __c - _CharT2('0');
else if (__c >= _CharT2('a') && __c <= _CharT2('f'))
__ret = 10 + (__c - _CharT2('a'));
else if (__c >= _CharT2('A') && __c <= _CharT2('F'))
__ret = 10 + (__c - _CharT2('A'));
}
return __ret;
}
template<typename _CharT2>
typename __gnu_cxx::__enable_if<!__is_char<_CharT2>::__value,
int>::__type
_M_find(const _CharT2* __zero, size_t __len, _CharT2 __c) const
{
int __ret = -1;
const char_type* __q = char_traits<_CharT2>::find(__zero, __len, __c);
if (__q)
{
__ret = __q - __zero;
if (__ret > 15)
__ret -= 6;
}
return __ret;
}
# 2207 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
virtual iter_type
do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const;
virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long& __v) const
{ return _M_extract_int(__beg, __end, __io, __err, __v); }
virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned short& __v) const
{ return _M_extract_int(__beg, __end, __io, __err, __v); }
virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned int& __v) const
{ return _M_extract_int(__beg, __end, __io, __err, __v); }
virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned long& __v) const
{ return _M_extract_int(__beg, __end, __io, __err, __v); }
virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long long& __v) const
{ return _M_extract_int(__beg, __end, __io, __err, __v); }
virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned long long& __v) const
{ return _M_extract_int(__beg, __end, __io, __err, __v); }
virtual iter_type
do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, float&) const;
virtual iter_type
do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
double&) const;
virtual iter_type
do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
long double&) const;
virtual iter_type
do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, void*&) const;
# 2270 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
};
template<typename _CharT, typename _InIter>
locale::id num_get<_CharT, _InIter>::id;
# 2288 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
template<typename _CharT, typename _OutIter>
class num_put : public locale::facet
{
public:
typedef _CharT char_type;
typedef _OutIter iter_type;
static locale::id id;
# 2309 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
explicit
num_put(size_t __refs = 0) : facet(__refs) { }
# 2327 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
iter_type
put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
{ return this->do_put(__s, __io, __fill, __v); }
# 2369 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
iter_type
put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
{ return this->do_put(__s, __io, __fill, __v); }
iter_type
put(iter_type __s, ios_base& __io, char_type __fill,
unsigned long __v) const
{ return this->do_put(__s, __io, __fill, __v); }
iter_type
put(iter_type __s, ios_base& __io, char_type __fill, long long __v) const
{ return this->do_put(__s, __io, __fill, __v); }
iter_type
put(iter_type __s, ios_base& __io, char_type __fill,
unsigned long long __v) const
{ return this->do_put(__s, __io, __fill, __v); }
# 2432 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
iter_type
put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
{ return this->do_put(__s, __io, __fill, __v); }
iter_type
put(iter_type __s, ios_base& __io, char_type __fill,
long double __v) const
{ return this->do_put(__s, __io, __fill, __v); }
# 2457 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
iter_type
put(iter_type __s, ios_base& __io, char_type __fill,
const void* __v) const
{ return this->do_put(__s, __io, __fill, __v); }
protected:
template<typename _ValueT>
iter_type
_M_insert_float(iter_type, ios_base& __io, char_type __fill,
char __mod, _ValueT __v) const;
void
_M_group_float(const char* __grouping, size_t __grouping_size,
char_type __sep, const char_type* __p, char_type* __new,
char_type* __cs, int& __len) const;
template<typename _ValueT>
iter_type
_M_insert_int(iter_type, ios_base& __io, char_type __fill,
_ValueT __v) const;
void
_M_group_int(const char* __grouping, size_t __grouping_size,
char_type __sep, ios_base& __io, char_type* __new,
char_type* __cs, int& __len) const;
void
_M_pad(char_type __fill, streamsize __w, ios_base& __io,
char_type* __new, const char_type* __cs, int& __len) const;
virtual
~num_put() { };
# 2505 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
virtual iter_type
do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const;
virtual iter_type
do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
{ return _M_insert_int(__s, __io, __fill, __v); }
virtual iter_type
do_put(iter_type __s, ios_base& __io, char_type __fill,
unsigned long __v) const
{ return _M_insert_int(__s, __io, __fill, __v); }
virtual iter_type
do_put(iter_type __s, ios_base& __io, char_type __fill,
long long __v) const
{ return _M_insert_int(__s, __io, __fill, __v); }
virtual iter_type
do_put(iter_type __s, ios_base& __io, char_type __fill,
unsigned long long __v) const
{ return _M_insert_int(__s, __io, __fill, __v); }
virtual iter_type
do_put(iter_type, ios_base&, char_type, double) const;
virtual iter_type
do_put(iter_type, ios_base&, char_type, long double) const;
virtual iter_type
do_put(iter_type, ios_base&, char_type, const void*) const;
};
template <typename _CharT, typename _OutIter>
locale::id num_put<_CharT, _OutIter>::id;
template<typename _CharT>
inline bool
isspace(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c); }
template<typename _CharT>
inline bool
isprint(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c); }
template<typename _CharT>
inline bool
iscntrl(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c); }
template<typename _CharT>
inline bool
isupper(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c); }
template<typename _CharT>
inline bool
islower(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c); }
template<typename _CharT>
inline bool
isalpha(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c); }
template<typename _CharT>
inline bool
isdigit(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c); }
template<typename _CharT>
inline bool
ispunct(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c); }
template<typename _CharT>
inline bool
isxdigit(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c); }
template<typename _CharT>
inline bool
isalnum(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c); }
template<typename _CharT>
inline bool
isgraph(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c); }
template<typename _CharT>
inline bool
isblank(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::blank, __c); }
template<typename _CharT>
inline _CharT
toupper(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).toupper(__c); }
template<typename _CharT>
inline _CharT
tolower(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).tolower(__c); }
}
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.tcc" 1 3
# 33 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.tcc" 3
# 34 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Facet>
struct __use_cache
{
const _Facet*
operator() (const locale& __loc) const;
};
template<typename _CharT>
struct __use_cache<__numpunct_cache<_CharT> >
{
const __numpunct_cache<_CharT>*
operator() (const locale& __loc) const
{
const size_t __i = numpunct<_CharT>::id._M_id();
const locale::facet** __caches = __loc._M_impl->_M_caches;
if (!__caches[__i])
{
__numpunct_cache<_CharT>* __tmp = 0;
try
{
__tmp = new __numpunct_cache<_CharT>;
__tmp->_M_cache(__loc);
}
catch(...)
{
delete __tmp;
throw;
}
__loc._M_impl->_M_install_cache(__tmp, __i);
}
return static_cast<const __numpunct_cache<_CharT>*>(__caches[__i]);
}
};
template<typename _CharT>
void
__numpunct_cache<_CharT>::_M_cache(const locale& __loc)
{
const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
char* __grouping = 0;
_CharT* __truename = 0;
_CharT* __falsename = 0;
try
{
const string& __g = __np.grouping();
_M_grouping_size = __g.size();
__grouping = new char[_M_grouping_size];
__g.copy(__grouping, _M_grouping_size);
_M_use_grouping = (_M_grouping_size
&& static_cast<signed char>(__grouping[0]) > 0
&& (__grouping[0]
!= __gnu_cxx::__numeric_traits<char>::__max));
const basic_string<_CharT>& __tn = __np.truename();
_M_truename_size = __tn.size();
__truename = new _CharT[_M_truename_size];
__tn.copy(__truename, _M_truename_size);
const basic_string<_CharT>& __fn = __np.falsename();
_M_falsename_size = __fn.size();
__falsename = new _CharT[_M_falsename_size];
__fn.copy(__falsename, _M_falsename_size);
_M_decimal_point = __np.decimal_point();
_M_thousands_sep = __np.thousands_sep();
const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
__ct.widen(__num_base::_S_atoms_out,
__num_base::_S_atoms_out
+ __num_base::_S_oend, _M_atoms_out);
__ct.widen(__num_base::_S_atoms_in,
__num_base::_S_atoms_in
+ __num_base::_S_iend, _M_atoms_in);
_M_grouping = __grouping;
_M_truename = __truename;
_M_falsename = __falsename;
_M_allocated = true;
}
catch(...)
{
delete [] __grouping;
delete [] __truename;
delete [] __falsename;
throw;
}
}
# 139 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.tcc" 3
__attribute__ ((__pure__)) bool
__verify_grouping(const char* __grouping, size_t __grouping_size,
const string& __grouping_tmp) throw ();
template<typename _CharT, typename _InIter>
__attribute ((__abi_tag__ ("cxx11")))
_InIter
num_get<_CharT, _InIter>::
_M_extract_float(_InIter __beg, _InIter __end, ios_base& __io,
ios_base::iostate& __err, string& __xtrc) const
{
typedef char_traits<_CharT> __traits_type;
typedef __numpunct_cache<_CharT> __cache_type;
__use_cache<__cache_type> __uc;
const locale& __loc = __io._M_getloc();
const __cache_type* __lc = __uc(__loc);
const _CharT* __lit = __lc->_M_atoms_in;
char_type __c = char_type();
bool __testeof = __beg == __end;
if (!__testeof)
{
__c = *__beg;
const bool __plus = __c == __lit[__num_base::_S_iplus];
if ((__plus || __c == __lit[__num_base::_S_iminus])
&& !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
&& !(__c == __lc->_M_decimal_point))
{
__xtrc += __plus ? '+' : '-';
if (++__beg != __end)
__c = *__beg;
else
__testeof = true;
}
}
bool __found_mantissa = false;
int __sep_pos = 0;
while (!__testeof)
{
if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
|| __c == __lc->_M_decimal_point)
break;
else if (__c == __lit[__num_base::_S_izero])
{
if (!__found_mantissa)
{
__xtrc += '0';
__found_mantissa = true;
}
++__sep_pos;
if (++__beg != __end)
__c = *__beg;
else
__testeof = true;
}
else
break;
}
bool __found_dec = false;
bool __found_sci = false;
string __found_grouping;
if (__lc->_M_use_grouping)
__found_grouping.reserve(32);
const char_type* __lit_zero = __lit + __num_base::_S_izero;
if (!__lc->_M_allocated)
while (!__testeof)
{
const int __digit = _M_find(__lit_zero, 10, __c);
if (__digit != -1)
{
__xtrc += '0' + __digit;
__found_mantissa = true;
}
else if (__c == __lc->_M_decimal_point
&& !__found_dec && !__found_sci)
{
__xtrc += '.';
__found_dec = true;
}
else if ((__c == __lit[__num_base::_S_ie]
|| __c == __lit[__num_base::_S_iE])
&& !__found_sci && __found_mantissa)
{
__xtrc += 'e';
__found_sci = true;
if (++__beg != __end)
{
__c = *__beg;
const bool __plus = __c == __lit[__num_base::_S_iplus];
if (__plus || __c == __lit[__num_base::_S_iminus])
__xtrc += __plus ? '+' : '-';
else
continue;
}
else
{
__testeof = true;
break;
}
}
else
break;
if (++__beg != __end)
__c = *__beg;
else
__testeof = true;
}
else
while (!__testeof)
{
if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
{
if (!__found_dec && !__found_sci)
{
if (__sep_pos)
{
__found_grouping += static_cast<char>(__sep_pos);
__sep_pos = 0;
}
else
{
__xtrc.clear();
break;
}
}
else
break;
}
else if (__c == __lc->_M_decimal_point)
{
if (!__found_dec && !__found_sci)
{
if (__found_grouping.size())
__found_grouping += static_cast<char>(__sep_pos);
__xtrc += '.';
__found_dec = true;
}
else
break;
}
else
{
const char_type* __q =
__traits_type::find(__lit_zero, 10, __c);
if (__q)
{
__xtrc += '0' + (__q - __lit_zero);
__found_mantissa = true;
++__sep_pos;
}
else if ((__c == __lit[__num_base::_S_ie]
|| __c == __lit[__num_base::_S_iE])
&& !__found_sci && __found_mantissa)
{
if (__found_grouping.size() && !__found_dec)
__found_grouping += static_cast<char>(__sep_pos);
__xtrc += 'e';
__found_sci = true;
if (++__beg != __end)
{
__c = *__beg;
const bool __plus = __c == __lit[__num_base::_S_iplus];
if ((__plus || __c == __lit[__num_base::_S_iminus])
&& !(__lc->_M_use_grouping
&& __c == __lc->_M_thousands_sep)
&& !(__c == __lc->_M_decimal_point))
__xtrc += __plus ? '+' : '-';
else
continue;
}
else
{
__testeof = true;
break;
}
}
else
break;
}
if (++__beg != __end)
__c = *__beg;
else
__testeof = true;
}
if (__found_grouping.size())
{
if (!__found_dec && !__found_sci)
__found_grouping += static_cast<char>(__sep_pos);
if (!std::__verify_grouping(__lc->_M_grouping,
__lc->_M_grouping_size,
__found_grouping))
__err = ios_base::failbit;
}
return __beg;
}
template<typename _CharT, typename _InIter>
template<typename _ValueT>
__attribute ((__abi_tag__ ("cxx11")))
_InIter
num_get<_CharT, _InIter>::
_M_extract_int(_InIter __beg, _InIter __end, ios_base& __io,
ios_base::iostate& __err, _ValueT& __v) const
{
typedef char_traits<_CharT> __traits_type;
using __gnu_cxx::__add_unsigned;
typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
typedef __numpunct_cache<_CharT> __cache_type;
__use_cache<__cache_type> __uc;
const locale& __loc = __io._M_getloc();
const __cache_type* __lc = __uc(__loc);
const _CharT* __lit = __lc->_M_atoms_in;
char_type __c = char_type();
const ios_base::fmtflags __basefield = __io.flags()
& ios_base::basefield;
const bool __oct = __basefield == ios_base::oct;
int __base = __oct ? 8 : (__basefield == ios_base::hex ? 16 : 10);
bool __testeof = __beg == __end;
bool __negative = false;
if (!__testeof)
{
__c = *__beg;
__negative = __c == __lit[__num_base::_S_iminus];
if ((__negative || __c == __lit[__num_base::_S_iplus])
&& !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
&& !(__c == __lc->_M_decimal_point))
{
if (++__beg != __end)
__c = *__beg;
else
__testeof = true;
}
}
bool __found_zero = false;
int __sep_pos = 0;
while (!__testeof)
{
if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
|| __c == __lc->_M_decimal_point)
break;
else if (__c == __lit[__num_base::_S_izero]
&& (!__found_zero || __base == 10))
{
__found_zero = true;
++__sep_pos;
if (__basefield == 0)
__base = 8;
if (__base == 8)
__sep_pos = 0;
}
else if (__found_zero
&& (__c == __lit[__num_base::_S_ix]
|| __c == __lit[__num_base::_S_iX]))
{
if (__basefield == 0)
__base = 16;
if (__base == 16)
{
__found_zero = false;
__sep_pos = 0;
}
else
break;
}
else
break;
if (++__beg != __end)
{
__c = *__beg;
if (!__found_zero)
break;
}
else
__testeof = true;
}
const size_t __len = (__base == 16 ? __num_base::_S_iend
- __num_base::_S_izero : __base);
string __found_grouping;
if (__lc->_M_use_grouping)
__found_grouping.reserve(32);
bool __testfail = false;
bool __testoverflow = false;
const __unsigned_type __max =
(__negative && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
? -__gnu_cxx::__numeric_traits<_ValueT>::__min
: __gnu_cxx::__numeric_traits<_ValueT>::__max;
const __unsigned_type __smax = __max / __base;
__unsigned_type __result = 0;
int __digit = 0;
const char_type* __lit_zero = __lit + __num_base::_S_izero;
if (!__lc->_M_allocated)
while (!__testeof)
{
__digit = _M_find(__lit_zero, __len, __c);
if (__digit == -1)
break;
if (__result > __smax)
__testoverflow = true;
else
{
__result *= __base;
__testoverflow |= __result > __max - __digit;
__result += __digit;
++__sep_pos;
}
if (++__beg != __end)
__c = *__beg;
else
__testeof = true;
}
else
while (!__testeof)
{
if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
{
if (__sep_pos)
{
__found_grouping += static_cast<char>(__sep_pos);
__sep_pos = 0;
}
else
{
__testfail = true;
break;
}
}
else if (__c == __lc->_M_decimal_point)
break;
else
{
const char_type* __q =
__traits_type::find(__lit_zero, __len, __c);
if (!__q)
break;
__digit = __q - __lit_zero;
if (__digit > 15)
__digit -= 6;
if (__result > __smax)
__testoverflow = true;
else
{
__result *= __base;
__testoverflow |= __result > __max - __digit;
__result += __digit;
++__sep_pos;
}
}
if (++__beg != __end)
__c = *__beg;
else
__testeof = true;
}
if (__found_grouping.size())
{
__found_grouping += static_cast<char>(__sep_pos);
if (!std::__verify_grouping(__lc->_M_grouping,
__lc->_M_grouping_size,
__found_grouping))
__err = ios_base::failbit;
}
if ((!__sep_pos && !__found_zero && !__found_grouping.size())
|| __testfail)
{
__v = 0;
__err = ios_base::failbit;
}
else if (__testoverflow)
{
if (__negative
&& __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
__v = __gnu_cxx::__numeric_traits<_ValueT>::__min;
else
__v = __gnu_cxx::__numeric_traits<_ValueT>::__max;
__err = ios_base::failbit;
}
else
__v = __negative ? -__result : __result;
if (__testeof)
__err |= ios_base::eofbit;
return __beg;
}
template<typename _CharT, typename _InIter>
_InIter
num_get<_CharT, _InIter>::
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, bool& __v) const
{
if (!(__io.flags() & ios_base::boolalpha))
{
long __l = -1;
__beg = _M_extract_int(__beg, __end, __io, __err, __l);
if (__l == 0 || __l == 1)
__v = bool(__l);
else
{
__v = true;
__err = ios_base::failbit;
if (__beg == __end)
__err |= ios_base::eofbit;
}
}
else
{
typedef __numpunct_cache<_CharT> __cache_type;
__use_cache<__cache_type> __uc;
const locale& __loc = __io._M_getloc();
const __cache_type* __lc = __uc(__loc);
bool __testf = true;
bool __testt = true;
bool __donef = __lc->_M_falsename_size == 0;
bool __donet = __lc->_M_truename_size == 0;
bool __testeof = false;
size_t __n = 0;
while (!__donef || !__donet)
{
if (__beg == __end)
{
__testeof = true;
break;
}
const char_type __c = *__beg;
if (!__donef)
__testf = __c == __lc->_M_falsename[__n];
if (!__testf && __donet)
break;
if (!__donet)
__testt = __c == __lc->_M_truename[__n];
if (!__testt && __donef)
break;
if (!__testt && !__testf)
break;
++__n;
++__beg;
__donef = !__testf || __n >= __lc->_M_falsename_size;
__donet = !__testt || __n >= __lc->_M_truename_size;
}
if (__testf && __n == __lc->_M_falsename_size && __n)
{
__v = false;
if (__testt && __n == __lc->_M_truename_size)
__err = ios_base::failbit;
else
__err = __testeof ? ios_base::eofbit : ios_base::goodbit;
}
else if (__testt && __n == __lc->_M_truename_size && __n)
{
__v = true;
__err = __testeof ? ios_base::eofbit : ios_base::goodbit;
}
else
{
__v = false;
__err = ios_base::failbit;
if (__testeof)
__err |= ios_base::eofbit;
}
}
return __beg;
}
template<typename _CharT, typename _InIter>
_InIter
num_get<_CharT, _InIter>::
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, float& __v) const
{
string __xtrc;
__xtrc.reserve(32);
__beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
if (__beg == __end)
__err |= ios_base::eofbit;
return __beg;
}
template<typename _CharT, typename _InIter>
_InIter
num_get<_CharT, _InIter>::
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, double& __v) const
{
string __xtrc;
__xtrc.reserve(32);
__beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
if (__beg == __end)
__err |= ios_base::eofbit;
return __beg;
}
# 735 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.tcc" 3
template<typename _CharT, typename _InIter>
_InIter
num_get<_CharT, _InIter>::
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long double& __v) const
{
string __xtrc;
__xtrc.reserve(32);
__beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
if (__beg == __end)
__err |= ios_base::eofbit;
return __beg;
}
template<typename _CharT, typename _InIter>
_InIter
num_get<_CharT, _InIter>::
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, void*& __v) const
{
typedef ios_base::fmtflags fmtflags;
const fmtflags __fmt = __io.flags();
__io.flags((__fmt & ~ios_base::basefield) | ios_base::hex);
typedef __gnu_cxx::__conditional_type<(sizeof(void*)
<= sizeof(unsigned long)),
unsigned long, unsigned long long>::__type _UIntPtrType;
_UIntPtrType __ul;
__beg = _M_extract_int(__beg, __end, __io, __err, __ul);
__io.flags(__fmt);
__v = reinterpret_cast<void*>(__ul);
return __beg;
}
template<typename _CharT, typename _OutIter>
void
num_put<_CharT, _OutIter>::
_M_pad(_CharT __fill, streamsize __w, ios_base& __io,
_CharT* __new, const _CharT* __cs, int& __len) const
{
__pad<_CharT, char_traits<_CharT> >::_S_pad(__io, __fill, __new,
__cs, __w, __len);
__len = static_cast<int>(__w);
}
template<typename _CharT, typename _ValueT>
int
__int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit,
ios_base::fmtflags __flags, bool __dec)
{
_CharT* __buf = __bufend;
if (__builtin_expect(__dec, true))
{
do
{
*--__buf = __lit[(__v % 10) + __num_base::_S_odigits];
__v /= 10;
}
while (__v != 0);
}
else if ((__flags & ios_base::basefield) == ios_base::oct)
{
do
{
*--__buf = __lit[(__v & 0x7) + __num_base::_S_odigits];
__v >>= 3;
}
while (__v != 0);
}
else
{
const bool __uppercase = __flags & ios_base::uppercase;
const int __case_offset = __uppercase ? __num_base::_S_oudigits
: __num_base::_S_odigits;
do
{
*--__buf = __lit[(__v & 0xf) + __case_offset];
__v >>= 4;
}
while (__v != 0);
}
return __bufend - __buf;
}
template<typename _CharT, typename _OutIter>
void
num_put<_CharT, _OutIter>::
_M_group_int(const char* __grouping, size_t __grouping_size, _CharT __sep,
ios_base&, _CharT* __new, _CharT* __cs, int& __len) const
{
_CharT* __p = std::__add_grouping(__new, __sep, __grouping,
__grouping_size, __cs, __cs + __len);
__len = __p - __new;
}
template<typename _CharT, typename _OutIter>
template<typename _ValueT>
_OutIter
num_put<_CharT, _OutIter>::
_M_insert_int(_OutIter __s, ios_base& __io, _CharT __fill,
_ValueT __v) const
{
using __gnu_cxx::__add_unsigned;
typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
typedef __numpunct_cache<_CharT> __cache_type;
__use_cache<__cache_type> __uc;
const locale& __loc = __io._M_getloc();
const __cache_type* __lc = __uc(__loc);
const _CharT* __lit = __lc->_M_atoms_out;
const ios_base::fmtflags __flags = __io.flags();
const int __ilen = 5 * sizeof(_ValueT);
_CharT* __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
* __ilen));
const ios_base::fmtflags __basefield = __flags & ios_base::basefield;
const bool __dec = (__basefield != ios_base::oct
&& __basefield != ios_base::hex);
const __unsigned_type __u = ((__v > 0 || !__dec)
? __unsigned_type(__v)
: -__unsigned_type(__v));
int __len = __int_to_char(__cs + __ilen, __u, __lit, __flags, __dec);
__cs += __ilen - __len;
if (__lc->_M_use_grouping)
{
_CharT* __cs2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
* (__len + 1)
* 2));
_M_group_int(__lc->_M_grouping, __lc->_M_grouping_size,
__lc->_M_thousands_sep, __io, __cs2 + 2, __cs, __len);
__cs = __cs2 + 2;
}
if (__builtin_expect(__dec, true))
{
if (__v >= 0)
{
if (bool(__flags & ios_base::showpos)
&& __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
*--__cs = __lit[__num_base::_S_oplus], ++__len;
}
else
*--__cs = __lit[__num_base::_S_ominus], ++__len;
}
else if (bool(__flags & ios_base::showbase) && __v)
{
if (__basefield == ios_base::oct)
*--__cs = __lit[__num_base::_S_odigits], ++__len;
else
{
const bool __uppercase = __flags & ios_base::uppercase;
*--__cs = __lit[__num_base::_S_ox + __uppercase];
*--__cs = __lit[__num_base::_S_odigits];
__len += 2;
}
}
const streamsize __w = __io.width();
if (__w > static_cast<streamsize>(__len))
{
_CharT* __cs3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
* __w));
_M_pad(__fill, __w, __io, __cs3, __cs, __len);
__cs = __cs3;
}
__io.width(0);
return std::__write(__s, __cs, __len);
}
template<typename _CharT, typename _OutIter>
void
num_put<_CharT, _OutIter>::
_M_group_float(const char* __grouping, size_t __grouping_size,
_CharT __sep, const _CharT* __p, _CharT* __new,
_CharT* __cs, int& __len) const
{
const int __declen = __p ? __p - __cs : __len;
_CharT* __p2 = std::__add_grouping(__new, __sep, __grouping,
__grouping_size,
__cs, __cs + __declen);
int __newlen = __p2 - __new;
if (__p)
{
char_traits<_CharT>::copy(__p2, __p, __len - __declen);
__newlen += __len - __declen;
}
__len = __newlen;
}
# 971 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.tcc" 3
template<typename _CharT, typename _OutIter>
template<typename _ValueT>
_OutIter
num_put<_CharT, _OutIter>::
_M_insert_float(_OutIter __s, ios_base& __io, _CharT __fill, char __mod,
_ValueT __v) const
{
typedef __numpunct_cache<_CharT> __cache_type;
__use_cache<__cache_type> __uc;
const locale& __loc = __io._M_getloc();
const __cache_type* __lc = __uc(__loc);
const streamsize __prec = __io.precision() < 0 ? 6 : __io.precision();
const int __max_digits =
__gnu_cxx::__numeric_traits<_ValueT>::__digits10;
int __len;
char __fbuf[16];
__num_base::_S_format_float(__io, __fbuf, __mod);
const bool __use_prec =
(__io.flags() & ios_base::floatfield) != ios_base::floatfield;
int __cs_size = __max_digits * 3;
char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
if (__use_prec)
__len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
__fbuf, __prec, __v);
else
__len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
__fbuf, __v);
if (__len >= __cs_size)
{
__cs_size = __len + 1;
__cs = static_cast<char*>(__builtin_alloca(__cs_size));
if (__use_prec)
__len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
__fbuf, __prec, __v);
else
__len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
__fbuf, __v);
}
# 1044 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.tcc" 3
const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
_CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
* __len));
__ctype.widen(__cs, __cs + __len, __ws);
_CharT* __wp = 0;
const char* __p = char_traits<char>::find(__cs, __len, '.');
if (__p)
{
__wp = __ws + (__p - __cs);
*__wp = __lc->_M_decimal_point;
}
if (__lc->_M_use_grouping
&& (__wp || __len < 3 || (__cs[1] <= '9' && __cs[2] <= '9'
&& __cs[1] >= '0' && __cs[2] >= '0')))
{
_CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
* __len * 2));
streamsize __off = 0;
if (__cs[0] == '-' || __cs[0] == '+')
{
__off = 1;
__ws2[0] = __ws[0];
__len -= 1;
}
_M_group_float(__lc->_M_grouping, __lc->_M_grouping_size,
__lc->_M_thousands_sep, __wp, __ws2 + __off,
__ws + __off, __len);
__len += __off;
__ws = __ws2;
}
const streamsize __w = __io.width();
if (__w > static_cast<streamsize>(__len))
{
_CharT* __ws3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
* __w));
_M_pad(__fill, __w, __io, __ws3, __ws, __len);
__ws = __ws3;
}
__io.width(0);
return std::__write(__s, __ws, __len);
}
template<typename _CharT, typename _OutIter>
_OutIter
num_put<_CharT, _OutIter>::
do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
{
const ios_base::fmtflags __flags = __io.flags();
if ((__flags & ios_base::boolalpha) == 0)
{
const long __l = __v;
__s = _M_insert_int(__s, __io, __fill, __l);
}
else
{
typedef __numpunct_cache<_CharT> __cache_type;
__use_cache<__cache_type> __uc;
const locale& __loc = __io._M_getloc();
const __cache_type* __lc = __uc(__loc);
const _CharT* __name = __v ? __lc->_M_truename
: __lc->_M_falsename;
int __len = __v ? __lc->_M_truename_size
: __lc->_M_falsename_size;
const streamsize __w = __io.width();
if (__w > static_cast<streamsize>(__len))
{
const streamsize __plen = __w - __len;
_CharT* __ps
= static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
* __plen));
char_traits<_CharT>::assign(__ps, __plen, __fill);
__io.width(0);
if ((__flags & ios_base::adjustfield) == ios_base::left)
{
__s = std::__write(__s, __name, __len);
__s = std::__write(__s, __ps, __plen);
}
else
{
__s = std::__write(__s, __ps, __plen);
__s = std::__write(__s, __name, __len);
}
return __s;
}
__io.width(0);
__s = std::__write(__s, __name, __len);
}
return __s;
}
template<typename _CharT, typename _OutIter>
_OutIter
num_put<_CharT, _OutIter>::
do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
{ return _M_insert_float(__s, __io, __fill, char(), __v); }
# 1169 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.tcc" 3
template<typename _CharT, typename _OutIter>
_OutIter
num_put<_CharT, _OutIter>::
do_put(iter_type __s, ios_base& __io, char_type __fill,
long double __v) const
{ return _M_insert_float(__s, __io, __fill, 'L', __v); }
template<typename _CharT, typename _OutIter>
_OutIter
num_put<_CharT, _OutIter>::
do_put(iter_type __s, ios_base& __io, char_type __fill,
const void* __v) const
{
const ios_base::fmtflags __flags = __io.flags();
const ios_base::fmtflags __fmt = ~(ios_base::basefield
| ios_base::uppercase);
__io.flags((__flags & __fmt) | (ios_base::hex | ios_base::showbase));
typedef __gnu_cxx::__conditional_type<(sizeof(const void*)
<= sizeof(unsigned long)),
unsigned long, unsigned long long>::__type _UIntPtrType;
__s = _M_insert_int(__s, __io, __fill,
reinterpret_cast<_UIntPtrType>(__v));
__io.flags(__flags);
return __s;
}
# 1206 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.tcc" 3
template<typename _CharT, typename _Traits>
void
__pad<_CharT, _Traits>::_S_pad(ios_base& __io, _CharT __fill,
_CharT* __news, const _CharT* __olds,
streamsize __newlen, streamsize __oldlen)
{
const size_t __plen = static_cast<size_t>(__newlen - __oldlen);
const ios_base::fmtflags __adjust = __io.flags() & ios_base::adjustfield;
if (__adjust == ios_base::left)
{
_Traits::copy(__news, __olds, __oldlen);
_Traits::assign(__news + __oldlen, __plen, __fill);
return;
}
size_t __mod = 0;
if (__adjust == ios_base::internal)
{
const locale& __loc = __io._M_getloc();
const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
if (__ctype.widen('-') == __olds[0]
|| __ctype.widen('+') == __olds[0])
{
__news[0] = __olds[0];
__mod = 1;
++__news;
}
else if (__ctype.widen('0') == __olds[0]
&& __oldlen > 1
&& (__ctype.widen('x') == __olds[1]
|| __ctype.widen('X') == __olds[1]))
{
__news[0] = __olds[0];
__news[1] = __olds[1];
__mod = 2;
__news += 2;
}
}
_Traits::assign(__news, __plen, __fill);
_Traits::copy(__news + __plen, __olds + __mod, __oldlen - __mod);
}
template<typename _CharT>
_CharT*
__add_grouping(_CharT* __s, _CharT __sep,
const char* __gbeg, size_t __gsize,
const _CharT* __first, const _CharT* __last)
{
size_t __idx = 0;
size_t __ctr = 0;
while (__last - __first > __gbeg[__idx]
&& static_cast<signed char>(__gbeg[__idx]) > 0
&& __gbeg[__idx] != __gnu_cxx::__numeric_traits<char>::__max)
{
__last -= __gbeg[__idx];
__idx < __gsize - 1 ? ++__idx : ++__ctr;
}
while (__first != __last)
*__s++ = *__first++;
while (__ctr--)
{
*__s++ = __sep;
for (char __i = __gbeg[__idx]; __i > 0; --__i)
*__s++ = *__first++;
}
while (__idx--)
{
*__s++ = __sep;
for (char __i = __gbeg[__idx]; __i > 0; --__i)
*__s++ = *__first++;
}
return __s;
}
extern template class __cxx11:: numpunct<char>;
extern template class __cxx11:: numpunct_byname<char>;
extern template class num_get<char>;
extern template class num_put<char>;
extern template class ctype_byname<char>;
extern template
const ctype<char>&
use_facet<ctype<char> >(const locale&);
extern template
const numpunct<char>&
use_facet<numpunct<char> >(const locale&);
extern template
const num_put<char>&
use_facet<num_put<char> >(const locale&);
extern template
const num_get<char>&
use_facet<num_get<char> >(const locale&);
extern template
bool
has_facet<ctype<char> >(const locale&);
extern template
bool
has_facet<numpunct<char> >(const locale&);
extern template
bool
has_facet<num_put<char> >(const locale&);
extern template
bool
has_facet<num_get<char> >(const locale&);
extern template class __cxx11:: numpunct<wchar_t>;
extern template class __cxx11:: numpunct_byname<wchar_t>;
extern template class num_get<wchar_t>;
extern template class num_put<wchar_t>;
extern template class ctype_byname<wchar_t>;
extern template
const ctype<wchar_t>&
use_facet<ctype<wchar_t> >(const locale&);
extern template
const numpunct<wchar_t>&
use_facet<numpunct<wchar_t> >(const locale&);
extern template
const num_put<wchar_t>&
use_facet<num_put<wchar_t> >(const locale&);
extern template
const num_get<wchar_t>&
use_facet<num_get<wchar_t> >(const locale&);
extern template
bool
has_facet<ctype<wchar_t> >(const locale&);
extern template
bool
has_facet<numpunct<wchar_t> >(const locale&);
extern template
bool
has_facet<num_put<wchar_t> >(const locale&);
extern template
bool
has_facet<num_get<wchar_t> >(const locale&);
}
# 2652 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 2 3
# 38 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_ios.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Facet>
inline const _Facet&
__check_facet(const _Facet* __f)
{
if (!__f)
__throw_bad_cast();
return *__f;
}
# 66 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_ios.h" 3
template<typename _CharT, typename _Traits>
class basic_ios : public ios_base
{
public:
typedef _CharT char_type;
typedef typename _Traits::int_type int_type;
typedef typename _Traits::pos_type pos_type;
typedef typename _Traits::off_type off_type;
typedef _Traits traits_type;
typedef ctype<_CharT> __ctype_type;
typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
__num_put_type;
typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
__num_get_type;
protected:
basic_ostream<_CharT, _Traits>* _M_tie;
mutable char_type _M_fill;
mutable bool _M_fill_init;
basic_streambuf<_CharT, _Traits>* _M_streambuf;
const __ctype_type* _M_ctype;
const __num_put_type* _M_num_put;
const __num_get_type* _M_num_get;
public:
# 117 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_ios.h" 3
explicit operator bool() const
{ return !this->fail(); }
bool
operator!() const
{ return this->fail(); }
# 136 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_ios.h" 3
iostate
rdstate() const
{ return _M_streambuf_state; }
# 147 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_ios.h" 3
void
clear(iostate __state = goodbit);
void
setstate(iostate __state)
{ this->clear(this->rdstate() | __state); }
void
_M_setstate(iostate __state)
{
_M_streambuf_state |= __state;
if (this->exceptions() & __state)
throw;
}
bool
good() const
{ return this->rdstate() == 0; }
bool
eof() const
{ return (this->rdstate() & eofbit) != 0; }
# 200 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_ios.h" 3
bool
fail() const
{ return (this->rdstate() & (badbit | failbit)) != 0; }
bool
bad() const
{ return (this->rdstate() & badbit) != 0; }
# 221 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_ios.h" 3
iostate
exceptions() const
{ return _M_exception; }
# 256 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_ios.h" 3
void
exceptions(iostate __except)
{
_M_exception = __except;
this->clear(_M_streambuf_state);
}
explicit
basic_ios(basic_streambuf<_CharT, _Traits>* __sb)
: ios_base(), _M_tie(0), _M_fill(), _M_fill_init(false), _M_streambuf(0),
_M_ctype(0), _M_num_put(0), _M_num_get(0)
{ this->init(__sb); }
virtual
~basic_ios() { }
# 294 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_ios.h" 3
basic_ostream<_CharT, _Traits>*
tie() const
{ return _M_tie; }
# 306 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_ios.h" 3
basic_ostream<_CharT, _Traits>*
tie(basic_ostream<_CharT, _Traits>* __tiestr)
{
basic_ostream<_CharT, _Traits>* __old = _M_tie;
_M_tie = __tiestr;
return __old;
}
basic_streambuf<_CharT, _Traits>*
rdbuf() const
{ return _M_streambuf; }
# 346 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_ios.h" 3
basic_streambuf<_CharT, _Traits>*
rdbuf(basic_streambuf<_CharT, _Traits>* __sb);
# 360 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_ios.h" 3
basic_ios&
copyfmt(const basic_ios& __rhs);
char_type
fill() const
{
if (!_M_fill_init)
{
_M_fill = this->widen(' ');
_M_fill_init = true;
}
return _M_fill;
}
# 389 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_ios.h" 3
char_type
fill(char_type __ch)
{
char_type __old = this->fill();
_M_fill = __ch;
return __old;
}
# 409 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_ios.h" 3
locale
imbue(const locale& __loc);
# 429 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_ios.h" 3
char
narrow(char_type __c, char __dfault) const
{ return __check_facet(_M_ctype).narrow(__c, __dfault); }
# 448 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_ios.h" 3
char_type
widen(char __c) const
{ return __check_facet(_M_ctype).widen(__c); }
protected:
basic_ios()
: ios_base(), _M_tie(0), _M_fill(char_type()), _M_fill_init(false),
_M_streambuf(0), _M_ctype(0), _M_num_put(0), _M_num_get(0)
{ }
void
init(basic_streambuf<_CharT, _Traits>* __sb);
basic_ios(const basic_ios&) = delete;
basic_ios& operator=(const basic_ios&) = delete;
void
move(basic_ios& __rhs)
{
ios_base::_M_move(__rhs);
_M_cache_locale(_M_ios_locale);
this->tie(__rhs.tie(nullptr));
_M_fill = __rhs._M_fill;
_M_fill_init = __rhs._M_fill_init;
_M_streambuf = nullptr;
}
void
move(basic_ios&& __rhs)
{ this->move(__rhs); }
void
swap(basic_ios& __rhs) noexcept
{
ios_base::_M_swap(__rhs);
_M_cache_locale(_M_ios_locale);
__rhs._M_cache_locale(__rhs._M_ios_locale);
std::swap(_M_tie, __rhs._M_tie);
std::swap(_M_fill, __rhs._M_fill);
std::swap(_M_fill_init, __rhs._M_fill_init);
}
void
set_rdbuf(basic_streambuf<_CharT, _Traits>* __sb)
{ _M_streambuf = __sb; }
void
_M_cache_locale(const locale& __loc);
};
}
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_ios.tcc" 1 3
# 33 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_ios.tcc" 3
# 34 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_ios.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits>
void
basic_ios<_CharT, _Traits>::clear(iostate __state)
{
if (this->rdbuf())
_M_streambuf_state = __state;
else
_M_streambuf_state = __state | badbit;
if (this->exceptions() & this->rdstate())
__throw_ios_failure(("basic_ios::clear"));
}
template<typename _CharT, typename _Traits>
basic_streambuf<_CharT, _Traits>*
basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<_CharT, _Traits>* __sb)
{
basic_streambuf<_CharT, _Traits>* __old = _M_streambuf;
_M_streambuf = __sb;
this->clear();
return __old;
}
template<typename _CharT, typename _Traits>
basic_ios<_CharT, _Traits>&
basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs)
{
if (this != &__rhs)
{
_Words* __words = (__rhs._M_word_size <= _S_local_word_size) ?
_M_local_word : new _Words[__rhs._M_word_size];
_Callback_list* __cb = __rhs._M_callbacks;
if (__cb)
__cb->_M_add_reference();
_M_call_callbacks(erase_event);
if (_M_word != _M_local_word)
{
delete [] _M_word;
_M_word = 0;
}
_M_dispose_callbacks();
_M_callbacks = __cb;
for (int __i = 0; __i < __rhs._M_word_size; ++__i)
__words[__i] = __rhs._M_word[__i];
_M_word = __words;
_M_word_size = __rhs._M_word_size;
this->flags(__rhs.flags());
this->width(__rhs.width());
this->precision(__rhs.precision());
this->tie(__rhs.tie());
this->fill(__rhs.fill());
_M_ios_locale = __rhs.getloc();
_M_cache_locale(_M_ios_locale);
_M_call_callbacks(copyfmt_event);
this->exceptions(__rhs.exceptions());
}
return *this;
}
template<typename _CharT, typename _Traits>
locale
basic_ios<_CharT, _Traits>::imbue(const locale& __loc)
{
locale __old(this->getloc());
ios_base::imbue(__loc);
_M_cache_locale(__loc);
if (this->rdbuf() != 0)
this->rdbuf()->pubimbue(__loc);
return __old;
}
template<typename _CharT, typename _Traits>
void
basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __sb)
{
ios_base::_M_init();
_M_cache_locale(_M_ios_locale);
# 146 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_ios.tcc" 3
_M_fill = _CharT();
_M_fill_init = false;
_M_tie = 0;
_M_exception = goodbit;
_M_streambuf = __sb;
_M_streambuf_state = __sb ? goodbit : badbit;
}
template<typename _CharT, typename _Traits>
void
basic_ios<_CharT, _Traits>::_M_cache_locale(const locale& __loc)
{
if (__builtin_expect(has_facet<__ctype_type>(__loc), true))
_M_ctype = &use_facet<__ctype_type>(__loc);
else
_M_ctype = 0;
if (__builtin_expect(has_facet<__num_put_type>(__loc), true))
_M_num_put = &use_facet<__num_put_type>(__loc);
else
_M_num_put = 0;
if (__builtin_expect(has_facet<__num_get_type>(__loc), true))
_M_num_get = &use_facet<__num_get_type>(__loc);
else
_M_num_get = 0;
}
extern template class basic_ios<char>;
extern template class basic_ios<wchar_t>;
}
# 517 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_ios.h" 2 3
# 45 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ios" 2 3
# 39 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 57 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 3
template<typename _CharT, typename _Traits>
class basic_ostream : virtual public basic_ios<_CharT, _Traits>
{
public:
typedef _CharT char_type;
typedef typename _Traits::int_type int_type;
typedef typename _Traits::pos_type pos_type;
typedef typename _Traits::off_type off_type;
typedef _Traits traits_type;
typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
typedef basic_ios<_CharT, _Traits> __ios_type;
typedef basic_ostream<_CharT, _Traits> __ostream_type;
typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
__num_put_type;
typedef ctype<_CharT> __ctype_type;
# 83 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 3
explicit
basic_ostream(__streambuf_type* __sb)
{ this->init(__sb); }
virtual
~basic_ostream() { }
class sentry;
friend class sentry;
# 107 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 3
__ostream_type&
operator<<(__ostream_type& (*__pf)(__ostream_type&))
{
return __pf(*this);
}
__ostream_type&
operator<<(__ios_type& (*__pf)(__ios_type&))
{
__pf(*this);
return *this;
}
__ostream_type&
operator<<(ios_base& (*__pf) (ios_base&))
{
__pf(*this);
return *this;
}
# 165 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 3
__ostream_type&
operator<<(long __n)
{ return _M_insert(__n); }
__ostream_type&
operator<<(unsigned long __n)
{ return _M_insert(__n); }
__ostream_type&
operator<<(bool __n)
{ return _M_insert(__n); }
__ostream_type&
operator<<(short __n);
__ostream_type&
operator<<(unsigned short __n)
{
return _M_insert(static_cast<unsigned long>(__n));
}
__ostream_type&
operator<<(int __n);
__ostream_type&
operator<<(unsigned int __n)
{
return _M_insert(static_cast<unsigned long>(__n));
}
__ostream_type&
operator<<(long long __n)
{ return _M_insert(__n); }
__ostream_type&
operator<<(unsigned long long __n)
{ return _M_insert(__n); }
# 219 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 3
__ostream_type&
operator<<(double __f)
{ return _M_insert(__f); }
__ostream_type&
operator<<(float __f)
{
return _M_insert(static_cast<double>(__f));
}
__ostream_type&
operator<<(long double __f)
{ return _M_insert(__f); }
# 244 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 3
__ostream_type&
operator<<(const void* __p)
{ return _M_insert(__p); }
# 269 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 3
__ostream_type&
operator<<(__streambuf_type* __sb);
# 302 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 3
__ostream_type&
put(char_type __c);
void
_M_write(const char_type* __s, streamsize __n)
{
const streamsize __put = this->rdbuf()->sputn(__s, __n);
if (__put != __n)
this->setstate(ios_base::badbit);
}
# 334 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 3
__ostream_type&
write(const char_type* __s, streamsize __n);
# 347 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 3
__ostream_type&
flush();
# 357 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 3
pos_type
tellp();
# 368 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 3
__ostream_type&
seekp(pos_type);
# 380 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 3
__ostream_type&
seekp(off_type, ios_base::seekdir);
protected:
basic_ostream()
{ this->init(0); }
basic_ostream(basic_iostream<_CharT, _Traits>&) { }
basic_ostream(const basic_ostream&) = delete;
basic_ostream(basic_ostream&& __rhs)
: __ios_type()
{ __ios_type::move(__rhs); }
basic_ostream& operator=(const basic_ostream&) = delete;
basic_ostream&
operator=(basic_ostream&& __rhs)
{
swap(__rhs);
return *this;
}
void
swap(basic_ostream& __rhs)
{ __ios_type::swap(__rhs); }
template<typename _ValueT>
__ostream_type&
_M_insert(_ValueT __v);
};
# 425 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 3
template <typename _CharT, typename _Traits>
class basic_ostream<_CharT, _Traits>::sentry
{
bool _M_ok;
basic_ostream<_CharT, _Traits>& _M_os;
public:
# 444 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 3
explicit
sentry(basic_ostream<_CharT, _Traits>& __os);
# 454 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 3
~sentry()
{
if (bool(_M_os.flags() & ios_base::unitbuf) && !uncaught_exception())
{
if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() == -1)
_M_os.setstate(ios_base::badbit);
}
}
# 473 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 3
explicit
operator bool() const
{ return _M_ok; }
};
# 495 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 3
template<typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c)
{ return __ostream_insert(__out, &__c, 1); }
template<typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __out, char __c)
{ return (__out << __out.widen(__c)); }
template <class _Traits>
inline basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, char __c)
{ return __ostream_insert(__out, &__c, 1); }
template<class _Traits>
inline basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, signed char __c)
{ return (__out << static_cast<char>(__c)); }
template<class _Traits>
inline basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c)
{ return (__out << static_cast<char>(__c)); }
# 537 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 3
template<typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
{
if (!__s)
__out.setstate(ios_base::badbit);
else
__ostream_insert(__out, __s,
static_cast<streamsize>(_Traits::length(__s)));
return __out;
}
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits> &
operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s);
template<class _Traits>
inline basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, const char* __s)
{
if (!__s)
__out.setstate(ios_base::badbit);
else
__ostream_insert(__out, __s,
static_cast<streamsize>(_Traits::length(__s)));
return __out;
}
template<class _Traits>
inline basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, const signed char* __s)
{ return (__out << reinterpret_cast<const char*>(__s)); }
template<class _Traits>
inline basic_ostream<char, _Traits> &
operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s)
{ return (__out << reinterpret_cast<const char*>(__s)); }
# 588 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 3
template<typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits>&
endl(basic_ostream<_CharT, _Traits>& __os)
{ return flush(__os.put(__os.widen('\n'))); }
# 600 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 3
template<typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits>&
ends(basic_ostream<_CharT, _Traits>& __os)
{ return __os.put(_CharT()); }
template<typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits>&
flush(basic_ostream<_CharT, _Traits>& __os)
{ return __os.flush(); }
# 626 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 3
template<typename _CharT, typename _Traits, typename _Tp>
inline basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>&& __os, const _Tp& __x)
{
__os << __x;
return __os;
}
}
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ostream.tcc" 1 3
# 37 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ostream.tcc" 3
# 38 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ostream.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>::sentry::
sentry(basic_ostream<_CharT, _Traits>& __os)
: _M_ok(false), _M_os(__os)
{
if (__os.tie() && __os.good())
__os.tie()->flush();
if (__os.good())
_M_ok = true;
else
__os.setstate(ios_base::failbit);
}
template<typename _CharT, typename _Traits>
template<typename _ValueT>
basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::
_M_insert(_ValueT __v)
{
sentry __cerb(*this);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
try
{
const __num_put_type& __np = __check_facet(this->_M_num_put);
if (__np.put(*this, *this, this->fill(), __v).failed())
__err |= ios_base::badbit;
}
catch(__cxxabiv1::__forced_unwind&)
{
this->_M_setstate(ios_base::badbit);
throw;
}
catch(...)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
}
return *this;
}
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::
operator<<(short __n)
{
const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
if (__fmt == ios_base::oct || __fmt == ios_base::hex)
return _M_insert(static_cast<long>(static_cast<unsigned short>(__n)));
else
return _M_insert(static_cast<long>(__n));
}
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::
operator<<(int __n)
{
const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
if (__fmt == ios_base::oct || __fmt == ios_base::hex)
return _M_insert(static_cast<long>(static_cast<unsigned int>(__n)));
else
return _M_insert(static_cast<long>(__n));
}
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::
operator<<(__streambuf_type* __sbin)
{
ios_base::iostate __err = ios_base::goodbit;
sentry __cerb(*this);
if (__cerb && __sbin)
{
try
{
if (!__copy_streambufs(__sbin, this->rdbuf()))
__err |= ios_base::failbit;
}
catch(__cxxabiv1::__forced_unwind&)
{
this->_M_setstate(ios_base::badbit);
throw;
}
catch(...)
{ this->_M_setstate(ios_base::failbit); }
}
else if (!__sbin)
__err |= ios_base::badbit;
if (__err)
this->setstate(__err);
return *this;
}
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::
put(char_type __c)
{
sentry __cerb(*this);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
try
{
const int_type __put = this->rdbuf()->sputc(__c);
if (traits_type::eq_int_type(__put, traits_type::eof()))
__err |= ios_base::badbit;
}
catch(__cxxabiv1::__forced_unwind&)
{
this->_M_setstate(ios_base::badbit);
throw;
}
catch(...)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
}
return *this;
}
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::
write(const _CharT* __s, streamsize __n)
{
sentry __cerb(*this);
if (__cerb)
{
try
{ _M_write(__s, __n); }
catch(__cxxabiv1::__forced_unwind&)
{
this->_M_setstate(ios_base::badbit);
throw;
}
catch(...)
{ this->_M_setstate(ios_base::badbit); }
}
return *this;
}
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::
flush()
{
ios_base::iostate __err = ios_base::goodbit;
try
{
if (this->rdbuf() && this->rdbuf()->pubsync() == -1)
__err |= ios_base::badbit;
}
catch(__cxxabiv1::__forced_unwind&)
{
this->_M_setstate(ios_base::badbit);
throw;
}
catch(...)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
return *this;
}
template<typename _CharT, typename _Traits>
typename basic_ostream<_CharT, _Traits>::pos_type
basic_ostream<_CharT, _Traits>::
tellp()
{
pos_type __ret = pos_type(-1);
try
{
if (!this->fail())
__ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
}
catch(__cxxabiv1::__forced_unwind&)
{
this->_M_setstate(ios_base::badbit);
throw;
}
catch(...)
{ this->_M_setstate(ios_base::badbit); }
return __ret;
}
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::
seekp(pos_type __pos)
{
ios_base::iostate __err = ios_base::goodbit;
try
{
if (!this->fail())
{
const pos_type __p = this->rdbuf()->pubseekpos(__pos,
ios_base::out);
if (__p == pos_type(off_type(-1)))
__err |= ios_base::failbit;
}
}
catch(__cxxabiv1::__forced_unwind&)
{
this->_M_setstate(ios_base::badbit);
throw;
}
catch(...)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
return *this;
}
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::
seekp(off_type __off, ios_base::seekdir __dir)
{
ios_base::iostate __err = ios_base::goodbit;
try
{
if (!this->fail())
{
const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
ios_base::out);
if (__p == pos_type(off_type(-1)))
__err |= ios_base::failbit;
}
}
catch(__cxxabiv1::__forced_unwind&)
{
this->_M_setstate(ios_base::badbit);
throw;
}
catch(...)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
return *this;
}
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s)
{
if (!__s)
__out.setstate(ios_base::badbit);
else
{
const size_t __clen = char_traits<char>::length(__s);
try
{
struct __ptr_guard
{
_CharT *__p;
__ptr_guard (_CharT *__ip): __p(__ip) { }
~__ptr_guard() { delete[] __p; }
_CharT* __get() { return __p; }
} __pg (new _CharT[__clen]);
_CharT *__ws = __pg.__get();
for (size_t __i = 0; __i < __clen; ++__i)
__ws[__i] = __out.widen(__s[__i]);
__ostream_insert(__out, __ws, __clen);
}
catch(__cxxabiv1::__forced_unwind&)
{
__out._M_setstate(ios_base::badbit);
throw;
}
catch(...)
{ __out._M_setstate(ios_base::badbit); }
}
return __out;
}
extern template class basic_ostream<char>;
extern template ostream& endl(ostream&);
extern template ostream& ends(ostream&);
extern template ostream& flush(ostream&);
extern template ostream& operator<<(ostream&, char);
extern template ostream& operator<<(ostream&, unsigned char);
extern template ostream& operator<<(ostream&, signed char);
extern template ostream& operator<<(ostream&, const char*);
extern template ostream& operator<<(ostream&, const unsigned char*);
extern template ostream& operator<<(ostream&, const signed char*);
extern template ostream& ostream::_M_insert(long);
extern template ostream& ostream::_M_insert(unsigned long);
extern template ostream& ostream::_M_insert(bool);
extern template ostream& ostream::_M_insert(long long);
extern template ostream& ostream::_M_insert(unsigned long long);
extern template ostream& ostream::_M_insert(double);
extern template ostream& ostream::_M_insert(long double);
extern template ostream& ostream::_M_insert(const void*);
extern template class basic_ostream<wchar_t>;
extern template wostream& endl(wostream&);
extern template wostream& ends(wostream&);
extern template wostream& flush(wostream&);
extern template wostream& operator<<(wostream&, wchar_t);
extern template wostream& operator<<(wostream&, char);
extern template wostream& operator<<(wostream&, const wchar_t*);
extern template wostream& operator<<(wostream&, const char*);
extern template wostream& wostream::_M_insert(long);
extern template wostream& wostream::_M_insert(unsigned long);
extern template wostream& wostream::_M_insert(bool);
extern template wostream& wostream::_M_insert(long long);
extern template wostream& wostream::_M_insert(unsigned long long);
extern template wostream& wostream::_M_insert(double);
extern template wostream& wostream::_M_insert(long double);
extern template wostream& wostream::_M_insert(const void*);
}
# 639 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 2 3
# 40 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iostream" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 1 3
# 36 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
# 37 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 57 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
template<typename _CharT, typename _Traits>
class basic_istream : virtual public basic_ios<_CharT, _Traits>
{
public:
typedef _CharT char_type;
typedef typename _Traits::int_type int_type;
typedef typename _Traits::pos_type pos_type;
typedef typename _Traits::off_type off_type;
typedef _Traits traits_type;
typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
typedef basic_ios<_CharT, _Traits> __ios_type;
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
__num_get_type;
typedef ctype<_CharT> __ctype_type;
protected:
streamsize _M_gcount;
public:
explicit
basic_istream(__streambuf_type* __sb)
: _M_gcount(streamsize(0))
{ this->init(__sb); }
virtual
~basic_istream()
{ _M_gcount = streamsize(0); }
class sentry;
friend class sentry;
# 119 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
__istream_type&
operator>>(__istream_type& (*__pf)(__istream_type&))
{ return __pf(*this); }
__istream_type&
operator>>(__ios_type& (*__pf)(__ios_type&))
{
__pf(*this);
return *this;
}
__istream_type&
operator>>(ios_base& (*__pf)(ios_base&))
{
__pf(*this);
return *this;
}
# 167 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
__istream_type&
operator>>(bool& __n)
{ return _M_extract(__n); }
__istream_type&
operator>>(short& __n);
__istream_type&
operator>>(unsigned short& __n)
{ return _M_extract(__n); }
__istream_type&
operator>>(int& __n);
__istream_type&
operator>>(unsigned int& __n)
{ return _M_extract(__n); }
__istream_type&
operator>>(long& __n)
{ return _M_extract(__n); }
__istream_type&
operator>>(unsigned long& __n)
{ return _M_extract(__n); }
__istream_type&
operator>>(long long& __n)
{ return _M_extract(__n); }
__istream_type&
operator>>(unsigned long long& __n)
{ return _M_extract(__n); }
# 213 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
__istream_type&
operator>>(float& __f)
{ return _M_extract(__f); }
__istream_type&
operator>>(double& __f)
{ return _M_extract(__f); }
__istream_type&
operator>>(long double& __f)
{ return _M_extract(__f); }
# 234 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
__istream_type&
operator>>(void*& __p)
{ return _M_extract(__p); }
# 258 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
__istream_type&
operator>>(__streambuf_type* __sb);
# 268 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
streamsize
gcount() const
{ return _M_gcount; }
# 301 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
int_type
get();
# 315 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
__istream_type&
get(char_type& __c);
# 342 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
__istream_type&
get(char_type* __s, streamsize __n, char_type __delim);
# 353 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
__istream_type&
get(char_type* __s, streamsize __n)
{ return this->get(__s, __n, this->widen('\n')); }
# 376 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
__istream_type&
get(__streambuf_type& __sb, char_type __delim);
# 386 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
__istream_type&
get(__streambuf_type& __sb)
{ return this->get(__sb, this->widen('\n')); }
# 415 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
__istream_type&
getline(char_type* __s, streamsize __n, char_type __delim);
# 426 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
__istream_type&
getline(char_type* __s, streamsize __n)
{ return this->getline(__s, __n, this->widen('\n')); }
# 450 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
__istream_type&
ignore(streamsize __n, int_type __delim);
__istream_type&
ignore(streamsize __n);
__istream_type&
ignore();
# 467 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
int_type
peek();
# 485 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
__istream_type&
read(char_type* __s, streamsize __n);
# 504 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
streamsize
readsome(char_type* __s, streamsize __n);
# 521 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
__istream_type&
putback(char_type __c);
# 537 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
__istream_type&
unget();
# 555 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
int
sync();
# 570 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
pos_type
tellg();
# 585 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
__istream_type&
seekg(pos_type);
# 601 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
__istream_type&
seekg(off_type, ios_base::seekdir);
protected:
basic_istream()
: _M_gcount(streamsize(0))
{ this->init(0); }
basic_istream(const basic_istream&) = delete;
basic_istream(basic_istream&& __rhs)
: __ios_type(), _M_gcount(__rhs._M_gcount)
{
__ios_type::move(__rhs);
__rhs._M_gcount = 0;
}
basic_istream& operator=(const basic_istream&) = delete;
basic_istream&
operator=(basic_istream&& __rhs)
{
swap(__rhs);
return *this;
}
void
swap(basic_istream& __rhs)
{
__ios_type::swap(__rhs);
std::swap(_M_gcount, __rhs._M_gcount);
}
template<typename _ValueT>
__istream_type&
_M_extract(_ValueT& __v);
};
template<>
basic_istream<char>&
basic_istream<char>::
getline(char_type* __s, streamsize __n, char_type __delim);
template<>
basic_istream<char>&
basic_istream<char>::
ignore(streamsize __n);
template<>
basic_istream<char>&
basic_istream<char>::
ignore(streamsize __n, int_type __delim);
template<>
basic_istream<wchar_t>&
basic_istream<wchar_t>::
getline(char_type* __s, streamsize __n, char_type __delim);
template<>
basic_istream<wchar_t>&
basic_istream<wchar_t>::
ignore(streamsize __n);
template<>
basic_istream<wchar_t>&
basic_istream<wchar_t>::
ignore(streamsize __n, int_type __delim);
# 685 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
template<typename _CharT, typename _Traits>
class basic_istream<_CharT, _Traits>::sentry
{
bool _M_ok;
public:
typedef _Traits traits_type;
typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef typename __istream_type::__ctype_type __ctype_type;
typedef typename _Traits::int_type __int_type;
# 721 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
explicit
sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
# 732 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
explicit
operator bool() const
{ return _M_ok; }
};
# 750 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c);
template<class _Traits>
inline basic_istream<char, _Traits>&
operator>>(basic_istream<char, _Traits>& __in, unsigned char& __c)
{ return (__in >> reinterpret_cast<char&>(__c)); }
template<class _Traits>
inline basic_istream<char, _Traits>&
operator>>(basic_istream<char, _Traits>& __in, signed char& __c)
{ return (__in >> reinterpret_cast<char&>(__c)); }
# 792 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s);
template<>
basic_istream<char>&
operator>>(basic_istream<char>& __in, char* __s);
template<class _Traits>
inline basic_istream<char, _Traits>&
operator>>(basic_istream<char, _Traits>& __in, unsigned char* __s)
{ return (__in >> reinterpret_cast<char*>(__s)); }
template<class _Traits>
inline basic_istream<char, _Traits>&
operator>>(basic_istream<char, _Traits>& __in, signed char* __s)
{ return (__in >> reinterpret_cast<char*>(__s)); }
# 823 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
template<typename _CharT, typename _Traits>
class basic_iostream
: public basic_istream<_CharT, _Traits>,
public basic_ostream<_CharT, _Traits>
{
public:
typedef _CharT char_type;
typedef typename _Traits::int_type int_type;
typedef typename _Traits::pos_type pos_type;
typedef typename _Traits::off_type off_type;
typedef _Traits traits_type;
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef basic_ostream<_CharT, _Traits> __ostream_type;
explicit
basic_iostream(basic_streambuf<_CharT, _Traits>* __sb)
: __istream_type(__sb), __ostream_type(__sb) { }
virtual
~basic_iostream() { }
protected:
basic_iostream()
: __istream_type(), __ostream_type() { }
basic_iostream(const basic_iostream&) = delete;
basic_iostream(basic_iostream&& __rhs)
: __istream_type(std::move(__rhs)), __ostream_type(*this)
{ }
basic_iostream& operator=(const basic_iostream&) = delete;
basic_iostream&
operator=(basic_iostream&& __rhs)
{
swap(__rhs);
return *this;
}
void
swap(basic_iostream& __rhs)
{ __istream_type::swap(__rhs); }
};
# 906 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
ws(basic_istream<_CharT, _Traits>& __is);
# 922 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
template<typename _CharT, typename _Traits, typename _Tp>
inline basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>&& __is, _Tp& __x)
{
__is >> __x;
return __is;
}
}
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/istream.tcc" 1 3
# 37 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/istream.tcc" 3
# 38 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/istream.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>::sentry::
sentry(basic_istream<_CharT, _Traits>& __in, bool __noskip) : _M_ok(false)
{
ios_base::iostate __err = ios_base::goodbit;
if (__in.good())
{
if (__in.tie())
__in.tie()->flush();
if (!__noskip && bool(__in.flags() & ios_base::skipws))
{
const __int_type __eof = traits_type::eof();
__streambuf_type* __sb = __in.rdbuf();
__int_type __c = __sb->sgetc();
const __ctype_type& __ct = __check_facet(__in._M_ctype);
while (!traits_type::eq_int_type(__c, __eof)
&& __ct.is(ctype_base::space,
traits_type::to_char_type(__c)))
__c = __sb->snextc();
if (traits_type::eq_int_type(__c, __eof))
__err |= ios_base::eofbit;
}
}
if (__in.good() && __err == ios_base::goodbit)
_M_ok = true;
else
{
__err |= ios_base::failbit;
__in.setstate(__err);
}
}
template<typename _CharT, typename _Traits>
template<typename _ValueT>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
_M_extract(_ValueT& __v)
{
sentry __cerb(*this, false);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
try
{
const __num_get_type& __ng = __check_facet(this->_M_num_get);
__ng.get(*this, 0, *this, __err, __v);
}
catch(__cxxabiv1::__forced_unwind&)
{
this->_M_setstate(ios_base::badbit);
throw;
}
catch(...)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
}
return *this;
}
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
operator>>(short& __n)
{
sentry __cerb(*this, false);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
try
{
long __l;
const __num_get_type& __ng = __check_facet(this->_M_num_get);
__ng.get(*this, 0, *this, __err, __l);
if (__l < __gnu_cxx::__numeric_traits<short>::__min)
{
__err |= ios_base::failbit;
__n = __gnu_cxx::__numeric_traits<short>::__min;
}
else if (__l > __gnu_cxx::__numeric_traits<short>::__max)
{
__err |= ios_base::failbit;
__n = __gnu_cxx::__numeric_traits<short>::__max;
}
else
__n = short(__l);
}
catch(__cxxabiv1::__forced_unwind&)
{
this->_M_setstate(ios_base::badbit);
throw;
}
catch(...)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
}
return *this;
}
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
operator>>(int& __n)
{
sentry __cerb(*this, false);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
try
{
long __l;
const __num_get_type& __ng = __check_facet(this->_M_num_get);
__ng.get(*this, 0, *this, __err, __l);
if (__l < __gnu_cxx::__numeric_traits<int>::__min)
{
__err |= ios_base::failbit;
__n = __gnu_cxx::__numeric_traits<int>::__min;
}
else if (__l > __gnu_cxx::__numeric_traits<int>::__max)
{
__err |= ios_base::failbit;
__n = __gnu_cxx::__numeric_traits<int>::__max;
}
else
__n = int(__l);
}
catch(__cxxabiv1::__forced_unwind&)
{
this->_M_setstate(ios_base::badbit);
throw;
}
catch(...)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
}
return *this;
}
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
operator>>(__streambuf_type* __sbout)
{
ios_base::iostate __err = ios_base::goodbit;
sentry __cerb(*this, false);
if (__cerb && __sbout)
{
try
{
bool __ineof;
if (!__copy_streambufs_eof(this->rdbuf(), __sbout, __ineof))
__err |= ios_base::failbit;
if (__ineof)
__err |= ios_base::eofbit;
}
catch(__cxxabiv1::__forced_unwind&)
{
this->_M_setstate(ios_base::failbit);
throw;
}
catch(...)
{ this->_M_setstate(ios_base::failbit); }
}
else if (!__sbout)
__err |= ios_base::failbit;
if (__err)
this->setstate(__err);
return *this;
}
template<typename _CharT, typename _Traits>
typename basic_istream<_CharT, _Traits>::int_type
basic_istream<_CharT, _Traits>::
get(void)
{
const int_type __eof = traits_type::eof();
int_type __c = __eof;
_M_gcount = 0;
ios_base::iostate __err = ios_base::goodbit;
sentry __cerb(*this, true);
if (__cerb)
{
try
{
__c = this->rdbuf()->sbumpc();
if (!traits_type::eq_int_type(__c, __eof))
_M_gcount = 1;
else
__err |= ios_base::eofbit;
}
catch(__cxxabiv1::__forced_unwind&)
{
this->_M_setstate(ios_base::badbit);
throw;
}
catch(...)
{ this->_M_setstate(ios_base::badbit); }
}
if (!_M_gcount)
__err |= ios_base::failbit;
if (__err)
this->setstate(__err);
return __c;
}
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
get(char_type& __c)
{
_M_gcount = 0;
ios_base::iostate __err = ios_base::goodbit;
sentry __cerb(*this, true);
if (__cerb)
{
try
{
const int_type __cb = this->rdbuf()->sbumpc();
if (!traits_type::eq_int_type(__cb, traits_type::eof()))
{
_M_gcount = 1;
__c = traits_type::to_char_type(__cb);
}
else
__err |= ios_base::eofbit;
}
catch(__cxxabiv1::__forced_unwind&)
{
this->_M_setstate(ios_base::badbit);
throw;
}
catch(...)
{ this->_M_setstate(ios_base::badbit); }
}
if (!_M_gcount)
__err |= ios_base::failbit;
if (__err)
this->setstate(__err);
return *this;
}
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
get(char_type* __s, streamsize __n, char_type __delim)
{
_M_gcount = 0;
ios_base::iostate __err = ios_base::goodbit;
sentry __cerb(*this, true);
if (__cerb)
{
try
{
const int_type __idelim = traits_type::to_int_type(__delim);
const int_type __eof = traits_type::eof();
__streambuf_type* __sb = this->rdbuf();
int_type __c = __sb->sgetc();
while (_M_gcount + 1 < __n
&& !traits_type::eq_int_type(__c, __eof)
&& !traits_type::eq_int_type(__c, __idelim))
{
*__s++ = traits_type::to_char_type(__c);
++_M_gcount;
__c = __sb->snextc();
}
if (traits_type::eq_int_type(__c, __eof))
__err |= ios_base::eofbit;
}
catch(__cxxabiv1::__forced_unwind&)
{
this->_M_setstate(ios_base::badbit);
throw;
}
catch(...)
{ this->_M_setstate(ios_base::badbit); }
}
if (__n > 0)
*__s = char_type();
if (!_M_gcount)
__err |= ios_base::failbit;
if (__err)
this->setstate(__err);
return *this;
}
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
get(__streambuf_type& __sb, char_type __delim)
{
_M_gcount = 0;
ios_base::iostate __err = ios_base::goodbit;
sentry __cerb(*this, true);
if (__cerb)
{
try
{
const int_type __idelim = traits_type::to_int_type(__delim);
const int_type __eof = traits_type::eof();
__streambuf_type* __this_sb = this->rdbuf();
int_type __c = __this_sb->sgetc();
char_type __c2 = traits_type::to_char_type(__c);
while (!traits_type::eq_int_type(__c, __eof)
&& !traits_type::eq_int_type(__c, __idelim)
&& !traits_type::eq_int_type(__sb.sputc(__c2), __eof))
{
++_M_gcount;
__c = __this_sb->snextc();
__c2 = traits_type::to_char_type(__c);
}
if (traits_type::eq_int_type(__c, __eof))
__err |= ios_base::eofbit;
}
catch(__cxxabiv1::__forced_unwind&)
{
this->_M_setstate(ios_base::badbit);
throw;
}
catch(...)
{ this->_M_setstate(ios_base::badbit); }
}
if (!_M_gcount)
__err |= ios_base::failbit;
if (__err)
this->setstate(__err);
return *this;
}
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
getline(char_type* __s, streamsize __n, char_type __delim)
{
_M_gcount = 0;
ios_base::iostate __err = ios_base::goodbit;
sentry __cerb(*this, true);
if (__cerb)
{
try
{
const int_type __idelim = traits_type::to_int_type(__delim);
const int_type __eof = traits_type::eof();
__streambuf_type* __sb = this->rdbuf();
int_type __c = __sb->sgetc();
while (_M_gcount + 1 < __n
&& !traits_type::eq_int_type(__c, __eof)
&& !traits_type::eq_int_type(__c, __idelim))
{
*__s++ = traits_type::to_char_type(__c);
__c = __sb->snextc();
++_M_gcount;
}
if (traits_type::eq_int_type(__c, __eof))
__err |= ios_base::eofbit;
else
{
if (traits_type::eq_int_type(__c, __idelim))
{
__sb->sbumpc();
++_M_gcount;
}
else
__err |= ios_base::failbit;
}
}
catch(__cxxabiv1::__forced_unwind&)
{
this->_M_setstate(ios_base::badbit);
throw;
}
catch(...)
{ this->_M_setstate(ios_base::badbit); }
}
if (__n > 0)
*__s = char_type();
if (!_M_gcount)
__err |= ios_base::failbit;
if (__err)
this->setstate(__err);
return *this;
}
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
ignore(void)
{
_M_gcount = 0;
sentry __cerb(*this, true);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
try
{
const int_type __eof = traits_type::eof();
__streambuf_type* __sb = this->rdbuf();
if (traits_type::eq_int_type(__sb->sbumpc(), __eof))
__err |= ios_base::eofbit;
else
_M_gcount = 1;
}
catch(__cxxabiv1::__forced_unwind&)
{
this->_M_setstate(ios_base::badbit);
throw;
}
catch(...)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
}
return *this;
}
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
ignore(streamsize __n)
{
_M_gcount = 0;
sentry __cerb(*this, true);
if (__cerb && __n > 0)
{
ios_base::iostate __err = ios_base::goodbit;
try
{
const int_type __eof = traits_type::eof();
__streambuf_type* __sb = this->rdbuf();
int_type __c = __sb->sgetc();
# 513 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/istream.tcc" 3
bool __large_ignore = false;
while (true)
{
while (_M_gcount < __n
&& !traits_type::eq_int_type(__c, __eof))
{
++_M_gcount;
__c = __sb->snextc();
}
if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
&& !traits_type::eq_int_type(__c, __eof))
{
_M_gcount =
__gnu_cxx::__numeric_traits<streamsize>::__min;
__large_ignore = true;
}
else
break;
}
if (__large_ignore)
_M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
if (traits_type::eq_int_type(__c, __eof))
__err |= ios_base::eofbit;
}
catch(__cxxabiv1::__forced_unwind&)
{
this->_M_setstate(ios_base::badbit);
throw;
}
catch(...)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
}
return *this;
}
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
ignore(streamsize __n, int_type __delim)
{
_M_gcount = 0;
sentry __cerb(*this, true);
if (__cerb && __n > 0)
{
ios_base::iostate __err = ios_base::goodbit;
try
{
const int_type __eof = traits_type::eof();
__streambuf_type* __sb = this->rdbuf();
int_type __c = __sb->sgetc();
bool __large_ignore = false;
while (true)
{
while (_M_gcount < __n
&& !traits_type::eq_int_type(__c, __eof)
&& !traits_type::eq_int_type(__c, __delim))
{
++_M_gcount;
__c = __sb->snextc();
}
if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
&& !traits_type::eq_int_type(__c, __eof)
&& !traits_type::eq_int_type(__c, __delim))
{
_M_gcount =
__gnu_cxx::__numeric_traits<streamsize>::__min;
__large_ignore = true;
}
else
break;
}
if (__large_ignore)
_M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
if (traits_type::eq_int_type(__c, __eof))
__err |= ios_base::eofbit;
else if (traits_type::eq_int_type(__c, __delim))
{
if (_M_gcount
< __gnu_cxx::__numeric_traits<streamsize>::__max)
++_M_gcount;
__sb->sbumpc();
}
}
catch(__cxxabiv1::__forced_unwind&)
{
this->_M_setstate(ios_base::badbit);
throw;
}
catch(...)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
}
return *this;
}
template<typename _CharT, typename _Traits>
typename basic_istream<_CharT, _Traits>::int_type
basic_istream<_CharT, _Traits>::
peek(void)
{
int_type __c = traits_type::eof();
_M_gcount = 0;
sentry __cerb(*this, true);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
try
{
__c = this->rdbuf()->sgetc();
if (traits_type::eq_int_type(__c, traits_type::eof()))
__err |= ios_base::eofbit;
}
catch(__cxxabiv1::__forced_unwind&)
{
this->_M_setstate(ios_base::badbit);
throw;
}
catch(...)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
}
return __c;
}
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
read(char_type* __s, streamsize __n)
{
_M_gcount = 0;
sentry __cerb(*this, true);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
try
{
_M_gcount = this->rdbuf()->sgetn(__s, __n);
if (_M_gcount != __n)
__err |= (ios_base::eofbit | ios_base::failbit);
}
catch(__cxxabiv1::__forced_unwind&)
{
this->_M_setstate(ios_base::badbit);
throw;
}
catch(...)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
}
return *this;
}
template<typename _CharT, typename _Traits>
streamsize
basic_istream<_CharT, _Traits>::
readsome(char_type* __s, streamsize __n)
{
_M_gcount = 0;
sentry __cerb(*this, true);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
try
{
const streamsize __num = this->rdbuf()->in_avail();
if (__num > 0)
_M_gcount = this->rdbuf()->sgetn(__s, std::min(__num, __n));
else if (__num == -1)
__err |= ios_base::eofbit;
}
catch(__cxxabiv1::__forced_unwind&)
{
this->_M_setstate(ios_base::badbit);
throw;
}
catch(...)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
}
return _M_gcount;
}
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
putback(char_type __c)
{
_M_gcount = 0;
this->clear(this->rdstate() & ~ios_base::eofbit);
sentry __cerb(*this, true);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
try
{
const int_type __eof = traits_type::eof();
__streambuf_type* __sb = this->rdbuf();
if (!__sb
|| traits_type::eq_int_type(__sb->sputbackc(__c), __eof))
__err |= ios_base::badbit;
}
catch(__cxxabiv1::__forced_unwind&)
{
this->_M_setstate(ios_base::badbit);
throw;
}
catch(...)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
}
return *this;
}
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
unget(void)
{
_M_gcount = 0;
this->clear(this->rdstate() & ~ios_base::eofbit);
sentry __cerb(*this, true);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
try
{
const int_type __eof = traits_type::eof();
__streambuf_type* __sb = this->rdbuf();
if (!__sb
|| traits_type::eq_int_type(__sb->sungetc(), __eof))
__err |= ios_base::badbit;
}
catch(__cxxabiv1::__forced_unwind&)
{
this->_M_setstate(ios_base::badbit);
throw;
}
catch(...)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
}
return *this;
}
template<typename _CharT, typename _Traits>
int
basic_istream<_CharT, _Traits>::
sync(void)
{
int __ret = -1;
sentry __cerb(*this, true);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
try
{
__streambuf_type* __sb = this->rdbuf();
if (__sb)
{
if (__sb->pubsync() == -1)
__err |= ios_base::badbit;
else
__ret = 0;
}
}
catch(__cxxabiv1::__forced_unwind&)
{
this->_M_setstate(ios_base::badbit);
throw;
}
catch(...)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
}
return __ret;
}
template<typename _CharT, typename _Traits>
typename basic_istream<_CharT, _Traits>::pos_type
basic_istream<_CharT, _Traits>::
tellg(void)
{
pos_type __ret = pos_type(-1);
sentry __cerb(*this, true);
if (__cerb)
{
try
{
if (!this->fail())
__ret = this->rdbuf()->pubseekoff(0, ios_base::cur,
ios_base::in);
}
catch(__cxxabiv1::__forced_unwind&)
{
this->_M_setstate(ios_base::badbit);
throw;
}
catch(...)
{ this->_M_setstate(ios_base::badbit); }
}
return __ret;
}
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
seekg(pos_type __pos)
{
this->clear(this->rdstate() & ~ios_base::eofbit);
sentry __cerb(*this, true);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
try
{
if (!this->fail())
{
const pos_type __p = this->rdbuf()->pubseekpos(__pos,
ios_base::in);
if (__p == pos_type(off_type(-1)))
__err |= ios_base::failbit;
}
}
catch(__cxxabiv1::__forced_unwind&)
{
this->_M_setstate(ios_base::badbit);
throw;
}
catch(...)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
}
return *this;
}
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
seekg(off_type __off, ios_base::seekdir __dir)
{
this->clear(this->rdstate() & ~ios_base::eofbit);
sentry __cerb(*this, true);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
try
{
if (!this->fail())
{
const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
ios_base::in);
if (__p == pos_type(off_type(-1)))
__err |= ios_base::failbit;
}
}
catch(__cxxabiv1::__forced_unwind&)
{
this->_M_setstate(ios_base::badbit);
throw;
}
catch(...)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
}
return *this;
}
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
{
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef typename __istream_type::int_type __int_type;
typename __istream_type::sentry __cerb(__in, false);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
try
{
const __int_type __cb = __in.rdbuf()->sbumpc();
if (!_Traits::eq_int_type(__cb, _Traits::eof()))
__c = _Traits::to_char_type(__cb);
else
__err |= (ios_base::eofbit | ios_base::failbit);
}
catch(__cxxabiv1::__forced_unwind&)
{
__in._M_setstate(ios_base::badbit);
throw;
}
catch(...)
{ __in._M_setstate(ios_base::badbit); }
if (__err)
__in.setstate(__err);
}
return __in;
}
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
{
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
typedef typename _Traits::int_type int_type;
typedef _CharT char_type;
typedef ctype<_CharT> __ctype_type;
streamsize __extracted = 0;
ios_base::iostate __err = ios_base::goodbit;
typename __istream_type::sentry __cerb(__in, false);
if (__cerb)
{
try
{
streamsize __num = __in.width();
if (__num <= 0)
__num = __gnu_cxx::__numeric_traits<streamsize>::__max;
const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
const int_type __eof = _Traits::eof();
__streambuf_type* __sb = __in.rdbuf();
int_type __c = __sb->sgetc();
while (__extracted < __num - 1
&& !_Traits::eq_int_type(__c, __eof)
&& !__ct.is(ctype_base::space,
_Traits::to_char_type(__c)))
{
*__s++ = _Traits::to_char_type(__c);
++__extracted;
__c = __sb->snextc();
}
if (_Traits::eq_int_type(__c, __eof))
__err |= ios_base::eofbit;
*__s = char_type();
__in.width(0);
}
catch(__cxxabiv1::__forced_unwind&)
{
__in._M_setstate(ios_base::badbit);
throw;
}
catch(...)
{ __in._M_setstate(ios_base::badbit); }
}
if (!__extracted)
__err |= ios_base::failbit;
if (__err)
__in.setstate(__err);
return __in;
}
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
ws(basic_istream<_CharT, _Traits>& __in)
{
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
typedef typename __istream_type::int_type __int_type;
typedef ctype<_CharT> __ctype_type;
const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
const __int_type __eof = _Traits::eof();
__streambuf_type* __sb = __in.rdbuf();
__int_type __c = __sb->sgetc();
while (!_Traits::eq_int_type(__c, __eof)
&& __ct.is(ctype_base::space, _Traits::to_char_type(__c)))
__c = __sb->snextc();
if (_Traits::eq_int_type(__c, __eof))
__in.setstate(ios_base::eofbit);
return __in;
}
extern template class basic_istream<char>;
extern template istream& ws(istream&);
extern template istream& operator>>(istream&, char&);
extern template istream& operator>>(istream&, char*);
extern template istream& operator>>(istream&, unsigned char&);
extern template istream& operator>>(istream&, signed char&);
extern template istream& operator>>(istream&, unsigned char*);
extern template istream& operator>>(istream&, signed char*);
extern template istream& istream::_M_extract(unsigned short&);
extern template istream& istream::_M_extract(unsigned int&);
extern template istream& istream::_M_extract(long&);
extern template istream& istream::_M_extract(unsigned long&);
extern template istream& istream::_M_extract(bool&);
extern template istream& istream::_M_extract(long long&);
extern template istream& istream::_M_extract(unsigned long long&);
extern template istream& istream::_M_extract(float&);
extern template istream& istream::_M_extract(double&);
extern template istream& istream::_M_extract(long double&);
extern template istream& istream::_M_extract(void*&);
extern template class basic_iostream<char>;
extern template class basic_istream<wchar_t>;
extern template wistream& ws(wistream&);
extern template wistream& operator>>(wistream&, wchar_t&);
extern template wistream& operator>>(wistream&, wchar_t*);
extern template wistream& wistream::_M_extract(unsigned short&);
extern template wistream& wistream::_M_extract(unsigned int&);
extern template wistream& wistream::_M_extract(long&);
extern template wistream& wistream::_M_extract(unsigned long&);
extern template wistream& wistream::_M_extract(bool&);
extern template wistream& wistream::_M_extract(long long&);
extern template wistream& wistream::_M_extract(unsigned long long&);
extern template wistream& wistream::_M_extract(float&);
extern template wistream& wistream::_M_extract(double&);
extern template wistream& wistream::_M_extract(long double&);
extern template wistream& wistream::_M_extract(void*&);
extern template class basic_iostream<wchar_t>;
}
# 935 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 2 3
# 41 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iostream" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 60 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iostream" 3
extern istream cin;
extern ostream cout;
extern ostream cerr;
extern ostream clog;
extern wistream wcin;
extern wostream wcout;
extern wostream wcerr;
extern wostream wclog;
static ios_base::Init __ioinit;
}
# 5 "/afs/cern.ch/user/p/piyush/work/bitonic64/src/bitonicSort.h" 2
# 1 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int.h" 1
# 54 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int.h"
# 1 "/data/tools/Xilinx/Vivado/2019.1/include/ap_common.h" 1
# 57 "/data/tools/Xilinx/Vivado/2019.1/include/ap_common.h"
# 1 "/data/tools/Xilinx/Vivado/2019.1/include/ap_decl.h" 1
# 100 "/data/tools/Xilinx/Vivado/2019.1/include/ap_decl.h"
# 100 "/data/tools/Xilinx/Vivado/2019.1/include/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 "/data/tools/Xilinx/Vivado/2019.1/include/ap_decl.h"
enum ap_o_mode {
AP_SAT,
AP_SAT_ZERO,
AP_SAT_SYM,
AP_WRAP,
AP_WRAP_SM,
};
# 179 "/data/tools/Xilinx/Vivado/2019.1/include/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 };
# 233 "/data/tools/Xilinx/Vivado/2019.1/include/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
};
# 58 "/data/tools/Xilinx/Vivado/2019.1/include/ap_common.h" 2
# 66 "/data/tools/Xilinx/Vivado/2019.1/include/ap_common.h"
# 1 "/usr/include/assert.h" 1 3 4
# 65 "/usr/include/assert.h" 3 4
# 65 "/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__));
}
# 67 "/data/tools/Xilinx/Vivado/2019.1/include/ap_common.h" 2
# 77 "/data/tools/Xilinx/Vivado/2019.1/include/ap_common.h"
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/stdlib.h" 1 3
# 36 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/stdlib.h" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 1 3
# 39 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 3
# 40 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 3
# 37 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/stdlib.h" 2 3
using std::abort;
using std::atexit;
using std::exit;
using std::at_quick_exit;
using std::quick_exit;
using std::div_t;
using std::ldiv_t;
using std::abs;
using std::atof;
using std::atoi;
using std::atol;
using std::bsearch;
using std::calloc;
using std::div;
using std::free;
using std::getenv;
using std::labs;
using std::ldiv;
using std::malloc;
using std::mblen;
using std::mbstowcs;
using std::mbtowc;
using std::qsort;
using std::rand;
using std::realloc;
using std::srand;
using std::strtod;
using std::strtol;
using std::strtoul;
using std::system;
using std::wcstombs;
using std::wctomb;
# 78 "/data/tools/Xilinx/Vivado/2019.1/include/ap_common.h" 2
# 151 "/data/tools/Xilinx/Vivado/2019.1/include/ap_common.h"
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/sstream" 1 3
# 36 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/sstream" 3
# 37 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/sstream" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
namespace __cxx11 {
# 64 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/sstream" 3
template<typename _CharT, typename _Traits, typename _Alloc>
class basic_stringbuf : public basic_streambuf<_CharT, _Traits>
{
struct __xfer_bufptrs;
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef _Alloc allocator_type;
typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type;
typedef basic_streambuf<char_type, traits_type> __streambuf_type;
typedef basic_string<char_type, _Traits, _Alloc> __string_type;
typedef typename __string_type::size_type __size_type;
protected:
ios_base::openmode _M_mode;
__string_type _M_string;
public:
# 99 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/sstream" 3
explicit
basic_stringbuf(ios_base::openmode __mode = ios_base::in | ios_base::out)
: __streambuf_type(), _M_mode(__mode), _M_string()
{ }
# 112 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/sstream" 3
explicit
basic_stringbuf(const __string_type& __str,
ios_base::openmode __mode = ios_base::in | ios_base::out)
: __streambuf_type(), _M_mode(), _M_string(__str.data(), __str.size())
{ _M_stringbuf_init(__mode); }
basic_stringbuf(const basic_stringbuf&) = delete;
basic_stringbuf(basic_stringbuf&& __rhs)
: basic_stringbuf(std::move(__rhs), __xfer_bufptrs(__rhs, this))
{ __rhs._M_sync(const_cast<char_type*>(__rhs._M_string.data()), 0, 0); }
basic_stringbuf&
operator=(const basic_stringbuf&) = delete;
basic_stringbuf&
operator=(basic_stringbuf&& __rhs)
{
__xfer_bufptrs __st{__rhs, this};
const __streambuf_type& __base = __rhs;
__streambuf_type::operator=(__base);
this->pubimbue(__rhs.getloc());
_M_mode = __rhs._M_mode;
_M_string = std::move(__rhs._M_string);
__rhs._M_sync(const_cast<char_type*>(__rhs._M_string.data()), 0, 0);
return *this;
}
void
swap(basic_stringbuf& __rhs)
{
__xfer_bufptrs __l_st{*this, std::__addressof(__rhs)};
__xfer_bufptrs __r_st{__rhs, this};
__streambuf_type& __base = __rhs;
__streambuf_type::swap(__base);
__rhs.pubimbue(this->pubimbue(__rhs.getloc()));
std::swap(_M_mode, __rhs._M_mode);
std::swap(_M_string, __rhs._M_string);
}
# 165 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/sstream" 3
__string_type
str() const
{
__string_type __ret;
if (this->pptr())
{
if (this->pptr() > this->egptr())
__ret = __string_type(this->pbase(), this->pptr());
else
__ret = __string_type(this->pbase(), this->egptr());
}
else
__ret = _M_string;
return __ret;
}
# 189 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/sstream" 3
void
str(const __string_type& __s)
{
_M_string.assign(__s.data(), __s.size());
_M_stringbuf_init(_M_mode);
}
protected:
void
_M_stringbuf_init(ios_base::openmode __mode)
{
_M_mode = __mode;
__size_type __len = 0;
if (_M_mode & (ios_base::ate | ios_base::app))
__len = _M_string.size();
_M_sync(const_cast<char_type*>(_M_string.data()), 0, __len);
}
virtual streamsize
showmanyc()
{
streamsize __ret = -1;
if (_M_mode & ios_base::in)
{
_M_update_egptr();
__ret = this->egptr() - this->gptr();
}
return __ret;
}
virtual int_type
underflow();
virtual int_type
pbackfail(int_type __c = traits_type::eof());
virtual int_type
overflow(int_type __c = traits_type::eof());
# 242 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/sstream" 3
virtual __streambuf_type*
setbuf(char_type* __s, streamsize __n)
{
if (__s && __n >= 0)
{
_M_string.clear();
_M_sync(__s, __n, 0);
}
return this;
}
virtual pos_type
seekoff(off_type __off, ios_base::seekdir __way,
ios_base::openmode __mode = ios_base::in | ios_base::out);
virtual pos_type
seekpos(pos_type __sp,
ios_base::openmode __mode = ios_base::in | ios_base::out);
void
_M_sync(char_type* __base, __size_type __i, __size_type __o);
void
_M_update_egptr()
{
const bool __testin = _M_mode & ios_base::in;
if (this->pptr() && this->pptr() > this->egptr())
{
if (__testin)
this->setg(this->eback(), this->gptr(), this->pptr());
else
this->setg(this->pptr(), this->pptr(), this->pptr());
}
}
void
_M_pbump(char_type* __pbeg, char_type* __pend, off_type __off);
private:
struct __xfer_bufptrs
{
__xfer_bufptrs(const basic_stringbuf& __from, basic_stringbuf* __to)
: _M_to{__to}, _M_goff{-1, -1, -1}, _M_poff{-1, -1, -1}
{
const _CharT* __str = __from._M_string.data();
if (__from.eback())
{
_M_goff[0] = __from.eback() - __str;
_M_goff[1] = __from.gptr() - __str;
_M_goff[2] = __from.egptr() - __str;
}
if (__from.pbase())
{
_M_poff[0] = __from.pbase() - __str;
_M_poff[1] = __from.pptr() - __from.pbase();
_M_poff[2] = __from.epptr() - __str;
}
}
~__xfer_bufptrs()
{
char_type* __str = const_cast<char_type*>(_M_to->_M_string.data());
if (_M_goff[0] != -1)
_M_to->setg(__str+_M_goff[0], __str+_M_goff[1], __str+_M_goff[2]);
if (_M_poff[0] != -1)
_M_to->_M_pbump(__str+_M_poff[0], __str+_M_poff[2], _M_poff[1]);
}
basic_stringbuf* _M_to;
off_type _M_goff[3];
off_type _M_poff[3];
};
# 343 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/sstream" 3
basic_stringbuf(basic_stringbuf&& __rhs, __xfer_bufptrs&&)
: __streambuf_type(static_cast<const __streambuf_type&>(__rhs)),
_M_mode(__rhs._M_mode), _M_string(std::move(__rhs._M_string))
{ }
};
# 366 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/sstream" 3
template<typename _CharT, typename _Traits, typename _Alloc>
class basic_istringstream : public basic_istream<_CharT, _Traits>
{
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef _Alloc allocator_type;
typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type;
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
typedef basic_istream<char_type, traits_type> __istream_type;
private:
__stringbuf_type _M_stringbuf;
public:
# 402 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/sstream" 3
explicit
basic_istringstream(ios_base::openmode __mode = ios_base::in)
: __istream_type(), _M_stringbuf(__mode | ios_base::in)
{ this->init(&_M_stringbuf); }
# 420 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/sstream" 3
explicit
basic_istringstream(const __string_type& __str,
ios_base::openmode __mode = ios_base::in)
: __istream_type(), _M_stringbuf(__str, __mode | ios_base::in)
{ this->init(&_M_stringbuf); }
~basic_istringstream()
{ }
basic_istringstream(const basic_istringstream&) = delete;
basic_istringstream(basic_istringstream&& __rhs)
: __istream_type(std::move(__rhs)),
_M_stringbuf(std::move(__rhs._M_stringbuf))
{ __istream_type::set_rdbuf(&_M_stringbuf); }
basic_istringstream&
operator=(const basic_istringstream&) = delete;
basic_istringstream&
operator=(basic_istringstream&& __rhs)
{
__istream_type::operator=(std::move(__rhs));
_M_stringbuf = std::move(__rhs._M_stringbuf);
return *this;
}
void
swap(basic_istringstream& __rhs)
{
__istream_type::swap(__rhs);
_M_stringbuf.swap(__rhs._M_stringbuf);
}
# 471 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/sstream" 3
__stringbuf_type*
rdbuf() const
{ return const_cast<__stringbuf_type*>(&_M_stringbuf); }
__string_type
str() const
{ return _M_stringbuf.str(); }
void
str(const __string_type& __s)
{ _M_stringbuf.str(__s); }
};
# 510 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/sstream" 3
template <typename _CharT, typename _Traits, typename _Alloc>
class basic_ostringstream : public basic_ostream<_CharT, _Traits>
{
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef _Alloc allocator_type;
typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type;
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
typedef basic_ostream<char_type, traits_type> __ostream_type;
private:
__stringbuf_type _M_stringbuf;
public:
# 546 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/sstream" 3
explicit
basic_ostringstream(ios_base::openmode __mode = ios_base::out)
: __ostream_type(), _M_stringbuf(__mode | ios_base::out)
{ this->init(&_M_stringbuf); }
# 564 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/sstream" 3
explicit
basic_ostringstream(const __string_type& __str,
ios_base::openmode __mode = ios_base::out)
: __ostream_type(), _M_stringbuf(__str, __mode | ios_base::out)
{ this->init(&_M_stringbuf); }
~basic_ostringstream()
{ }
basic_ostringstream(const basic_ostringstream&) = delete;
basic_ostringstream(basic_ostringstream&& __rhs)
: __ostream_type(std::move(__rhs)),
_M_stringbuf(std::move(__rhs._M_stringbuf))
{ __ostream_type::set_rdbuf(&_M_stringbuf); }
basic_ostringstream&
operator=(const basic_ostringstream&) = delete;
basic_ostringstream&
operator=(basic_ostringstream&& __rhs)
{
__ostream_type::operator=(std::move(__rhs));
_M_stringbuf = std::move(__rhs._M_stringbuf);
return *this;
}
void
swap(basic_ostringstream& __rhs)
{
__ostream_type::swap(__rhs);
_M_stringbuf.swap(__rhs._M_stringbuf);
}
# 615 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/sstream" 3
__stringbuf_type*
rdbuf() const
{ return const_cast<__stringbuf_type*>(&_M_stringbuf); }
__string_type
str() const
{ return _M_stringbuf.str(); }
void
str(const __string_type& __s)
{ _M_stringbuf.str(__s); }
};
# 654 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/sstream" 3
template <typename _CharT, typename _Traits, typename _Alloc>
class basic_stringstream : public basic_iostream<_CharT, _Traits>
{
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef _Alloc allocator_type;
typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type;
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
typedef basic_iostream<char_type, traits_type> __iostream_type;
private:
__stringbuf_type _M_stringbuf;
public:
# 689 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/sstream" 3
explicit
basic_stringstream(ios_base::openmode __m = ios_base::out | ios_base::in)
: __iostream_type(), _M_stringbuf(__m)
{ this->init(&_M_stringbuf); }
# 705 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/sstream" 3
explicit
basic_stringstream(const __string_type& __str,
ios_base::openmode __m = ios_base::out | ios_base::in)
: __iostream_type(), _M_stringbuf(__str, __m)
{ this->init(&_M_stringbuf); }
~basic_stringstream()
{ }
basic_stringstream(const basic_stringstream&) = delete;
basic_stringstream(basic_stringstream&& __rhs)
: __iostream_type(std::move(__rhs)),
_M_stringbuf(std::move(__rhs._M_stringbuf))
{ __iostream_type::set_rdbuf(&_M_stringbuf); }
basic_stringstream&
operator=(const basic_stringstream&) = delete;
basic_stringstream&
operator=(basic_stringstream&& __rhs)
{
__iostream_type::operator=(std::move(__rhs));
_M_stringbuf = std::move(__rhs._M_stringbuf);
return *this;
}
void
swap(basic_stringstream& __rhs)
{
__iostream_type::swap(__rhs);
_M_stringbuf.swap(__rhs._M_stringbuf);
}
# 756 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/sstream" 3
__stringbuf_type*
rdbuf() const
{ return const_cast<__stringbuf_type*>(&_M_stringbuf); }
__string_type
str() const
{ return _M_stringbuf.str(); }
void
str(const __string_type& __s)
{ _M_stringbuf.str(__s); }
};
template <class _CharT, class _Traits, class _Allocator>
inline void
swap(basic_stringbuf<_CharT, _Traits, _Allocator>& __x,
basic_stringbuf<_CharT, _Traits, _Allocator>& __y)
{ __x.swap(__y); }
template <class _CharT, class _Traits, class _Allocator>
inline void
swap(basic_istringstream<_CharT, _Traits, _Allocator>& __x,
basic_istringstream<_CharT, _Traits, _Allocator>& __y)
{ __x.swap(__y); }
template <class _CharT, class _Traits, class _Allocator>
inline void
swap(basic_ostringstream<_CharT, _Traits, _Allocator>& __x,
basic_ostringstream<_CharT, _Traits, _Allocator>& __y)
{ __x.swap(__y); }
template <class _CharT, class _Traits, class _Allocator>
inline void
swap(basic_stringstream<_CharT, _Traits, _Allocator>& __x,
basic_stringstream<_CharT, _Traits, _Allocator>& __y)
{ __x.swap(__y); }
}
}
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/sstream.tcc" 1 3
# 37 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/sstream.tcc" 3
# 38 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/sstream.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template <class _CharT, class _Traits, class _Alloc>
typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
basic_stringbuf<_CharT, _Traits, _Alloc>::
pbackfail(int_type __c)
{
int_type __ret = traits_type::eof();
if (this->eback() < this->gptr())
{
const bool __testeof = traits_type::eq_int_type(__c, __ret);
if (!__testeof)
{
const bool __testeq = traits_type::eq(traits_type::
to_char_type(__c),
this->gptr()[-1]);
const bool __testout = this->_M_mode & ios_base::out;
if (__testeq || __testout)
{
this->gbump(-1);
if (!__testeq)
*this->gptr() = traits_type::to_char_type(__c);
__ret = __c;
}
}
else
{
this->gbump(-1);
__ret = traits_type::not_eof(__c);
}
}
return __ret;
}
template <class _CharT, class _Traits, class _Alloc>
typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
basic_stringbuf<_CharT, _Traits, _Alloc>::
overflow(int_type __c)
{
const bool __testout = this->_M_mode & ios_base::out;
if (__builtin_expect(!__testout, false))
return traits_type::eof();
const bool __testeof = traits_type::eq_int_type(__c, traits_type::eof());
if (__builtin_expect(__testeof, false))
return traits_type::not_eof(__c);
const __size_type __capacity = _M_string.capacity();
const __size_type __max_size = _M_string.max_size();
const bool __testput = this->pptr() < this->epptr();
if (__builtin_expect(!__testput && __capacity == __max_size, false))
return traits_type::eof();
const char_type __conv = traits_type::to_char_type(__c);
if (!__testput)
{
# 110 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/sstream.tcc" 3
const __size_type __opt_len = std::max(__size_type(2 * __capacity),
__size_type(512));
const __size_type __len = std::min(__opt_len, __max_size);
__string_type __tmp;
__tmp.reserve(__len);
if (this->pbase())
__tmp.assign(this->pbase(), this->epptr() - this->pbase());
__tmp.push_back(__conv);
_M_string.swap(__tmp);
_M_sync(const_cast<char_type*>(_M_string.data()),
this->gptr() - this->eback(), this->pptr() - this->pbase());
}
else
*this->pptr() = __conv;
this->pbump(1);
return __c;
}
template <class _CharT, class _Traits, class _Alloc>
typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
basic_stringbuf<_CharT, _Traits, _Alloc>::
underflow()
{
int_type __ret = traits_type::eof();
const bool __testin = this->_M_mode & ios_base::in;
if (__testin)
{
_M_update_egptr();
if (this->gptr() < this->egptr())
__ret = traits_type::to_int_type(*this->gptr());
}
return __ret;
}
template <class _CharT, class _Traits, class _Alloc>
typename basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type
basic_stringbuf<_CharT, _Traits, _Alloc>::
seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __mode)
{
pos_type __ret = pos_type(off_type(-1));
bool __testin = (ios_base::in & this->_M_mode & __mode) != 0;
bool __testout = (ios_base::out & this->_M_mode & __mode) != 0;
const bool __testboth = __testin && __testout && __way != ios_base::cur;
__testin &= !(__mode & ios_base::out);
__testout &= !(__mode & ios_base::in);
const char_type* __beg = __testin ? this->eback() : this->pbase();
if ((__beg || !__off) && (__testin || __testout || __testboth))
{
_M_update_egptr();
off_type __newoffi = __off;
off_type __newoffo = __newoffi;
if (__way == ios_base::cur)
{
__newoffi += this->gptr() - __beg;
__newoffo += this->pptr() - __beg;
}
else if (__way == ios_base::end)
__newoffo = __newoffi += this->egptr() - __beg;
if ((__testin || __testboth)
&& __newoffi >= 0
&& this->egptr() - __beg >= __newoffi)
{
this->setg(this->eback(), this->eback() + __newoffi,
this->egptr());
__ret = pos_type(__newoffi);
}
if ((__testout || __testboth)
&& __newoffo >= 0
&& this->egptr() - __beg >= __newoffo)
{
_M_pbump(this->pbase(), this->epptr(), __newoffo);
__ret = pos_type(__newoffo);
}
}
return __ret;
}
template <class _CharT, class _Traits, class _Alloc>
typename basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type
basic_stringbuf<_CharT, _Traits, _Alloc>::
seekpos(pos_type __sp, ios_base::openmode __mode)
{
pos_type __ret = pos_type(off_type(-1));
const bool __testin = (ios_base::in & this->_M_mode & __mode) != 0;
const bool __testout = (ios_base::out & this->_M_mode & __mode) != 0;
const char_type* __beg = __testin ? this->eback() : this->pbase();
if ((__beg || !off_type(__sp)) && (__testin || __testout))
{
_M_update_egptr();
const off_type __pos(__sp);
const bool __testpos = (0 <= __pos
&& __pos <= this->egptr() - __beg);
if (__testpos)
{
if (__testin)
this->setg(this->eback(), this->eback() + __pos,
this->egptr());
if (__testout)
_M_pbump(this->pbase(), this->epptr(), __pos);
__ret = __sp;
}
}
return __ret;
}
template <class _CharT, class _Traits, class _Alloc>
void
basic_stringbuf<_CharT, _Traits, _Alloc>::
_M_sync(char_type* __base, __size_type __i, __size_type __o)
{
const bool __testin = _M_mode & ios_base::in;
const bool __testout = _M_mode & ios_base::out;
char_type* __endg = __base + _M_string.size();
char_type* __endp = __base + _M_string.capacity();
if (__base != _M_string.data())
{
__endg += __i;
__i = 0;
__endp = __endg;
}
if (__testin)
this->setg(__base, __base + __i, __endg);
if (__testout)
{
_M_pbump(__base, __endp, __o);
if (!__testin)
this->setg(__endg, __endg, __endg);
}
}
template <class _CharT, class _Traits, class _Alloc>
void
basic_stringbuf<_CharT, _Traits, _Alloc>::
_M_pbump(char_type* __pbeg, char_type* __pend, off_type __off)
{
this->setp(__pbeg, __pend);
while (__off > __gnu_cxx::__numeric_traits<int>::__max)
{
this->pbump(__gnu_cxx::__numeric_traits<int>::__max);
__off -= __gnu_cxx::__numeric_traits<int>::__max;
}
this->pbump(__off);
}
extern template class basic_stringbuf<char>;
extern template class basic_istringstream<char>;
extern template class basic_ostringstream<char>;
extern template class basic_stringstream<char>;
extern template class basic_stringbuf<wchar_t>;
extern template class basic_istringstream<wchar_t>;
extern template class basic_ostringstream<wchar_t>;
extern template class basic_stringstream<wchar_t>;
}
# 814 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/sstream" 2 3
# 152 "/data/tools/Xilinx/Vivado/2019.1/include/ap_common.h" 2
# 157 "/data/tools/Xilinx/Vivado/2019.1/include/ap_common.h"
enum { CHAR_IS_SIGNED = (char)-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;
};
}
# 574 "/data/tools/Xilinx/Vivado/2019.1/include/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;
}
# 602 "/data/tools/Xilinx/Vivado/2019.1/include/ap_common.h"
class half;
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cmath" 1 3
# 39 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cmath" 3
# 40 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cmath" 3
# 1 "/usr/include/math.h" 1 3 4
# 29 "/usr/include/math.h" 3 4
# 29 "/usr/include/math.h" 3 4
extern "C" {
# 1 "/usr/include/bits/huge_val.h" 1 3 4
# 34 "/usr/include/math.h" 2 3 4
# 1 "/usr/include/bits/huge_valf.h" 1 3 4
# 36 "/usr/include/math.h" 2 3 4
# 1 "/usr/include/bits/huge_vall.h" 1 3 4
# 37 "/usr/include/math.h" 2 3 4
# 1 "/usr/include/bits/inf.h" 1 3 4
# 40 "/usr/include/math.h" 2 3 4
# 1 "/usr/include/bits/nan.h" 1 3 4
# 43 "/usr/include/math.h" 2 3 4
# 1 "/usr/include/bits/mathdef.h" 1 3 4
# 28 "/usr/include/bits/mathdef.h" 3 4
typedef float float_t;
typedef double double_t;
# 47 "/usr/include/math.h" 2 3 4
# 70 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls.h" 1 3 4
# 52 "/usr/include/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 ();
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 ();
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__));
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 ();
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 ();
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 ();
extern double scalb (double __x, double __n) throw (); extern double __scalb (double __x, double __n) throw ();
# 71 "/usr/include/math.h" 2 3 4
# 89 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls.h" 1 3 4
# 52 "/usr/include/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 ();
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 ();
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__));
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 ();
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 ();
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 ();
extern float scalbf (float __x, float __n) throw (); extern float __scalbf (float __x, float __n) throw ();
# 90 "/usr/include/math.h" 2 3 4
# 133 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls.h" 1 3 4
# 52 "/usr/include/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 ();
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 ();
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__));
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 ();
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 ();
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 ();
extern long double scalbl (long double __x, long double __n) throw (); extern long double __scalbl (long double __x, long double __n) throw ();
# 134 "/usr/include/math.h" 2 3 4
# 149 "/usr/include/math.h" 3 4
extern int signgam;
# 190 "/usr/include/math.h" 3 4
enum
{
FP_NAN =
0,
FP_INFINITE =
1,
FP_ZERO =
2,
FP_SUBNORMAL =
3,
FP_NORMAL =
4
};
# 288 "/usr/include/math.h" 3 4
typedef enum
{
_IEEE_ = -1,
_SVID_,
_XOPEN_,
_POSIX_,
_ISOC_
} _LIB_VERSION_TYPE;
extern _LIB_VERSION_TYPE _LIB_VERSION;
# 311 "/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 ();
# 475 "/usr/include/math.h" 3 4
}
# 46 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cmath" 2 3
# 77 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cmath" 3
extern "C++"
{
namespace std __attribute__ ((__visibility__ ("default")))
{
inline constexpr double
abs(double __x)
{ return __builtin_fabs(__x); }
inline constexpr float
abs(float __x)
{ return __builtin_fabsf(__x); }
inline constexpr long double
abs(long double __x)
{ return __builtin_fabsl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
abs(_Tp __x)
{ return __builtin_fabs(__x); }
using ::acos;
inline constexpr float
acos(float __x)
{ return __builtin_acosf(__x); }
inline constexpr long double
acos(long double __x)
{ return __builtin_acosl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
acos(_Tp __x)
{ return __builtin_acos(__x); }
using ::asin;
inline constexpr float
asin(float __x)
{ return __builtin_asinf(__x); }
inline constexpr long double
asin(long double __x)
{ return __builtin_asinl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
asin(_Tp __x)
{ return __builtin_asin(__x); }
using ::atan;
inline constexpr float
atan(float __x)
{ return __builtin_atanf(__x); }
inline constexpr long double
atan(long double __x)
{ return __builtin_atanl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
atan(_Tp __x)
{ return __builtin_atan(__x); }
using ::atan2;
inline constexpr float
atan2(float __y, float __x)
{ return __builtin_atan2f(__y, __x); }
inline constexpr long double
atan2(long double __y, long double __x)
{ return __builtin_atan2l(__y, __x); }
template<typename _Tp, typename _Up>
inline constexpr
typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
atan2(_Tp __y, _Up __x)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return atan2(__type(__y), __type(__x));
}
using ::ceil;
inline constexpr float
ceil(float __x)
{ return __builtin_ceilf(__x); }
inline constexpr long double
ceil(long double __x)
{ return __builtin_ceill(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
ceil(_Tp __x)
{ return __builtin_ceil(__x); }
using ::cos;
inline constexpr float
cos(float __x)
{ return __builtin_cosf(__x); }
inline constexpr long double
cos(long double __x)
{ return __builtin_cosl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
cos(_Tp __x)
{ return __builtin_cos(__x); }
using ::cosh;
inline constexpr float
cosh(float __x)
{ return __builtin_coshf(__x); }
inline constexpr long double
cosh(long double __x)
{ return __builtin_coshl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
cosh(_Tp __x)
{ return __builtin_cosh(__x); }
using ::exp;
inline constexpr float
exp(float __x)
{ return __builtin_expf(__x); }
inline constexpr long double
exp(long double __x)
{ return __builtin_expl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
exp(_Tp __x)
{ return __builtin_exp(__x); }
using ::fabs;
inline constexpr float
fabs(float __x)
{ return __builtin_fabsf(__x); }
inline constexpr long double
fabs(long double __x)
{ return __builtin_fabsl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
fabs(_Tp __x)
{ return __builtin_fabs(__x); }
using ::floor;
inline constexpr float
floor(float __x)
{ return __builtin_floorf(__x); }
inline constexpr long double
floor(long double __x)
{ return __builtin_floorl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
floor(_Tp __x)
{ return __builtin_floor(__x); }
using ::fmod;
inline constexpr float
fmod(float __x, float __y)
{ return __builtin_fmodf(__x, __y); }
inline constexpr long double
fmod(long double __x, long double __y)
{ return __builtin_fmodl(__x, __y); }
template<typename _Tp, typename _Up>
inline constexpr
typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
fmod(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return fmod(__type(__x), __type(__y));
}
using ::frexp;
inline float
frexp(float __x, int* __exp)
{ return __builtin_frexpf(__x, __exp); }
inline long double
frexp(long double __x, int* __exp)
{ return __builtin_frexpl(__x, __exp); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
frexp(_Tp __x, int* __exp)
{ return __builtin_frexp(__x, __exp); }
using ::ldexp;
inline constexpr float
ldexp(float __x, int __exp)
{ return __builtin_ldexpf(__x, __exp); }
inline constexpr long double
ldexp(long double __x, int __exp)
{ return __builtin_ldexpl(__x, __exp); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
ldexp(_Tp __x, int __exp)
{ return __builtin_ldexp(__x, __exp); }
using ::log;
inline constexpr float
log(float __x)
{ return __builtin_logf(__x); }
inline constexpr long double
log(long double __x)
{ return __builtin_logl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
log(_Tp __x)
{ return __builtin_log(__x); }
using ::log10;
inline constexpr float
log10(float __x)
{ return __builtin_log10f(__x); }
inline constexpr long double
log10(long double __x)
{ return __builtin_log10l(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
log10(_Tp __x)
{ return __builtin_log10(__x); }
using ::modf;
inline float
modf(float __x, float* __iptr)
{ return __builtin_modff(__x, __iptr); }
inline long double
modf(long double __x, long double* __iptr)
{ return __builtin_modfl(__x, __iptr); }
using ::pow;
inline constexpr float
pow(float __x, float __y)
{ return __builtin_powf(__x, __y); }
inline constexpr long double
pow(long double __x, long double __y)
{ return __builtin_powl(__x, __y); }
# 435 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cmath" 3
template<typename _Tp, typename _Up>
inline constexpr
typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
pow(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return pow(__type(__x), __type(__y));
}
using ::sin;
inline constexpr float
sin(float __x)
{ return __builtin_sinf(__x); }
inline constexpr long double
sin(long double __x)
{ return __builtin_sinl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
sin(_Tp __x)
{ return __builtin_sin(__x); }
using ::sinh;
inline constexpr float
sinh(float __x)
{ return __builtin_sinhf(__x); }
inline constexpr long double
sinh(long double __x)
{ return __builtin_sinhl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
sinh(_Tp __x)
{ return __builtin_sinh(__x); }
using ::sqrt;
inline constexpr float
sqrt(float __x)
{ return __builtin_sqrtf(__x); }
inline constexpr long double
sqrt(long double __x)
{ return __builtin_sqrtl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
sqrt(_Tp __x)
{ return __builtin_sqrt(__x); }
using ::tan;
inline constexpr float
tan(float __x)
{ return __builtin_tanf(__x); }
inline constexpr long double
tan(long double __x)
{ return __builtin_tanl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
tan(_Tp __x)
{ return __builtin_tan(__x); }
using ::tanh;
inline constexpr float
tanh(float __x)
{ return __builtin_tanhf(__x); }
inline constexpr long double
tanh(long double __x)
{ return __builtin_tanhl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
tanh(_Tp __x)
{ return __builtin_tanh(__x); }
}
# 559 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cmath" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
constexpr int
fpclassify(float __x)
{ return __builtin_fpclassify(0, 1, 4,
3, 2, __x); }
constexpr int
fpclassify(double __x)
{ return __builtin_fpclassify(0, 1, 4,
3, 2, __x); }
constexpr int
fpclassify(long double __x)
{ return __builtin_fpclassify(0, 1, 4,
3, 2, __x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
int>::__type
fpclassify(_Tp __x)
{ return __x != 0 ? 4 : 2; }
constexpr bool
isfinite(float __x)
{ return __builtin_isfinite(__x); }
constexpr bool
isfinite(double __x)
{ return __builtin_isfinite(__x); }
constexpr bool
isfinite(long double __x)
{ return __builtin_isfinite(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
bool>::__type
isfinite(_Tp __x)
{ return true; }
constexpr bool
isinf(float __x)
{ return __builtin_isinf(__x); }
using ::isinf;
constexpr bool
isinf(long double __x)
{ return __builtin_isinf(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
bool>::__type
isinf(_Tp __x)
{ return false; }
constexpr bool
isnan(float __x)
{ return __builtin_isnan(__x); }
using ::isnan;
constexpr bool
isnan(long double __x)
{ return __builtin_isnan(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
bool>::__type
isnan(_Tp __x)
{ return false; }
constexpr bool
isnormal(float __x)
{ return __builtin_isnormal(__x); }
constexpr bool
isnormal(double __x)
{ return __builtin_isnormal(__x); }
constexpr bool
isnormal(long double __x)
{ return __builtin_isnormal(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
bool>::__type
isnormal(_Tp __x)
{ return __x != 0 ? true : false; }
constexpr bool
signbit(float __x)
{ return __builtin_signbit(__x); }
constexpr bool
signbit(double __x)
{ return __builtin_signbit(__x); }
constexpr bool
signbit(long double __x)
{ return __builtin_signbit(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
bool>::__type
signbit(_Tp __x)
{ return __x < 0 ? true : false; }
constexpr bool
isgreater(float __x, float __y)
{ return __builtin_isgreater(__x, __y); }
constexpr bool
isgreater(double __x, double __y)
{ return __builtin_isgreater(__x, __y); }
constexpr bool
isgreater(long double __x, long double __y)
{ return __builtin_isgreater(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename
__gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
&& __is_arithmetic<_Up>::__value), bool>::__type
isgreater(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return __builtin_isgreater(__type(__x), __type(__y));
}
constexpr bool
isgreaterequal(float __x, float __y)
{ return __builtin_isgreaterequal(__x, __y); }
constexpr bool
isgreaterequal(double __x, double __y)
{ return __builtin_isgreaterequal(__x, __y); }
constexpr bool
isgreaterequal(long double __x, long double __y)
{ return __builtin_isgreaterequal(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename
__gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
&& __is_arithmetic<_Up>::__value), bool>::__type
isgreaterequal(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return __builtin_isgreaterequal(__type(__x), __type(__y));
}
constexpr bool
isless(float __x, float __y)
{ return __builtin_isless(__x, __y); }
constexpr bool
isless(double __x, double __y)
{ return __builtin_isless(__x, __y); }
constexpr bool
isless(long double __x, long double __y)
{ return __builtin_isless(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename
__gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
&& __is_arithmetic<_Up>::__value), bool>::__type
isless(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return __builtin_isless(__type(__x), __type(__y));
}
constexpr bool
islessequal(float __x, float __y)
{ return __builtin_islessequal(__x, __y); }
constexpr bool
islessequal(double __x, double __y)
{ return __builtin_islessequal(__x, __y); }
constexpr bool
islessequal(long double __x, long double __y)
{ return __builtin_islessequal(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename
__gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
&& __is_arithmetic<_Up>::__value), bool>::__type
islessequal(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return __builtin_islessequal(__type(__x), __type(__y));
}
constexpr bool
islessgreater(float __x, float __y)
{ return __builtin_islessgreater(__x, __y); }
constexpr bool
islessgreater(double __x, double __y)
{ return __builtin_islessgreater(__x, __y); }
constexpr bool
islessgreater(long double __x, long double __y)
{ return __builtin_islessgreater(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename
__gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
&& __is_arithmetic<_Up>::__value), bool>::__type
islessgreater(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return __builtin_islessgreater(__type(__x), __type(__y));
}
constexpr bool
isunordered(float __x, float __y)
{ return __builtin_isunordered(__x, __y); }
constexpr bool
isunordered(double __x, double __y)
{ return __builtin_isunordered(__x, __y); }
constexpr bool
isunordered(long double __x, long double __y)
{ return __builtin_isunordered(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename
__gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
&& __is_arithmetic<_Up>::__value), bool>::__type
isunordered(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return __builtin_isunordered(__type(__x), __type(__y));
}
# 956 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cmath" 3
}
# 1072 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cmath" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
using ::double_t;
using ::float_t;
using ::acosh;
using ::acoshf;
using ::acoshl;
using ::asinh;
using ::asinhf;
using ::asinhl;
using ::atanh;
using ::atanhf;
using ::atanhl;
using ::cbrt;
using ::cbrtf;
using ::cbrtl;
using ::copysign;
using ::copysignf;
using ::copysignl;
using ::erf;
using ::erff;
using ::erfl;
using ::erfc;
using ::erfcf;
using ::erfcl;
using ::exp2;
using ::exp2f;
using ::exp2l;
using ::expm1;
using ::expm1f;
using ::expm1l;
using ::fdim;
using ::fdimf;
using ::fdiml;
using ::fma;
using ::fmaf;
using ::fmal;
using ::fmax;
using ::fmaxf;
using ::fmaxl;
using ::fmin;
using ::fminf;
using ::fminl;
using ::hypot;
using ::hypotf;
using ::hypotl;
using ::ilogb;
using ::ilogbf;
using ::ilogbl;
using ::lgamma;
using ::lgammaf;
using ::lgammal;
using ::llrint;
using ::llrintf;
using ::llrintl;
using ::llround;
using ::llroundf;
using ::llroundl;
using ::log1p;
using ::log1pf;
using ::log1pl;
using ::log2;
using ::log2f;
using ::log2l;
using ::logb;
using ::logbf;
using ::logbl;
using ::lrint;
using ::lrintf;
using ::lrintl;
using ::lround;
using ::lroundf;
using ::lroundl;
using ::nan;
using ::nanf;
using ::nanl;
using ::nearbyint;
using ::nearbyintf;
using ::nearbyintl;
using ::nextafter;
using ::nextafterf;
using ::nextafterl;
using ::nexttoward;
using ::nexttowardf;
using ::nexttowardl;
using ::remainder;
using ::remainderf;
using ::remainderl;
using ::remquo;
using ::remquof;
using ::remquol;
using ::rint;
using ::rintf;
using ::rintl;
using ::round;
using ::roundf;
using ::roundl;
using ::scalbln;
using ::scalblnf;
using ::scalblnl;
using ::scalbn;
using ::scalbnf;
using ::scalbnl;
using ::tgamma;
using ::tgammaf;
using ::tgammal;
using ::trunc;
using ::truncf;
using ::truncl;
constexpr float
acosh(float __x)
{ return __builtin_acoshf(__x); }
constexpr long double
acosh(long double __x)
{ return __builtin_acoshl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
acosh(_Tp __x)
{ return __builtin_acosh(__x); }
constexpr float
asinh(float __x)
{ return __builtin_asinhf(__x); }
constexpr long double
asinh(long double __x)
{ return __builtin_asinhl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
asinh(_Tp __x)
{ return __builtin_asinh(__x); }
constexpr float
atanh(float __x)
{ return __builtin_atanhf(__x); }
constexpr long double
atanh(long double __x)
{ return __builtin_atanhl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
atanh(_Tp __x)
{ return __builtin_atanh(__x); }
constexpr float
cbrt(float __x)
{ return __builtin_cbrtf(__x); }
constexpr long double
cbrt(long double __x)
{ return __builtin_cbrtl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
cbrt(_Tp __x)
{ return __builtin_cbrt(__x); }
constexpr float
copysign(float __x, float __y)
{ return __builtin_copysignf(__x, __y); }
constexpr long double
copysign(long double __x, long double __y)
{ return __builtin_copysignl(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
copysign(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return copysign(__type(__x), __type(__y));
}
constexpr float
erf(float __x)
{ return __builtin_erff(__x); }
constexpr long double
erf(long double __x)
{ return __builtin_erfl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
erf(_Tp __x)
{ return __builtin_erf(__x); }
constexpr float
erfc(float __x)
{ return __builtin_erfcf(__x); }
constexpr long double
erfc(long double __x)
{ return __builtin_erfcl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
erfc(_Tp __x)
{ return __builtin_erfc(__x); }
constexpr float
exp2(float __x)
{ return __builtin_exp2f(__x); }
constexpr long double
exp2(long double __x)
{ return __builtin_exp2l(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
exp2(_Tp __x)
{ return __builtin_exp2(__x); }
constexpr float
expm1(float __x)
{ return __builtin_expm1f(__x); }
constexpr long double
expm1(long double __x)
{ return __builtin_expm1l(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
expm1(_Tp __x)
{ return __builtin_expm1(__x); }
constexpr float
fdim(float __x, float __y)
{ return __builtin_fdimf(__x, __y); }
constexpr long double
fdim(long double __x, long double __y)
{ return __builtin_fdiml(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
fdim(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return fdim(__type(__x), __type(__y));
}
constexpr float
fma(float __x, float __y, float __z)
{ return __builtin_fmaf(__x, __y, __z); }
constexpr long double
fma(long double __x, long double __y, long double __z)
{ return __builtin_fmal(__x, __y, __z); }
template<typename _Tp, typename _Up, typename _Vp>
constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type
fma(_Tp __x, _Up __y, _Vp __z)
{
typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type;
return fma(__type(__x), __type(__y), __type(__z));
}
constexpr float
fmax(float __x, float __y)
{ return __builtin_fmaxf(__x, __y); }
constexpr long double
fmax(long double __x, long double __y)
{ return __builtin_fmaxl(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
fmax(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return fmax(__type(__x), __type(__y));
}
constexpr float
fmin(float __x, float __y)
{ return __builtin_fminf(__x, __y); }
constexpr long double
fmin(long double __x, long double __y)
{ return __builtin_fminl(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
fmin(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return fmin(__type(__x), __type(__y));
}
constexpr float
hypot(float __x, float __y)
{ return __builtin_hypotf(__x, __y); }
constexpr long double
hypot(long double __x, long double __y)
{ return __builtin_hypotl(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
hypot(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return hypot(__type(__x), __type(__y));
}
constexpr int
ilogb(float __x)
{ return __builtin_ilogbf(__x); }
constexpr int
ilogb(long double __x)
{ return __builtin_ilogbl(__x); }
template<typename _Tp>
constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
int>::__type
ilogb(_Tp __x)
{ return __builtin_ilogb(__x); }
constexpr float
lgamma(float __x)
{ return __builtin_lgammaf(__x); }
constexpr long double
lgamma(long double __x)
{ return __builtin_lgammal(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
lgamma(_Tp __x)
{ return __builtin_lgamma(__x); }
constexpr long long
llrint(float __x)
{ return __builtin_llrintf(__x); }
constexpr long long
llrint(long double __x)
{ return __builtin_llrintl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
long long>::__type
llrint(_Tp __x)
{ return __builtin_llrint(__x); }
constexpr long long
llround(float __x)
{ return __builtin_llroundf(__x); }
constexpr long long
llround(long double __x)
{ return __builtin_llroundl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
long long>::__type
llround(_Tp __x)
{ return __builtin_llround(__x); }
constexpr float
log1p(float __x)
{ return __builtin_log1pf(__x); }
constexpr long double
log1p(long double __x)
{ return __builtin_log1pl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
log1p(_Tp __x)
{ return __builtin_log1p(__x); }
constexpr float
log2(float __x)
{ return __builtin_log2f(__x); }
constexpr long double
log2(long double __x)
{ return __builtin_log2l(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
log2(_Tp __x)
{ return __builtin_log2(__x); }
constexpr float
logb(float __x)
{ return __builtin_logbf(__x); }
constexpr long double
logb(long double __x)
{ return __builtin_logbl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
logb(_Tp __x)
{ return __builtin_logb(__x); }
constexpr long
lrint(float __x)
{ return __builtin_lrintf(__x); }
constexpr long
lrint(long double __x)
{ return __builtin_lrintl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
long>::__type
lrint(_Tp __x)
{ return __builtin_lrint(__x); }
constexpr long
lround(float __x)
{ return __builtin_lroundf(__x); }
constexpr long
lround(long double __x)
{ return __builtin_lroundl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
long>::__type
lround(_Tp __x)
{ return __builtin_lround(__x); }
constexpr float
nearbyint(float __x)
{ return __builtin_nearbyintf(__x); }
constexpr long double
nearbyint(long double __x)
{ return __builtin_nearbyintl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
nearbyint(_Tp __x)
{ return __builtin_nearbyint(__x); }
constexpr float
nextafter(float __x, float __y)
{ return __builtin_nextafterf(__x, __y); }
constexpr long double
nextafter(long double __x, long double __y)
{ return __builtin_nextafterl(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
nextafter(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return nextafter(__type(__x), __type(__y));
}
constexpr float
nexttoward(float __x, long double __y)
{ return __builtin_nexttowardf(__x, __y); }
constexpr long double
nexttoward(long double __x, long double __y)
{ return __builtin_nexttowardl(__x, __y); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
nexttoward(_Tp __x, long double __y)
{ return __builtin_nexttoward(__x, __y); }
constexpr float
remainder(float __x, float __y)
{ return __builtin_remainderf(__x, __y); }
constexpr long double
remainder(long double __x, long double __y)
{ return __builtin_remainderl(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
remainder(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return remainder(__type(__x), __type(__y));
}
inline float
remquo(float __x, float __y, int* __pquo)
{ return __builtin_remquof(__x, __y, __pquo); }
inline long double
remquo(long double __x, long double __y, int* __pquo)
{ return __builtin_remquol(__x, __y, __pquo); }
template<typename _Tp, typename _Up>
inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
remquo(_Tp __x, _Up __y, int* __pquo)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return remquo(__type(__x), __type(__y), __pquo);
}
constexpr float
rint(float __x)
{ return __builtin_rintf(__x); }
constexpr long double
rint(long double __x)
{ return __builtin_rintl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
rint(_Tp __x)
{ return __builtin_rint(__x); }
constexpr float
round(float __x)
{ return __builtin_roundf(__x); }
constexpr long double
round(long double __x)
{ return __builtin_roundl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
round(_Tp __x)
{ return __builtin_round(__x); }
constexpr float
scalbln(float __x, long __ex)
{ return __builtin_scalblnf(__x, __ex); }
constexpr long double
scalbln(long double __x, long __ex)
{ return __builtin_scalblnl(__x, __ex); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
scalbln(_Tp __x, long __ex)
{ return __builtin_scalbln(__x, __ex); }
constexpr float
scalbn(float __x, int __ex)
{ return __builtin_scalbnf(__x, __ex); }
constexpr long double
scalbn(long double __x, int __ex)
{ return __builtin_scalbnl(__x, __ex); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
scalbn(_Tp __x, int __ex)
{ return __builtin_scalbn(__x, __ex); }
constexpr float
tgamma(float __x)
{ return __builtin_tgammaf(__x); }
constexpr long double
tgamma(long double __x)
{ return __builtin_tgammal(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
tgamma(_Tp __x)
{ return __builtin_tgamma(__x); }
constexpr float
trunc(float __x)
{ return __builtin_truncf(__x); }
constexpr long double
trunc(long double __x)
{ return __builtin_truncl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
trunc(_Tp __x)
{ return __builtin_trunc(__x); }
}
# 1797 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cmath" 3
}
# 610 "/data/tools/Xilinx/Vivado/2019.1/include/ap_common.h" 2
# 630 "/data/tools/Xilinx/Vivado/2019.1/include/ap_common.h"
# 630 "/data/tools/Xilinx/Vivado/2019.1/include/ap_common.h"
template <int _AP_W, bool _AP_S, bool _AP_C = _AP_W <= 64>
class ap_private;
template <int _AP_W, bool _AP_S>
struct ssdm_int_sim {
ap_private<_AP_W, _AP_S> V;
ssdm_int_sim() {}
};
# 1 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 1
# 63 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
template <int _AP_W, bool _AP_S>
struct _private_range_ref;
template <int _AP_W, bool _AP_S>
struct _private_bit_ref;
# 90 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
# 1 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h" 1
# 31 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cmath" 1 3
# 39 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cmath" 3
# 40 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cmath" 3
# 32 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h" 2
# 43 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstddef" 1 3
# 42 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstddef" 3
# 43 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstddef" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include/stddef.h" 1 3 4
# 149 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include/stddef.h" 3 4
# 149 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include/stddef.h" 3 4
typedef long int ptrdiff_t;
# 426 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include/stddef.h" 3 4
typedef struct {
long long __max_align_ll __attribute__((__aligned__(__alignof__(long long))));
long double __max_align_ld __attribute__((__aligned__(__alignof__(long double))));
} max_align_t;
typedef decltype(nullptr) nullptr_t;
# 51 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstddef" 2 3
namespace std
{
using ::max_align_t;
}
# 44 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h" 2
# 1 "/data/tools/Xilinx/Vivado/2019.1/include/hls_fpo.h" 1
# 59 "/data/tools/Xilinx/Vivado/2019.1/include/hls_fpo.h"
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/math.h" 1 3
# 36 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/math.h" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cmath" 1 3
# 39 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cmath" 3
# 40 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cmath" 3
# 37 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/math.h" 2 3
using std::abs;
using std::acos;
using std::asin;
using std::atan;
using std::atan2;
using std::cos;
using std::sin;
using std::tan;
using std::cosh;
using std::sinh;
using std::tanh;
using std::exp;
using std::frexp;
using std::ldexp;
using std::log;
using std::log10;
using std::modf;
using std::pow;
using std::sqrt;
using std::ceil;
using std::fabs;
using std::floor;
using std::fmod;
using std::fpclassify;
using std::isfinite;
using std::isinf;
using std::isnan;
using std::isnormal;
using std::signbit;
using std::isgreater;
using std::isgreaterequal;
using std::isless;
using std::islessequal;
using std::islessgreater;
using std::isunordered;
using std::acosh;
using std::asinh;
using std::atanh;
using std::cbrt;
using std::copysign;
using std::erf;
using std::erfc;
using std::exp2;
using std::expm1;
using std::fdim;
using std::fma;
using std::fmax;
using std::fmin;
using std::hypot;
using std::ilogb;
using std::lgamma;
using std::llrint;
using std::llround;
using std::log1p;
using std::log2;
using std::logb;
using std::lrint;
using std::lround;
using std::nearbyint;
using std::nextafter;
using std::nexttoward;
using std::remainder;
using std::remquo;
using std::rint;
using std::round;
using std::scalbln;
using std::scalbn;
using std::tgamma;
using std::trunc;
# 60 "/data/tools/Xilinx/Vivado/2019.1/include/hls_fpo.h" 2
# 1 "/usr/include/assert.h" 1 3 4
# 65 "/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__));
}
# 63 "/data/tools/Xilinx/Vivado/2019.1/include/hls_fpo.h" 2
# 186 "/data/tools/Xilinx/Vivado/2019.1/include/hls_fpo.h"
# 1 "/data/tools/Xilinx/Vivado/2019.1/include/floating_point_v7_0_bitacc_cmodel.h" 1
# 115 "/data/tools/Xilinx/Vivado/2019.1/include/floating_point_v7_0_bitacc_cmodel.h"
# 115 "/data/tools/Xilinx/Vivado/2019.1/include/floating_point_v7_0_bitacc_cmodel.h"
typedef int8_t xint8;
typedef int16_t xint16;
typedef int32_t xint32;
typedef int64_t xint64;
typedef uint8_t xuint8;
typedef uint16_t xuint16;
typedef uint32_t xuint32;
typedef uint64_t xuint64;
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include/stdbool.h" 1 3 4
# 126 "/data/tools/Xilinx/Vivado/2019.1/include/floating_point_v7_0_bitacc_cmodel.h" 2
# 143 "/data/tools/Xilinx/Vivado/2019.1/include/floating_point_v7_0_bitacc_cmodel.h"
# 1 "/data/tools/Xilinx/Vivado/2019.1/include/gmp.h" 1
# 27 "/data/tools/Xilinx/Vivado/2019.1/include/gmp.h"
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdio" 1 3
# 39 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdio" 3
# 40 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdio" 3
# 28 "/data/tools/Xilinx/Vivado/2019.1/include/gmp.h" 2
# 201 "/data/tools/Xilinx/Vivado/2019.1/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 "/data/tools/Xilinx/Vivado/2019.1/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 "/data/tools/Xilinx/Vivado/2019.1/include/gmp.h"
int __gmp_printf (const char *, ...);
int __gmp_snprintf (char *, size_t, const char *, ...);
int __gmp_sprintf (char *, const char *, ...);
# 653 "/data/tools/Xilinx/Vivado/2019.1/include/gmp.h"
int __gmp_fscanf (FILE *, const char *, ...);
int __gmp_scanf (const char *, ...);
int __gmp_sscanf (const char *, const char *, ...);
# 684 "/data/tools/Xilinx/Vivado/2019.1/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 "/data/tools/Xilinx/Vivado/2019.1/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 "/data/tools/Xilinx/Vivado/2019.1/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 "/data/tools/Xilinx/Vivado/2019.1/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 "/data/tools/Xilinx/Vivado/2019.1/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 "/data/tools/Xilinx/Vivado/2019.1/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 "/data/tools/Xilinx/Vivado/2019.1/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 "/data/tools/Xilinx/Vivado/2019.1/include/gmp.h"
typedef __mpz_struct MP_INT;
typedef __mpq_struct MP_RAT;
# 2358 "/data/tools/Xilinx/Vivado/2019.1/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
};
# 144 "/data/tools/Xilinx/Vivado/2019.1/include/floating_point_v7_0_bitacc_cmodel.h" 2
# 1 "/data/tools/Xilinx/Vivado/2019.1/include/mpfr.h" 1
# 73 "/data/tools/Xilinx/Vivado/2019.1/include/mpfr.h"
typedef void mpfr_void;
typedef int mpfr_int;
typedef unsigned int mpfr_uint;
typedef long mpfr_long;
typedef unsigned long mpfr_ulong;
typedef size_t mpfr_size_t;
# 95 "/data/tools/Xilinx/Vivado/2019.1/include/mpfr.h"
typedef enum {
MPFR_RNDN=0,
MPFR_RNDZ,
MPFR_RNDU,
MPFR_RNDD,
MPFR_RNDA,
MPFR_RNDF,
MPFR_RNDNA=-1
} mpfr_rnd_t;
# 130 "/data/tools/Xilinx/Vivado/2019.1/include/mpfr.h"
typedef long mpfr_prec_t;
typedef unsigned long mpfr_uprec_t;
# 143 "/data/tools/Xilinx/Vivado/2019.1/include/mpfr.h"
typedef int mpfr_sign_t;
typedef mp_exp_t mpfr_exp_t;
typedef struct {
mpfr_prec_t _mpfr_prec;
mpfr_sign_t _mpfr_sign;
mpfr_exp_t _mpfr_exp;
mp_limb_t *_mpfr_d;
} __mpfr_struct;
# 179 "/data/tools/Xilinx/Vivado/2019.1/include/mpfr.h"
typedef __mpfr_struct mpfr_t[1];
typedef __mpfr_struct *mpfr_ptr;
typedef const __mpfr_struct *mpfr_srcptr;
# 192 "/data/tools/Xilinx/Vivado/2019.1/include/mpfr.h"
typedef enum {
MPFR_NAN_KIND = 0,
MPFR_INF_KIND = 1, MPFR_ZERO_KIND = 2, MPFR_REGULAR_KIND = 3
} mpfr_kind_t;
# 241 "/data/tools/Xilinx/Vivado/2019.1/include/mpfr.h"
extern "C" {
const char * mpfr_get_version (void);
const char * mpfr_get_patches (void);
int mpfr_buildopt_tls_p (void);
int mpfr_buildopt_decimal_p (void);
mpfr_exp_t mpfr_get_emin (void);
int mpfr_set_emin (mpfr_exp_t);
mpfr_exp_t mpfr_get_emin_min (void);
mpfr_exp_t mpfr_get_emin_max (void);
mpfr_exp_t mpfr_get_emax (void);
int mpfr_set_emax (mpfr_exp_t);
mpfr_exp_t mpfr_get_emax_min (void);
mpfr_exp_t mpfr_get_emax_max (void);
void mpfr_set_default_rounding_mode (mpfr_rnd_t);
mpfr_rnd_t mpfr_get_default_rounding_mode (void);
const char *
mpfr_print_rnd_mode (mpfr_rnd_t);
void mpfr_clear_flags (void);
void mpfr_clear_underflow (void);
void mpfr_clear_overflow (void);
void mpfr_clear_nanflag (void);
void mpfr_clear_inexflag (void);
void mpfr_clear_erangeflag (void);
void mpfr_set_underflow (void);
void mpfr_set_overflow (void);
void mpfr_set_nanflag (void);
void mpfr_set_inexflag (void);
void mpfr_set_erangeflag (void);
int mpfr_underflow_p (void);
int mpfr_overflow_p (void);
int mpfr_nanflag_p (void);
int mpfr_inexflag_p (void);
int mpfr_erangeflag_p (void);
int
mpfr_check_range (mpfr_ptr, int, mpfr_rnd_t);
void mpfr_init2 (mpfr_ptr, mpfr_prec_t);
void mpfr_init (mpfr_ptr);
void mpfr_clear (mpfr_ptr);
void
mpfr_inits2 (mpfr_prec_t, mpfr_ptr, ...) __attribute__ ((sentinel));
void
mpfr_inits (mpfr_ptr, ...) __attribute__ ((sentinel));
void
mpfr_clears (mpfr_ptr, ...) __attribute__ ((sentinel));
int
mpfr_prec_round (mpfr_ptr, mpfr_prec_t, mpfr_rnd_t);
int
mpfr_can_round (mpfr_srcptr, mpfr_exp_t, mpfr_rnd_t, mpfr_rnd_t, mpfr_prec_t)
;
mpfr_prec_t mpfr_min_prec (mpfr_srcptr);
mpfr_exp_t mpfr_get_exp (mpfr_srcptr);
int mpfr_set_exp (mpfr_ptr, mpfr_exp_t);
mpfr_prec_t mpfr_get_prec (mpfr_srcptr);
void mpfr_set_prec (mpfr_ptr, mpfr_prec_t);
void mpfr_set_prec_raw (mpfr_ptr, mpfr_prec_t);
void mpfr_set_default_prec (mpfr_prec_t);
mpfr_prec_t mpfr_get_default_prec (void);
int mpfr_set_d (mpfr_ptr, double, mpfr_rnd_t);
int mpfr_set_flt (mpfr_ptr, float, mpfr_rnd_t);
int
mpfr_set_ld (mpfr_ptr, long double, mpfr_rnd_t);
int
mpfr_set_z (mpfr_ptr, mpz_srcptr, mpfr_rnd_t);
int
mpfr_set_z_2exp (mpfr_ptr, mpz_srcptr, mpfr_exp_t, mpfr_rnd_t);
void mpfr_set_nan (mpfr_ptr);
void mpfr_set_inf (mpfr_ptr, int);
void mpfr_set_zero (mpfr_ptr, int);
int
mpfr_set_f (mpfr_ptr, mpf_srcptr, mpfr_rnd_t);
int
mpfr_get_f (mpf_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_set_si (mpfr_ptr, long, mpfr_rnd_t);
int
mpfr_set_ui (mpfr_ptr, unsigned long, mpfr_rnd_t);
int
mpfr_set_si_2exp (mpfr_ptr, long, mpfr_exp_t, mpfr_rnd_t);
int
mpfr_set_ui_2exp (mpfr_ptr,unsigned long,mpfr_exp_t,mpfr_rnd_t);
int
mpfr_set_q (mpfr_ptr, mpq_srcptr, mpfr_rnd_t);
int
mpfr_set_str (mpfr_ptr, const char *, int, mpfr_rnd_t);
int
mpfr_init_set_str (mpfr_ptr, const char *, int, mpfr_rnd_t)
;
int
mpfr_set4 (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t, int);
int
mpfr_abs (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int
mpfr_set (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_neg (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_signbit (mpfr_srcptr);
int
mpfr_setsign (mpfr_ptr, mpfr_srcptr, int, mpfr_rnd_t);
int
mpfr_copysign (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t);
# 364 "/data/tools/Xilinx/Vivado/2019.1/include/mpfr.h"
int __gmpfr_set_sj (mpfr_t, intmax_t, mpfr_rnd_t);
int
__gmpfr_set_sj_2exp (mpfr_t, intmax_t, intmax_t, mpfr_rnd_t);
int __gmpfr_set_uj (mpfr_t, uintmax_t, mpfr_rnd_t);
int
__gmpfr_set_uj_2exp (mpfr_t, uintmax_t, intmax_t, mpfr_rnd_t);
intmax_t __gmpfr_mpfr_get_sj (mpfr_srcptr, mpfr_rnd_t);
uintmax_t __gmpfr_mpfr_get_uj (mpfr_srcptr, mpfr_rnd_t);
mpfr_exp_t mpfr_get_z_2exp (mpz_ptr, mpfr_srcptr);
float mpfr_get_flt (mpfr_srcptr, mpfr_rnd_t);
double mpfr_get_d (mpfr_srcptr, mpfr_rnd_t);
long double mpfr_get_ld (mpfr_srcptr, mpfr_rnd_t)
;
double mpfr_get_d1 (mpfr_srcptr);
double mpfr_get_d_2exp (long*, mpfr_srcptr, mpfr_rnd_t)
;
long double mpfr_get_ld_2exp (long*, mpfr_srcptr, mpfr_rnd_t)
;
long mpfr_get_si (mpfr_srcptr, mpfr_rnd_t);
unsigned long mpfr_get_ui (mpfr_srcptr, mpfr_rnd_t)
;
char*mpfr_get_str (char*, mpfr_exp_t*, int, size_t, mpfr_srcptr, mpfr_rnd_t)
;
int mpfr_get_z (mpz_ptr z, mpfr_srcptr f, mpfr_rnd_t)
;
void mpfr_free_str (char *);
int mpfr_urandom (mpfr_ptr, gmp_randstate_t, mpfr_rnd_t)
;
int mpfr_urandomb (mpfr_ptr, gmp_randstate_t);
void mpfr_nextabove (mpfr_ptr);
void mpfr_nextbelow (mpfr_ptr);
void mpfr_nexttoward (mpfr_ptr, mpfr_srcptr);
size_t __gmpfr_inp_str (mpfr_ptr, FILE*, int, mpfr_rnd_t)
;
size_t __gmpfr_out_str (FILE*, int, size_t, mpfr_srcptr, mpfr_rnd_t)
;
int __gmpfr_fprintf (FILE*, const char*, ...)
;
int mpfr_printf (const char*, ...);
int mpfr_asprintf (char**, const char*, ...)
;
int mpfr_sprintf (char*, const char*, ...)
;
int mpfr_snprintf (char*, size_t, const char*, ...)
;
# 444 "/data/tools/Xilinx/Vivado/2019.1/include/mpfr.h"
int mpfr_pow (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t)
;
int mpfr_pow_si (mpfr_ptr, mpfr_srcptr, long int, mpfr_rnd_t)
;
int mpfr_pow_ui (mpfr_ptr, mpfr_srcptr, unsigned long int, mpfr_rnd_t)
;
int mpfr_ui_pow_ui (mpfr_ptr, unsigned long int, unsigned long int, mpfr_rnd_t)
;
int mpfr_ui_pow (mpfr_ptr, unsigned long int, mpfr_srcptr, mpfr_rnd_t)
;
int mpfr_pow_z (mpfr_ptr, mpfr_srcptr, mpz_srcptr, mpfr_rnd_t)
;
int mpfr_sqrt (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t)
;
int mpfr_sqrt_ui (mpfr_ptr, unsigned long, mpfr_rnd_t)
;
int mpfr_rec_sqrt (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t)
;
int mpfr_add (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t)
;
int mpfr_sub (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t)
;
int mpfr_mul (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t)
;
int mpfr_div (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t)
;
int mpfr_add_ui (mpfr_ptr, mpfr_srcptr, unsigned long, mpfr_rnd_t)
;
int mpfr_sub_ui (mpfr_ptr, mpfr_srcptr, unsigned long, mpfr_rnd_t)
;
int mpfr_ui_sub (mpfr_ptr, unsigned long, mpfr_srcptr, mpfr_rnd_t)
;
int mpfr_mul_ui (mpfr_ptr, mpfr_srcptr, unsigned long, mpfr_rnd_t)
;
int mpfr_div_ui (mpfr_ptr, mpfr_srcptr, unsigned long, mpfr_rnd_t)
;
int mpfr_ui_div (mpfr_ptr, unsigned long, mpfr_srcptr, mpfr_rnd_t)
;
int mpfr_add_si (mpfr_ptr, mpfr_srcptr, long int, mpfr_rnd_t)
;
int mpfr_sub_si (mpfr_ptr, mpfr_srcptr, long int, mpfr_rnd_t)
;
int mpfr_si_sub (mpfr_ptr, long int, mpfr_srcptr, mpfr_rnd_t)
;
int mpfr_mul_si (mpfr_ptr, mpfr_srcptr, long int, mpfr_rnd_t)
;
int mpfr_div_si (mpfr_ptr, mpfr_srcptr, long int, mpfr_rnd_t)
;
int mpfr_si_div (mpfr_ptr, long int, mpfr_srcptr, mpfr_rnd_t)
;
int mpfr_add_d (mpfr_ptr, mpfr_srcptr, double, mpfr_rnd_t)
;
int mpfr_sub_d (mpfr_ptr, mpfr_srcptr, double, mpfr_rnd_t)
;
int mpfr_d_sub (mpfr_ptr, double, mpfr_srcptr, mpfr_rnd_t)
;
int mpfr_mul_d (mpfr_ptr, mpfr_srcptr, double, mpfr_rnd_t)
;
int mpfr_div_d (mpfr_ptr, mpfr_srcptr, double, mpfr_rnd_t)
;
int mpfr_d_div (mpfr_ptr, double, mpfr_srcptr, mpfr_rnd_t)
;
int mpfr_sqr (mpfr_ptr, mpfr_srcptr,mpfr_rnd_t);
int mpfr_const_pi (mpfr_ptr, mpfr_rnd_t);
int mpfr_const_log2 (mpfr_ptr, mpfr_rnd_t);
int mpfr_const_euler (mpfr_ptr, mpfr_rnd_t);
int mpfr_const_catalan (mpfr_ptr, mpfr_rnd_t);
int mpfr_agm (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t)
;
int mpfr_log (mpfr_ptr, mpfr_srcptr,mpfr_rnd_t);
int mpfr_log2 (mpfr_ptr,mpfr_srcptr,mpfr_rnd_t);
int mpfr_log10 (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t)
;
int mpfr_log1p (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t)
;
int mpfr_exp (mpfr_ptr, mpfr_srcptr,mpfr_rnd_t);
int mpfr_exp2 (mpfr_ptr,mpfr_srcptr,mpfr_rnd_t);
int mpfr_exp10 (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t)
;
int mpfr_expm1 (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t)
;
int mpfr_eint (mpfr_ptr,mpfr_srcptr,mpfr_rnd_t);
int mpfr_li2 (mpfr_ptr,mpfr_srcptr,mpfr_rnd_t);
int mpfr_cmp (mpfr_srcptr, mpfr_srcptr);
int mpfr_cmp3 (mpfr_srcptr, mpfr_srcptr, int);
int mpfr_cmp_d (mpfr_srcptr, double);
int mpfr_cmp_ld (mpfr_srcptr, long double);
int mpfr_cmpabs (mpfr_srcptr, mpfr_srcptr);
int mpfr_cmp_ui (mpfr_srcptr, unsigned long);
int mpfr_cmp_si (mpfr_srcptr, long);
int mpfr_cmp_ui_2exp (mpfr_srcptr, unsigned long, mpfr_exp_t)
;
int mpfr_cmp_si_2exp (mpfr_srcptr, long, mpfr_exp_t)
;
void mpfr_reldiff (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t)
;
int mpfr_eq (mpfr_srcptr, mpfr_srcptr, unsigned long)
;
int mpfr_sgn (mpfr_srcptr);
int mpfr_mul_2exp (mpfr_ptr, mpfr_srcptr, unsigned long, mpfr_rnd_t)
;
int mpfr_div_2exp (mpfr_ptr, mpfr_srcptr, unsigned long, mpfr_rnd_t)
;
int mpfr_mul_2ui (mpfr_ptr, mpfr_srcptr, unsigned long, mpfr_rnd_t)
;
int mpfr_div_2ui (mpfr_ptr, mpfr_srcptr, unsigned long, mpfr_rnd_t)
;
int mpfr_mul_2si (mpfr_ptr, mpfr_srcptr, long, mpfr_rnd_t)
;
int mpfr_div_2si (mpfr_ptr, mpfr_srcptr, long, mpfr_rnd_t)
;
int mpfr_rint (mpfr_ptr,mpfr_srcptr, mpfr_rnd_t);
int mpfr_round (mpfr_ptr, mpfr_srcptr);
int mpfr_trunc (mpfr_ptr, mpfr_srcptr);
int mpfr_ceil (mpfr_ptr, mpfr_srcptr);
int mpfr_floor (mpfr_ptr, mpfr_srcptr);
int mpfr_rint_round (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t)
;
int mpfr_rint_trunc (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t)
;
int mpfr_rint_ceil (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t)
;
int mpfr_rint_floor (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t)
;
int mpfr_frac (mpfr_ptr,mpfr_srcptr,mpfr_rnd_t);
int mpfr_modf (mpfr_ptr, mpfr_ptr, mpfr_srcptr, mpfr_rnd_t)
;
int mpfr_remquo (mpfr_ptr, long*, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t)
;
int mpfr_remainder (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t)
;
int mpfr_fmod (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t)
;
int mpfr_fits_ulong_p (mpfr_srcptr, mpfr_rnd_t);
int mpfr_fits_slong_p (mpfr_srcptr, mpfr_rnd_t);
int mpfr_fits_uint_p (mpfr_srcptr, mpfr_rnd_t);
int mpfr_fits_sint_p (mpfr_srcptr, mpfr_rnd_t);
int mpfr_fits_ushort_p (mpfr_srcptr, mpfr_rnd_t);
int mpfr_fits_sshort_p (mpfr_srcptr, mpfr_rnd_t);
int mpfr_fits_uintmax_p (mpfr_srcptr,mpfr_rnd_t);
int mpfr_fits_intmax_p (mpfr_srcptr, mpfr_rnd_t);
void mpfr_extract (mpz_ptr, mpfr_srcptr, unsigned int)
;
void mpfr_swap (mpfr_ptr, mpfr_ptr);
void mpfr_dump (mpfr_srcptr);
int mpfr_nan_p (mpfr_srcptr);
int mpfr_inf_p (mpfr_srcptr);
int mpfr_number_p (mpfr_srcptr);
int mpfr_integer_p (mpfr_srcptr);
int mpfr_zero_p (mpfr_srcptr);
int mpfr_regular_p (mpfr_srcptr);
int mpfr_greater_p (mpfr_srcptr, mpfr_srcptr);
int mpfr_greaterequal_p (mpfr_srcptr, mpfr_srcptr)
;
int mpfr_less_p (mpfr_srcptr, mpfr_srcptr);
int mpfr_lessequal_p (mpfr_srcptr, mpfr_srcptr);
int mpfr_lessgreater_p (mpfr_srcptr,mpfr_srcptr);
int mpfr_equal_p (mpfr_srcptr, mpfr_srcptr);
int mpfr_unordered_p (mpfr_srcptr, mpfr_srcptr);
int mpfr_atanh (mpfr_ptr,mpfr_srcptr,mpfr_rnd_t);
int mpfr_acosh (mpfr_ptr,mpfr_srcptr,mpfr_rnd_t);
int mpfr_asinh (mpfr_ptr,mpfr_srcptr,mpfr_rnd_t);
int mpfr_cosh (mpfr_ptr,mpfr_srcptr, mpfr_rnd_t);
int mpfr_sinh (mpfr_ptr,mpfr_srcptr, mpfr_rnd_t);
int mpfr_tanh (mpfr_ptr,mpfr_srcptr, mpfr_rnd_t);
int mpfr_sinh_cosh (mpfr_ptr, mpfr_ptr, mpfr_srcptr, mpfr_rnd_t)
;
int mpfr_sech (mpfr_ptr, mpfr_srcptr,mpfr_rnd_t);
int mpfr_csch (mpfr_ptr, mpfr_srcptr,mpfr_rnd_t);
int mpfr_coth (mpfr_ptr, mpfr_srcptr,mpfr_rnd_t);
int mpfr_acos (mpfr_ptr,mpfr_srcptr,mpfr_rnd_t);
int mpfr_asin (mpfr_ptr,mpfr_srcptr,mpfr_rnd_t);
int mpfr_atan (mpfr_ptr,mpfr_srcptr,mpfr_rnd_t);
int mpfr_sin (mpfr_ptr, mpfr_srcptr,mpfr_rnd_t);
int mpfr_sin_cos (mpfr_ptr, mpfr_ptr, mpfr_srcptr, mpfr_rnd_t)
;
int mpfr_cos (mpfr_ptr, mpfr_srcptr,mpfr_rnd_t);
int mpfr_tan (mpfr_ptr, mpfr_srcptr,mpfr_rnd_t);
int mpfr_atan2 (mpfr_ptr,mpfr_srcptr,mpfr_srcptr, mpfr_rnd_t)
;
int mpfr_sec (mpfr_ptr, mpfr_srcptr,mpfr_rnd_t);
int mpfr_csc (mpfr_ptr, mpfr_srcptr,mpfr_rnd_t);
int mpfr_cot (mpfr_ptr, mpfr_srcptr,mpfr_rnd_t);
int mpfr_hypot (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t)
;
int mpfr_erf (mpfr_ptr, mpfr_srcptr,mpfr_rnd_t);
int mpfr_erfc (mpfr_ptr, mpfr_srcptr,mpfr_rnd_t);
int mpfr_cbrt (mpfr_ptr,mpfr_srcptr,mpfr_rnd_t);
int mpfr_root (mpfr_ptr,mpfr_srcptr,unsigned long,mpfr_rnd_t);
int mpfr_gamma (mpfr_ptr,mpfr_srcptr,mpfr_rnd_t);
int mpfr_lngamma (mpfr_ptr,mpfr_srcptr,mpfr_rnd_t);
int mpfr_lgamma (mpfr_ptr,int*,mpfr_srcptr,mpfr_rnd_t);
int mpfr_digamma (mpfr_ptr,mpfr_srcptr,mpfr_rnd_t);
int mpfr_zeta (mpfr_ptr,mpfr_srcptr,mpfr_rnd_t);
int mpfr_zeta_ui (mpfr_ptr,unsigned long,mpfr_rnd_t);
int mpfr_fac_ui (mpfr_ptr, unsigned long int, mpfr_rnd_t)
;
int mpfr_j0 (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_j1 (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_jn (mpfr_ptr, long, mpfr_srcptr, mpfr_rnd_t)
;
int mpfr_y0 (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_y1 (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_yn (mpfr_ptr, long, mpfr_srcptr, mpfr_rnd_t)
;
int mpfr_ai (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
int mpfr_min (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t)
;
int mpfr_max (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t)
;
int mpfr_dim (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t)
;
int mpfr_mul_z (mpfr_ptr, mpfr_srcptr, mpz_srcptr, mpfr_rnd_t)
;
int mpfr_div_z (mpfr_ptr, mpfr_srcptr, mpz_srcptr, mpfr_rnd_t)
;
int mpfr_add_z (mpfr_ptr, mpfr_srcptr, mpz_srcptr, mpfr_rnd_t)
;
int mpfr_sub_z (mpfr_ptr, mpfr_srcptr, mpz_srcptr, mpfr_rnd_t)
;
int mpfr_cmp_z (mpfr_srcptr, mpz_srcptr);
int mpfr_mul_q (mpfr_ptr, mpfr_srcptr, mpq_srcptr, mpfr_rnd_t)
;
int mpfr_div_q (mpfr_ptr, mpfr_srcptr, mpq_srcptr, mpfr_rnd_t)
;
int mpfr_add_q (mpfr_ptr, mpfr_srcptr, mpq_srcptr, mpfr_rnd_t)
;
int mpfr_sub_q (mpfr_ptr, mpfr_srcptr, mpq_srcptr, mpfr_rnd_t)
;
int mpfr_cmp_q (mpfr_srcptr, mpq_srcptr);
int mpfr_cmp_f (mpfr_srcptr, mpf_srcptr);
int mpfr_fma (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t)
;
int mpfr_fms (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t)
;
int mpfr_sum (mpfr_ptr, mpfr_ptr *const, unsigned long, mpfr_rnd_t)
;
void mpfr_free_cache (void);
int mpfr_subnormalize (mpfr_ptr, int, mpfr_rnd_t)
;
int mpfr_strtofr (mpfr_ptr, const char *, char **, int, mpfr_rnd_t)
;
size_t mpfr_custom_get_size (mpfr_prec_t);
void mpfr_custom_init (void *, mpfr_prec_t);
void * mpfr_custom_get_significand (mpfr_srcptr);
mpfr_exp_t mpfr_custom_get_exp (mpfr_srcptr);
void mpfr_custom_move (mpfr_ptr, void *);
void mpfr_custom_init_set (mpfr_ptr, int, mpfr_exp_t, mpfr_prec_t, void *)
;
int mpfr_custom_get_kind (mpfr_srcptr);
}
# 149 "/data/tools/Xilinx/Vivado/2019.1/include/floating_point_v7_0_bitacc_cmodel.h" 2
typedef long xip_fpo_prec_t;
typedef int xip_fpo_sign_t;
typedef long xip_fpo_exp_t;
typedef struct {
xip_fpo_prec_t _xip_fpo_exp_prec;
xip_fpo_prec_t _xip_fpo_mant_prec;
xip_fpo_sign_t _xip_fpo_sign;
xip_fpo_exp_t _xip_fpo_exp;
mp_limb_t *_xip_fpo_d;
} __xip_fpo_struct;
typedef struct {
xip_fpo_prec_t _xip_fpo_i_prec;
xip_fpo_prec_t _xip_fpo_frac_prec;
xint64 _xip_fpo_i;
xint64 _xip_fpo_frac;
} __xip_fpo_fix_struct;
typedef __xip_fpo_struct xip_fpo_t[1];
typedef __xip_fpo_fix_struct xip_fpo_fix_t[1];
typedef __xip_fpo_struct *xip_fpo_ptr;
typedef const __xip_fpo_struct *xip_fpo_srcptr;
typedef __xip_fpo_fix_struct *xip_fpo_fix_ptr;
typedef const __xip_fpo_fix_struct *xip_fpo_fix_srcptr;
# 197 "/data/tools/Xilinx/Vivado/2019.1/include/floating_point_v7_0_bitacc_cmodel.h"
typedef int xip_fpo_exc_t;
extern "C" {
typedef struct xil_fpo_accum_state xil_fpo_accum_state;
const char * xip_fpo_get_version (void);
void xip_fpo_init2 (xip_fpo_ptr, xip_fpo_prec_t, xip_fpo_prec_t);
void xip_fpo_fix_init2 (xip_fpo_fix_ptr, xip_fpo_prec_t, xip_fpo_prec_t);
void xip_fpo_inits2 (xip_fpo_prec_t, xip_fpo_prec_t, xip_fpo_ptr, ...) __attribute__ ((sentinel));
void xip_fpo_fix_inits2 (xip_fpo_prec_t, xip_fpo_prec_t, xip_fpo_fix_ptr, ...) __attribute__ ((sentinel));
void xip_fpo_clear (xip_fpo_ptr);
void xip_fpo_fix_clear (xip_fpo_fix_ptr);
void xip_fpo_clears (xip_fpo_ptr, ...) __attribute__ ((sentinel));
void xip_fpo_fix_clears (xip_fpo_fix_ptr, ...) __attribute__ ((sentinel));
void xip_fpo_set_prec (xip_fpo_ptr, xip_fpo_prec_t, xip_fpo_prec_t);
void xip_fpo_fix_set_prec (xip_fpo_fix_ptr, xip_fpo_prec_t, xip_fpo_prec_t);
xip_fpo_prec_t xip_fpo_get_prec_mant (xip_fpo_ptr);
xip_fpo_prec_t xip_fpo_get_prec_exp (xip_fpo_ptr);
xip_fpo_prec_t xip_fpo_fix_get_prec_frac (xip_fpo_fix_ptr);
xip_fpo_prec_t xip_fpo_fix_get_prec_int (xip_fpo_fix_ptr);
xip_fpo_exc_t xip_fpo_set (xip_fpo_ptr, xip_fpo_srcptr);
xip_fpo_exc_t xip_fpo_fix_set (xip_fpo_fix_ptr, xip_fpo_fix_srcptr);
xip_fpo_exc_t xip_fpo_set_ui (xip_fpo_ptr, unsigned long);
xip_fpo_exc_t xip_fpo_fix_set_ui (xip_fpo_fix_ptr, unsigned long);
xip_fpo_exc_t xip_fpo_set_si (xip_fpo_ptr, long);
xip_fpo_exc_t xip_fpo_fix_set_si (xip_fpo_fix_ptr, long);
xip_fpo_exc_t xip_fpo_set_uj (xip_fpo_ptr, uintmax_t);
xip_fpo_exc_t xip_fpo_fix_set_uj (xip_fpo_fix_ptr, uintmax_t);
xip_fpo_exc_t xip_fpo_set_sj (xip_fpo_ptr, intmax_t);
xip_fpo_exc_t xip_fpo_fix_set_sj (xip_fpo_fix_ptr, intmax_t);
xip_fpo_exc_t xip_fpo_set_flt (xip_fpo_ptr, float);
xip_fpo_exc_t xip_fpo_fix_set_flt (xip_fpo_fix_ptr, float);
xip_fpo_exc_t xip_fpo_set_d (xip_fpo_ptr, double);
xip_fpo_exc_t xip_fpo_fix_set_d (xip_fpo_fix_ptr, double);
xip_fpo_exc_t xip_fpo_set_z (xip_fpo_ptr, mpz_srcptr);
xip_fpo_exc_t xip_fpo_fix_set_z (xip_fpo_fix_ptr, mpz_srcptr);
xip_fpo_exc_t xip_fpo_set_q (xip_fpo_ptr, mpq_srcptr);
xip_fpo_exc_t xip_fpo_fix_set_q (xip_fpo_fix_ptr, mpq_srcptr);
xip_fpo_exc_t xip_fpo_set_f (xip_fpo_ptr, mpf_srcptr);
xip_fpo_exc_t xip_fpo_fix_set_f (xip_fpo_fix_ptr, mpf_srcptr);
xip_fpo_exc_t xip_fpo_set_fr (xip_fpo_ptr, mpfr_srcptr);
xip_fpo_exc_t xip_fpo_fix_set_fr (xip_fpo_fix_ptr, mpfr_srcptr);
xip_fpo_exc_t xip_fpo_set_ui_2exp (xip_fpo_ptr, unsigned long, xip_fpo_exp_t);
xip_fpo_exc_t xip_fpo_set_si_2exp (xip_fpo_ptr, long, xip_fpo_exp_t);
xip_fpo_exc_t xip_fpo_set_uj_2exp (xip_fpo_ptr, uintmax_t, intmax_t);
xip_fpo_exc_t xip_fpo_set_sj_2exp (xip_fpo_ptr, intmax_t, intmax_t);
xip_fpo_exc_t xip_fpo_set_str (xip_fpo_ptr, const char *, int);
xip_fpo_exc_t xip_fpo_fix_set_str (xip_fpo_fix_ptr, const char *, int);
void xip_fpo_set_nan (xip_fpo_ptr);
void xip_fpo_set_inf (xip_fpo_ptr, int);
void xip_fpo_set_zero (xip_fpo_ptr, int);
unsigned long xip_fpo_get_ui (xip_fpo_srcptr);
unsigned long xip_fpo_fix_get_ui (xip_fpo_fix_srcptr);
long xip_fpo_get_si (xip_fpo_srcptr);
long xip_fpo_fix_get_si (xip_fpo_fix_srcptr);
uintmax_t xip_fpo_get_uj (xip_fpo_srcptr);
uintmax_t xip_fpo_fix_get_uj (xip_fpo_fix_srcptr);
intmax_t xip_fpo_get_sj (xip_fpo_srcptr);
intmax_t xip_fpo_fix_get_sj (xip_fpo_fix_srcptr);
float xip_fpo_get_flt (xip_fpo_srcptr);
float xip_fpo_fix_get_flt (xip_fpo_fix_srcptr);
double xip_fpo_get_d (xip_fpo_srcptr);
double xip_fpo_fix_get_d (xip_fpo_fix_srcptr);
double xip_fpo_get_d_2exp (long *, xip_fpo_srcptr);
xip_fpo_exc_t xip_fpo_get_z (mpz_ptr, xip_fpo_srcptr);
xip_fpo_exc_t xip_fpo_fix_get_z (mpz_ptr, xip_fpo_fix_srcptr);
xip_fpo_exc_t xip_fpo_get_f (mpf_ptr, xip_fpo_srcptr);
xip_fpo_exc_t xip_fpo_fix_get_f (mpf_ptr, xip_fpo_fix_srcptr);
xip_fpo_exc_t xip_fpo_get_fr (mpfr_ptr, xip_fpo_srcptr);
xip_fpo_exc_t xip_fpo_fix_get_fr (mpfr_ptr, xip_fpo_fix_srcptr);
char * xip_fpo_get_str (char *, xip_fpo_exp_t *, int, int, xip_fpo_srcptr);
char * xip_fpo_fix_get_str (char *, int, xip_fpo_fix_srcptr);
void xip_fpo_free_str (char *);
void xip_fpo_fix_free_str (char *);
int xip_fpo_sizeinbase (xip_fpo_srcptr, int);
int xip_fpo_fix_sizeinbase (xip_fpo_fix_srcptr, int);
xip_fpo_exc_t xip_fpo_add (xip_fpo_ptr, xip_fpo_srcptr, xip_fpo_srcptr);
xip_fpo_exc_t xip_fpo_add_flt (float *, float, float);
xip_fpo_exc_t xip_fpo_add_d (double *, double, double);
xip_fpo_exc_t xip_fpo_sub (xip_fpo_ptr, xip_fpo_srcptr, xip_fpo_srcptr);
xip_fpo_exc_t xip_fpo_sub_flt (float *, float, float);
xip_fpo_exc_t xip_fpo_sub_d (double *, double, double);
xip_fpo_exc_t xip_fpo_mul (xip_fpo_ptr, xip_fpo_srcptr, xip_fpo_srcptr);
xip_fpo_exc_t xip_fpo_mul_flt (float *, float, float);
xip_fpo_exc_t xip_fpo_mul_d (double *, double, double);
xip_fpo_exc_t xip_fpo_fma (xip_fpo_ptr, xip_fpo_srcptr, xip_fpo_srcptr, xip_fpo_srcptr);
xip_fpo_exc_t xip_fpo_fma_flt (float *, float, float, float);
xip_fpo_exc_t xip_fpo_fma_d (double *, double, double, double);
xip_fpo_exc_t xip_fpo_fms (xip_fpo_ptr, xip_fpo_srcptr, xip_fpo_srcptr, xip_fpo_srcptr);
xip_fpo_exc_t xip_fpo_fms_flt (float *, float, float, float);
xip_fpo_exc_t xip_fpo_fms_d (double *, double, double, double);
xip_fpo_exc_t xip_fpo_div (xip_fpo_ptr, xip_fpo_srcptr, xip_fpo_srcptr);
xip_fpo_exc_t xip_fpo_div_flt (float *, float, float);
xip_fpo_exc_t xip_fpo_div_d (double *, double, double);
xip_fpo_exc_t xip_fpo_rec (xip_fpo_ptr, xip_fpo_srcptr);
xip_fpo_exc_t xip_fpo_rec_flt (float *, float);
xip_fpo_exc_t xip_fpo_rec_d (double *, double);
xip_fpo_exc_t xip_fpo_abs (xip_fpo_ptr, xip_fpo_srcptr);
xip_fpo_exc_t xip_fpo_abs_flt (float *, float);
xip_fpo_exc_t xip_fpo_abs_d (double *, double);
xip_fpo_exc_t xip_fpo_log (xip_fpo_ptr, xip_fpo_srcptr);
xip_fpo_exc_t xip_fpo_log_flt (float *, float);
xip_fpo_exc_t xip_fpo_log_d (double *, double);
int xip_fpo_exp_array (xip_fpo_t * , xip_fpo_t * , xip_fpo_exc_t *, unsigned long long);
void xip_fpo_exp_flt_array (float * , float * , xip_fpo_exc_t *, unsigned long long);
void xip_fpo_exp_d_array (double * , double * , xip_fpo_exc_t *, unsigned long long);
xip_fpo_exc_t xip_fpo_exp (xip_fpo_ptr , xip_fpo_srcptr );
xip_fpo_exc_t xip_fpo_exp_flt (float * , float );
xip_fpo_exc_t xip_fpo_exp_d (double * , double );
struct xil_fpo_accum_state * xip_fpo_accum_create_state (int , int , int , int , int);
void xip_fpo_accum_reset_state (struct xil_fpo_accum_state *);
void xip_fpo_accum_destroy_state (struct xil_fpo_accum_state *);
xip_fpo_exc_t xip_fpo_accum_sample (xip_fpo_t, xip_fpo_t, bool, struct xil_fpo_accum_state *);
xip_fpo_exc_t xip_fpo_accum_sample_flt (float *, float , bool, struct xil_fpo_accum_state *);
xip_fpo_exc_t xip_fpo_accum_sample_d (double *, double , bool, struct xil_fpo_accum_state *);
xip_fpo_exc_t xip_fpo_sqrt (xip_fpo_ptr, xip_fpo_srcptr);
xip_fpo_exc_t xip_fpo_sqrt_flt (float *, float);
xip_fpo_exc_t xip_fpo_sqrt_d (double *, double);
xip_fpo_exc_t xip_fpo_recsqrt (xip_fpo_ptr, xip_fpo_srcptr);
xip_fpo_exc_t xip_fpo_recsqrt_flt (float *, float);
xip_fpo_exc_t xip_fpo_recsqrt_d (double *, double);
xip_fpo_exc_t xip_fpo_unordered (int *, xip_fpo_srcptr, xip_fpo_srcptr);
xip_fpo_exc_t xip_fpo_unordered_flt (int *, float, float);
xip_fpo_exc_t xip_fpo_unordered_d (int *, double, double);
xip_fpo_exc_t xip_fpo_equal (int *, xip_fpo_srcptr, xip_fpo_srcptr);
xip_fpo_exc_t xip_fpo_equal_flt (int *, float, float);
xip_fpo_exc_t xip_fpo_equal_d (int *, double, double);
xip_fpo_exc_t xip_fpo_less (int *, xip_fpo_srcptr, xip_fpo_srcptr);
xip_fpo_exc_t xip_fpo_less_flt (int *, float, float);
xip_fpo_exc_t xip_fpo_less_d (int *, double, double);
xip_fpo_exc_t xip_fpo_lessequal (int *, xip_fpo_srcptr, xip_fpo_srcptr);
xip_fpo_exc_t xip_fpo_lessequal_flt (int *, float, float);
xip_fpo_exc_t xip_fpo_lessequal_d (int *, double, double);
xip_fpo_exc_t xip_fpo_greater (int *, xip_fpo_srcptr, xip_fpo_srcptr);
xip_fpo_exc_t xip_fpo_greater_flt (int *, float, float);
xip_fpo_exc_t xip_fpo_greater_d (int *, double, double);
xip_fpo_exc_t xip_fpo_greaterequal (int *, xip_fpo_srcptr, xip_fpo_srcptr);
xip_fpo_exc_t xip_fpo_greaterequal_flt (int *, float, float);
xip_fpo_exc_t xip_fpo_greaterequal_d (int *, double, double);
xip_fpo_exc_t xip_fpo_notequal (int *, xip_fpo_srcptr, xip_fpo_srcptr);
xip_fpo_exc_t xip_fpo_notequal_flt (int *, float, float);
xip_fpo_exc_t xip_fpo_notequal_d (int *, double, double);
xip_fpo_exc_t xip_fpo_condcode (int *, xip_fpo_srcptr, xip_fpo_srcptr);
xip_fpo_exc_t xip_fpo_condcode_flt (int *, float, float);
xip_fpo_exc_t xip_fpo_condcode_d (int *, double, double);
xip_fpo_exc_t xip_fpo_flttofix (xip_fpo_fix_ptr, xip_fpo_srcptr);
xip_fpo_exc_t xip_fpo_flttofix_int_flt (int *, float);
xip_fpo_exc_t xip_fpo_flttofix_int_d (int *, double);
xip_fpo_exc_t xip_fpo_fixtoflt (xip_fpo_ptr, xip_fpo_fix_srcptr);
xip_fpo_exc_t xip_fpo_fixtoflt_flt_int (float *, int);
xip_fpo_exc_t xip_fpo_fixtoflt_d_int (double *, int);
xip_fpo_exc_t xip_fpo_flttoflt (xip_fpo_ptr, xip_fpo_srcptr);
xip_fpo_exc_t xip_fpo_flttoflt_flt_flt (float *, float);
xip_fpo_exc_t xip_fpo_flttoflt_flt_d (float *, double);
xip_fpo_exc_t xip_fpo_flttoflt_d_flt (double *, float);
xip_fpo_exc_t xip_fpo_flttoflt_d_d (double *, double);
}
# 187 "/data/tools/Xilinx/Vivado/2019.1/include/hls_fpo.h" 2
# 1 "/data/tools/Xilinx/Vivado/2019.1/include/gmp.h" 1
# 188 "/data/tools/Xilinx/Vivado/2019.1/include/hls_fpo.h" 2
# 1 "/data/tools/Xilinx/Vivado/2019.1/include/mpfr.h" 1
# 189 "/data/tools/Xilinx/Vivado/2019.1/include/hls_fpo.h" 2
inline float xil_fpo_add_flt(float a, float b)
{
float res_flt = 0.0f;
xip_fpo_add_flt(&res_flt, a, b);
return res_flt;
}
inline double xil_fpo_add_d(double a, double b)
{
double res_d = 0.0;
xip_fpo_add_d(&res_d, a, b);
return res_d;
}
inline float xil_fpo_sub_flt(float a, float b)
{
float res_flt = 0.0f;
xip_fpo_sub_flt(&res_flt, a, b);
return res_flt;
}
inline double xil_fpo_sub_d(double a, double b)
{
double res_d = 0.0;
xip_fpo_sub_d(&res_d, a, b);
return res_d;
}
inline float xil_fpo_mul_flt(float a, float b)
{
float res_flt = 0.0f;
xip_fpo_mul_flt(&res_flt, a, b);
return res_flt;
}
inline double xil_fpo_mul_d(double a, double b)
{
double res_d = 0.0;
xip_fpo_mul_d(&res_d, a, b);
return res_d;
}
inline float xil_fpo_div_flt(float a, float b)
{
float res_flt = 0.0f;
xip_fpo_div_flt(&res_flt, a, b);
return res_flt;
}
inline double xil_fpo_div_d(double a, double b)
{
double res_d = 0.0;
xip_fpo_div_d(&res_d, a, b);
return res_d;
}
inline float xil_fpo_rec_flt(float a)
{
float res_flt = 0.0f;
xip_fpo_rec_flt(&res_flt, a);
return res_flt;
}
inline double xil_fpo_rec_d(double a)
{
double res_d = 0.0;
xip_fpo_rec_d(&res_d, a);
return res_d;
}
inline float xil_fpo_sqrt_flt(float a)
{
float res_flt = 0.0f;
xip_fpo_sqrt_flt(&res_flt, a);
return res_flt;
}
inline double xil_fpo_sqrt_d(double a)
{
double res_d = 0.0;
xip_fpo_sqrt_d(&res_d, a);
return res_d;
}
inline float xil_fpo_recsqrt_flt(float a)
{
float res_flt = 0.0f;
xip_fpo_recsqrt_flt(&res_flt, a);
return res_flt;
}
inline double xil_fpo_recsqrt_d(double a)
{
double res_d = 0.0;
xip_fpo_recsqrt_d(&res_d, a);
return res_d;
}
inline float xil_fpo_abs_flt(float a)
{
float res_flt = 0.0f;
xip_fpo_abs_flt(&res_flt, a);
return res_flt;
}
inline double xil_fpo_abs_d(double a)
{
double res_d = 0.0;
xip_fpo_abs_d(&res_d, a);
return res_d;
}
inline float xil_fpo_log_flt(float a)
{
float res_flt = 0.0f;
xip_fpo_log_flt(&res_flt, a);
return res_flt;
}
inline double xil_fpo_log_d(double a)
{
double res_d = 0.0;
xip_fpo_log_d(&res_d, a);
return res_d;
}
inline float xil_fpo_exp_flt(float a)
{
float res_flt = 0.0f;
xip_fpo_exp_flt(&res_flt, a);
return res_flt;
}
inline double xil_fpo_exp_d(double a)
{
double res_d = 0.0;
xip_fpo_exp_d(&res_d, a);
return res_d;
}
inline int xil_fpo_unordered_flt(float a, float b)
{
int res_int = 0;
xip_fpo_unordered_flt(&res_int, a, b);
return res_int;
}
inline int xil_fpo_unordered_d(double a, double b)
{
int res_int = 0;
xip_fpo_unordered_d(&res_int, a, b);
return res_int;
}
inline int xil_fpo_equal_flt(float a, float b)
{
int res_int = 0;
xip_fpo_equal_flt(&res_int, a, b);
return res_int;
}
inline int xil_fpo_equal_d(double a, double b)
{
int res_int = 0;
xip_fpo_equal_d(&res_int, a, b);
return res_int;
}
inline int xil_fpo_less_flt(float a, float b)
{
int res_int = 0;
xip_fpo_less_flt(&res_int, a, b);
return res_int;
}
inline int xil_fpo_less_d(double a, double b)
{
int res_int = 0;
xip_fpo_less_d(&res_int, a, b);
return res_int;
}
inline int xil_fpo_lessequal_flt(float a, float b)
{
int res_int = 0;
xip_fpo_lessequal_flt(&res_int, a, b);
return res_int;
}
inline int xil_fpo_lessequal_d(double a, double b)
{
int res_int = 0;
xip_fpo_lessequal_d(&res_int, a, b);
return res_int;
}
inline int xil_fpo_greater_flt(float a, float b)
{
int res_int = 0;
xip_fpo_greater_flt(&res_int, a, b);
return res_int;
}
inline int xil_fpo_greater_d(double a, double b)
{
int res_int = 0;
xip_fpo_greater_d(&res_int, a, b);
return res_int;
}
inline int xil_fpo_greaterequal_flt(float a, float b)
{
int res_int = 0;
xip_fpo_greaterequal_flt(&res_int, a, b);
return res_int;
}
inline int xil_fpo_greaterequal_d(double a, double b)
{
int res_int = 0;
xip_fpo_greaterequal_d(&res_int, a, b);
return res_int;
}
inline int xil_fpo_notequal_flt(float a, float b)
{
int res_int = 0;
xip_fpo_notequal_flt(&res_int, a, b);
return res_int;
}
inline int xil_fpo_notequal_d(double a, double b)
{
int res_int = 0;
xip_fpo_notequal_d(&res_int, a, b);
return res_int;
}
inline int xil_fpo_condcode_flt(float a, float b)
{
int res_int = 0;
xip_fpo_condcode_flt(&res_int, a, b);
return res_int;
}
inline int xil_fpo_condcode_d(double a, double b)
{
int res_int = 0;
xip_fpo_condcode_d(&res_int, a, b);
return res_int;
}
inline int xil_fpo_flttofix_int_flt(float a)
{
int res_int = 0;
xip_fpo_flttofix_int_flt(&res_int, a);
return res_int;
}
inline int xil_fpo_flttofix_int_d(double a)
{
int res_int = 0;
xip_fpo_flttofix_int_d(&res_int, a);
return res_int;
}
inline float xil_fpo_fixtoflt_flt_int(int a)
{
float res_flt = 0.0f;
xip_fpo_fixtoflt_flt_int(&res_flt, a);
return res_flt;
}
inline double xil_fpo_fixtoflt_d_int(int a)
{
double res_d = 0.0;
xip_fpo_fixtoflt_d_int(&res_d, a);
return res_d;
}
inline float xil_fpo_flttoflt_flt_flt(float a)
{
float res_flt = 0.0f;
xip_fpo_flttoflt_flt_flt(&res_flt, a);
return res_flt;
}
inline float xil_fpo_flttoflt_flt_d(double a)
{
float res_flt = 0.0f;
xip_fpo_flttoflt_flt_d(&res_flt, a);
return res_flt;
}
inline double xil_fpo_flttoflt_d_flt(float a)
{
double res_d = 0.0;
xip_fpo_flttoflt_d_flt(&res_d, a);
return res_d;
}
inline double xil_fpo_flttoflt_d_d(double a)
{
double res_d = 0.0;
xip_fpo_flttoflt_d_d(&res_d, a);
return res_d;
}
# 45 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h" 2
# 1 "/data/tools/Xilinx/Vivado/2019.1/include/ap_decl.h" 1
# 48 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h" 2
# 129 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/utility" 1 3
# 58 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/utility" 3
# 59 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/utility" 3
# 69 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/utility" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_relops.h" 1 3
# 67 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_relops.h" 3
# 67 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_relops.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
namespace rel_ops
{
# 85 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_relops.h" 3
template <class _Tp>
inline bool
operator!=(const _Tp& __x, const _Tp& __y)
{ return !(__x == __y); }
# 98 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_relops.h" 3
template <class _Tp>
inline bool
operator>(const _Tp& __x, const _Tp& __y)
{ return __y < __x; }
# 111 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_relops.h" 3
template <class _Tp>
inline bool
operator<=(const _Tp& __x, const _Tp& __y)
{ return !(__y < __x); }
# 124 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_relops.h" 3
template <class _Tp>
inline bool
operator>=(const _Tp& __x, const _Tp& __y)
{ return !(__x < __y); }
}
}
# 70 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/utility" 2 3
# 78 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/utility" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Tp>
struct tuple_size;
template<typename _Tp>
struct tuple_size<const _Tp>
: integral_constant<size_t, tuple_size<_Tp>::value> { };
template<typename _Tp>
struct tuple_size<volatile _Tp>
: integral_constant<size_t, tuple_size<_Tp>::value> { };
template<typename _Tp>
struct tuple_size<const volatile _Tp>
: integral_constant<size_t, tuple_size<_Tp>::value> { };
template<std::size_t __i, typename _Tp>
struct tuple_element;
template<std::size_t __i, typename _Tp>
using __tuple_element_t = typename tuple_element<__i, _Tp>::type;
template<std::size_t __i, typename _Tp>
struct tuple_element<__i, const _Tp>
{
typedef typename add_const<__tuple_element_t<__i, _Tp>>::type type;
};
template<std::size_t __i, typename _Tp>
struct tuple_element<__i, volatile _Tp>
{
typedef typename add_volatile<__tuple_element_t<__i, _Tp>>::type type;
};
template<std::size_t __i, typename _Tp>
struct tuple_element<__i, const volatile _Tp>
{
typedef typename add_cv<__tuple_element_t<__i, _Tp>>::type type;
};
template<std::size_t __i, typename _Tp>
using tuple_element_t = typename tuple_element<__i, _Tp>::type;
template<typename>
struct __is_tuple_like_impl : false_type
{ };
template<typename _T1, typename _T2>
struct __is_tuple_like_impl<std::pair<_T1, _T2>> : true_type
{ };
template<class _Tp1, class _Tp2>
struct tuple_size<std::pair<_Tp1, _Tp2>>
: public integral_constant<std::size_t, 2> { };
template<class _Tp1, class _Tp2>
struct tuple_element<0, std::pair<_Tp1, _Tp2>>
{ typedef _Tp1 type; };
template<class _Tp1, class _Tp2>
struct tuple_element<1, std::pair<_Tp1, _Tp2>>
{ typedef _Tp2 type; };
template<std::size_t _Int>
struct __pair_get;
template<>
struct __pair_get<0>
{
template<typename _Tp1, typename _Tp2>
static constexpr _Tp1&
__get(std::pair<_Tp1, _Tp2>& __pair) noexcept
{ return __pair.first; }
template<typename _Tp1, typename _Tp2>
static constexpr _Tp1&&
__move_get(std::pair<_Tp1, _Tp2>&& __pair) noexcept
{ return std::forward<_Tp1>(__pair.first); }
template<typename _Tp1, typename _Tp2>
static constexpr const _Tp1&
__const_get(const std::pair<_Tp1, _Tp2>& __pair) noexcept
{ return __pair.first; }
};
template<>
struct __pair_get<1>
{
template<typename _Tp1, typename _Tp2>
static constexpr _Tp2&
__get(std::pair<_Tp1, _Tp2>& __pair) noexcept
{ return __pair.second; }
template<typename _Tp1, typename _Tp2>
static constexpr _Tp2&&
__move_get(std::pair<_Tp1, _Tp2>&& __pair) noexcept
{ return std::forward<_Tp2>(__pair.second); }
template<typename _Tp1, typename _Tp2>
static constexpr const _Tp2&
__const_get(const std::pair<_Tp1, _Tp2>& __pair) noexcept
{ return __pair.second; }
};
template<std::size_t _Int, class _Tp1, class _Tp2>
constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
get(std::pair<_Tp1, _Tp2>& __in) noexcept
{ return __pair_get<_Int>::__get(__in); }
template<std::size_t _Int, class _Tp1, class _Tp2>
constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&&
get(std::pair<_Tp1, _Tp2>&& __in) noexcept
{ return __pair_get<_Int>::__move_get(std::move(__in)); }
template<std::size_t _Int, class _Tp1, class _Tp2>
constexpr const typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
get(const std::pair<_Tp1, _Tp2>& __in) noexcept
{ return __pair_get<_Int>::__const_get(__in); }
template <typename _Tp, typename _Up>
constexpr _Tp&
get(pair<_Tp, _Up>& __p) noexcept
{ return __p.first; }
template <typename _Tp, typename _Up>
constexpr const _Tp&
get(const pair<_Tp, _Up>& __p) noexcept
{ return __p.first; }
template <typename _Tp, typename _Up>
constexpr _Tp&&
get(pair<_Tp, _Up>&& __p) noexcept
{ return std::move(__p.first); }
template <typename _Tp, typename _Up>
constexpr _Tp&
get(pair<_Up, _Tp>& __p) noexcept
{ return __p.second; }
template <typename _Tp, typename _Up>
constexpr const _Tp&
get(const pair<_Up, _Tp>& __p) noexcept
{ return __p.second; }
template <typename _Tp, typename _Up>
constexpr _Tp&&
get(pair<_Up, _Tp>&& __p) noexcept
{ return std::move(__p.second); }
template <typename _Tp, typename _Up = _Tp>
inline _Tp
exchange(_Tp& __obj, _Up&& __new_val)
{ return std::__exchange(__obj, std::forward<_Up>(__new_val)); }
template<size_t... _Indexes> struct _Index_tuple { };
template<typename _Itup1, typename _Itup2> struct _Itup_cat;
template<size_t... _Ind1, size_t... _Ind2>
struct _Itup_cat<_Index_tuple<_Ind1...>, _Index_tuple<_Ind2...>>
{
using __type = _Index_tuple<_Ind1..., (_Ind2 + sizeof...(_Ind1))...>;
};
template<size_t _Num>
struct _Build_index_tuple
: _Itup_cat<typename _Build_index_tuple<_Num / 2>::__type,
typename _Build_index_tuple<_Num - _Num / 2>::__type>
{ };
template<>
struct _Build_index_tuple<1>
{
typedef _Index_tuple<0> __type;
};
template<>
struct _Build_index_tuple<0>
{
typedef _Index_tuple<> __type;
};
template<typename _Tp, _Tp... _Idx>
struct integer_sequence
{
typedef _Tp value_type;
static constexpr size_t size() { return sizeof...(_Idx); }
};
template<typename _Tp, _Tp _Num,
typename _ISeq = typename _Build_index_tuple<_Num>::__type>
struct _Make_integer_sequence;
template<typename _Tp, _Tp _Num, size_t... _Idx>
struct _Make_integer_sequence<_Tp, _Num, _Index_tuple<_Idx...>>
{
static_assert( _Num >= 0,
"Cannot make integer sequence of negative length" );
typedef integer_sequence<_Tp, static_cast<_Tp>(_Idx)...> __type;
};
template<typename _Tp, _Tp _Num>
using make_integer_sequence
= typename _Make_integer_sequence<_Tp, _Num>::__type;
template<size_t... _Idx>
using index_sequence = integer_sequence<size_t, _Idx...>;
template<size_t _Num>
using make_index_sequence = make_integer_sequence<size_t, _Num>;
template<typename... _Types>
using index_sequence_for = make_index_sequence<sizeof...(_Types)>;
}
# 130 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h" 2
# 210 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/algorithm" 1 3
# 58 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/algorithm" 3
# 59 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/algorithm" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 1 3
# 59 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 1 3
# 39 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 3
# 40 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 3
# 60 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/algorithmfwd.h" 1 3
# 33 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/algorithmfwd.h" 3
# 34 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/algorithmfwd.h" 3
# 42 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/algorithmfwd.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 194 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/algorithmfwd.h" 3
template<typename _IIter, typename _Predicate>
bool
all_of(_IIter, _IIter, _Predicate);
template<typename _IIter, typename _Predicate>
bool
any_of(_IIter, _IIter, _Predicate);
template<typename _FIter, typename _Tp>
bool
binary_search(_FIter, _FIter, const _Tp&);
template<typename _FIter, typename _Tp, typename _Compare>
bool
binary_search(_FIter, _FIter, const _Tp&, _Compare);
template<typename _IIter, typename _OIter>
_OIter
copy(_IIter, _IIter, _OIter);
template<typename _BIter1, typename _BIter2>
_BIter2
copy_backward(_BIter1, _BIter1, _BIter2);
template<typename _IIter, typename _OIter, typename _Predicate>
_OIter
copy_if(_IIter, _IIter, _OIter, _Predicate);
template<typename _IIter, typename _Size, typename _OIter>
_OIter
copy_n(_IIter, _Size, _OIter);
template<typename _FIter, typename _Tp>
pair<_FIter, _FIter>
equal_range(_FIter, _FIter, const _Tp&);
template<typename _FIter, typename _Tp, typename _Compare>
pair<_FIter, _FIter>
equal_range(_FIter, _FIter, const _Tp&, _Compare);
template<typename _FIter, typename _Tp>
void
fill(_FIter, _FIter, const _Tp&);
template<typename _OIter, typename _Size, typename _Tp>
_OIter
fill_n(_OIter, _Size, const _Tp&);
template<typename _FIter1, typename _FIter2>
_FIter1
find_end(_FIter1, _FIter1, _FIter2, _FIter2);
template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
_FIter1
find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
template<typename _IIter, typename _Predicate>
_IIter
find_if_not(_IIter, _IIter, _Predicate);
template<typename _IIter1, typename _IIter2>
bool
includes(_IIter1, _IIter1, _IIter2, _IIter2);
template<typename _IIter1, typename _IIter2, typename _Compare>
bool
includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
template<typename _BIter>
void
inplace_merge(_BIter, _BIter, _BIter);
template<typename _BIter, typename _Compare>
void
inplace_merge(_BIter, _BIter, _BIter, _Compare);
template<typename _RAIter>
bool
is_heap(_RAIter, _RAIter);
template<typename _RAIter, typename _Compare>
bool
is_heap(_RAIter, _RAIter, _Compare);
template<typename _RAIter>
_RAIter
is_heap_until(_RAIter, _RAIter);
template<typename _RAIter, typename _Compare>
_RAIter
is_heap_until(_RAIter, _RAIter, _Compare);
template<typename _IIter, typename _Predicate>
bool
is_partitioned(_IIter, _IIter, _Predicate);
template<typename _FIter1, typename _FIter2>
bool
is_permutation(_FIter1, _FIter1, _FIter2);
template<typename _FIter1, typename _FIter2,
typename _BinaryPredicate>
bool
is_permutation(_FIter1, _FIter1, _FIter2, _BinaryPredicate);
template<typename _FIter>
bool
is_sorted(_FIter, _FIter);
template<typename _FIter, typename _Compare>
bool
is_sorted(_FIter, _FIter, _Compare);
template<typename _FIter>
_FIter
is_sorted_until(_FIter, _FIter);
template<typename _FIter, typename _Compare>
_FIter
is_sorted_until(_FIter, _FIter, _Compare);
template<typename _FIter1, typename _FIter2>
void
iter_swap(_FIter1, _FIter2);
template<typename _FIter, typename _Tp>
_FIter
lower_bound(_FIter, _FIter, const _Tp&);
template<typename _FIter, typename _Tp, typename _Compare>
_FIter
lower_bound(_FIter, _FIter, const _Tp&, _Compare);
template<typename _RAIter>
void
make_heap(_RAIter, _RAIter);
template<typename _RAIter, typename _Compare>
void
make_heap(_RAIter, _RAIter, _Compare);
template<typename _Tp>
constexpr
const _Tp&
max(const _Tp&, const _Tp&);
template<typename _Tp, typename _Compare>
constexpr
const _Tp&
max(const _Tp&, const _Tp&, _Compare);
template<typename _Tp>
constexpr
const _Tp&
min(const _Tp&, const _Tp&);
template<typename _Tp, typename _Compare>
constexpr
const _Tp&
min(const _Tp&, const _Tp&, _Compare);
template<typename _Tp>
constexpr
pair<const _Tp&, const _Tp&>
minmax(const _Tp&, const _Tp&);
template<typename _Tp, typename _Compare>
constexpr
pair<const _Tp&, const _Tp&>
minmax(const _Tp&, const _Tp&, _Compare);
template<typename _FIter>
constexpr
pair<_FIter, _FIter>
minmax_element(_FIter, _FIter);
template<typename _FIter, typename _Compare>
constexpr
pair<_FIter, _FIter>
minmax_element(_FIter, _FIter, _Compare);
template<typename _Tp>
constexpr
_Tp
min(initializer_list<_Tp>);
template<typename _Tp, typename _Compare>
constexpr
_Tp
min(initializer_list<_Tp>, _Compare);
template<typename _Tp>
constexpr
_Tp
max(initializer_list<_Tp>);
template<typename _Tp, typename _Compare>
constexpr
_Tp
max(initializer_list<_Tp>, _Compare);
template<typename _Tp>
constexpr
pair<_Tp, _Tp>
minmax(initializer_list<_Tp>);
template<typename _Tp, typename _Compare>
constexpr
pair<_Tp, _Tp>
minmax(initializer_list<_Tp>, _Compare);
template<typename _BIter>
bool
next_permutation(_BIter, _BIter);
template<typename _BIter, typename _Compare>
bool
next_permutation(_BIter, _BIter, _Compare);
template<typename _IIter, typename _Predicate>
bool
none_of(_IIter, _IIter, _Predicate);
template<typename _IIter, typename _RAIter>
_RAIter
partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter);
template<typename _IIter, typename _RAIter, typename _Compare>
_RAIter
partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare);
template<typename _IIter, typename _OIter1,
typename _OIter2, typename _Predicate>
pair<_OIter1, _OIter2>
partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate);
template<typename _FIter, typename _Predicate>
_FIter
partition_point(_FIter, _FIter, _Predicate);
template<typename _RAIter>
void
pop_heap(_RAIter, _RAIter);
template<typename _RAIter, typename _Compare>
void
pop_heap(_RAIter, _RAIter, _Compare);
template<typename _BIter>
bool
prev_permutation(_BIter, _BIter);
template<typename _BIter, typename _Compare>
bool
prev_permutation(_BIter, _BIter, _Compare);
template<typename _RAIter>
void
push_heap(_RAIter, _RAIter);
template<typename _RAIter, typename _Compare>
void
push_heap(_RAIter, _RAIter, _Compare);
template<typename _FIter, typename _Tp>
_FIter
remove(_FIter, _FIter, const _Tp&);
template<typename _FIter, typename _Predicate>
_FIter
remove_if(_FIter, _FIter, _Predicate);
template<typename _IIter, typename _OIter, typename _Tp>
_OIter
remove_copy(_IIter, _IIter, _OIter, const _Tp&);
template<typename _IIter, typename _OIter, typename _Predicate>
_OIter
remove_copy_if(_IIter, _IIter, _OIter, _Predicate);
template<typename _IIter, typename _OIter, typename _Tp>
_OIter
replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&);
template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp>
_OIter
replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&);
template<typename _BIter>
void
reverse(_BIter, _BIter);
template<typename _BIter, typename _OIter>
_OIter
reverse_copy(_BIter, _BIter, _OIter);
inline namespace _V2
{
template<typename _FIter>
_FIter
rotate(_FIter, _FIter, _FIter);
}
template<typename _FIter, typename _OIter>
_OIter
rotate_copy(_FIter, _FIter, _FIter, _OIter);
# 552 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/algorithmfwd.h" 3
template<typename _RAIter, typename _UGenerator>
void
shuffle(_RAIter, _RAIter, _UGenerator&&);
template<typename _RAIter>
void
sort_heap(_RAIter, _RAIter);
template<typename _RAIter, typename _Compare>
void
sort_heap(_RAIter, _RAIter, _Compare);
template<typename _BIter, typename _Predicate>
_BIter
stable_partition(_BIter, _BIter, _Predicate);
# 581 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/algorithmfwd.h" 3
template<typename _FIter1, typename _FIter2>
_FIter2
swap_ranges(_FIter1, _FIter1, _FIter2);
template<typename _FIter>
_FIter
unique(_FIter, _FIter);
template<typename _FIter, typename _BinaryPredicate>
_FIter
unique(_FIter, _FIter, _BinaryPredicate);
template<typename _FIter, typename _Tp>
_FIter
upper_bound(_FIter, _FIter, const _Tp&);
template<typename _FIter, typename _Tp, typename _Compare>
_FIter
upper_bound(_FIter, _FIter, const _Tp&, _Compare);
template<typename _FIter>
_FIter
adjacent_find(_FIter, _FIter);
template<typename _FIter, typename _BinaryPredicate>
_FIter
adjacent_find(_FIter, _FIter, _BinaryPredicate);
template<typename _IIter, typename _Tp>
typename iterator_traits<_IIter>::difference_type
count(_IIter, _IIter, const _Tp&);
template<typename _IIter, typename _Predicate>
typename iterator_traits<_IIter>::difference_type
count_if(_IIter, _IIter, _Predicate);
template<typename _IIter1, typename _IIter2>
bool
equal(_IIter1, _IIter1, _IIter2);
template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
bool
equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
template<typename _IIter, typename _Tp>
_IIter
find(_IIter, _IIter, const _Tp&);
template<typename _FIter1, typename _FIter2>
_FIter1
find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);
template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
_FIter1
find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
template<typename _IIter, typename _Predicate>
_IIter
find_if(_IIter, _IIter, _Predicate);
template<typename _IIter, typename _Funct>
_Funct
for_each(_IIter, _IIter, _Funct);
template<typename _FIter, typename _Generator>
void
generate(_FIter, _FIter, _Generator);
template<typename _OIter, typename _Size, typename _Generator>
_OIter
generate_n(_OIter, _Size, _Generator);
template<typename _IIter1, typename _IIter2>
bool
lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);
template<typename _IIter1, typename _IIter2, typename _Compare>
bool
lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
template<typename _FIter>
constexpr
_FIter
max_element(_FIter, _FIter);
template<typename _FIter, typename _Compare>
constexpr
_FIter
max_element(_FIter, _FIter, _Compare);
template<typename _IIter1, typename _IIter2, typename _OIter>
_OIter
merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
template<typename _IIter1, typename _IIter2, typename _OIter,
typename _Compare>
_OIter
merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
template<typename _FIter>
constexpr
_FIter
min_element(_FIter, _FIter);
template<typename _FIter, typename _Compare>
constexpr
_FIter
min_element(_FIter, _FIter, _Compare);
template<typename _IIter1, typename _IIter2>
pair<_IIter1, _IIter2>
mismatch(_IIter1, _IIter1, _IIter2);
template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
pair<_IIter1, _IIter2>
mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
template<typename _RAIter>
void
nth_element(_RAIter, _RAIter, _RAIter);
template<typename _RAIter, typename _Compare>
void
nth_element(_RAIter, _RAIter, _RAIter, _Compare);
template<typename _RAIter>
void
partial_sort(_RAIter, _RAIter, _RAIter);
template<typename _RAIter, typename _Compare>
void
partial_sort(_RAIter, _RAIter, _RAIter, _Compare);
template<typename _BIter, typename _Predicate>
_BIter
partition(_BIter, _BIter, _Predicate);
template<typename _RAIter>
void
random_shuffle(_RAIter, _RAIter);
template<typename _RAIter, typename _Generator>
void
random_shuffle(_RAIter, _RAIter,
_Generator&&);
template<typename _FIter, typename _Tp>
void
replace(_FIter, _FIter, const _Tp&, const _Tp&);
template<typename _FIter, typename _Predicate, typename _Tp>
void
replace_if(_FIter, _FIter, _Predicate, const _Tp&);
template<typename _FIter1, typename _FIter2>
_FIter1
search(_FIter1, _FIter1, _FIter2, _FIter2);
template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
_FIter1
search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
template<typename _FIter, typename _Size, typename _Tp>
_FIter
search_n(_FIter, _FIter, _Size, const _Tp&);
template<typename _FIter, typename _Size, typename _Tp,
typename _BinaryPredicate>
_FIter
search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);
template<typename _IIter1, typename _IIter2, typename _OIter>
_OIter
set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
template<typename _IIter1, typename _IIter2, typename _OIter,
typename _Compare>
_OIter
set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
template<typename _IIter1, typename _IIter2, typename _OIter>
_OIter
set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
template<typename _IIter1, typename _IIter2, typename _OIter,
typename _Compare>
_OIter
set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
template<typename _IIter1, typename _IIter2, typename _OIter>
_OIter
set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
template<typename _IIter1, typename _IIter2, typename _OIter,
typename _Compare>
_OIter
set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2,
_OIter, _Compare);
template<typename _IIter1, typename _IIter2, typename _OIter>
_OIter
set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
template<typename _IIter1, typename _IIter2, typename _OIter,
typename _Compare>
_OIter
set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
template<typename _RAIter>
void
sort(_RAIter, _RAIter);
template<typename _RAIter, typename _Compare>
void
sort(_RAIter, _RAIter, _Compare);
template<typename _RAIter>
void
stable_sort(_RAIter, _RAIter);
template<typename _RAIter, typename _Compare>
void
stable_sort(_RAIter, _RAIter, _Compare);
template<typename _IIter, typename _OIter, typename _UnaryOperation>
_OIter
transform(_IIter, _IIter, _OIter, _UnaryOperation);
template<typename _IIter1, typename _IIter2, typename _OIter,
typename _BinaryOperation>
_OIter
transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);
template<typename _IIter, typename _OIter>
_OIter
unique_copy(_IIter, _IIter, _OIter);
template<typename _IIter, typename _OIter, typename _BinaryPredicate>
_OIter
unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);
}
# 61 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_heap.h" 1 3
# 62 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_heap.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _RandomAccessIterator, typename _Distance,
typename _Compare>
_Distance
__is_heap_until(_RandomAccessIterator __first, _Distance __n,
_Compare __comp)
{
_Distance __parent = 0;
for (_Distance __child = 1; __child < __n; ++__child)
{
if (__comp(__first + __parent, __first + __child))
return __child;
if ((__child & 1) == 0)
++__parent;
}
return __n;
}
template<typename _RandomAccessIterator, typename _Distance>
inline bool
__is_heap(_RandomAccessIterator __first, _Distance __n)
{
return std::__is_heap_until(__first, __n,
__gnu_cxx::__ops::__iter_less_iter()) == __n;
}
template<typename _RandomAccessIterator, typename _Compare,
typename _Distance>
inline bool
__is_heap(_RandomAccessIterator __first, _Compare __comp, _Distance __n)
{
return std::__is_heap_until(__first, __n,
__gnu_cxx::__ops::__iter_comp_iter(__comp)) == __n;
}
template<typename _RandomAccessIterator>
inline bool
__is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
{ return std::__is_heap(__first, std::distance(__first, __last)); }
template<typename _RandomAccessIterator, typename _Compare>
inline bool
__is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
{ return std::__is_heap(__first, __comp, std::distance(__first, __last)); }
template<typename _RandomAccessIterator, typename _Distance, typename _Tp,
typename _Compare>
void
__push_heap(_RandomAccessIterator __first,
_Distance __holeIndex, _Distance __topIndex, _Tp __value,
_Compare __comp)
{
_Distance __parent = (__holeIndex - 1) / 2;
while (__holeIndex > __topIndex && __comp(__first + __parent, __value))
{
*(__first + __holeIndex) = std::move(*(__first + __parent));
__holeIndex = __parent;
__parent = (__holeIndex - 1) / 2;
}
*(__first + __holeIndex) = std::move(__value);
}
# 148 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_heap.h" 3
template<typename _RandomAccessIterator>
inline void
push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
{
typedef typename iterator_traits<_RandomAccessIterator>::value_type
_ValueType;
typedef typename iterator_traits<_RandomAccessIterator>::difference_type
_DistanceType;
;
;
;
_ValueType __value = std::move(*(__last - 1));
std::__push_heap(__first, _DistanceType((__last - __first) - 1),
_DistanceType(0), std::move(__value),
__gnu_cxx::__ops::__iter_less_val());
}
# 183 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_heap.h" 3
template<typename _RandomAccessIterator, typename _Compare>
inline void
push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
{
typedef typename iterator_traits<_RandomAccessIterator>::value_type
_ValueType;
typedef typename iterator_traits<_RandomAccessIterator>::difference_type
_DistanceType;
;
;
;
_ValueType __value = std::move(*(__last - 1));
std::__push_heap(__first, _DistanceType((__last - __first) - 1),
_DistanceType(0), std::move(__value),
__gnu_cxx::__ops::__iter_comp_val(__comp));
}
template<typename _RandomAccessIterator, typename _Distance,
typename _Tp, typename _Compare>
void
__adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
_Distance __len, _Tp __value, _Compare __comp)
{
const _Distance __topIndex = __holeIndex;
_Distance __secondChild = __holeIndex;
while (__secondChild < (__len - 1) / 2)
{
__secondChild = 2 * (__secondChild + 1);
if (__comp(__first + __secondChild,
__first + (__secondChild - 1)))
__secondChild--;
*(__first + __holeIndex) = std::move(*(__first + __secondChild));
__holeIndex = __secondChild;
}
if ((__len & 1) == 0 && __secondChild == (__len - 2) / 2)
{
__secondChild = 2 * (__secondChild + 1);
*(__first + __holeIndex) = std::move(*(__first + (__secondChild - 1)))
;
__holeIndex = __secondChild - 1;
}
std::__push_heap(__first, __holeIndex, __topIndex,
std::move(__value),
__gnu_cxx::__ops::__iter_comp_val(__comp));
}
template<typename _RandomAccessIterator, typename _Compare>
inline void
__pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_RandomAccessIterator __result, _Compare __comp)
{
typedef typename iterator_traits<_RandomAccessIterator>::value_type
_ValueType;
typedef typename iterator_traits<_RandomAccessIterator>::difference_type
_DistanceType;
_ValueType __value = std::move(*__result);
*__result = std::move(*__first);
std::__adjust_heap(__first, _DistanceType(0),
_DistanceType(__last - __first),
std::move(__value), __comp);
}
# 263 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_heap.h" 3
template<typename _RandomAccessIterator>
inline void
pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
{
;
;
;
;
if (__last - __first > 1)
{
--__last;
std::__pop_heap(__first, __last, __last,
__gnu_cxx::__ops::__iter_less_iter());
}
}
# 296 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_heap.h" 3
template<typename _RandomAccessIterator, typename _Compare>
inline void
pop_heap(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
{
;
;
;
;
if (__last - __first > 1)
{
--__last;
std::__pop_heap(__first, __last, __last,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
}
template<typename _RandomAccessIterator, typename _Compare>
void
__make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
{
typedef typename iterator_traits<_RandomAccessIterator>::value_type
_ValueType;
typedef typename iterator_traits<_RandomAccessIterator>::difference_type
_DistanceType;
if (__last - __first < 2)
return;
const _DistanceType __len = __last - __first;
_DistanceType __parent = (__len - 2) / 2;
while (true)
{
_ValueType __value = std::move(*(__first + __parent));
std::__adjust_heap(__first, __parent, __len, std::move(__value),
__comp);
if (__parent == 0)
return;
__parent--;
}
}
# 351 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_heap.h" 3
template<typename _RandomAccessIterator>
inline void
make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
{
;
;
std::__make_heap(__first, __last,
__gnu_cxx::__ops::__iter_less_iter());
}
# 377 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_heap.h" 3
template<typename _RandomAccessIterator, typename _Compare>
inline void
make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
{
;
;
std::__make_heap(__first, __last,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
template<typename _RandomAccessIterator, typename _Compare>
void
__sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
{
while (__last - __first > 1)
{
--__last;
std::__pop_heap(__first, __last, __last, __comp);
}
}
# 412 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_heap.h" 3
template<typename _RandomAccessIterator>
inline void
sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
{
;
;
;
std::__sort_heap(__first, __last,
__gnu_cxx::__ops::__iter_less_iter());
}
# 439 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_heap.h" 3
template<typename _RandomAccessIterator, typename _Compare>
inline void
sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
{
;
;
;
std::__sort_heap(__first, __last,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
# 466 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_heap.h" 3
template<typename _RandomAccessIterator>
inline _RandomAccessIterator
is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last)
{
;
;
return __first +
std::__is_heap_until(__first, std::distance(__first, __last),
__gnu_cxx::__ops::__iter_less_iter());
}
# 494 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_heap.h" 3
template<typename _RandomAccessIterator, typename _Compare>
inline _RandomAccessIterator
is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
{
;
;
return __first
+ std::__is_heap_until(__first, std::distance(__first, __last),
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
# 517 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_heap.h" 3
template<typename _RandomAccessIterator>
inline bool
is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
{ return std::is_heap_until(__first, __last) == __last; }
# 530 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_heap.h" 3
template<typename _RandomAccessIterator, typename _Compare>
inline bool
is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
{ return std::is_heap_until(__first, __last, __comp) == __last; }
}
# 62 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_tempbuf.h" 1 3
# 60 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_tempbuf.h" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_construct.h" 1 3
# 63 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_construct.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _T1, typename... _Args>
inline void
_Construct(_T1* __p, _Args&&... __args)
{ ::new(static_cast<void*>(__p)) _T1(std::forward<_Args>(__args)...); }
# 90 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_construct.h" 3
template<typename _Tp>
inline void
_Destroy(_Tp* __pointer)
{ __pointer->~_Tp(); }
template<bool>
struct _Destroy_aux
{
template<typename _ForwardIterator>
static void
__destroy(_ForwardIterator __first, _ForwardIterator __last)
{
for (; __first != __last; ++__first)
std::_Destroy(std::__addressof(*__first));
}
};
template<>
struct _Destroy_aux<true>
{
template<typename _ForwardIterator>
static void
__destroy(_ForwardIterator, _ForwardIterator) { }
};
template<typename _ForwardIterator>
inline void
_Destroy(_ForwardIterator __first, _ForwardIterator __last)
{
typedef typename iterator_traits<_ForwardIterator>::value_type
_Value_type;
std::_Destroy_aux<__has_trivial_destructor(_Value_type)>::
__destroy(__first, __last);
}
template<typename _ForwardIterator, typename _Allocator>
void
_Destroy(_ForwardIterator __first, _ForwardIterator __last,
_Allocator& __alloc)
{
typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
for (; __first != __last; ++__first)
__traits::destroy(__alloc, std::__addressof(*__first));
}
template<typename _ForwardIterator, typename _Tp>
inline void
_Destroy(_ForwardIterator __first, _ForwardIterator __last,
allocator<_Tp>&)
{
_Destroy(__first, __last);
}
}
# 61 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_tempbuf.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 83 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_tempbuf.h" 3
template<typename _Tp>
pair<_Tp*, ptrdiff_t>
get_temporary_buffer(ptrdiff_t __len) noexcept
{
const ptrdiff_t __max =
__gnu_cxx::__numeric_traits<ptrdiff_t>::__max / sizeof(_Tp);
if (__len > __max)
__len = __max;
while (__len > 0)
{
_Tp* __tmp = static_cast<_Tp*>(::operator new(__len * sizeof(_Tp),
std::nothrow));
if (__tmp != 0)
return std::pair<_Tp*, ptrdiff_t>(__tmp, __len);
__len /= 2;
}
return std::pair<_Tp*, ptrdiff_t>(static_cast<_Tp*>(0), 0);
}
# 110 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_tempbuf.h" 3
template<typename _Tp>
inline void
return_temporary_buffer(_Tp* __p)
{ ::operator delete(__p, std::nothrow); }
template<typename _ForwardIterator, typename _Tp>
class _Temporary_buffer
{
public:
typedef _Tp value_type;
typedef value_type* pointer;
typedef pointer iterator;
typedef ptrdiff_t size_type;
protected:
size_type _M_original_len;
size_type _M_len;
pointer _M_buffer;
public:
size_type
size() const
{ return _M_len; }
size_type
requested_size() const
{ return _M_original_len; }
iterator
begin()
{ return _M_buffer; }
iterator
end()
{ return _M_buffer + _M_len; }
_Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last);
~_Temporary_buffer()
{
std::_Destroy(_M_buffer, _M_buffer + _M_len);
std::return_temporary_buffer(_M_buffer);
}
private:
_Temporary_buffer(const _Temporary_buffer&);
void
operator=(const _Temporary_buffer&);
};
template<bool>
struct __uninitialized_construct_buf_dispatch
{
template<typename _Pointer, typename _ForwardIterator>
static void
__ucr(_Pointer __first, _Pointer __last,
_ForwardIterator __seed)
{
if(__first == __last)
return;
_Pointer __cur = __first;
try
{
std::_Construct(std::__addressof(*__first),
std::move(*__seed));
_Pointer __prev = __cur;
++__cur;
for(; __cur != __last; ++__cur, ++__prev)
std::_Construct(std::__addressof(*__cur),
std::move(*__prev));
*__seed = std::move(*__prev);
}
catch(...)
{
std::_Destroy(__first, __cur);
throw;
}
}
};
template<>
struct __uninitialized_construct_buf_dispatch<true>
{
template<typename _Pointer, typename _ForwardIterator>
static void
__ucr(_Pointer, _Pointer, _ForwardIterator) { }
};
# 229 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_tempbuf.h" 3
template<typename _Pointer, typename _ForwardIterator>
inline void
__uninitialized_construct_buf(_Pointer __first, _Pointer __last,
_ForwardIterator __seed)
{
typedef typename std::iterator_traits<_Pointer>::value_type
_ValueType;
std::__uninitialized_construct_buf_dispatch<
__has_trivial_constructor(_ValueType)>::
__ucr(__first, __last, __seed);
}
template<typename _ForwardIterator, typename _Tp>
_Temporary_buffer<_ForwardIterator, _Tp>::
_Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last)
: _M_original_len(std::distance(__first, __last)),
_M_len(0), _M_buffer(0)
{
try
{
std::pair<pointer, size_type> __p(std::get_temporary_buffer<
value_type>(_M_original_len));
_M_buffer = __p.first;
_M_len = __p.second;
if (_M_buffer)
std::__uninitialized_construct_buf(_M_buffer, _M_buffer + _M_len,
__first);
}
catch(...)
{
std::return_temporary_buffer(_M_buffer);
_M_buffer = 0;
_M_len = 0;
throw;
}
}
}
# 63 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/uniform_int_dist.h" 1 3
# 35 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/uniform_int_dist.h" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/limits" 1 3
# 40 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/limits" 3
# 41 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/limits" 3
# 158 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/limits" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
enum float_round_style
{
round_indeterminate = -1,
round_toward_zero = 0,
round_to_nearest = 1,
round_toward_infinity = 2,
round_toward_neg_infinity = 3
};
enum float_denorm_style
{
denorm_indeterminate = -1,
denorm_absent = 0,
denorm_present = 1
};
# 202 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/limits" 3
struct __numeric_limits_base
{
static constexpr bool is_specialized = false;
static constexpr int digits = 0;
static constexpr int digits10 = 0;
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = false;
static constexpr bool is_integer = false;
static constexpr bool is_exact = false;
static constexpr int radix = 0;
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm = denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = false;
# 288 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/limits" 3
static constexpr bool is_modulo = false;
static constexpr bool traps = false;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style =
round_toward_zero;
};
# 314 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/limits" 3
template<typename _Tp>
struct numeric_limits : public __numeric_limits_base
{
static constexpr _Tp
min() noexcept { return _Tp(); }
static constexpr _Tp
max() noexcept { return _Tp(); }
static constexpr _Tp
lowest() noexcept { return _Tp(); }
static constexpr _Tp
epsilon() noexcept { return _Tp(); }
static constexpr _Tp
round_error() noexcept { return _Tp(); }
static constexpr _Tp
infinity() noexcept { return _Tp(); }
static constexpr _Tp
quiet_NaN() noexcept { return _Tp(); }
static constexpr _Tp
signaling_NaN() noexcept { return _Tp(); }
static constexpr _Tp
denorm_min() noexcept { return _Tp(); }
};
template<typename _Tp>
struct numeric_limits<const _Tp>
: public numeric_limits<_Tp> { };
template<typename _Tp>
struct numeric_limits<volatile _Tp>
: public numeric_limits<_Tp> { };
template<typename _Tp>
struct numeric_limits<const volatile _Tp>
: public numeric_limits<_Tp> { };
template<>
struct numeric_limits<bool>
{
static constexpr bool is_specialized = true;
static constexpr bool
min() noexcept { return false; }
static constexpr bool
max() noexcept { return true; }
static constexpr bool
lowest() noexcept { return min(); }
static constexpr int digits = 1;
static constexpr int digits10 = 0;
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = false;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr bool
epsilon() noexcept { return false; }
static constexpr bool
round_error() noexcept { return false; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr bool
infinity() noexcept { return false; }
static constexpr bool
quiet_NaN() noexcept { return false; }
static constexpr bool
signaling_NaN() noexcept { return false; }
static constexpr bool
denorm_min() noexcept { return false; }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<char>
{
static constexpr bool is_specialized = true;
static constexpr char
min() noexcept { return (((char)(-1) < 0) ? -(((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0) - 1 : (char)0); }
static constexpr char
max() noexcept { return (((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0); }
static constexpr char
lowest() noexcept { return min(); }
static constexpr int digits = (sizeof(char) * 8 - ((char)(-1) < 0));
static constexpr int digits10 = ((sizeof(char) * 8 - ((char)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = ((char)(-1) < 0);
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr char
epsilon() noexcept { return 0; }
static constexpr char
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr
char infinity() noexcept { return char(); }
static constexpr char
quiet_NaN() noexcept { return char(); }
static constexpr char
signaling_NaN() noexcept { return char(); }
static constexpr char
denorm_min() noexcept { return static_cast<char>(0); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = !is_signed;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<signed char>
{
static constexpr bool is_specialized = true;
static constexpr signed char
min() noexcept { return -0x7f - 1; }
static constexpr signed char
max() noexcept { return 0x7f; }
static constexpr signed char
lowest() noexcept { return min(); }
static constexpr int digits = (sizeof(signed char) * 8 - ((signed char)(-1) < 0));
static constexpr int digits10
= ((sizeof(signed char) * 8 - ((signed char)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = true;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr signed char
epsilon() noexcept { return 0; }
static constexpr signed char
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr signed char
infinity() noexcept { return static_cast<signed char>(0); }
static constexpr signed char
quiet_NaN() noexcept { return static_cast<signed char>(0); }
static constexpr signed char
signaling_NaN() noexcept
{ return static_cast<signed char>(0); }
static constexpr signed char
denorm_min() noexcept
{ return static_cast<signed char>(0); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<unsigned char>
{
static constexpr bool is_specialized = true;
static constexpr unsigned char
min() noexcept { return 0; }
static constexpr unsigned char
max() noexcept { return 0x7f * 2U + 1; }
static constexpr unsigned char
lowest() noexcept { return min(); }
static constexpr int digits
= (sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0));
static constexpr int digits10
= ((sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = false;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr unsigned char
epsilon() noexcept { return 0; }
static constexpr unsigned char
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr unsigned char
infinity() noexcept
{ return static_cast<unsigned char>(0); }
static constexpr unsigned char
quiet_NaN() noexcept
{ return static_cast<unsigned char>(0); }
static constexpr unsigned char
signaling_NaN() noexcept
{ return static_cast<unsigned char>(0); }
static constexpr unsigned char
denorm_min() noexcept
{ return static_cast<unsigned char>(0); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = true;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<wchar_t>
{
static constexpr bool is_specialized = true;
static constexpr wchar_t
min() noexcept { return (((wchar_t)(-1) < 0) ? -(((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0) - 1 : (wchar_t)0); }
static constexpr wchar_t
max() noexcept { return (((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0); }
static constexpr wchar_t
lowest() noexcept { return min(); }
static constexpr int digits = (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0));
static constexpr int digits10
= ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = ((wchar_t)(-1) < 0);
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr wchar_t
epsilon() noexcept { return 0; }
static constexpr wchar_t
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr wchar_t
infinity() noexcept { return wchar_t(); }
static constexpr wchar_t
quiet_NaN() noexcept { return wchar_t(); }
static constexpr wchar_t
signaling_NaN() noexcept { return wchar_t(); }
static constexpr wchar_t
denorm_min() noexcept { return wchar_t(); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = !is_signed;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<char16_t>
{
static constexpr bool is_specialized = true;
static constexpr char16_t
min() noexcept { return (((char16_t)(-1) < 0) ? -(((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0) - 1 : (char16_t)0); }
static constexpr char16_t
max() noexcept { return (((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0); }
static constexpr char16_t
lowest() noexcept { return min(); }
static constexpr int digits = (sizeof(char16_t) * 8 - ((char16_t)(-1) < 0));
static constexpr int digits10 = ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = ((char16_t)(-1) < 0);
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr char16_t
epsilon() noexcept { return 0; }
static constexpr char16_t
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm = denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr char16_t
infinity() noexcept { return char16_t(); }
static constexpr char16_t
quiet_NaN() noexcept { return char16_t(); }
static constexpr char16_t
signaling_NaN() noexcept { return char16_t(); }
static constexpr char16_t
denorm_min() noexcept { return char16_t(); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = !is_signed;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style = round_toward_zero;
};
template<>
struct numeric_limits<char32_t>
{
static constexpr bool is_specialized = true;
static constexpr char32_t
min() noexcept { return (((char32_t)(-1) < 0) ? -(((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0) - 1 : (char32_t)0); }
static constexpr char32_t
max() noexcept { return (((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0); }
static constexpr char32_t
lowest() noexcept { return min(); }
static constexpr int digits = (sizeof(char32_t) * 8 - ((char32_t)(-1) < 0));
static constexpr int digits10 = ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = ((char32_t)(-1) < 0);
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr char32_t
epsilon() noexcept { return 0; }
static constexpr char32_t
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm = denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr char32_t
infinity() noexcept { return char32_t(); }
static constexpr char32_t
quiet_NaN() noexcept { return char32_t(); }
static constexpr char32_t
signaling_NaN() noexcept { return char32_t(); }
static constexpr char32_t
denorm_min() noexcept { return char32_t(); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = !is_signed;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style = round_toward_zero;
};
template<>
struct numeric_limits<short>
{
static constexpr bool is_specialized = true;
static constexpr short
min() noexcept { return -0x7fff - 1; }
static constexpr short
max() noexcept { return 0x7fff; }
static constexpr short
lowest() noexcept { return min(); }
static constexpr int digits = (sizeof(short) * 8 - ((short)(-1) < 0));
static constexpr int digits10 = ((sizeof(short) * 8 - ((short)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = true;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr short
epsilon() noexcept { return 0; }
static constexpr short
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr short
infinity() noexcept { return short(); }
static constexpr short
quiet_NaN() noexcept { return short(); }
static constexpr short
signaling_NaN() noexcept { return short(); }
static constexpr short
denorm_min() noexcept { return short(); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<unsigned short>
{
static constexpr bool is_specialized = true;
static constexpr unsigned short
min() noexcept { return 0; }
static constexpr unsigned short
max() noexcept { return 0x7fff * 2U + 1; }
static constexpr unsigned short
lowest() noexcept { return min(); }
static constexpr int digits
= (sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0));
static constexpr int digits10
= ((sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = false;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr unsigned short
epsilon() noexcept { return 0; }
static constexpr unsigned short
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr unsigned short
infinity() noexcept
{ return static_cast<unsigned short>(0); }
static constexpr unsigned short
quiet_NaN() noexcept
{ return static_cast<unsigned short>(0); }
static constexpr unsigned short
signaling_NaN() noexcept
{ return static_cast<unsigned short>(0); }
static constexpr unsigned short
denorm_min() noexcept
{ return static_cast<unsigned short>(0); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = true;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<int>
{
static constexpr bool is_specialized = true;
static constexpr int
min() noexcept { return -0x7fffffff - 1; }
static constexpr int
max() noexcept { return 0x7fffffff; }
static constexpr int
lowest() noexcept { return min(); }
static constexpr int digits = (sizeof(int) * 8 - ((int)(-1) < 0));
static constexpr int digits10 = ((sizeof(int) * 8 - ((int)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = true;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr int
epsilon() noexcept { return 0; }
static constexpr int
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr int
infinity() noexcept { return static_cast<int>(0); }
static constexpr int
quiet_NaN() noexcept { return static_cast<int>(0); }
static constexpr int
signaling_NaN() noexcept { return static_cast<int>(0); }
static constexpr int
denorm_min() noexcept { return static_cast<int>(0); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<unsigned int>
{
static constexpr bool is_specialized = true;
static constexpr unsigned int
min() noexcept { return 0; }
static constexpr unsigned int
max() noexcept { return 0x7fffffff * 2U + 1; }
static constexpr unsigned int
lowest() noexcept { return min(); }
static constexpr int digits
= (sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0));
static constexpr int digits10
= ((sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = false;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr unsigned int
epsilon() noexcept { return 0; }
static constexpr unsigned int
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr unsigned int
infinity() noexcept { return static_cast<unsigned int>(0); }
static constexpr unsigned int
quiet_NaN() noexcept
{ return static_cast<unsigned int>(0); }
static constexpr unsigned int
signaling_NaN() noexcept
{ return static_cast<unsigned int>(0); }
static constexpr unsigned int
denorm_min() noexcept
{ return static_cast<unsigned int>(0); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = true;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<long>
{
static constexpr bool is_specialized = true;
static constexpr long
min() noexcept { return -0x7fffffffffffffffL - 1; }
static constexpr long
max() noexcept { return 0x7fffffffffffffffL; }
static constexpr long
lowest() noexcept { return min(); }
static constexpr int digits = (sizeof(long) * 8 - ((long)(-1) < 0));
static constexpr int digits10 = ((sizeof(long) * 8 - ((long)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = true;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr long
epsilon() noexcept { return 0; }
static constexpr long
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr long
infinity() noexcept { return static_cast<long>(0); }
static constexpr long
quiet_NaN() noexcept { return static_cast<long>(0); }
static constexpr long
signaling_NaN() noexcept { return static_cast<long>(0); }
static constexpr long
denorm_min() noexcept { return static_cast<long>(0); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<unsigned long>
{
static constexpr bool is_specialized = true;
static constexpr unsigned long
min() noexcept { return 0; }
static constexpr unsigned long
max() noexcept { return 0x7fffffffffffffffL * 2UL + 1; }
static constexpr unsigned long
lowest() noexcept { return min(); }
static constexpr int digits
= (sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0));
static constexpr int digits10
= ((sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = false;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr unsigned long
epsilon() noexcept { return 0; }
static constexpr unsigned long
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr unsigned long
infinity() noexcept
{ return static_cast<unsigned long>(0); }
static constexpr unsigned long
quiet_NaN() noexcept
{ return static_cast<unsigned long>(0); }
static constexpr unsigned long
signaling_NaN() noexcept
{ return static_cast<unsigned long>(0); }
static constexpr unsigned long
denorm_min() noexcept
{ return static_cast<unsigned long>(0); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = true;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<long long>
{
static constexpr bool is_specialized = true;
static constexpr long long
min() noexcept { return -0x7fffffffffffffffLL - 1; }
static constexpr long long
max() noexcept { return 0x7fffffffffffffffLL; }
static constexpr long long
lowest() noexcept { return min(); }
static constexpr int digits
= (sizeof(long long) * 8 - ((long long)(-1) < 0));
static constexpr int digits10
= ((sizeof(long long) * 8 - ((long long)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = true;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr long long
epsilon() noexcept { return 0; }
static constexpr long long
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr long long
infinity() noexcept { return static_cast<long long>(0); }
static constexpr long long
quiet_NaN() noexcept { return static_cast<long long>(0); }
static constexpr long long
signaling_NaN() noexcept
{ return static_cast<long long>(0); }
static constexpr long long
denorm_min() noexcept { return static_cast<long long>(0); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<unsigned long long>
{
static constexpr bool is_specialized = true;
static constexpr unsigned long long
min() noexcept { return 0; }
static constexpr unsigned long long
max() noexcept { return 0x7fffffffffffffffLL * 2ULL + 1; }
static constexpr unsigned long long
lowest() noexcept { return min(); }
static constexpr int digits
= (sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0));
static constexpr int digits10
= ((sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = false;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr unsigned long long
epsilon() noexcept { return 0; }
static constexpr unsigned long long
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr unsigned long long
infinity() noexcept
{ return static_cast<unsigned long long>(0); }
static constexpr unsigned long long
quiet_NaN() noexcept
{ return static_cast<unsigned long long>(0); }
static constexpr unsigned long long
signaling_NaN() noexcept
{ return static_cast<unsigned long long>(0); }
static constexpr unsigned long long
denorm_min() noexcept
{ return static_cast<unsigned long long>(0); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = true;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
# 1569 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/limits" 3
template<> struct numeric_limits<__int128> { static constexpr bool is_specialized = true; static constexpr __int128 min() noexcept { return (((__int128)(-1) < 0) ? -(((__int128)(-1) < 0) ? (((((__int128)1 << ((128 - ((__int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(__int128)0) - 1 : (__int128)0); } static constexpr __int128 max() noexcept { return (((__int128)(-1) < 0) ? (((((__int128)1 << ((128 - ((__int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(__int128)0); } static constexpr int digits = 128 - 1; static constexpr int digits10 = (128 - 1) * 643L / 2136; static constexpr bool is_signed = true; static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr __int128 epsilon() noexcept { return 0; } static constexpr __int128 round_error() noexcept { return 0; } static constexpr __int128 lowest() noexcept { return min(); } static constexpr int max_digits10 = 0; static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr __int128 infinity() noexcept { return static_cast<__int128>(0); } static constexpr __int128 quiet_NaN() noexcept { return static_cast<__int128>(0); } static constexpr __int128 signaling_NaN() noexcept { return static_cast<__int128>(0); } static constexpr __int128 denorm_min() noexcept { return static_cast<__int128>(0); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; template<> struct numeric_limits<unsigned __int128> { static constexpr bool is_specialized = true; static constexpr unsigned __int128 min() noexcept { return 0; } static constexpr unsigned __int128 max() noexcept { return (((unsigned __int128)(-1) < 0) ? (((((unsigned __int128)1 << ((128 - ((unsigned __int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(unsigned __int128)0); } static constexpr unsigned __int128 lowest() noexcept { return min(); } static constexpr int max_digits10 = 0; static constexpr int digits = 128; static constexpr int digits10 = 128 * 643L / 2136; static constexpr bool is_signed = false; static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr unsigned __int128 epsilon() noexcept { return 0; } static constexpr unsigned __int128 round_error() noexcept { return 0; } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr unsigned __int128 infinity() noexcept { return static_cast<unsigned __int128>(0); } static constexpr unsigned __int128 quiet_NaN() noexcept { return static_cast<unsigned __int128>(0); } static constexpr unsigned __int128 signaling_NaN() noexcept { return static_cast<unsigned __int128>(0); } static constexpr unsigned __int128 denorm_min() noexcept { return static_cast<unsigned __int128>(0); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = true; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; };
# 1592 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/limits" 3
template<>
struct numeric_limits<float>
{
static constexpr bool is_specialized = true;
static constexpr float
min() noexcept { return 1.17549435082228750797e-38F; }
static constexpr float
max() noexcept { return 3.40282346638528859812e+38F; }
static constexpr float
lowest() noexcept { return -3.40282346638528859812e+38F; }
static constexpr int digits = 24;
static constexpr int digits10 = 6;
static constexpr int max_digits10
= (2 + (24) * 643L / 2136);
static constexpr bool is_signed = true;
static constexpr bool is_integer = false;
static constexpr bool is_exact = false;
static constexpr int radix = 2;
static constexpr float
epsilon() noexcept { return 1.19209289550781250000e-7F; }
static constexpr float
round_error() noexcept { return 0.5F; }
static constexpr int min_exponent = (-125);
static constexpr int min_exponent10 = (-37);
static constexpr int max_exponent = 128;
static constexpr int max_exponent10 = 38;
static constexpr bool has_infinity = 1;
static constexpr bool has_quiet_NaN = 1;
static constexpr bool has_signaling_NaN = has_quiet_NaN;
static constexpr float_denorm_style has_denorm
= bool(1) ? denorm_present : denorm_absent;
static constexpr bool has_denorm_loss
= false;
static constexpr float
infinity() noexcept { return __builtin_huge_valf(); }
static constexpr float
quiet_NaN() noexcept { return __builtin_nanf(""); }
static constexpr float
signaling_NaN() noexcept { return __builtin_nansf(""); }
static constexpr float
denorm_min() noexcept { return 1.40129846432481707092e-45F; }
static constexpr bool is_iec559
= has_infinity && has_quiet_NaN && has_denorm == denorm_present;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool traps = false;
static constexpr bool tinyness_before
= false;
static constexpr float_round_style round_style
= round_to_nearest;
};
template<>
struct numeric_limits<double>
{
static constexpr bool is_specialized = true;
static constexpr double
min() noexcept { return double(2.22507385850720138309e-308L); }
static constexpr double
max() noexcept { return double(1.79769313486231570815e+308L); }
static constexpr double
lowest() noexcept { return -double(1.79769313486231570815e+308L); }
static constexpr int digits = 53;
static constexpr int digits10 = 15;
static constexpr int max_digits10
= (2 + (53) * 643L / 2136);
static constexpr bool is_signed = true;
static constexpr bool is_integer = false;
static constexpr bool is_exact = false;
static constexpr int radix = 2;
static constexpr double
epsilon() noexcept { return double(2.22044604925031308085e-16L); }
static constexpr double
round_error() noexcept { return 0.5; }
static constexpr int min_exponent = (-1021);
static constexpr int min_exponent10 = (-307);
static constexpr int max_exponent = 1024;
static constexpr int max_exponent10 = 308;
static constexpr bool has_infinity = 1;
static constexpr bool has_quiet_NaN = 1;
static constexpr bool has_signaling_NaN = has_quiet_NaN;
static constexpr float_denorm_style has_denorm
= bool(1) ? denorm_present : denorm_absent;
static constexpr bool has_denorm_loss
= false;
static constexpr double
infinity() noexcept { return __builtin_huge_val(); }
static constexpr double
quiet_NaN() noexcept { return __builtin_nan(""); }
static constexpr double
signaling_NaN() noexcept { return __builtin_nans(""); }
static constexpr double
denorm_min() noexcept { return double(4.94065645841246544177e-324L); }
static constexpr bool is_iec559
= has_infinity && has_quiet_NaN && has_denorm == denorm_present;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool traps = false;
static constexpr bool tinyness_before
= false;
static constexpr float_round_style round_style
= round_to_nearest;
};
template<>
struct numeric_limits<long double>
{
static constexpr bool is_specialized = true;
static constexpr long double
min() noexcept { return 3.36210314311209350626e-4932L; }
static constexpr long double
max() noexcept { return 1.18973149535723176502e+4932L; }
static constexpr long double
lowest() noexcept { return -1.18973149535723176502e+4932L; }
static constexpr int digits = 64;
static constexpr int digits10 = 18;
static constexpr int max_digits10
= (2 + (64) * 643L / 2136);
static constexpr bool is_signed = true;
static constexpr bool is_integer = false;
static constexpr bool is_exact = false;
static constexpr int radix = 2;
static constexpr long double
epsilon() noexcept { return 1.08420217248550443401e-19L; }
static constexpr long double
round_error() noexcept { return 0.5L; }
static constexpr int min_exponent = (-16381);
static constexpr int min_exponent10 = (-4931);
static constexpr int max_exponent = 16384;
static constexpr int max_exponent10 = 4932;
static constexpr bool has_infinity = 1;
static constexpr bool has_quiet_NaN = 1;
static constexpr bool has_signaling_NaN = has_quiet_NaN;
static constexpr float_denorm_style has_denorm
= bool(1) ? denorm_present : denorm_absent;
static constexpr bool has_denorm_loss
= false;
static constexpr long double
infinity() noexcept { return __builtin_huge_vall(); }
static constexpr long double
quiet_NaN() noexcept { return __builtin_nanl(""); }
static constexpr long double
signaling_NaN() noexcept { return __builtin_nansl(""); }
static constexpr long double
denorm_min() noexcept { return 3.64519953188247460253e-4951L; }
static constexpr bool is_iec559
= has_infinity && has_quiet_NaN && has_denorm == denorm_present;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool traps = false;
static constexpr bool tinyness_before =
false;
static constexpr float_round_style round_style =
round_to_nearest;
};
}
# 36 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/uniform_int_dist.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
namespace __detail
{
template<typename _Tp>
inline bool
_Power_of_2(_Tp __x)
{
return ((__x - 1) & __x) == 0;
};
}
template<typename _IntType = int>
class uniform_int_distribution
{
static_assert(std::is_integral<_IntType>::value,
"template argument not an integral type");
public:
typedef _IntType result_type;
struct param_type
{
typedef uniform_int_distribution<_IntType> distribution_type;
explicit
param_type(_IntType __a = 0,
_IntType __b = std::numeric_limits<_IntType>::max())
: _M_a(__a), _M_b(__b)
{
;
}
result_type
a() const
{ return _M_a; }
result_type
b() const
{ return _M_b; }
friend bool
operator==(const param_type& __p1, const param_type& __p2)
{ return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
private:
_IntType _M_a;
_IntType _M_b;
};
public:
explicit
uniform_int_distribution(_IntType __a = 0,
_IntType __b = std::numeric_limits<_IntType>::max())
: _M_param(__a, __b)
{ }
explicit
uniform_int_distribution(const param_type& __p)
: _M_param(__p)
{ }
void
reset() { }
result_type
a() const
{ return _M_param.a(); }
result_type
b() const
{ return _M_param.b(); }
param_type
param() const
{ return _M_param; }
void
param(const param_type& __param)
{ _M_param = __param; }
result_type
min() const
{ return this->a(); }
result_type
max() const
{ return this->b(); }
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
{ return this->operator()(__urng, _M_param); }
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
{ this->__generate(__f, __t, __urng, _M_param); }
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
{ this->__generate_impl(__f, __t, __urng, __p); }
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
{ this->__generate_impl(__f, __t, __urng, __p); }
friend bool
operator==(const uniform_int_distribution& __d1,
const uniform_int_distribution& __d2)
{ return __d1._M_param == __d2._M_param; }
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
};
template<typename _IntType>
template<typename _UniformRandomNumberGenerator>
typename uniform_int_distribution<_IntType>::result_type
uniform_int_distribution<_IntType>::
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __param)
{
typedef typename _UniformRandomNumberGenerator::result_type
_Gresult_type;
typedef typename std::make_unsigned<result_type>::type __utype;
typedef typename std::common_type<_Gresult_type, __utype>::type
__uctype;
const __uctype __urngmin = __urng.min();
const __uctype __urngmax = __urng.max();
const __uctype __urngrange = __urngmax - __urngmin;
const __uctype __urange
= __uctype(__param.b()) - __uctype(__param.a());
__uctype __ret;
if (__urngrange > __urange)
{
const __uctype __uerange = __urange + 1;
const __uctype __scaling = __urngrange / __uerange;
const __uctype __past = __uerange * __scaling;
do
__ret = __uctype(__urng()) - __urngmin;
while (__ret >= __past);
__ret /= __scaling;
}
else if (__urngrange < __urange)
{
# 260 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/uniform_int_dist.h" 3
__uctype __tmp;
do
{
const __uctype __uerngrange = __urngrange + 1;
__tmp = (__uerngrange * operator()
(__urng, param_type(0, __urange / __uerngrange)));
__ret = __tmp + (__uctype(__urng()) - __urngmin);
}
while (__ret > __urange || __ret < __tmp);
}
else
__ret = __uctype(__urng()) - __urngmin;
return __ret + __param.a();
}
template<typename _IntType>
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
uniform_int_distribution<_IntType>::
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __param)
{
typedef typename _UniformRandomNumberGenerator::result_type
_Gresult_type;
typedef typename std::make_unsigned<result_type>::type __utype;
typedef typename std::common_type<_Gresult_type, __utype>::type
__uctype;
const __uctype __urngmin = __urng.min();
const __uctype __urngmax = __urng.max();
const __uctype __urngrange = __urngmax - __urngmin;
const __uctype __urange
= __uctype(__param.b()) - __uctype(__param.a());
__uctype __ret;
if (__urngrange > __urange)
{
if (__detail::_Power_of_2(__urngrange + 1)
&& __detail::_Power_of_2(__urange + 1))
{
while (__f != __t)
{
__ret = __uctype(__urng()) - __urngmin;
*__f++ = (__ret & __urange) + __param.a();
}
}
else
{
const __uctype __uerange = __urange + 1;
const __uctype __scaling = __urngrange / __uerange;
const __uctype __past = __uerange * __scaling;
while (__f != __t)
{
do
__ret = __uctype(__urng()) - __urngmin;
while (__ret >= __past);
*__f++ = __ret / __scaling + __param.a();
}
}
}
else if (__urngrange < __urange)
{
# 344 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/uniform_int_dist.h" 3
__uctype __tmp;
while (__f != __t)
{
do
{
const __uctype __uerngrange = __urngrange + 1;
__tmp = (__uerngrange * operator()
(__urng, param_type(0, __urange / __uerngrange)));
__ret = __tmp + (__uctype(__urng()) - __urngmin);
}
while (__ret > __urange || __ret < __tmp);
*__f++ = __ret;
}
}
else
while (__f != __t)
*__f++ = __uctype(__urng()) - __urngmin + __param.a();
}
}
# 67 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Iterator, typename _Compare>
void
__move_median_to_first(_Iterator __result,_Iterator __a, _Iterator __b,
_Iterator __c, _Compare __comp)
{
if (__comp(__a, __b))
{
if (__comp(__b, __c))
std::iter_swap(__result, __b);
else if (__comp(__a, __c))
std::iter_swap(__result, __c);
else
std::iter_swap(__result, __a);
}
else if (__comp(__a, __c))
std::iter_swap(__result, __a);
else if (__comp(__b, __c))
std::iter_swap(__result, __c);
else
std::iter_swap(__result, __b);
}
template<typename _InputIterator, typename _Predicate>
inline _InputIterator
__find_if(_InputIterator __first, _InputIterator __last,
_Predicate __pred, input_iterator_tag)
{
while (__first != __last && !__pred(__first))
++__first;
return __first;
}
template<typename _RandomAccessIterator, typename _Predicate>
_RandomAccessIterator
__find_if(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Predicate __pred, random_access_iterator_tag)
{
typename iterator_traits<_RandomAccessIterator>::difference_type
__trip_count = (__last - __first) >> 2;
for (; __trip_count > 0; --__trip_count)
{
if (__pred(__first))
return __first;
++__first;
if (__pred(__first))
return __first;
++__first;
if (__pred(__first))
return __first;
++__first;
if (__pred(__first))
return __first;
++__first;
}
switch (__last - __first)
{
case 3:
if (__pred(__first))
return __first;
++__first;
case 2:
if (__pred(__first))
return __first;
++__first;
case 1:
if (__pred(__first))
return __first;
++__first;
case 0:
default:
return __last;
}
}
template<typename _Iterator, typename _Predicate>
inline _Iterator
__find_if(_Iterator __first, _Iterator __last, _Predicate __pred)
{
return __find_if(__first, __last, __pred,
std::__iterator_category(__first));
}
template<typename _InputIterator, typename _Predicate>
inline _InputIterator
__find_if_not(_InputIterator __first, _InputIterator __last,
_Predicate __pred)
{
return std::__find_if(__first, __last,
__gnu_cxx::__ops::__negate(__pred),
std::__iterator_category(__first));
}
template<typename _InputIterator, typename _Predicate, typename _Distance>
_InputIterator
__find_if_not_n(_InputIterator __first, _Distance& __len, _Predicate __pred)
{
for (; __len; --__len, ++__first)
if (!__pred(__first))
break;
return __first;
}
# 202 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _ForwardIterator1, typename _ForwardIterator2,
typename _BinaryPredicate>
_ForwardIterator1
__search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2,
_BinaryPredicate __predicate)
{
if (__first1 == __last1 || __first2 == __last2)
return __first1;
_ForwardIterator2 __p1(__first2);
if (++__p1 == __last2)
return std::__find_if(__first1, __last1,
__gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2));
_ForwardIterator2 __p;
_ForwardIterator1 __current = __first1;
for (;;)
{
__first1 =
std::__find_if(__first1, __last1,
__gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2));
if (__first1 == __last1)
return __last1;
__p = __p1;
__current = __first1;
if (++__current == __last1)
return __last1;
while (__predicate(__current, __p))
{
if (++__p == __last2)
return __first1;
if (++__current == __last1)
return __last1;
}
++__first1;
}
return __first1;
}
template<typename _ForwardIterator, typename _Integer,
typename _UnaryPredicate>
_ForwardIterator
__search_n_aux(_ForwardIterator __first, _ForwardIterator __last,
_Integer __count, _UnaryPredicate __unary_pred,
std::forward_iterator_tag)
{
__first = std::__find_if(__first, __last, __unary_pred);
while (__first != __last)
{
typename iterator_traits<_ForwardIterator>::difference_type
__n = __count;
_ForwardIterator __i = __first;
++__i;
while (__i != __last && __n != 1 && __unary_pred(__i))
{
++__i;
--__n;
}
if (__n == 1)
return __first;
if (__i == __last)
return __last;
__first = std::__find_if(++__i, __last, __unary_pred);
}
return __last;
}
template<typename _RandomAccessIter, typename _Integer,
typename _UnaryPredicate>
_RandomAccessIter
__search_n_aux(_RandomAccessIter __first, _RandomAccessIter __last,
_Integer __count, _UnaryPredicate __unary_pred,
std::random_access_iterator_tag)
{
typedef typename std::iterator_traits<_RandomAccessIter>::difference_type
_DistanceType;
_DistanceType __tailSize = __last - __first;
_DistanceType __remainder = __count;
while (__remainder <= __tailSize)
{
__first += __remainder;
__tailSize -= __remainder;
_RandomAccessIter __backTrack = __first;
while (__unary_pred(--__backTrack))
{
if (--__remainder == 0)
return (__first - __count);
}
__remainder = __count + 1 - (__first - __backTrack);
}
return __last;
}
template<typename _ForwardIterator, typename _Integer,
typename _UnaryPredicate>
_ForwardIterator
__search_n(_ForwardIterator __first, _ForwardIterator __last,
_Integer __count,
_UnaryPredicate __unary_pred)
{
if (__count <= 0)
return __first;
if (__count == 1)
return std::__find_if(__first, __last, __unary_pred);
return std::__search_n_aux(__first, __last, __count, __unary_pred,
std::__iterator_category(__first));
}
template<typename _ForwardIterator1, typename _ForwardIterator2,
typename _BinaryPredicate>
_ForwardIterator1
__find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2,
forward_iterator_tag, forward_iterator_tag,
_BinaryPredicate __comp)
{
if (__first2 == __last2)
return __last1;
_ForwardIterator1 __result = __last1;
while (1)
{
_ForwardIterator1 __new_result
= std::__search(__first1, __last1, __first2, __last2, __comp);
if (__new_result == __last1)
return __result;
else
{
__result = __new_result;
__first1 = __new_result;
++__first1;
}
}
}
template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
typename _BinaryPredicate>
_BidirectionalIterator1
__find_end(_BidirectionalIterator1 __first1,
_BidirectionalIterator1 __last1,
_BidirectionalIterator2 __first2,
_BidirectionalIterator2 __last2,
bidirectional_iterator_tag, bidirectional_iterator_tag,
_BinaryPredicate __comp)
{
typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1;
typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2;
_RevIterator1 __rlast1(__first1);
_RevIterator2 __rlast2(__first2);
_RevIterator1 __rresult = std::__search(_RevIterator1(__last1), __rlast1,
_RevIterator2(__last2), __rlast2,
__comp);
if (__rresult == __rlast1)
return __last1;
else
{
_BidirectionalIterator1 __result = __rresult.base();
std::advance(__result, -std::distance(__first2, __last2));
return __result;
}
}
# 423 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _ForwardIterator1, typename _ForwardIterator2>
inline _ForwardIterator1
find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2)
{
;
;
return std::__find_end(__first1, __last1, __first2, __last2,
std::__iterator_category(__first1),
std::__iterator_category(__first2),
__gnu_cxx::__ops::__iter_equal_to_iter());
}
# 471 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _ForwardIterator1, typename _ForwardIterator2,
typename _BinaryPredicate>
inline _ForwardIterator1
find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2,
_BinaryPredicate __comp)
{
;
;
return std::__find_end(__first1, __last1, __first2, __last2,
std::__iterator_category(__first1),
std::__iterator_category(__first2),
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
# 506 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _Predicate>
inline bool
all_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
{ return __last == std::find_if_not(__first, __last, __pred); }
# 523 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _Predicate>
inline bool
none_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
{ return __last == std::find_if(__first, __last, __pred); }
# 541 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _Predicate>
inline bool
any_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
{ return !std::none_of(__first, __last, __pred); }
# 556 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _Predicate>
inline _InputIterator
find_if_not(_InputIterator __first, _InputIterator __last,
_Predicate __pred)
{
;
return std::__find_if_not(__first, __last,
__gnu_cxx::__ops::__pred_iter(__pred));
}
# 580 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _Predicate>
inline bool
is_partitioned(_InputIterator __first, _InputIterator __last,
_Predicate __pred)
{
__first = std::find_if_not(__first, __last, __pred);
return std::none_of(__first, __last, __pred);
}
# 598 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Predicate>
_ForwardIterator
partition_point(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred)
{
;
typedef typename iterator_traits<_ForwardIterator>::difference_type
_DistanceType;
_DistanceType __len = std::distance(__first, __last);
_DistanceType __half;
_ForwardIterator __middle;
while (__len > 0)
{
__half = __len >> 1;
__middle = __first;
std::advance(__middle, __half);
if (__pred(*__middle))
{
__first = __middle;
++__first;
__len = __len - __half - 1;
}
else
__len = __half;
}
return __first;
}
template<typename _InputIterator, typename _OutputIterator,
typename _Predicate>
_OutputIterator
__remove_copy_if(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, _Predicate __pred)
{
for (; __first != __last; ++__first)
if (!__pred(__first))
{
*__result = *__first;
++__result;
}
return __result;
}
# 665 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _OutputIterator, typename _Tp>
inline _OutputIterator
remove_copy(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, const _Tp& __value)
{
;
return std::__remove_copy_if(__first, __last, __result,
__gnu_cxx::__ops::__iter_equals_val(__value));
}
# 697 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _OutputIterator,
typename _Predicate>
inline _OutputIterator
remove_copy_if(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, _Predicate __pred)
{
;
return std::__remove_copy_if(__first, __last, __result,
__gnu_cxx::__ops::__pred_iter(__pred));
}
# 731 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _OutputIterator,
typename _Predicate>
_OutputIterator
copy_if(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, _Predicate __pred)
{
;
for (; __first != __last; ++__first)
if (__pred(*__first))
{
*__result = *__first;
++__result;
}
return __result;
}
template<typename _InputIterator, typename _Size, typename _OutputIterator>
_OutputIterator
__copy_n(_InputIterator __first, _Size __n,
_OutputIterator __result, input_iterator_tag)
{
if (__n > 0)
{
while (true)
{
*__result = *__first;
++__result;
if (--__n > 0)
++__first;
else
break;
}
}
return __result;
}
template<typename _RandomAccessIterator, typename _Size,
typename _OutputIterator>
inline _OutputIterator
__copy_n(_RandomAccessIterator __first, _Size __n,
_OutputIterator __result, random_access_iterator_tag)
{ return std::copy(__first, __first + __n, __result); }
# 794 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _Size, typename _OutputIterator>
inline _OutputIterator
copy_n(_InputIterator __first, _Size __n, _OutputIterator __result)
{
return std::__copy_n(__first, __n, __result,
std::__iterator_category(__first));
}
# 822 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _OutputIterator1,
typename _OutputIterator2, typename _Predicate>
pair<_OutputIterator1, _OutputIterator2>
partition_copy(_InputIterator __first, _InputIterator __last,
_OutputIterator1 __out_true, _OutputIterator2 __out_false,
_Predicate __pred)
{
;
for (; __first != __last; ++__first)
if (__pred(*__first))
{
*__out_true = *__first;
++__out_true;
}
else
{
*__out_false = *__first;
++__out_false;
}
return pair<_OutputIterator1, _OutputIterator2>(__out_true, __out_false);
}
template<typename _ForwardIterator, typename _Predicate>
_ForwardIterator
__remove_if(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred)
{
__first = std::__find_if(__first, __last, __pred);
if (__first == __last)
return __first;
_ForwardIterator __result = __first;
++__first;
for (; __first != __last; ++__first)
if (!__pred(__first))
{
*__result = std::move(*__first);
++__result;
}
return __result;
}
# 891 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Tp>
inline _ForwardIterator
remove(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __value)
{
;
return std::__remove_if(__first, __last,
__gnu_cxx::__ops::__iter_equals_val(__value));
}
# 924 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Predicate>
inline _ForwardIterator
remove_if(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred)
{
;
return std::__remove_if(__first, __last,
__gnu_cxx::__ops::__pred_iter(__pred));
}
template<typename _ForwardIterator, typename _BinaryPredicate>
_ForwardIterator
__adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
_BinaryPredicate __binary_pred)
{
if (__first == __last)
return __last;
_ForwardIterator __next = __first;
while (++__next != __last)
{
if (__binary_pred(__first, __next))
return __first;
__first = __next;
}
return __last;
}
template<typename _ForwardIterator, typename _BinaryPredicate>
_ForwardIterator
__unique(_ForwardIterator __first, _ForwardIterator __last,
_BinaryPredicate __binary_pred)
{
__first = std::__adjacent_find(__first, __last, __binary_pred);
if (__first == __last)
return __last;
_ForwardIterator __dest = __first;
++__first;
while (++__first != __last)
if (!__binary_pred(__dest, __first))
*++__dest = std::move(*__first);
return ++__dest;
}
# 990 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _ForwardIterator>
inline _ForwardIterator
unique(_ForwardIterator __first, _ForwardIterator __last)
{
;
return std::__unique(__first, __last,
__gnu_cxx::__ops::__iter_equal_to_iter());
}
# 1020 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _BinaryPredicate>
inline _ForwardIterator
unique(_ForwardIterator __first, _ForwardIterator __last,
_BinaryPredicate __binary_pred)
{
;
return std::__unique(__first, __last,
__gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
}
template<typename _ForwardIterator, typename _OutputIterator,
typename _BinaryPredicate>
_OutputIterator
__unique_copy(_ForwardIterator __first, _ForwardIterator __last,
_OutputIterator __result, _BinaryPredicate __binary_pred,
forward_iterator_tag, output_iterator_tag)
{
_ForwardIterator __next = __first;
*__result = *__first;
while (++__next != __last)
if (!__binary_pred(__first, __next))
{
__first = __next;
*++__result = *__first;
}
return ++__result;
}
template<typename _InputIterator, typename _OutputIterator,
typename _BinaryPredicate>
_OutputIterator
__unique_copy(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, _BinaryPredicate __binary_pred,
input_iterator_tag, output_iterator_tag)
{
typename iterator_traits<_InputIterator>::value_type __value = *__first;
__decltype(__gnu_cxx::__ops::__iter_comp_val(__binary_pred))
__rebound_pred
= __gnu_cxx::__ops::__iter_comp_val(__binary_pred);
*__result = __value;
while (++__first != __last)
if (!__rebound_pred(__first, __value))
{
__value = *__first;
*++__result = __value;
}
return ++__result;
}
template<typename _InputIterator, typename _ForwardIterator,
typename _BinaryPredicate>
_ForwardIterator
__unique_copy(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result, _BinaryPredicate __binary_pred,
input_iterator_tag, forward_iterator_tag)
{
*__result = *__first;
while (++__first != __last)
if (!__binary_pred(__result, __first))
*++__result = *__first;
return ++__result;
}
template<typename _BidirectionalIterator>
void
__reverse(_BidirectionalIterator __first, _BidirectionalIterator __last,
bidirectional_iterator_tag)
{
while (true)
if (__first == __last || __first == --__last)
return;
else
{
std::iter_swap(__first, __last);
++__first;
}
}
template<typename _RandomAccessIterator>
void
__reverse(_RandomAccessIterator __first, _RandomAccessIterator __last,
random_access_iterator_tag)
{
if (__first == __last)
return;
--__last;
while (__first < __last)
{
std::iter_swap(__first, __last);
++__first;
--__last;
}
}
# 1175 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _BidirectionalIterator>
inline void
reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
{
;
std::__reverse(__first, __last, std::__iterator_category(__first));
}
# 1202 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _BidirectionalIterator, typename _OutputIterator>
_OutputIterator
reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last,
_OutputIterator __result)
{
;
while (__first != __last)
{
--__last;
*__result = *__last;
++__result;
}
return __result;
}
template<typename _EuclideanRingElement>
_EuclideanRingElement
__gcd(_EuclideanRingElement __m, _EuclideanRingElement __n)
{
while (__n != 0)
{
_EuclideanRingElement __t = __m % __n;
__m = __n;
__n = __t;
}
return __m;
}
inline namespace _V2
{
template<typename _ForwardIterator>
_ForwardIterator
__rotate(_ForwardIterator __first,
_ForwardIterator __middle,
_ForwardIterator __last,
forward_iterator_tag)
{
if (__first == __middle)
return __last;
else if (__last == __middle)
return __first;
_ForwardIterator __first2 = __middle;
do
{
std::iter_swap(__first, __first2);
++__first;
++__first2;
if (__first == __middle)
__middle = __first2;
}
while (__first2 != __last);
_ForwardIterator __ret = __first;
__first2 = __middle;
while (__first2 != __last)
{
std::iter_swap(__first, __first2);
++__first;
++__first2;
if (__first == __middle)
__middle = __first2;
else if (__first2 == __last)
__first2 = __middle;
}
return __ret;
}
template<typename _BidirectionalIterator>
_BidirectionalIterator
__rotate(_BidirectionalIterator __first,
_BidirectionalIterator __middle,
_BidirectionalIterator __last,
bidirectional_iterator_tag)
{
if (__first == __middle)
return __last;
else if (__last == __middle)
return __first;
std::__reverse(__first, __middle, bidirectional_iterator_tag());
std::__reverse(__middle, __last, bidirectional_iterator_tag());
while (__first != __middle && __middle != __last)
{
std::iter_swap(__first, --__last);
++__first;
}
if (__first == __middle)
{
std::__reverse(__middle, __last, bidirectional_iterator_tag());
return __last;
}
else
{
std::__reverse(__first, __middle, bidirectional_iterator_tag());
return __first;
}
}
template<typename _RandomAccessIterator>
_RandomAccessIterator
__rotate(_RandomAccessIterator __first,
_RandomAccessIterator __middle,
_RandomAccessIterator __last,
random_access_iterator_tag)
{
if (__first == __middle)
return __last;
else if (__last == __middle)
return __first;
typedef typename iterator_traits<_RandomAccessIterator>::difference_type
_Distance;
typedef typename iterator_traits<_RandomAccessIterator>::value_type
_ValueType;
_Distance __n = __last - __first;
_Distance __k = __middle - __first;
if (__k == __n - __k)
{
std::swap_ranges(__first, __middle, __middle);
return __middle;
}
_RandomAccessIterator __p = __first;
_RandomAccessIterator __ret = __first + (__last - __middle);
for (;;)
{
if (__k < __n - __k)
{
if (__is_pod(_ValueType) && __k == 1)
{
_ValueType __t = std::move(*__p);
std::move(__p + 1, __p + __n, __p);
*(__p + __n - 1) = std::move(__t);
return __ret;
}
_RandomAccessIterator __q = __p + __k;
for (_Distance __i = 0; __i < __n - __k; ++ __i)
{
std::iter_swap(__p, __q);
++__p;
++__q;
}
__n %= __k;
if (__n == 0)
return __ret;
std::swap(__n, __k);
__k = __n - __k;
}
else
{
__k = __n - __k;
if (__is_pod(_ValueType) && __k == 1)
{
_ValueType __t = std::move(*(__p + __n - 1));
std::move_backward(__p, __p + __n - 1, __p + __n);
*__p = std::move(__t);
return __ret;
}
_RandomAccessIterator __q = __p + __n;
__p = __q - __k;
for (_Distance __i = 0; __i < __n - __k; ++ __i)
{
--__p;
--__q;
std::iter_swap(__p, __q);
}
__n %= __k;
if (__n == 0)
return __ret;
std::swap(__n, __k);
}
}
}
# 1429 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _ForwardIterator>
inline _ForwardIterator
rotate(_ForwardIterator __first, _ForwardIterator __middle,
_ForwardIterator __last)
{
;
;
return std::__rotate(__first, __middle, __last,
std::__iterator_category(__first));
}
}
# 1466 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _OutputIterator>
inline _OutputIterator
rotate_copy(_ForwardIterator __first, _ForwardIterator __middle,
_ForwardIterator __last, _OutputIterator __result)
{
;
;
return std::copy(__first, __middle,
std::copy(__middle, __last, __result));
}
template<typename _ForwardIterator, typename _Predicate>
_ForwardIterator
__partition(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred, forward_iterator_tag)
{
if (__first == __last)
return __first;
while (__pred(*__first))
if (++__first == __last)
return __first;
_ForwardIterator __next = __first;
while (++__next != __last)
if (__pred(*__next))
{
std::iter_swap(__first, __next);
++__first;
}
return __first;
}
template<typename _BidirectionalIterator, typename _Predicate>
_BidirectionalIterator
__partition(_BidirectionalIterator __first, _BidirectionalIterator __last,
_Predicate __pred, bidirectional_iterator_tag)
{
while (true)
{
while (true)
if (__first == __last)
return __first;
else if (__pred(*__first))
++__first;
else
break;
--__last;
while (true)
if (__first == __last)
return __first;
else if (!bool(__pred(*__last)))
--__last;
else
break;
std::iter_swap(__first, __last);
++__first;
}
}
# 1543 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Pointer, typename _Predicate,
typename _Distance>
_ForwardIterator
__stable_partition_adaptive(_ForwardIterator __first,
_ForwardIterator __last,
_Predicate __pred, _Distance __len,
_Pointer __buffer,
_Distance __buffer_size)
{
if (__len == 1)
return __first;
if (__len <= __buffer_size)
{
_ForwardIterator __result1 = __first;
_Pointer __result2 = __buffer;
*__result2 = std::move(*__first);
++__result2;
++__first;
for (; __first != __last; ++__first)
if (__pred(__first))
{
*__result1 = std::move(*__first);
++__result1;
}
else
{
*__result2 = std::move(*__first);
++__result2;
}
std::move(__buffer, __result2, __result1);
return __result1;
}
_ForwardIterator __middle = __first;
std::advance(__middle, __len / 2);
_ForwardIterator __left_split =
std::__stable_partition_adaptive(__first, __middle, __pred,
__len / 2, __buffer,
__buffer_size);
_Distance __right_len = __len - __len / 2;
_ForwardIterator __right_split =
std::__find_if_not_n(__middle, __right_len, __pred);
if (__right_len)
__right_split =
std::__stable_partition_adaptive(__right_split, __last, __pred,
__right_len,
__buffer, __buffer_size);
std::rotate(__left_split, __middle, __right_split);
std::advance(__left_split, std::distance(__middle, __right_split));
return __left_split;
}
template<typename _ForwardIterator, typename _Predicate>
_ForwardIterator
__stable_partition(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred)
{
__first = std::__find_if_not(__first, __last, __pred);
if (__first == __last)
return __first;
typedef typename iterator_traits<_ForwardIterator>::value_type
_ValueType;
typedef typename iterator_traits<_ForwardIterator>::difference_type
_DistanceType;
_Temporary_buffer<_ForwardIterator, _ValueType> __buf(__first, __last);
return
std::__stable_partition_adaptive(__first, __last, __pred,
_DistanceType(__buf.requested_size()),
__buf.begin(),
_DistanceType(__buf.size()));
}
# 1646 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Predicate>
inline _ForwardIterator
stable_partition(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred)
{
;
return std::__stable_partition(__first, __last,
__gnu_cxx::__ops::__pred_iter(__pred));
}
template<typename _RandomAccessIterator, typename _Compare>
void
__heap_select(_RandomAccessIterator __first,
_RandomAccessIterator __middle,
_RandomAccessIterator __last, _Compare __comp)
{
std::__make_heap(__first, __middle, __comp);
for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
if (__comp(__i, __first))
std::__pop_heap(__first, __middle, __i, __comp);
}
template<typename _InputIterator, typename _RandomAccessIterator,
typename _Compare>
_RandomAccessIterator
__partial_sort_copy(_InputIterator __first, _InputIterator __last,
_RandomAccessIterator __result_first,
_RandomAccessIterator __result_last,
_Compare __comp)
{
typedef typename iterator_traits<_InputIterator>::value_type
_InputValueType;
typedef iterator_traits<_RandomAccessIterator> _RItTraits;
typedef typename _RItTraits::difference_type _DistanceType;
if (__result_first == __result_last)
return __result_last;
_RandomAccessIterator __result_real_last = __result_first;
while (__first != __last && __result_real_last != __result_last)
{
*__result_real_last = *__first;
++__result_real_last;
++__first;
}
std::__make_heap(__result_first, __result_real_last, __comp);
while (__first != __last)
{
if (__comp(__first, __result_first))
std::__adjust_heap(__result_first, _DistanceType(0),
_DistanceType(__result_real_last
- __result_first),
_InputValueType(*__first), __comp);
++__first;
}
std::__sort_heap(__result_first, __result_real_last, __comp);
return __result_real_last;
}
# 1732 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _RandomAccessIterator>
inline _RandomAccessIterator
partial_sort_copy(_InputIterator __first, _InputIterator __last,
_RandomAccessIterator __result_first,
_RandomAccessIterator __result_last)
{
# 1746 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
;
;
;
return std::__partial_sort_copy(__first, __last,
__result_first, __result_last,
__gnu_cxx::__ops::__iter_less_iter());
}
# 1781 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _RandomAccessIterator,
typename _Compare>
inline _RandomAccessIterator
partial_sort_copy(_InputIterator __first, _InputIterator __last,
_RandomAccessIterator __result_first,
_RandomAccessIterator __result_last,
_Compare __comp)
{
# 1797 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
;
;
;
return std::__partial_sort_copy(__first, __last,
__result_first, __result_last,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
template<typename _RandomAccessIterator, typename _Compare>
void
__unguarded_linear_insert(_RandomAccessIterator __last,
_Compare __comp)
{
typename iterator_traits<_RandomAccessIterator>::value_type
__val = std::move(*__last);
_RandomAccessIterator __next = __last;
--__next;
while (__comp(__val, __next))
{
*__last = std::move(*__next);
__last = __next;
--__next;
}
*__last = std::move(__val);
}
template<typename _RandomAccessIterator, typename _Compare>
void
__insertion_sort(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
{
if (__first == __last) return;
for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
{
if (__comp(__i, __first))
{
typename iterator_traits<_RandomAccessIterator>::value_type
__val = std::move(*__i);
std::move_backward(__first, __i, __i + 1);
*__first = std::move(__val);
}
else
std::__unguarded_linear_insert(__i,
__gnu_cxx::__ops::__val_comp_iter(__comp));
}
}
template<typename _RandomAccessIterator, typename _Compare>
inline void
__unguarded_insertion_sort(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
{
for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
std::__unguarded_linear_insert(__i,
__gnu_cxx::__ops::__val_comp_iter(__comp));
}
enum { _S_threshold = 16 };
template<typename _RandomAccessIterator, typename _Compare>
void
__final_insertion_sort(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
{
if (__last - __first > int(_S_threshold))
{
std::__insertion_sort(__first, __first + int(_S_threshold), __comp);
std::__unguarded_insertion_sort(__first + int(_S_threshold), __last,
__comp);
}
else
std::__insertion_sort(__first, __last, __comp);
}
template<typename _RandomAccessIterator, typename _Compare>
_RandomAccessIterator
__unguarded_partition(_RandomAccessIterator __first,
_RandomAccessIterator __last,
_RandomAccessIterator __pivot, _Compare __comp)
{
while (true)
{
while (__comp(__first, __pivot))
++__first;
--__last;
while (__comp(__pivot, __last))
--__last;
if (!(__first < __last))
return __first;
std::iter_swap(__first, __last);
++__first;
}
}
template<typename _RandomAccessIterator, typename _Compare>
inline _RandomAccessIterator
__unguarded_partition_pivot(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
{
_RandomAccessIterator __mid = __first + (__last - __first) / 2;
std::__move_median_to_first(__first, __first + 1, __mid, __last - 1,
__comp);
return std::__unguarded_partition(__first + 1, __last, __first, __comp);
}
template<typename _RandomAccessIterator, typename _Compare>
inline void
__partial_sort(_RandomAccessIterator __first,
_RandomAccessIterator __middle,
_RandomAccessIterator __last,
_Compare __comp)
{
std::__heap_select(__first, __middle, __last, __comp);
std::__sort_heap(__first, __middle, __comp);
}
template<typename _RandomAccessIterator, typename _Size, typename _Compare>
void
__introsort_loop(_RandomAccessIterator __first,
_RandomAccessIterator __last,
_Size __depth_limit, _Compare __comp)
{
while (__last - __first > int(_S_threshold))
{
if (__depth_limit == 0)
{
std::__partial_sort(__first, __last, __last, __comp);
return;
}
--__depth_limit;
_RandomAccessIterator __cut =
std::__unguarded_partition_pivot(__first, __last, __comp);
std::__introsort_loop(__cut, __last, __depth_limit, __comp);
__last = __cut;
}
}
template<typename _RandomAccessIterator, typename _Compare>
inline void
__sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
{
if (__first != __last)
{
std::__introsort_loop(__first, __last,
std::__lg(__last - __first) * 2,
__comp);
std::__final_insertion_sort(__first, __last, __comp);
}
}
template<typename _RandomAccessIterator, typename _Size, typename _Compare>
void
__introselect(_RandomAccessIterator __first, _RandomAccessIterator __nth,
_RandomAccessIterator __last, _Size __depth_limit,
_Compare __comp)
{
while (__last - __first > 3)
{
if (__depth_limit == 0)
{
std::__heap_select(__first, __nth + 1, __last, __comp);
std::iter_swap(__first, __nth);
return;
}
--__depth_limit;
_RandomAccessIterator __cut =
std::__unguarded_partition_pivot(__first, __last, __comp);
if (__cut <= __nth)
__first = __cut;
else
__last = __cut;
}
std::__insertion_sort(__first, __last, __comp);
}
# 2018 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Tp, typename _Compare>
inline _ForwardIterator
lower_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __comp)
{
;
return std::__lower_bound(__first, __last, __val,
__gnu_cxx::__ops::__iter_comp_val(__comp));
}
template<typename _ForwardIterator, typename _Tp, typename _Compare>
_ForwardIterator
__upper_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __comp)
{
typedef typename iterator_traits<_ForwardIterator>::difference_type
_DistanceType;
_DistanceType __len = std::distance(__first, __last);
while (__len > 0)
{
_DistanceType __half = __len >> 1;
_ForwardIterator __middle = __first;
std::advance(__middle, __half);
if (__comp(__val, __middle))
__len = __half;
else
{
__first = __middle;
++__first;
__len = __len - __half - 1;
}
}
return __first;
}
# 2072 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Tp>
inline _ForwardIterator
upper_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val)
{
;
return std::__upper_bound(__first, __last, __val,
__gnu_cxx::__ops::__val_less_iter());
}
# 2102 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Tp, typename _Compare>
inline _ForwardIterator
upper_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __comp)
{
;
return std::__upper_bound(__first, __last, __val,
__gnu_cxx::__ops::__val_comp_iter(__comp));
}
template<typename _ForwardIterator, typename _Tp,
typename _CompareItTp, typename _CompareTpIt>
pair<_ForwardIterator, _ForwardIterator>
__equal_range(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val,
_CompareItTp __comp_it_val, _CompareTpIt __comp_val_it)
{
typedef typename iterator_traits<_ForwardIterator>::difference_type
_DistanceType;
_DistanceType __len = std::distance(__first, __last);
while (__len > 0)
{
_DistanceType __half = __len >> 1;
_ForwardIterator __middle = __first;
std::advance(__middle, __half);
if (__comp_it_val(__middle, __val))
{
__first = __middle;
++__first;
__len = __len - __half - 1;
}
else if (__comp_val_it(__val, __middle))
__len = __half;
else
{
_ForwardIterator __left
= std::__lower_bound(__first, __middle, __val, __comp_it_val);
std::advance(__first, __len);
_ForwardIterator __right
= std::__upper_bound(++__middle, __first, __val, __comp_val_it);
return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
}
}
return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
}
# 2173 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Tp>
inline pair<_ForwardIterator, _ForwardIterator>
equal_range(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val)
{
;
;
return std::__equal_range(__first, __last, __val,
__gnu_cxx::__ops::__iter_less_val(),
__gnu_cxx::__ops::__val_less_iter());
}
# 2209 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Tp, typename _Compare>
inline pair<_ForwardIterator, _ForwardIterator>
equal_range(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __comp)
{
;
;
return std::__equal_range(__first, __last, __val,
__gnu_cxx::__ops::__iter_comp_val(__comp),
__gnu_cxx::__ops::__val_comp_iter(__comp));
}
# 2242 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Tp>
bool
binary_search(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val)
{
;
;
_ForwardIterator __i
= std::__lower_bound(__first, __last, __val,
__gnu_cxx::__ops::__iter_less_val());
return __i != __last && !(__val < *__i);
}
# 2275 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Tp, typename _Compare>
bool
binary_search(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __comp)
{
;
;
_ForwardIterator __i
= std::__lower_bound(__first, __last, __val,
__gnu_cxx::__ops::__iter_comp_val(__comp));
return __i != __last && !bool(__comp(__val, *__i));
}
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator, typename _Compare>
void
__move_merge_adaptive(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result, _Compare __comp)
{
while (__first1 != __last1 && __first2 != __last2)
{
if (__comp(__first2, __first1))
{
*__result = std::move(*__first2);
++__first2;
}
else
{
*__result = std::move(*__first1);
++__first1;
}
++__result;
}
if (__first1 != __last1)
std::move(__first1, __last1, __result);
}
template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
typename _BidirectionalIterator3, typename _Compare>
void
__move_merge_adaptive_backward(_BidirectionalIterator1 __first1,
_BidirectionalIterator1 __last1,
_BidirectionalIterator2 __first2,
_BidirectionalIterator2 __last2,
_BidirectionalIterator3 __result,
_Compare __comp)
{
if (__first1 == __last1)
{
std::move_backward(__first2, __last2, __result);
return;
}
else if (__first2 == __last2)
return;
--__last1;
--__last2;
while (true)
{
if (__comp(__last2, __last1))
{
*--__result = std::move(*__last1);
if (__first1 == __last1)
{
std::move_backward(__first2, ++__last2, __result);
return;
}
--__last1;
}
else
{
*--__result = std::move(*__last2);
if (__first2 == __last2)
return;
--__last2;
}
}
}
template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
typename _Distance>
_BidirectionalIterator1
__rotate_adaptive(_BidirectionalIterator1 __first,
_BidirectionalIterator1 __middle,
_BidirectionalIterator1 __last,
_Distance __len1, _Distance __len2,
_BidirectionalIterator2 __buffer,
_Distance __buffer_size)
{
_BidirectionalIterator2 __buffer_end;
if (__len1 > __len2 && __len2 <= __buffer_size)
{
if (__len2)
{
__buffer_end = std::move(__middle, __last, __buffer);
std::move_backward(__first, __middle, __last);
return std::move(__buffer, __buffer_end, __first);
}
else
return __first;
}
else if (__len1 <= __buffer_size)
{
if (__len1)
{
__buffer_end = std::move(__first, __middle, __buffer);
std::move(__middle, __last, __first);
return std::move_backward(__buffer, __buffer_end, __last);
}
else
return __last;
}
else
{
std::rotate(__first, __middle, __last);
std::advance(__first, std::distance(__middle, __last));
return __first;
}
}
template<typename _BidirectionalIterator, typename _Distance,
typename _Pointer, typename _Compare>
void
__merge_adaptive(_BidirectionalIterator __first,
_BidirectionalIterator __middle,
_BidirectionalIterator __last,
_Distance __len1, _Distance __len2,
_Pointer __buffer, _Distance __buffer_size,
_Compare __comp)
{
if (__len1 <= __len2 && __len1 <= __buffer_size)
{
_Pointer __buffer_end = std::move(__first, __middle, __buffer);
std::__move_merge_adaptive(__buffer, __buffer_end, __middle, __last,
__first, __comp);
}
else if (__len2 <= __buffer_size)
{
_Pointer __buffer_end = std::move(__middle, __last, __buffer);
std::__move_merge_adaptive_backward(__first, __middle, __buffer,
__buffer_end, __last, __comp);
}
else
{
_BidirectionalIterator __first_cut = __first;
_BidirectionalIterator __second_cut = __middle;
_Distance __len11 = 0;
_Distance __len22 = 0;
if (__len1 > __len2)
{
__len11 = __len1 / 2;
std::advance(__first_cut, __len11);
__second_cut
= std::__lower_bound(__middle, __last, *__first_cut,
__gnu_cxx::__ops::__iter_comp_val(__comp));
__len22 = std::distance(__middle, __second_cut);
}
else
{
__len22 = __len2 / 2;
std::advance(__second_cut, __len22);
__first_cut
= std::__upper_bound(__first, __middle, *__second_cut,
__gnu_cxx::__ops::__val_comp_iter(__comp));
__len11 = std::distance(__first, __first_cut);
}
_BidirectionalIterator __new_middle
= std::__rotate_adaptive(__first_cut, __middle, __second_cut,
__len1 - __len11, __len22, __buffer,
__buffer_size);
std::__merge_adaptive(__first, __first_cut, __new_middle, __len11,
__len22, __buffer, __buffer_size, __comp);
std::__merge_adaptive(__new_middle, __second_cut, __last,
__len1 - __len11,
__len2 - __len22, __buffer,
__buffer_size, __comp);
}
}
template<typename _BidirectionalIterator, typename _Distance,
typename _Compare>
void
__merge_without_buffer(_BidirectionalIterator __first,
_BidirectionalIterator __middle,
_BidirectionalIterator __last,
_Distance __len1, _Distance __len2,
_Compare __comp)
{
if (__len1 == 0 || __len2 == 0)
return;
if (__len1 + __len2 == 2)
{
if (__comp(__middle, __first))
std::iter_swap(__first, __middle);
return;
}
_BidirectionalIterator __first_cut = __first;
_BidirectionalIterator __second_cut = __middle;
_Distance __len11 = 0;
_Distance __len22 = 0;
if (__len1 > __len2)
{
__len11 = __len1 / 2;
std::advance(__first_cut, __len11);
__second_cut
= std::__lower_bound(__middle, __last, *__first_cut,
__gnu_cxx::__ops::__iter_comp_val(__comp));
__len22 = std::distance(__middle, __second_cut);
}
else
{
__len22 = __len2 / 2;
std::advance(__second_cut, __len22);
__first_cut
= std::__upper_bound(__first, __middle, *__second_cut,
__gnu_cxx::__ops::__val_comp_iter(__comp));
__len11 = std::distance(__first, __first_cut);
}
std::rotate(__first_cut, __middle, __second_cut);
_BidirectionalIterator __new_middle = __first_cut;
std::advance(__new_middle, std::distance(__middle, __second_cut));
std::__merge_without_buffer(__first, __first_cut, __new_middle,
__len11, __len22, __comp);
std::__merge_without_buffer(__new_middle, __second_cut, __last,
__len1 - __len11, __len2 - __len22, __comp);
}
template<typename _BidirectionalIterator, typename _Compare>
void
__inplace_merge(_BidirectionalIterator __first,
_BidirectionalIterator __middle,
_BidirectionalIterator __last,
_Compare __comp)
{
typedef typename iterator_traits<_BidirectionalIterator>::value_type
_ValueType;
typedef typename iterator_traits<_BidirectionalIterator>::difference_type
_DistanceType;
if (__first == __middle || __middle == __last)
return;
const _DistanceType __len1 = std::distance(__first, __middle);
const _DistanceType __len2 = std::distance(__middle, __last);
typedef _Temporary_buffer<_BidirectionalIterator, _ValueType> _TmpBuf;
_TmpBuf __buf(__first, __last);
if (__buf.begin() == 0)
std::__merge_without_buffer
(__first, __middle, __last, __len1, __len2, __comp);
else
std::__merge_adaptive
(__first, __middle, __last, __len1, __len2, __buf.begin(),
_DistanceType(__buf.size()), __comp);
}
# 2569 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _BidirectionalIterator>
inline void
inplace_merge(_BidirectionalIterator __first,
_BidirectionalIterator __middle,
_BidirectionalIterator __last)
{
;
;
;
std::__inplace_merge(__first, __middle, __last,
__gnu_cxx::__ops::__iter_less_iter());
}
# 2610 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _BidirectionalIterator, typename _Compare>
inline void
inplace_merge(_BidirectionalIterator __first,
_BidirectionalIterator __middle,
_BidirectionalIterator __last,
_Compare __comp)
{
;
;
;
std::__inplace_merge(__first, __middle, __last,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
template<typename _InputIterator, typename _OutputIterator,
typename _Compare>
_OutputIterator
__move_merge(_InputIterator __first1, _InputIterator __last1,
_InputIterator __first2, _InputIterator __last2,
_OutputIterator __result, _Compare __comp)
{
while (__first1 != __last1 && __first2 != __last2)
{
if (__comp(__first2, __first1))
{
*__result = std::move(*__first2);
++__first2;
}
else
{
*__result = std::move(*__first1);
++__first1;
}
++__result;
}
return std::move(__first2, __last2, std::move(__first1, __last1, __result))
;
}
template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
typename _Distance, typename _Compare>
void
__merge_sort_loop(_RandomAccessIterator1 __first,
_RandomAccessIterator1 __last,
_RandomAccessIterator2 __result, _Distance __step_size,
_Compare __comp)
{
const _Distance __two_step = 2 * __step_size;
while (__last - __first >= __two_step)
{
__result = std::__move_merge(__first, __first + __step_size,
__first + __step_size,
__first + __two_step,
__result, __comp);
__first += __two_step;
}
__step_size = std::min(_Distance(__last - __first), __step_size);
std::__move_merge(__first, __first + __step_size,
__first + __step_size, __last, __result, __comp);
}
template<typename _RandomAccessIterator, typename _Distance,
typename _Compare>
void
__chunk_insertion_sort(_RandomAccessIterator __first,
_RandomAccessIterator __last,
_Distance __chunk_size, _Compare __comp)
{
while (__last - __first >= __chunk_size)
{
std::__insertion_sort(__first, __first + __chunk_size, __comp);
__first += __chunk_size;
}
std::__insertion_sort(__first, __last, __comp);
}
enum { _S_chunk_size = 7 };
template<typename _RandomAccessIterator, typename _Pointer, typename _Compare>
void
__merge_sort_with_buffer(_RandomAccessIterator __first,
_RandomAccessIterator __last,
_Pointer __buffer, _Compare __comp)
{
typedef typename iterator_traits<_RandomAccessIterator>::difference_type
_Distance;
const _Distance __len = __last - __first;
const _Pointer __buffer_last = __buffer + __len;
_Distance __step_size = _S_chunk_size;
std::__chunk_insertion_sort(__first, __last, __step_size, __comp);
while (__step_size < __len)
{
std::__merge_sort_loop(__first, __last, __buffer,
__step_size, __comp);
__step_size *= 2;
std::__merge_sort_loop(__buffer, __buffer_last, __first,
__step_size, __comp);
__step_size *= 2;
}
}
template<typename _RandomAccessIterator, typename _Pointer,
typename _Distance, typename _Compare>
void
__stable_sort_adaptive(_RandomAccessIterator __first,
_RandomAccessIterator __last,
_Pointer __buffer, _Distance __buffer_size,
_Compare __comp)
{
const _Distance __len = (__last - __first + 1) / 2;
const _RandomAccessIterator __middle = __first + __len;
if (__len > __buffer_size)
{
std::__stable_sort_adaptive(__first, __middle, __buffer,
__buffer_size, __comp);
std::__stable_sort_adaptive(__middle, __last, __buffer,
__buffer_size, __comp);
}
else
{
std::__merge_sort_with_buffer(__first, __middle, __buffer, __comp);
std::__merge_sort_with_buffer(__middle, __last, __buffer, __comp);
}
std::__merge_adaptive(__first, __middle, __last,
_Distance(__middle - __first),
_Distance(__last - __middle),
__buffer, __buffer_size,
__comp);
}
template<typename _RandomAccessIterator, typename _Compare>
void
__inplace_stable_sort(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
{
if (__last - __first < 15)
{
std::__insertion_sort(__first, __last, __comp);
return;
}
_RandomAccessIterator __middle = __first + (__last - __first) / 2;
std::__inplace_stable_sort(__first, __middle, __comp);
std::__inplace_stable_sort(__middle, __last, __comp);
std::__merge_without_buffer(__first, __middle, __last,
__middle - __first,
__last - __middle,
__comp);
}
# 2782 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _InputIterator1, typename _InputIterator2,
typename _Compare>
bool
__includes(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_Compare __comp)
{
while (__first1 != __last1 && __first2 != __last2)
if (__comp(__first2, __first1))
return false;
else if (__comp(__first1, __first2))
++__first1;
else
{
++__first1;
++__first2;
}
return __first2 == __last2;
}
# 2821 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _InputIterator1, typename _InputIterator2>
inline bool
includes(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2)
{
;
;
;
;
return std::__includes(__first1, __last1, __first2, __last2,
__gnu_cxx::__ops::__iter_less_iter());
}
# 2865 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _InputIterator1, typename _InputIterator2,
typename _Compare>
inline bool
includes(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_Compare __comp)
{
;
;
;
;
return std::__includes(__first1, __last1, __first2, __last2,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
# 2900 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _BidirectionalIterator, typename _Compare>
bool
__next_permutation(_BidirectionalIterator __first,
_BidirectionalIterator __last, _Compare __comp)
{
if (__first == __last)
return false;
_BidirectionalIterator __i = __first;
++__i;
if (__i == __last)
return false;
__i = __last;
--__i;
for(;;)
{
_BidirectionalIterator __ii = __i;
--__i;
if (__comp(__i, __ii))
{
_BidirectionalIterator __j = __last;
while (!__comp(__i, --__j))
{}
std::iter_swap(__i, __j);
std::__reverse(__ii, __last,
std::__iterator_category(__first));
return true;
}
if (__i == __first)
{
std::__reverse(__first, __last,
std::__iterator_category(__first));
return false;
}
}
}
# 2949 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _BidirectionalIterator>
inline bool
next_permutation(_BidirectionalIterator __first,
_BidirectionalIterator __last)
{
;
;
return std::__next_permutation
(__first, __last, __gnu_cxx::__ops::__iter_less_iter());
}
# 2981 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _BidirectionalIterator, typename _Compare>
inline bool
next_permutation(_BidirectionalIterator __first,
_BidirectionalIterator __last, _Compare __comp)
{
;
;
return std::__next_permutation
(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));
}
template<typename _BidirectionalIterator, typename _Compare>
bool
__prev_permutation(_BidirectionalIterator __first,
_BidirectionalIterator __last, _Compare __comp)
{
if (__first == __last)
return false;
_BidirectionalIterator __i = __first;
++__i;
if (__i == __last)
return false;
__i = __last;
--__i;
for(;;)
{
_BidirectionalIterator __ii = __i;
--__i;
if (__comp(__ii, __i))
{
_BidirectionalIterator __j = __last;
while (!__comp(--__j, __i))
{}
std::iter_swap(__i, __j);
std::__reverse(__ii, __last,
std::__iterator_category(__first));
return true;
}
if (__i == __first)
{
std::__reverse(__first, __last,
std::__iterator_category(__first));
return false;
}
}
}
# 3049 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _BidirectionalIterator>
inline bool
prev_permutation(_BidirectionalIterator __first,
_BidirectionalIterator __last)
{
;
;
return std::__prev_permutation(__first, __last,
__gnu_cxx::__ops::__iter_less_iter());
}
# 3081 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _BidirectionalIterator, typename _Compare>
inline bool
prev_permutation(_BidirectionalIterator __first,
_BidirectionalIterator __last, _Compare __comp)
{
;
;
return std::__prev_permutation(__first, __last,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
template<typename _InputIterator, typename _OutputIterator,
typename _Predicate, typename _Tp>
_OutputIterator
__replace_copy_if(_InputIterator __first, _InputIterator __last,
_OutputIterator __result,
_Predicate __pred, const _Tp& __new_value)
{
for (; __first != __last; ++__first, (void)++__result)
if (__pred(__first))
*__result = __new_value;
else
*__result = *__first;
return __result;
}
# 3131 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _OutputIterator, typename _Tp>
inline _OutputIterator
replace_copy(_InputIterator __first, _InputIterator __last,
_OutputIterator __result,
const _Tp& __old_value, const _Tp& __new_value)
{
;
return std::__replace_copy_if(__first, __last, __result,
__gnu_cxx::__ops::__iter_equals_val(__old_value),
__new_value);
}
# 3165 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _OutputIterator,
typename _Predicate, typename _Tp>
inline _OutputIterator
replace_copy_if(_InputIterator __first, _InputIterator __last,
_OutputIterator __result,
_Predicate __pred, const _Tp& __new_value)
{
;
return std::__replace_copy_if(__first, __last, __result,
__gnu_cxx::__ops::__pred_iter(__pred),
__new_value);
}
template<typename _InputIterator, typename _Predicate>
typename iterator_traits<_InputIterator>::difference_type
__count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
{
typename iterator_traits<_InputIterator>::difference_type __n = 0;
for (; __first != __last; ++__first)
if (__pred(__first))
++__n;
return __n;
}
# 3204 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _ForwardIterator>
inline bool
is_sorted(_ForwardIterator __first, _ForwardIterator __last)
{ return std::is_sorted_until(__first, __last) == __last; }
# 3218 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Compare>
inline bool
is_sorted(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
{ return std::is_sorted_until(__first, __last, __comp) == __last; }
template<typename _ForwardIterator, typename _Compare>
_ForwardIterator
__is_sorted_until(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
{
if (__first == __last)
return __last;
_ForwardIterator __next = __first;
for (++__next; __next != __last; __first = __next, (void)++__next)
if (__comp(__next, __first))
return __next;
return __next;
}
# 3247 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _ForwardIterator>
inline _ForwardIterator
is_sorted_until(_ForwardIterator __first, _ForwardIterator __last)
{
;
;
return std::__is_sorted_until(__first, __last,
__gnu_cxx::__ops::__iter_less_iter());
}
# 3271 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Compare>
inline _ForwardIterator
is_sorted_until(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
{
;
;
return std::__is_sorted_until(__first, __last,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
# 3296 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _Tp>
constexpr
inline pair<const _Tp&, const _Tp&>
minmax(const _Tp& __a, const _Tp& __b)
{
return __b < __a ? pair<const _Tp&, const _Tp&>(__b, __a)
: pair<const _Tp&, const _Tp&>(__a, __b);
}
# 3317 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _Tp, typename _Compare>
constexpr
inline pair<const _Tp&, const _Tp&>
minmax(const _Tp& __a, const _Tp& __b, _Compare __comp)
{
return __comp(__b, __a) ? pair<const _Tp&, const _Tp&>(__b, __a)
: pair<const _Tp&, const _Tp&>(__a, __b);
}
template<typename _ForwardIterator, typename _Compare>
constexpr
pair<_ForwardIterator, _ForwardIterator>
__minmax_element(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
{
_ForwardIterator __next = __first;
if (__first == __last
|| ++__next == __last)
return std::make_pair(__first, __first);
_ForwardIterator __min{}, __max{};
if (__comp(__next, __first))
{
__min = __next;
__max = __first;
}
else
{
__min = __first;
__max = __next;
}
__first = __next;
++__first;
while (__first != __last)
{
__next = __first;
if (++__next == __last)
{
if (__comp(__first, __min))
__min = __first;
else if (!__comp(__first, __max))
__max = __first;
break;
}
if (__comp(__next, __first))
{
if (__comp(__next, __min))
__min = __next;
if (!__comp(__first, __max))
__max = __first;
}
else
{
if (__comp(__first, __min))
__min = __first;
if (!__comp(__next, __max))
__max = __next;
}
__first = __next;
++__first;
}
return std::make_pair(__min, __max);
}
# 3397 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _ForwardIterator>
constexpr
inline pair<_ForwardIterator, _ForwardIterator>
minmax_element(_ForwardIterator __first, _ForwardIterator __last)
{
;
;
return std::__minmax_element(__first, __last,
__gnu_cxx::__ops::__iter_less_iter());
}
# 3425 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Compare>
constexpr
inline pair<_ForwardIterator, _ForwardIterator>
minmax_element(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
{
;
;
return std::__minmax_element(__first, __last,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
template<typename _Tp>
constexpr
inline _Tp
min(initializer_list<_Tp> __l)
{ return *std::min_element(__l.begin(), __l.end()); }
template<typename _Tp, typename _Compare>
constexpr
inline _Tp
min(initializer_list<_Tp> __l, _Compare __comp)
{ return *std::min_element(__l.begin(), __l.end(), __comp); }
template<typename _Tp>
constexpr
inline _Tp
max(initializer_list<_Tp> __l)
{ return *std::max_element(__l.begin(), __l.end()); }
template<typename _Tp, typename _Compare>
constexpr
inline _Tp
max(initializer_list<_Tp> __l, _Compare __comp)
{ return *std::max_element(__l.begin(), __l.end(), __comp); }
template<typename _Tp>
constexpr
inline pair<_Tp, _Tp>
minmax(initializer_list<_Tp> __l)
{
pair<const _Tp*, const _Tp*> __p =
std::minmax_element(__l.begin(), __l.end());
return std::make_pair(*__p.first, *__p.second);
}
template<typename _Tp, typename _Compare>
constexpr
inline pair<_Tp, _Tp>
minmax(initializer_list<_Tp> __l, _Compare __comp)
{
pair<const _Tp*, const _Tp*> __p =
std::minmax_element(__l.begin(), __l.end(), __comp);
return std::make_pair(*__p.first, *__p.second);
}
template<typename _ForwardIterator1, typename _ForwardIterator2,
typename _BinaryPredicate>
bool
__is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _BinaryPredicate __pred)
{
for (; __first1 != __last1; ++__first1, (void)++__first2)
if (!__pred(__first1, __first2))
break;
if (__first1 == __last1)
return true;
_ForwardIterator2 __last2 = __first2;
std::advance(__last2, std::distance(__first1, __last1));
for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan)
{
if (__scan != std::__find_if(__first1, __scan,
__gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)))
continue;
auto __matches
= std::__count_if(__first2, __last2,
__gnu_cxx::__ops::__iter_comp_iter(__pred, __scan));
if (0 == __matches ||
std::__count_if(__scan, __last1,
__gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))
!= __matches)
return false;
}
return true;
}
# 3537 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _ForwardIterator1, typename _ForwardIterator2>
inline bool
is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2)
{
;
return std::__is_permutation(__first1, __last1, __first2,
__gnu_cxx::__ops::__iter_equal_to_iter());
}
# 3568 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _ForwardIterator1, typename _ForwardIterator2,
typename _BinaryPredicate>
inline bool
is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _BinaryPredicate __pred)
{
;
return std::__is_permutation(__first1, __last1, __first2,
__gnu_cxx::__ops::__iter_comp_iter(__pred));
}
template<typename _ForwardIterator1, typename _ForwardIterator2,
typename _BinaryPredicate>
bool
__is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2,
_BinaryPredicate __pred)
{
using _Cat1
= typename iterator_traits<_ForwardIterator1>::iterator_category;
using _Cat2
= typename iterator_traits<_ForwardIterator2>::iterator_category;
using _It1_is_RA = is_same<_Cat1, random_access_iterator_tag>;
using _It2_is_RA = is_same<_Cat2, random_access_iterator_tag>;
constexpr bool __ra_iters = _It1_is_RA() && _It2_is_RA();
if (__ra_iters)
{
auto __d1 = std::distance(__first1, __last1);
auto __d2 = std::distance(__first2, __last2);
if (__d1 != __d2)
return false;
}
for (; __first1 != __last1 && __first2 != __last2;
++__first1, (void)++__first2)
if (!__pred(__first1, __first2))
break;
if (__ra_iters)
{
if (__first1 == __last1)
return true;
}
else
{
auto __d1 = std::distance(__first1, __last1);
auto __d2 = std::distance(__first2, __last2);
if (__d1 == 0 && __d2 == 0)
return true;
if (__d1 != __d2)
return false;
}
for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan)
{
if (__scan != std::__find_if(__first1, __scan,
__gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)))
continue;
auto __matches = std::__count_if(__first2, __last2,
__gnu_cxx::__ops::__iter_comp_iter(__pred, __scan));
if (0 == __matches
|| std::__count_if(__scan, __last1,
__gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))
!= __matches)
return false;
}
return true;
}
# 3661 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _ForwardIterator1, typename _ForwardIterator2>
inline bool
is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2)
{
;
;
return
std::__is_permutation(__first1, __last1, __first2, __last2,
__gnu_cxx::__ops::__iter_equal_to_iter());
}
# 3688 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _ForwardIterator1, typename _ForwardIterator2,
typename _BinaryPredicate>
inline bool
is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2,
_BinaryPredicate __pred)
{
;
;
return std::__is_permutation(__first1, __last1, __first2, __last2,
__gnu_cxx::__ops::__iter_comp_iter(__pred));
}
# 3716 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _RandomAccessIterator,
typename _UniformRandomNumberGenerator>
void
shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
_UniformRandomNumberGenerator&& __g)
{
;
if (__first == __last)
return;
typedef typename iterator_traits<_RandomAccessIterator>::difference_type
_DistanceType;
typedef typename std::make_unsigned<_DistanceType>::type __ud_type;
typedef typename std::uniform_int_distribution<__ud_type> __distr_type;
typedef typename __distr_type::param_type __p_type;
__distr_type __d;
for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
std::iter_swap(__i, __first + __d(__g, __p_type(0, __i - __first)));
}
# 3761 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _Function>
_Function
for_each(_InputIterator __first, _InputIterator __last, _Function __f)
{
;
for (; __first != __last; ++__first)
__f(*__first);
return std::move(__f);
}
# 3782 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _Tp>
inline _InputIterator
find(_InputIterator __first, _InputIterator __last,
const _Tp& __val)
{
;
return std::__find_if(__first, __last,
__gnu_cxx::__ops::__iter_equals_val(__val));
}
# 3806 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _Predicate>
inline _InputIterator
find_if(_InputIterator __first, _InputIterator __last,
_Predicate __pred)
{
;
return std::__find_if(__first, __last,
__gnu_cxx::__ops::__pred_iter(__pred));
}
# 3837 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _ForwardIterator>
_InputIterator
find_first_of(_InputIterator __first1, _InputIterator __last1,
_ForwardIterator __first2, _ForwardIterator __last2)
{
;
;
for (; __first1 != __last1; ++__first1)
for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
if (*__first1 == *__iter)
return __first1;
return __last1;
}
# 3877 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _ForwardIterator,
typename _BinaryPredicate>
_InputIterator
find_first_of(_InputIterator __first1, _InputIterator __last1,
_ForwardIterator __first2, _ForwardIterator __last2,
_BinaryPredicate __comp)
{
;
;
for (; __first1 != __last1; ++__first1)
for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
if (__comp(*__first1, *__iter))
return __first1;
return __last1;
}
# 3909 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _ForwardIterator>
inline _ForwardIterator
adjacent_find(_ForwardIterator __first, _ForwardIterator __last)
{
;
return std::__adjacent_find(__first, __last,
__gnu_cxx::__ops::__iter_equal_to_iter());
}
# 3934 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _BinaryPredicate>
inline _ForwardIterator
adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
_BinaryPredicate __binary_pred)
{
;
return std::__adjacent_find(__first, __last,
__gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
}
# 3959 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _Tp>
inline typename iterator_traits<_InputIterator>::difference_type
count(_InputIterator __first, _InputIterator __last, const _Tp& __value)
{
;
return std::__count_if(__first, __last,
__gnu_cxx::__ops::__iter_equals_val(__value));
}
# 3982 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _Predicate>
inline typename iterator_traits<_InputIterator>::difference_type
count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
{
;
return std::__count_if(__first, __last,
__gnu_cxx::__ops::__pred_iter(__pred));
}
# 4022 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _ForwardIterator1, typename _ForwardIterator2>
inline _ForwardIterator1
search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2)
{
;
;
return std::__search(__first1, __last1, __first2, __last2,
__gnu_cxx::__ops::__iter_equal_to_iter());
}
# 4061 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _ForwardIterator1, typename _ForwardIterator2,
typename _BinaryPredicate>
inline _ForwardIterator1
search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2,
_BinaryPredicate __predicate)
{
;
;
return std::__search(__first1, __last1, __first2, __last2,
__gnu_cxx::__ops::__iter_comp_iter(__predicate));
}
# 4096 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Integer, typename _Tp>
inline _ForwardIterator
search_n(_ForwardIterator __first, _ForwardIterator __last,
_Integer __count, const _Tp& __val)
{
;
return std::__search_n(__first, __last, __count,
__gnu_cxx::__ops::__iter_equals_val(__val));
}
# 4129 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Integer, typename _Tp,
typename _BinaryPredicate>
inline _ForwardIterator
search_n(_ForwardIterator __first, _ForwardIterator __last,
_Integer __count, const _Tp& __val,
_BinaryPredicate __binary_pred)
{
;
return std::__search_n(__first, __last, __count,
__gnu_cxx::__ops::__iter_comp_val(__binary_pred, __val));
}
# 4163 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _OutputIterator,
typename _UnaryOperation>
_OutputIterator
transform(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, _UnaryOperation __unary_op)
{
;
for (; __first != __last; ++__first, (void)++__result)
*__result = __unary_op(*__first);
return __result;
}
# 4200 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator, typename _BinaryOperation>
_OutputIterator
transform(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _OutputIterator __result,
_BinaryOperation __binary_op)
{
;
for (; __first1 != __last1; ++__first1, (void)++__first2, ++__result)
*__result = __binary_op(*__first1, *__first2);
return __result;
}
# 4233 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Tp>
void
replace(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __old_value, const _Tp& __new_value)
{
;
for (; __first != __last; ++__first)
if (*__first == __old_value)
*__first = __new_value;
}
# 4265 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Predicate, typename _Tp>
void
replace_if(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred, const _Tp& __new_value)
{
;
for (; __first != __last; ++__first)
if (__pred(*__first))
*__first = __new_value;
}
# 4297 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Generator>
void
generate(_ForwardIterator __first, _ForwardIterator __last,
_Generator __gen)
{
;
for (; __first != __last; ++__first)
*__first = __gen();
}
# 4328 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _OutputIterator, typename _Size, typename _Generator>
_OutputIterator
generate_n(_OutputIterator __first, _Size __n, _Generator __gen)
{
for (__decltype(__n + 0) __niter = __n;
__niter > 0; --__niter, ++__first)
*__first = __gen();
return __first;
}
# 4364 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _OutputIterator>
inline _OutputIterator
unique_copy(_InputIterator __first, _InputIterator __last,
_OutputIterator __result)
{
;
if (__first == __last)
return __result;
return std::__unique_copy(__first, __last, __result,
__gnu_cxx::__ops::__iter_equal_to_iter(),
std::__iterator_category(__first),
std::__iterator_category(__result));
}
# 4404 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _OutputIterator,
typename _BinaryPredicate>
inline _OutputIterator
unique_copy(_InputIterator __first, _InputIterator __last,
_OutputIterator __result,
_BinaryPredicate __binary_pred)
{
;
if (__first == __last)
return __result;
return std::__unique_copy(__first, __last, __result,
__gnu_cxx::__ops::__iter_comp_iter(__binary_pred),
std::__iterator_category(__first),
std::__iterator_category(__result));
}
# 4437 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _RandomAccessIterator>
inline void
random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
{
;
if (__first != __last)
for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
{
_RandomAccessIterator __j = __first
+ std::rand() % ((__i - __first) + 1);
if (__i != __j)
std::iter_swap(__i, __j);
}
}
# 4472 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _RandomAccessIterator, typename _RandomNumberGenerator>
void
random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
_RandomNumberGenerator&& __rand)
{
;
if (__first == __last)
return;
for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
{
_RandomAccessIterator __j = __first + __rand((__i - __first) + 1);
if (__i != __j)
std::iter_swap(__i, __j);
}
}
# 4512 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Predicate>
inline _ForwardIterator
partition(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred)
{
;
return std::__partition(__first, __last, __pred,
std::__iterator_category(__first));
}
# 4545 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _RandomAccessIterator>
inline void
partial_sort(_RandomAccessIterator __first,
_RandomAccessIterator __middle,
_RandomAccessIterator __last)
{
;
;
;
std::__partial_sort(__first, __middle, __last,
__gnu_cxx::__ops::__iter_less_iter());
}
# 4583 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _RandomAccessIterator, typename _Compare>
inline void
partial_sort(_RandomAccessIterator __first,
_RandomAccessIterator __middle,
_RandomAccessIterator __last,
_Compare __comp)
{
;
;
;
std::__partial_sort(__first, __middle, __last,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
# 4619 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _RandomAccessIterator>
inline void
nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
_RandomAccessIterator __last)
{
;
;
;
if (__first == __last || __nth == __last)
return;
std::__introselect(__first, __nth, __last,
std::__lg(__last - __first) * 2,
__gnu_cxx::__ops::__iter_less_iter());
}
# 4658 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _RandomAccessIterator, typename _Compare>
inline void
nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
_RandomAccessIterator __last, _Compare __comp)
{
;
;
;
if (__first == __last || __nth == __last)
return;
std::__introselect(__first, __nth, __last,
std::__lg(__last - __first) * 2,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
# 4695 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _RandomAccessIterator>
inline void
sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
{
;
;
std::__sort(__first, __last, __gnu_cxx::__ops::__iter_less_iter());
}
# 4725 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _RandomAccessIterator, typename _Compare>
inline void
sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
{
;
;
std::__sort(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));
}
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator, typename _Compare>
_OutputIterator
__merge(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result, _Compare __comp)
{
while (__first1 != __last1 && __first2 != __last2)
{
if (__comp(__first2, __first1))
{
*__result = *__first2;
++__first2;
}
else
{
*__result = *__first1;
++__first1;
}
++__result;
}
return std::copy(__first2, __last2,
std::copy(__first1, __last1, __result));
}
# 4786 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator>
inline _OutputIterator
merge(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result)
{
;
;
;
;
return std::__merge(__first1, __last1,
__first2, __last2, __result,
__gnu_cxx::__ops::__iter_less_iter());
}
# 4836 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator, typename _Compare>
inline _OutputIterator
merge(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result, _Compare __comp)
{
;
;
;
;
return std::__merge(__first1, __last1,
__first2, __last2, __result,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
template<typename _RandomAccessIterator, typename _Compare>
inline void
__stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
{
typedef typename iterator_traits<_RandomAccessIterator>::value_type
_ValueType;
typedef typename iterator_traits<_RandomAccessIterator>::difference_type
_DistanceType;
typedef _Temporary_buffer<_RandomAccessIterator, _ValueType> _TmpBuf;
_TmpBuf __buf(__first, __last);
if (__buf.begin() == 0)
std::__inplace_stable_sort(__first, __last, __comp);
else
std::__stable_sort_adaptive(__first, __last, __buf.begin(),
_DistanceType(__buf.size()), __comp);
}
# 4900 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _RandomAccessIterator>
inline void
stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
{
;
;
std::__stable_sort(__first, __last,
__gnu_cxx::__ops::__iter_less_iter());
}
# 4934 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _RandomAccessIterator, typename _Compare>
inline void
stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
{
;
;
std::__stable_sort(__first, __last,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator,
typename _Compare>
_OutputIterator
__set_union(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result, _Compare __comp)
{
while (__first1 != __last1 && __first2 != __last2)
{
if (__comp(__first1, __first2))
{
*__result = *__first1;
++__first1;
}
else if (__comp(__first2, __first1))
{
*__result = *__first2;
++__first2;
}
else
{
*__result = *__first1;
++__first1;
++__first2;
}
++__result;
}
return std::copy(__first2, __last2,
std::copy(__first1, __last1, __result));
}
# 5002 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator>
inline _OutputIterator
set_union(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result)
{
;
;
;
;
return std::__set_union(__first1, __last1,
__first2, __last2, __result,
__gnu_cxx::__ops::__iter_less_iter());
}
# 5051 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator, typename _Compare>
inline _OutputIterator
set_union(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result, _Compare __comp)
{
;
;
;
;
return std::__set_union(__first1, __last1,
__first2, __last2, __result,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator,
typename _Compare>
_OutputIterator
__set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result, _Compare __comp)
{
while (__first1 != __last1 && __first2 != __last2)
if (__comp(__first1, __first2))
++__first1;
else if (__comp(__first2, __first1))
++__first2;
else
{
*__result = *__first1;
++__first1;
++__first2;
++__result;
}
return __result;
}
# 5121 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator>
inline _OutputIterator
set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result)
{
;
;
;
;
return std::__set_intersection(__first1, __last1,
__first2, __last2, __result,
__gnu_cxx::__ops::__iter_less_iter());
}
# 5169 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator, typename _Compare>
inline _OutputIterator
set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result, _Compare __comp)
{
;
;
;
;
return std::__set_intersection(__first1, __last1,
__first2, __last2, __result,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator,
typename _Compare>
_OutputIterator
__set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result, _Compare __comp)
{
while (__first1 != __last1 && __first2 != __last2)
if (__comp(__first1, __first2))
{
*__result = *__first1;
++__first1;
++__result;
}
else if (__comp(__first2, __first1))
++__first2;
else
{
++__first1;
++__first2;
}
return std::copy(__first1, __last1, __result);
}
# 5241 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator>
inline _OutputIterator
set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result)
{
;
;
;
;
return std::__set_difference(__first1, __last1,
__first2, __last2, __result,
__gnu_cxx::__ops::__iter_less_iter());
}
# 5291 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator, typename _Compare>
inline _OutputIterator
set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result, _Compare __comp)
{
;
;
;
;
return std::__set_difference(__first1, __last1,
__first2, __last2, __result,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator,
typename _Compare>
_OutputIterator
__set_symmetric_difference(_InputIterator1 __first1,
_InputIterator1 __last1,
_InputIterator2 __first2,
_InputIterator2 __last2,
_OutputIterator __result,
_Compare __comp)
{
while (__first1 != __last1 && __first2 != __last2)
if (__comp(__first1, __first2))
{
*__result = *__first1;
++__first1;
++__result;
}
else if (__comp(__first2, __first1))
{
*__result = *__first2;
++__first2;
++__result;
}
else
{
++__first1;
++__first2;
}
return std::copy(__first2, __last2,
std::copy(__first1, __last1, __result));
}
# 5369 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator>
inline _OutputIterator
set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result)
{
;
;
;
;
return std::__set_symmetric_difference(__first1, __last1,
__first2, __last2, __result,
__gnu_cxx::__ops::__iter_less_iter());
}
# 5419 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator, typename _Compare>
inline _OutputIterator
set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result,
_Compare __comp)
{
;
;
;
;
return std::__set_symmetric_difference(__first1, __last1,
__first2, __last2, __result,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
template<typename _ForwardIterator, typename _Compare>
constexpr
_ForwardIterator
__min_element(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
{
if (__first == __last)
return __first;
_ForwardIterator __result = __first;
while (++__first != __last)
if (__comp(__first, __result))
__result = __first;
return __result;
}
# 5472 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _ForwardIterator>
constexpr
_ForwardIterator
inline min_element(_ForwardIterator __first, _ForwardIterator __last)
{
;
;
return std::__min_element(__first, __last,
__gnu_cxx::__ops::__iter_less_iter());
}
# 5497 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Compare>
constexpr
inline _ForwardIterator
min_element(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
{
;
;
return std::__min_element(__first, __last,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
template<typename _ForwardIterator, typename _Compare>
constexpr
_ForwardIterator
__max_element(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
{
if (__first == __last) return __first;
_ForwardIterator __result = __first;
while (++__first != __last)
if (__comp(__result, __first))
__result = __first;
return __result;
}
# 5536 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _ForwardIterator>
constexpr
inline _ForwardIterator
max_element(_ForwardIterator __first, _ForwardIterator __last)
{
;
;
return std::__max_element(__first, __last,
__gnu_cxx::__ops::__iter_less_iter());
}
# 5561 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Compare>
constexpr
inline _ForwardIterator
max_element(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
{
;
;
return std::__max_element(__first, __last,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
}
# 63 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/algorithm" 2 3
# 211 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h" 2
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/climits" 1 3
# 39 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/climits" 3
# 40 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/climits" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include-fixed/limits.h" 1 3 4
# 34 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include-fixed/limits.h" 3 4
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include-fixed/syslimits.h" 1 3 4
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include-fixed/limits.h" 1 3 4
# 168 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include-fixed/limits.h" 3 4
# 1 "/usr/include/limits.h" 1 3 4
# 144 "/usr/include/limits.h" 3 4
# 1 "/usr/include/bits/posix1_lim.h" 1 3 4
# 160 "/usr/include/bits/posix1_lim.h" 3 4
# 1 "/usr/include/bits/local_lim.h" 1 3 4
# 38 "/usr/include/bits/local_lim.h" 3 4
# 1 "/usr/include/linux/limits.h" 1 3 4
# 39 "/usr/include/bits/local_lim.h" 2 3 4
# 161 "/usr/include/bits/posix1_lim.h" 2 3 4
# 145 "/usr/include/limits.h" 2 3 4
# 1 "/usr/include/bits/posix2_lim.h" 1 3 4
# 149 "/usr/include/limits.h" 2 3 4
# 1 "/usr/include/bits/xopen_lim.h" 1 3 4
# 33 "/usr/include/bits/xopen_lim.h" 3 4
# 1 "/usr/include/bits/stdio_lim.h" 1 3 4
# 34 "/usr/include/bits/xopen_lim.h" 2 3 4
# 153 "/usr/include/limits.h" 2 3 4
# 169 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include-fixed/limits.h" 2 3 4
# 8 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include-fixed/syslimits.h" 2 3 4
# 35 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include-fixed/limits.h" 2 3 4
# 43 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/climits" 2 3
# 214 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h" 2
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstring" 1 3
# 39 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstring" 3
# 40 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstring" 3
# 1 "/usr/include/string.h" 1 3 4
# 27 "/usr/include/string.h" 3 4
extern "C" {
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include/stddef.h" 1 3 4
# 33 "/usr/include/string.h" 2 3 4
extern void *memcpy (void *__restrict __dest, const void *__restrict __src,
size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
extern void *memmove (void *__dest, const void *__src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern void *memccpy (void *__restrict __dest, const void *__restrict __src,
int __c, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern void *memset (void *__s, int __c, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
extern int memcmp (const void *__s1, const void *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern "C++"
{
extern void *memchr (void *__s, int __c, size_t __n)
throw () __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const void *memchr (const void *__s, int __c, size_t __n)
throw () __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
# 90 "/usr/include/string.h" 3 4
}
extern "C++" void *rawmemchr (void *__s, int __c)
throw () __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern "C++" const void *rawmemchr (const void *__s, int __c)
throw () __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern "C++" void *memrchr (void *__s, int __c, size_t __n)
throw () __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern "C++" const void *memrchr (const void *__s, int __c, size_t __n)
throw () __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern char *strcpy (char *__restrict __dest, const char *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *strncpy (char *__restrict __dest,
const char *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *strcat (char *__restrict __dest, const char *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *strncat (char *__restrict __dest, const char *__restrict __src,
size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int strcmp (const char *__s1, const char *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern int strncmp (const char *__s1, const char *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern int strcoll (const char *__s1, const char *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern size_t strxfrm (char *__restrict __dest,
const char *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (2)));
# 162 "/usr/include/string.h" 3 4
extern int strcoll_l (const char *__s1, const char *__s2, __locale_t __l)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n,
__locale_t __l) throw () __attribute__ ((__nonnull__ (2, 4)));
extern char *strdup (const char *__s)
throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
extern char *strndup (const char *__string, size_t __n)
throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
# 207 "/usr/include/string.h" 3 4
extern "C++"
{
extern char *strchr (char *__s, int __c)
throw () __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const char *strchr (const char *__s, int __c)
throw () __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
# 230 "/usr/include/string.h" 3 4
}
extern "C++"
{
extern char *strrchr (char *__s, int __c)
throw () __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const char *strrchr (const char *__s, int __c)
throw () __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
# 257 "/usr/include/string.h" 3 4
}
extern "C++" char *strchrnul (char *__s, int __c)
throw () __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern "C++" const char *strchrnul (const char *__s, int __c)
throw () __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern size_t strcspn (const char *__s, const char *__reject)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern size_t strspn (const char *__s, const char *__accept)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern "C++"
{
extern char *strpbrk (char *__s, const char *__accept)
throw () __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern const char *strpbrk (const char *__s, const char *__accept)
throw () __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
# 309 "/usr/include/string.h" 3 4
}
extern "C++"
{
extern char *strstr (char *__haystack, const char *__needle)
throw () __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern const char *strstr (const char *__haystack, const char *__needle)
throw () __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
# 336 "/usr/include/string.h" 3 4
}
extern char *strtok (char *__restrict __s, const char *__restrict __delim)
throw () __attribute__ ((__nonnull__ (2)));
extern char *__strtok_r (char *__restrict __s,
const char *__restrict __delim,
char **__restrict __save_ptr)
throw () __attribute__ ((__nonnull__ (2, 3)));
extern char *strtok_r (char *__restrict __s, const char *__restrict __delim,
char **__restrict __save_ptr)
throw () __attribute__ ((__nonnull__ (2, 3)));
extern "C++" char *strcasestr (char *__haystack, const char *__needle)
throw () __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern "C++" const char *strcasestr (const char *__haystack,
const char *__needle)
throw () __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
# 378 "/usr/include/string.h" 3 4
extern void *memmem (const void *__haystack, size_t __haystacklen,
const void *__needle, size_t __needlelen)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3)));
extern void *__mempcpy (void *__restrict __dest,
const void *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern void *mempcpy (void *__restrict __dest,
const void *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern size_t strlen (const char *__s)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern size_t strnlen (const char *__string, size_t __maxlen)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern char *strerror (int __errnum) throw ();
# 434 "/usr/include/string.h" 3 4
extern char *strerror_r (int __errnum, char *__buf, size_t __buflen)
throw () __attribute__ ((__nonnull__ (2))) ;
extern char *strerror_l (int __errnum, __locale_t __l) throw ();
extern void __bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
extern void bcopy (const void *__src, void *__dest, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern void bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
extern int bcmp (const void *__s1, const void *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern "C++"
{
extern char *index (char *__s, int __c)
throw () __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const char *index (const char *__s, int __c)
throw () __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
# 483 "/usr/include/string.h" 3 4
}
extern "C++"
{
extern char *rindex (char *__s, int __c)
throw () __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const char *rindex (const char *__s, int __c)
throw () __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
# 511 "/usr/include/string.h" 3 4
}
extern int ffs (int __i) throw () __attribute__ ((__const__));
extern int ffsl (long int __l) throw () __attribute__ ((__const__));
__extension__ extern int ffsll (long long int __ll)
throw () __attribute__ ((__const__));
extern int strcasecmp (const char *__s1, const char *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern int strncasecmp (const char *__s1, const char *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern int strcasecmp_l (const char *__s1, const char *__s2,
__locale_t __loc)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
extern int strncasecmp_l (const char *__s1, const char *__s2,
size_t __n, __locale_t __loc)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4)));
extern char *strsep (char **__restrict __stringp,
const char *__restrict __delim)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *strsignal (int __sig) throw ();
extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *stpcpy (char *__restrict __dest, const char *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *__stpncpy (char *__restrict __dest,
const char *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *stpncpy (char *__restrict __dest,
const char *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int strverscmp (const char *__s1, const char *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern char *strfry (char *__string) throw () __attribute__ ((__nonnull__ (1)));
extern void *memfrob (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
extern "C++" char *basename (char *__filename)
throw () __asm ("basename") __attribute__ ((__nonnull__ (1)));
extern "C++" const char *basename (const char *__filename)
throw () __asm ("basename") __attribute__ ((__nonnull__ (1)));
# 642 "/usr/include/string.h" 3 4
}
# 43 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstring" 2 3
# 71 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstring" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
using ::memchr;
using ::memcmp;
using ::memcpy;
using ::memmove;
using ::memset;
using ::strcat;
using ::strcmp;
using ::strcoll;
using ::strcpy;
using ::strcspn;
using ::strerror;
using ::strlen;
using ::strncat;
using ::strncmp;
using ::strncpy;
using ::strspn;
using ::strtok;
using ::strxfrm;
using ::strchr;
using ::strpbrk;
using ::strrchr;
using ::strstr;
# 120 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstring" 3
}
# 216 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h" 2
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/functional" 1 3
# 46 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/functional" 3
# 47 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/functional" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/typeinfo" 1 3
# 32 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/typeinfo" 3
# 33 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/typeinfo" 3
#pragma GCC visibility push(default)
extern "C++" {
namespace __cxxabiv1
{
class __class_type_info;
}
# 80 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/typeinfo" 3
namespace std
{
class type_info
{
public:
virtual ~type_info();
const char* name() const noexcept
{ return __name[0] == '*' ? __name + 1 : __name; }
# 115 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/typeinfo" 3
bool before(const type_info& __arg) const noexcept
{ return (__name[0] == '*' && __arg.__name[0] == '*')
? __name < __arg.__name
: __builtin_strcmp (__name, __arg.__name) < 0; }
bool operator==(const type_info& __arg) const noexcept
{
return ((__name == __arg.__name)
|| (__name[0] != '*' &&
__builtin_strcmp (__name, __arg.__name) == 0));
}
# 136 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/typeinfo" 3
bool operator!=(const type_info& __arg) const noexcept
{ return !operator==(__arg); }
size_t hash_code() const noexcept
{
return _Hash_bytes(name(), __builtin_strlen(name()),
static_cast<size_t>(0xc70f6907UL));
}
virtual bool __is_pointer_p() const;
virtual bool __is_function_p() const;
virtual bool __do_catch(const type_info *__thr_type, void **__thr_obj,
unsigned __outer) const;
virtual bool __do_upcast(const __cxxabiv1::__class_type_info *__target,
void **__obj_ptr) const;
protected:
const char *__name;
explicit type_info(const char *__n): __name(__n) { }
private:
type_info& operator=(const type_info&);
type_info(const type_info&);
};
class bad_cast : public exception
{
public:
bad_cast() noexcept { }
virtual ~bad_cast() noexcept;
virtual const char* what() const noexcept;
};
class bad_typeid : public exception
{
public:
bad_typeid () noexcept { }
virtual ~bad_typeid() noexcept;
virtual const char* what() const noexcept;
};
}
}
#pragma GCC visibility pop
# 54 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/functional" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/tuple" 1 3
# 32 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/tuple" 3
# 33 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/tuple" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/array" 1 3
# 32 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/array" 3
# 33 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/array" 3
# 43 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/array" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Tp, std::size_t _Nm>
struct __array_traits
{
typedef _Tp _Type[_Nm];
static constexpr _Tp&
_S_ref(const _Type& __t, std::size_t __n) noexcept
{ return const_cast<_Tp&>(__t[__n]); }
static constexpr _Tp*
_S_ptr(const _Type& __t) noexcept
{ return const_cast<_Tp*>(__t); }
};
template<typename _Tp>
struct __array_traits<_Tp, 0>
{
struct _Type { };
static constexpr _Tp&
_S_ref(const _Type&, std::size_t) noexcept
{ return *static_cast<_Tp*>(nullptr); }
static constexpr _Tp*
_S_ptr(const _Type&) noexcept
{ return nullptr; }
};
# 89 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/array" 3
template<typename _Tp, std::size_t _Nm>
struct array
{
typedef _Tp value_type;
typedef value_type* pointer;
typedef const value_type* const_pointer;
typedef value_type& reference;
typedef const value_type& const_reference;
typedef value_type* iterator;
typedef const value_type* const_iterator;
typedef std::size_t size_type;
typedef std::ptrdiff_t difference_type;
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
typedef std::__array_traits<_Tp, _Nm> _AT_Type;
typename _AT_Type::_Type _M_elems;
void
fill(const value_type& __u)
{ std::fill_n(begin(), size(), __u); }
void
swap(array& __other)
noexcept(__is_nothrow_swappable<_Tp>::value)
{ std::swap_ranges(begin(), end(), __other.begin()); }
iterator
begin() noexcept
{ return iterator(data()); }
const_iterator
begin() const noexcept
{ return const_iterator(data()); }
iterator
end() noexcept
{ return iterator(data() + _Nm); }
const_iterator
end() const noexcept
{ return const_iterator(data() + _Nm); }
reverse_iterator
rbegin() noexcept
{ return reverse_iterator(end()); }
const_reverse_iterator
rbegin() const noexcept
{ return const_reverse_iterator(end()); }
reverse_iterator
rend() noexcept
{ return reverse_iterator(begin()); }
const_reverse_iterator
rend() const noexcept
{ return const_reverse_iterator(begin()); }
const_iterator
cbegin() const noexcept
{ return const_iterator(data()); }
const_iterator
cend() const noexcept
{ return const_iterator(data() + _Nm); }
const_reverse_iterator
crbegin() const noexcept
{ return const_reverse_iterator(end()); }
const_reverse_iterator
crend() const noexcept
{ return const_reverse_iterator(begin()); }
constexpr size_type
size() const noexcept { return _Nm; }
constexpr size_type
max_size() const noexcept { return _Nm; }
constexpr bool
empty() const noexcept { return size() == 0; }
reference
operator[](size_type __n) noexcept
{ return _AT_Type::_S_ref(_M_elems, __n); }
constexpr const_reference
operator[](size_type __n) const noexcept
{ return _AT_Type::_S_ref(_M_elems, __n); }
reference
at(size_type __n)
{
if (__n >= _Nm)
std::__throw_out_of_range_fmt(("array::at: __n (which is %zu) " ">= _Nm (which is %zu)")
,
__n, _Nm);
return _AT_Type::_S_ref(_M_elems, __n);
}
constexpr const_reference
at(size_type __n) const
{
return __n < _Nm ? _AT_Type::_S_ref(_M_elems, __n)
: (std::__throw_out_of_range_fmt(("array::at: __n (which is %zu) " ">= _Nm (which is %zu)")
,
__n, _Nm),
_AT_Type::_S_ref(_M_elems, 0));
}
reference
front() noexcept
{ return *begin(); }
constexpr const_reference
front() const noexcept
{ return _AT_Type::_S_ref(_M_elems, 0); }
reference
back() noexcept
{ return _Nm ? *(end() - 1) : *end(); }
constexpr const_reference
back() const noexcept
{
return _Nm ? _AT_Type::_S_ref(_M_elems, _Nm - 1)
: _AT_Type::_S_ref(_M_elems, 0);
}
pointer
data() noexcept
{ return _AT_Type::_S_ptr(_M_elems); }
const_pointer
data() const noexcept
{ return _AT_Type::_S_ptr(_M_elems); }
};
template<typename _Tp, std::size_t _Nm>
inline bool
operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
{ return std::equal(__one.begin(), __one.end(), __two.begin()); }
template<typename _Tp, std::size_t _Nm>
inline bool
operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
{ return !(__one == __two); }
template<typename _Tp, std::size_t _Nm>
inline bool
operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b)
{
return std::lexicographical_compare(__a.begin(), __a.end(),
__b.begin(), __b.end());
}
template<typename _Tp, std::size_t _Nm>
inline bool
operator>(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
{ return __two < __one; }
template<typename _Tp, std::size_t _Nm>
inline bool
operator<=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
{ return !(__one > __two); }
template<typename _Tp, std::size_t _Nm>
inline bool
operator>=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
{ return !(__one < __two); }
template<typename _Tp, std::size_t _Nm>
inline void
swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two)
noexcept(noexcept(__one.swap(__two)))
{ __one.swap(__two); }
template<std::size_t _Int, typename _Tp, std::size_t _Nm>
constexpr _Tp&
get(array<_Tp, _Nm>& __arr) noexcept
{
static_assert(_Int < _Nm, "index is out of bounds");
return std::__array_traits<_Tp, _Nm>::
_S_ref(__arr._M_elems, _Int);
}
template<std::size_t _Int, typename _Tp, std::size_t _Nm>
constexpr _Tp&&
get(array<_Tp, _Nm>&& __arr) noexcept
{
static_assert(_Int < _Nm, "index is out of bounds");
return std::move(std::get<_Int>(__arr));
}
template<std::size_t _Int, typename _Tp, std::size_t _Nm>
constexpr const _Tp&
get(const array<_Tp, _Nm>& __arr) noexcept
{
static_assert(_Int < _Nm, "index is out of bounds");
return std::__array_traits<_Tp, _Nm>::
_S_ref(__arr._M_elems, _Int);
}
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Tp>
class tuple_size;
template<typename _Tp, std::size_t _Nm>
struct tuple_size<std::array<_Tp, _Nm>>
: public integral_constant<std::size_t, _Nm> { };
template<std::size_t _Int, typename _Tp>
class tuple_element;
template<std::size_t _Int, typename _Tp, std::size_t _Nm>
struct tuple_element<_Int, std::array<_Tp, _Nm>>
{
static_assert(_Int < _Nm, "index is out of bounds");
typedef _Tp type;
};
template<typename _Tp, std::size_t _Nm>
struct __is_tuple_like_impl<std::array<_Tp, _Nm>> : true_type
{ };
}
# 40 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/tuple" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/uses_allocator.h" 1 3
# 35 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/uses_allocator.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
struct __erased_type { };
template<typename _Alloc, typename _Tp>
using __is_erased_or_convertible
= __or_<is_same<_Tp, __erased_type>, is_convertible<_Alloc, _Tp>>;
struct allocator_arg_t { explicit allocator_arg_t() = default; };
constexpr allocator_arg_t allocator_arg = allocator_arg_t();
template<typename _Tp, typename _Alloc, typename = __void_t<>>
struct __uses_allocator_helper
: false_type { };
template<typename _Tp, typename _Alloc>
struct __uses_allocator_helper<_Tp, _Alloc,
__void_t<typename _Tp::allocator_type>>
: __is_erased_or_convertible<_Alloc, typename _Tp::allocator_type>::type
{ };
template<typename _Tp, typename _Alloc>
struct uses_allocator
: __uses_allocator_helper<_Tp, _Alloc>::type
{ };
struct __uses_alloc_base { };
struct __uses_alloc0 : __uses_alloc_base
{
struct _Sink { void operator=(const void*) { } } _M_a;
};
template<typename _Alloc>
struct __uses_alloc1 : __uses_alloc_base { const _Alloc* _M_a; };
template<typename _Alloc>
struct __uses_alloc2 : __uses_alloc_base { const _Alloc* _M_a; };
template<bool, typename _Tp, typename _Alloc, typename... _Args>
struct __uses_alloc;
template<typename _Tp, typename _Alloc, typename... _Args>
struct __uses_alloc<true, _Tp, _Alloc, _Args...>
: conditional<
is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>::value,
__uses_alloc1<_Alloc>,
__uses_alloc2<_Alloc>>::type
{
static_assert(__or_<
is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>,
is_constructible<_Tp, _Args..., _Alloc>>::value, "construction with"
" an allocator must be possible if uses_allocator is true");
};
template<typename _Tp, typename _Alloc, typename... _Args>
struct __uses_alloc<false, _Tp, _Alloc, _Args...>
: __uses_alloc0 { };
template<typename _Tp, typename _Alloc, typename... _Args>
using __uses_alloc_t =
__uses_alloc<uses_allocator<_Tp, _Alloc>::value, _Tp, _Alloc, _Args...>;
template<typename _Tp, typename _Alloc, typename... _Args>
inline __uses_alloc_t<_Tp, _Alloc, _Args...>
__use_alloc(const _Alloc& __a)
{
__uses_alloc_t<_Tp, _Alloc, _Args...> __ret;
__ret._M_a = std::__addressof(__a);
return __ret;
}
}
# 41 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/tuple" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<std::size_t _Idx, typename _Head, bool _IsEmptyNotFinal>
struct _Head_base;
template<std::size_t _Idx, typename _Head>
struct _Head_base<_Idx, _Head, true>
: public _Head
{
constexpr _Head_base()
: _Head() { }
constexpr _Head_base(const _Head& __h)
: _Head(__h) { }
constexpr _Head_base(const _Head_base&) = default;
constexpr _Head_base(_Head_base&&) = default;
template<typename _UHead>
constexpr _Head_base(_UHead&& __h)
: _Head(std::forward<_UHead>(__h)) { }
_Head_base(allocator_arg_t, __uses_alloc0)
: _Head() { }
template<typename _Alloc>
_Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
: _Head(allocator_arg, *__a._M_a) { }
template<typename _Alloc>
_Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a)
: _Head(*__a._M_a) { }
template<typename _UHead>
_Head_base(__uses_alloc0, _UHead&& __uhead)
: _Head(std::forward<_UHead>(__uhead)) { }
template<typename _Alloc, typename _UHead>
_Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
: _Head(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) { }
template<typename _Alloc, typename _UHead>
_Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
: _Head(std::forward<_UHead>(__uhead), *__a._M_a) { }
static constexpr _Head&
_M_head(_Head_base& __b) noexcept { return __b; }
static constexpr const _Head&
_M_head(const _Head_base& __b) noexcept { return __b; }
};
template<std::size_t _Idx, typename _Head>
struct _Head_base<_Idx, _Head, false>
{
constexpr _Head_base()
: _M_head_impl() { }
constexpr _Head_base(const _Head& __h)
: _M_head_impl(__h) { }
constexpr _Head_base(const _Head_base&) = default;
constexpr _Head_base(_Head_base&&) = default;
template<typename _UHead>
constexpr _Head_base(_UHead&& __h)
: _M_head_impl(std::forward<_UHead>(__h)) { }
_Head_base(allocator_arg_t, __uses_alloc0)
: _M_head_impl() { }
template<typename _Alloc>
_Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
: _M_head_impl(allocator_arg, *__a._M_a) { }
template<typename _Alloc>
_Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a)
: _M_head_impl(*__a._M_a) { }
template<typename _UHead>
_Head_base(__uses_alloc0, _UHead&& __uhead)
: _M_head_impl(std::forward<_UHead>(__uhead)) { }
template<typename _Alloc, typename _UHead>
_Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
: _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead))
{ }
template<typename _Alloc, typename _UHead>
_Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
: _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { }
static constexpr _Head&
_M_head(_Head_base& __b) noexcept { return __b._M_head_impl; }
static constexpr const _Head&
_M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; }
_Head _M_head_impl;
};
# 158 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/tuple" 3
template<std::size_t _Idx, typename... _Elements>
struct _Tuple_impl;
template<typename _Tp>
struct __is_empty_non_tuple : is_empty<_Tp> { };
template<typename _El0, typename... _El>
struct __is_empty_non_tuple<tuple<_El0, _El...>> : false_type { };
template<typename _Tp>
using __empty_not_final
= typename conditional<__is_final(_Tp), false_type,
__is_empty_non_tuple<_Tp>>::type;
template<std::size_t _Idx, typename _Head, typename... _Tail>
struct _Tuple_impl<_Idx, _Head, _Tail...>
: public _Tuple_impl<_Idx + 1, _Tail...>,
private _Head_base<_Idx, _Head, __empty_not_final<_Head>::value>
{
template<std::size_t, typename...> friend class _Tuple_impl;
typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
typedef _Head_base<_Idx, _Head, __empty_not_final<_Head>::value> _Base;
static constexpr _Head&
_M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
static constexpr const _Head&
_M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
static constexpr _Inherited&
_M_tail(_Tuple_impl& __t) noexcept { return __t; }
static constexpr const _Inherited&
_M_tail(const _Tuple_impl& __t) noexcept { return __t; }
constexpr _Tuple_impl()
: _Inherited(), _Base() { }
explicit
constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail)
: _Inherited(__tail...), _Base(__head) { }
template<typename _UHead, typename... _UTail, typename = typename
enable_if<sizeof...(_Tail) == sizeof...(_UTail)>::type>
explicit
constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
: _Inherited(std::forward<_UTail>(__tail)...),
_Base(std::forward<_UHead>(__head)) { }
constexpr _Tuple_impl(const _Tuple_impl&) = default;
constexpr
_Tuple_impl(_Tuple_impl&& __in)
noexcept(__and_<is_nothrow_move_constructible<_Head>,
is_nothrow_move_constructible<_Inherited>>::value)
: _Inherited(std::move(_M_tail(__in))),
_Base(std::forward<_Head>(_M_head(__in))) { }
template<typename... _UElements>
constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
: _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
_Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { }
template<typename _UHead, typename... _UTails>
constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
: _Inherited(std::move
(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
_Base(std::forward<_UHead>
(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { }
template<typename _Alloc>
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
: _Inherited(__tag, __a),
_Base(__tag, __use_alloc<_Head>(__a)) { }
template<typename _Alloc>
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
const _Head& __head, const _Tail&... __tail)
: _Inherited(__tag, __a, __tail...),
_Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { }
template<typename _Alloc, typename _UHead, typename... _UTail,
typename = typename enable_if<sizeof...(_Tail)
== sizeof...(_UTail)>::type>
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
_UHead&& __head, _UTail&&... __tail)
: _Inherited(__tag, __a, std::forward<_UTail>(__tail)...),
_Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
std::forward<_UHead>(__head)) { }
template<typename _Alloc>
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
const _Tuple_impl& __in)
: _Inherited(__tag, __a, _M_tail(__in)),
_Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { }
template<typename _Alloc>
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
_Tuple_impl&& __in)
: _Inherited(__tag, __a, std::move(_M_tail(__in))),
_Base(__use_alloc<_Head, _Alloc, _Head>(__a),
std::forward<_Head>(_M_head(__in))) { }
template<typename _Alloc, typename... _UElements>
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
const _Tuple_impl<_Idx, _UElements...>& __in)
: _Inherited(__tag, __a,
_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
_Base(__use_alloc<_Head, _Alloc, _Head>(__a),
_Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { }
template<typename _Alloc, typename _UHead, typename... _UTails>
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
: _Inherited(__tag, __a, std::move
(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
_Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
std::forward<_UHead>
(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { }
_Tuple_impl&
operator=(const _Tuple_impl& __in)
{
_M_head(*this) = _M_head(__in);
_M_tail(*this) = _M_tail(__in);
return *this;
}
_Tuple_impl&
operator=(_Tuple_impl&& __in)
noexcept(__and_<is_nothrow_move_assignable<_Head>,
is_nothrow_move_assignable<_Inherited>>::value)
{
_M_head(*this) = std::forward<_Head>(_M_head(__in));
_M_tail(*this) = std::move(_M_tail(__in));
return *this;
}
template<typename... _UElements>
_Tuple_impl&
operator=(const _Tuple_impl<_Idx, _UElements...>& __in)
{
_M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in);
_M_tail(*this) = _Tuple_impl<_Idx, _UElements...>::_M_tail(__in);
return *this;
}
template<typename _UHead, typename... _UTails>
_Tuple_impl&
operator=(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
{
_M_head(*this) = std::forward<_UHead>
(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in));
_M_tail(*this) = std::move
(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in));
return *this;
}
protected:
void
_M_swap(_Tuple_impl& __in)
noexcept(__is_nothrow_swappable<_Head>::value
&& noexcept(_M_tail(__in)._M_swap(_M_tail(__in))))
{
using std::swap;
swap(_M_head(*this), _M_head(__in));
_Inherited::_M_swap(_M_tail(__in));
}
};
template<std::size_t _Idx, typename _Head>
struct _Tuple_impl<_Idx, _Head>
: private _Head_base<_Idx, _Head, __empty_not_final<_Head>::value>
{
template<std::size_t, typename...> friend class _Tuple_impl;
typedef _Head_base<_Idx, _Head, __empty_not_final<_Head>::value> _Base;
static constexpr _Head&
_M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
static constexpr const _Head&
_M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
constexpr _Tuple_impl()
: _Base() { }
explicit
constexpr _Tuple_impl(const _Head& __head)
: _Base(__head) { }
template<typename _UHead>
explicit
constexpr _Tuple_impl(_UHead&& __head)
: _Base(std::forward<_UHead>(__head)) { }
constexpr _Tuple_impl(const _Tuple_impl&) = default;
constexpr
_Tuple_impl(_Tuple_impl&& __in)
noexcept(is_nothrow_move_constructible<_Head>::value)
: _Base(std::forward<_Head>(_M_head(__in))) { }
template<typename _UHead>
constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UHead>& __in)
: _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in)) { }
template<typename _UHead>
constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead>&& __in)
: _Base(std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
{ }
template<typename _Alloc>
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
: _Base(__tag, __use_alloc<_Head>(__a)) { }
template<typename _Alloc>
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
const _Head& __head)
: _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { }
template<typename _Alloc, typename _UHead>
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
_UHead&& __head)
: _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
std::forward<_UHead>(__head)) { }
template<typename _Alloc>
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
const _Tuple_impl& __in)
: _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { }
template<typename _Alloc>
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
_Tuple_impl&& __in)
: _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
std::forward<_Head>(_M_head(__in))) { }
template<typename _Alloc, typename _UHead>
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
const _Tuple_impl<_Idx, _UHead>& __in)
: _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
_Tuple_impl<_Idx, _UHead>::_M_head(__in)) { }
template<typename _Alloc, typename _UHead>
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
_Tuple_impl<_Idx, _UHead>&& __in)
: _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
{ }
_Tuple_impl&
operator=(const _Tuple_impl& __in)
{
_M_head(*this) = _M_head(__in);
return *this;
}
_Tuple_impl&
operator=(_Tuple_impl&& __in)
noexcept(is_nothrow_move_assignable<_Head>::value)
{
_M_head(*this) = std::forward<_Head>(_M_head(__in));
return *this;
}
template<typename _UHead>
_Tuple_impl&
operator=(const _Tuple_impl<_Idx, _UHead>& __in)
{
_M_head(*this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in);
return *this;
}
template<typename _UHead>
_Tuple_impl&
operator=(_Tuple_impl<_Idx, _UHead>&& __in)
{
_M_head(*this)
= std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in));
return *this;
}
protected:
void
_M_swap(_Tuple_impl& __in)
noexcept(__is_nothrow_swappable<_Head>::value)
{
using std::swap;
swap(_M_head(*this), _M_head(__in));
}
};
template<typename... _Elements>
class tuple;
template<bool, typename... _Elements>
struct _TC
{
template<typename... _UElements>
static constexpr bool _ConstructibleTuple()
{
return __and_<is_constructible<_Elements, const _UElements&>...>::value;
}
template<typename... _UElements>
static constexpr bool _ImplicitlyConvertibleTuple()
{
return __and_<is_convertible<const _UElements&, _Elements>...>::value;
}
template<typename... _UElements>
static constexpr bool _MoveConstructibleTuple()
{
return __and_<is_constructible<_Elements, _UElements&&>...>::value;
}
template<typename... _UElements>
static constexpr bool _ImplicitlyMoveConvertibleTuple()
{
return __and_<is_convertible<_UElements&&, _Elements>...>::value;
}
template<typename _SrcTuple>
static constexpr bool _NonNestedTuple()
{
return __and_<__not_<is_same<tuple<_Elements...>,
typename remove_cv<
typename remove_reference<_SrcTuple>::type
>::type>>,
__not_<is_convertible<_SrcTuple, _Elements...>>,
__not_<is_constructible<_Elements..., _SrcTuple>>
>::value;
}
template<typename... _UElements>
static constexpr bool _NotSameTuple()
{
return __not_<is_same<tuple<_Elements...>,
typename remove_const<
typename remove_reference<_UElements...>::type
>::type>>::value;
}
};
template<typename... _Elements>
struct _TC<false, _Elements...>
{
template<typename... _UElements>
static constexpr bool _ConstructibleTuple()
{
return false;
}
template<typename... _UElements>
static constexpr bool _ImplicitlyConvertibleTuple()
{
return false;
}
template<typename... _UElements>
static constexpr bool _MoveConstructibleTuple()
{
return false;
}
template<typename... _UElements>
static constexpr bool _ImplicitlyMoveConvertibleTuple()
{
return false;
}
template<typename... _UElements>
static constexpr bool _NonNestedTuple()
{
return true;
}
template<typename... _UElements>
static constexpr bool _NotSameTuple()
{
return true;
}
};
template<typename... _Elements>
class tuple : public _Tuple_impl<0, _Elements...>
{
typedef _Tuple_impl<0, _Elements...> _Inherited;
template<typename _Dummy>
struct _TC2
{
static constexpr bool _DefaultConstructibleTuple()
{
return __and_<is_default_constructible<_Elements>...>::value;
}
static constexpr bool _ImplicitlyDefaultConstructibleTuple()
{
return __and_<__is_implicitly_default_constructible<_Elements>...>
::value;
}
};
public:
template<typename _Dummy = void,
typename enable_if<_TC2<_Dummy>::
_ImplicitlyDefaultConstructibleTuple(),
bool>::type = true>
constexpr tuple()
: _Inherited() { }
template<typename _Dummy = void,
typename enable_if<_TC2<_Dummy>::
_DefaultConstructibleTuple()
&&
!_TC2<_Dummy>::
_ImplicitlyDefaultConstructibleTuple(),
bool>::type = false>
explicit constexpr tuple()
: _Inherited() { }
template<typename _Dummy> using _TCC =
_TC<is_same<_Dummy, void>::value,
_Elements...>;
template<typename _Dummy = void,
typename enable_if<
_TCC<_Dummy>::template
_ConstructibleTuple<_Elements...>()
&& _TCC<_Dummy>::template
_ImplicitlyConvertibleTuple<_Elements...>()
&& (sizeof...(_Elements) >= 1),
bool>::type=true>
constexpr tuple(const _Elements&... __elements)
: _Inherited(__elements...) { }
template<typename _Dummy = void,
typename enable_if<
_TCC<_Dummy>::template
_ConstructibleTuple<_Elements...>()
&& !_TCC<_Dummy>::template
_ImplicitlyConvertibleTuple<_Elements...>()
&& (sizeof...(_Elements) >= 1),
bool>::type=false>
explicit constexpr tuple(const _Elements&... __elements)
: _Inherited(__elements...) { }
template<typename... _UElements> using _TMC =
_TC<(sizeof...(_Elements) == sizeof...(_UElements)),
_Elements...>;
template<typename... _UElements, typename
enable_if<
_TC<sizeof...(_UElements) == 1, _Elements...>::template
_NotSameTuple<_UElements...>()
&& _TMC<_UElements...>::template
_MoveConstructibleTuple<_UElements...>()
&& _TMC<_UElements...>::template
_ImplicitlyMoveConvertibleTuple<_UElements...>()
&& (sizeof...(_Elements) >= 1),
bool>::type=true>
constexpr tuple(_UElements&&... __elements)
: _Inherited(std::forward<_UElements>(__elements)...) { }
template<typename... _UElements, typename
enable_if<
_TC<sizeof...(_UElements) == 1, _Elements...>::template
_NotSameTuple<_UElements...>()
&& _TMC<_UElements...>::template
_MoveConstructibleTuple<_UElements...>()
&& !_TMC<_UElements...>::template
_ImplicitlyMoveConvertibleTuple<_UElements...>()
&& (sizeof...(_Elements) >= 1),
bool>::type=false>
explicit constexpr tuple(_UElements&&... __elements)
: _Inherited(std::forward<_UElements>(__elements)...) { }
constexpr tuple(const tuple&) = default;
constexpr tuple(tuple&&) = default;
template<typename _Dummy> using _TNTC =
_TC<is_same<_Dummy, void>::value && sizeof...(_Elements) == 1,
_Elements...>;
template<typename... _UElements, typename _Dummy = void, typename
enable_if<_TMC<_UElements...>::template
_ConstructibleTuple<_UElements...>()
&& _TMC<_UElements...>::template
_ImplicitlyConvertibleTuple<_UElements...>()
&& _TNTC<_Dummy>::template
_NonNestedTuple<const tuple<_UElements...>&>(),
bool>::type=true>
constexpr tuple(const tuple<_UElements...>& __in)
: _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
{ }
template<typename... _UElements, typename _Dummy = void, typename
enable_if<_TMC<_UElements...>::template
_ConstructibleTuple<_UElements...>()
&& !_TMC<_UElements...>::template
_ImplicitlyConvertibleTuple<_UElements...>()
&& _TNTC<_Dummy>::template
_NonNestedTuple<const tuple<_UElements...>&>(),
bool>::type=false>
explicit constexpr tuple(const tuple<_UElements...>& __in)
: _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
{ }
template<typename... _UElements, typename _Dummy = void, typename
enable_if<_TMC<_UElements...>::template
_MoveConstructibleTuple<_UElements...>()
&& _TMC<_UElements...>::template
_ImplicitlyMoveConvertibleTuple<_UElements...>()
&& _TNTC<_Dummy>::template
_NonNestedTuple<tuple<_UElements...>&&>(),
bool>::type=true>
constexpr tuple(tuple<_UElements...>&& __in)
: _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { }
template<typename... _UElements, typename _Dummy = void, typename
enable_if<_TMC<_UElements...>::template
_MoveConstructibleTuple<_UElements...>()
&& !_TMC<_UElements...>::template
_ImplicitlyMoveConvertibleTuple<_UElements...>()
&& _TNTC<_Dummy>::template
_NonNestedTuple<tuple<_UElements...>&&>(),
bool>::type=false>
explicit constexpr tuple(tuple<_UElements...>&& __in)
: _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { }
template<typename _Alloc>
tuple(allocator_arg_t __tag, const _Alloc& __a)
: _Inherited(__tag, __a) { }
template<typename _Alloc, typename _Dummy = void,
typename enable_if<
_TCC<_Dummy>::template
_ConstructibleTuple<_Elements...>()
&& _TCC<_Dummy>::template
_ImplicitlyConvertibleTuple<_Elements...>(),
bool>::type=true>
tuple(allocator_arg_t __tag, const _Alloc& __a,
const _Elements&... __elements)
: _Inherited(__tag, __a, __elements...) { }
template<typename _Alloc, typename _Dummy = void,
typename enable_if<
_TCC<_Dummy>::template
_ConstructibleTuple<_Elements...>()
&& !_TCC<_Dummy>::template
_ImplicitlyConvertibleTuple<_Elements...>(),
bool>::type=false>
explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
const _Elements&... __elements)
: _Inherited(__tag, __a, __elements...) { }
template<typename _Alloc, typename... _UElements, typename
enable_if<_TMC<_UElements...>::template
_MoveConstructibleTuple<_UElements...>()
&& _TMC<_UElements...>::template
_ImplicitlyMoveConvertibleTuple<_UElements...>(),
bool>::type=true>
tuple(allocator_arg_t __tag, const _Alloc& __a,
_UElements&&... __elements)
: _Inherited(__tag, __a, std::forward<_UElements>(__elements)...)
{ }
template<typename _Alloc, typename... _UElements, typename
enable_if<_TMC<_UElements...>::template
_MoveConstructibleTuple<_UElements...>()
&& !_TMC<_UElements...>::template
_ImplicitlyMoveConvertibleTuple<_UElements...>(),
bool>::type=false>
explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
_UElements&&... __elements)
: _Inherited(__tag, __a, std::forward<_UElements>(__elements)...)
{ }
template<typename _Alloc>
tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
: _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
template<typename _Alloc>
tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
: _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
template<typename _Alloc, typename... _UElements, typename
enable_if<_TMC<_UElements...>::template
_ConstructibleTuple<_UElements...>()
&& _TMC<_UElements...>::template
_ImplicitlyConvertibleTuple<_UElements...>(),
bool>::type=true>
tuple(allocator_arg_t __tag, const _Alloc& __a,
const tuple<_UElements...>& __in)
: _Inherited(__tag, __a,
static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
{ }
template<typename _Alloc, typename... _UElements, typename
enable_if<_TMC<_UElements...>::template
_ConstructibleTuple<_UElements...>()
&& !_TMC<_UElements...>::template
_ImplicitlyConvertibleTuple<_UElements...>(),
bool>::type=false>
explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
const tuple<_UElements...>& __in)
: _Inherited(__tag, __a,
static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
{ }
template<typename _Alloc, typename... _UElements, typename
enable_if<_TMC<_UElements...>::template
_MoveConstructibleTuple<_UElements...>()
&& _TMC<_UElements...>::template
_ImplicitlyMoveConvertibleTuple<_UElements...>(),
bool>::type=true>
tuple(allocator_arg_t __tag, const _Alloc& __a,
tuple<_UElements...>&& __in)
: _Inherited(__tag, __a,
static_cast<_Tuple_impl<0, _UElements...>&&>(__in))
{ }
template<typename _Alloc, typename... _UElements, typename
enable_if<_TMC<_UElements...>::template
_MoveConstructibleTuple<_UElements...>()
&& !_TMC<_UElements...>::template
_ImplicitlyMoveConvertibleTuple<_UElements...>(),
bool>::type=false>
explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
tuple<_UElements...>&& __in)
: _Inherited(__tag, __a,
static_cast<_Tuple_impl<0, _UElements...>&&>(__in))
{ }
tuple&
operator=(const tuple& __in)
{
static_cast<_Inherited&>(*this) = __in;
return *this;
}
tuple&
operator=(tuple&& __in)
noexcept(is_nothrow_move_assignable<_Inherited>::value)
{
static_cast<_Inherited&>(*this) = std::move(__in);
return *this;
}
template<typename... _UElements, typename = typename
enable_if<sizeof...(_UElements)
== sizeof...(_Elements)>::type>
tuple&
operator=(const tuple<_UElements...>& __in)
{
static_cast<_Inherited&>(*this) = __in;
return *this;
}
template<typename... _UElements, typename = typename
enable_if<sizeof...(_UElements)
== sizeof...(_Elements)>::type>
tuple&
operator=(tuple<_UElements...>&& __in)
{
static_cast<_Inherited&>(*this) = std::move(__in);
return *this;
}
void
swap(tuple& __in)
noexcept(noexcept(__in._M_swap(__in)))
{ _Inherited::_M_swap(__in); }
};
template<>
class tuple<>
{
public:
void swap(tuple&) noexcept { }
};
template<typename _T1, typename _T2>
class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2>
{
typedef _Tuple_impl<0, _T1, _T2> _Inherited;
public:
template <typename _U1 = _T1,
typename _U2 = _T2,
typename enable_if<__and_<
__is_implicitly_default_constructible<_U1>,
__is_implicitly_default_constructible<_U2>>
::value, bool>::type = true>
constexpr tuple()
: _Inherited() { }
template <typename _U1 = _T1,
typename _U2 = _T2,
typename enable_if<
__and_<
is_default_constructible<_U1>,
is_default_constructible<_U2>,
__not_<
__and_<__is_implicitly_default_constructible<_U1>,
__is_implicitly_default_constructible<_U2>>>>
::value, bool>::type = false>
explicit constexpr tuple()
: _Inherited() { }
template<typename _Dummy> using _TCC =
_TC<is_same<_Dummy, void>::value, _T1, _T2>;
template<typename _Dummy = void, typename
enable_if<_TCC<_Dummy>::template
_ConstructibleTuple<_T1, _T2>()
&& _TCC<_Dummy>::template
_ImplicitlyConvertibleTuple<_T1, _T2>(),
bool>::type = true>
constexpr tuple(const _T1& __a1, const _T2& __a2)
: _Inherited(__a1, __a2) { }
template<typename _Dummy = void, typename
enable_if<_TCC<_Dummy>::template
_ConstructibleTuple<_T1, _T2>()
&& !_TCC<_Dummy>::template
_ImplicitlyConvertibleTuple<_T1, _T2>(),
bool>::type = false>
explicit constexpr tuple(const _T1& __a1, const _T2& __a2)
: _Inherited(__a1, __a2) { }
using _TMC = _TC<true, _T1, _T2>;
template<typename _U1, typename _U2, typename
enable_if<_TMC::template
_MoveConstructibleTuple<_U1, _U2>()
&& _TMC::template
_ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
bool>::type = true>
constexpr tuple(_U1&& __a1, _U2&& __a2)
: _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { }
template<typename _U1, typename _U2, typename
enable_if<_TMC::template
_MoveConstructibleTuple<_U1, _U2>()
&& !_TMC::template
_ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
bool>::type = false>
explicit constexpr tuple(_U1&& __a1, _U2&& __a2)
: _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { }
constexpr tuple(const tuple&) = default;
constexpr tuple(tuple&&) = default;
template<typename _U1, typename _U2, typename
enable_if<_TMC::template
_ConstructibleTuple<_U1, _U2>()
&& _TMC::template
_ImplicitlyConvertibleTuple<_U1, _U2>(),
bool>::type = true>
constexpr tuple(const tuple<_U1, _U2>& __in)
: _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { }
template<typename _U1, typename _U2, typename
enable_if<_TMC::template
_ConstructibleTuple<_U1, _U2>()
&& !_TMC::template
_ImplicitlyConvertibleTuple<_U1, _U2>(),
bool>::type = false>
explicit constexpr tuple(const tuple<_U1, _U2>& __in)
: _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { }
template<typename _U1, typename _U2, typename
enable_if<_TMC::template
_MoveConstructibleTuple<_U1, _U2>()
&& _TMC::template
_ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
bool>::type = true>
constexpr tuple(tuple<_U1, _U2>&& __in)
: _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { }
template<typename _U1, typename _U2, typename
enable_if<_TMC::template
_MoveConstructibleTuple<_U1, _U2>()
&& !_TMC::template
_ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
bool>::type = false>
explicit constexpr tuple(tuple<_U1, _U2>&& __in)
: _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { }
template<typename _U1, typename _U2, typename
enable_if<_TMC::template
_ConstructibleTuple<_U1, _U2>()
&& _TMC::template
_ImplicitlyConvertibleTuple<_U1, _U2>(),
bool>::type = true>
constexpr tuple(const pair<_U1, _U2>& __in)
: _Inherited(__in.first, __in.second) { }
template<typename _U1, typename _U2, typename
enable_if<_TMC::template
_ConstructibleTuple<_U1, _U2>()
&& !_TMC::template
_ImplicitlyConvertibleTuple<_U1, _U2>(),
bool>::type = false>
explicit constexpr tuple(const pair<_U1, _U2>& __in)
: _Inherited(__in.first, __in.second) { }
template<typename _U1, typename _U2, typename
enable_if<_TMC::template
_MoveConstructibleTuple<_U1, _U2>()
&& _TMC::template
_ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
bool>::type = true>
constexpr tuple(pair<_U1, _U2>&& __in)
: _Inherited(std::forward<_U1>(__in.first),
std::forward<_U2>(__in.second)) { }
template<typename _U1, typename _U2, typename
enable_if<_TMC::template
_MoveConstructibleTuple<_U1, _U2>()
&& !_TMC::template
_ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
bool>::type = false>
explicit constexpr tuple(pair<_U1, _U2>&& __in)
: _Inherited(std::forward<_U1>(__in.first),
std::forward<_U2>(__in.second)) { }
template<typename _Alloc>
tuple(allocator_arg_t __tag, const _Alloc& __a)
: _Inherited(__tag, __a) { }
template<typename _Alloc, typename _Dummy = void,
typename enable_if<
_TCC<_Dummy>::template
_ConstructibleTuple<_T1, _T2>()
&& _TCC<_Dummy>::template
_ImplicitlyConvertibleTuple<_T1, _T2>(),
bool>::type=true>
tuple(allocator_arg_t __tag, const _Alloc& __a,
const _T1& __a1, const _T2& __a2)
: _Inherited(__tag, __a, __a1, __a2) { }
template<typename _Alloc, typename _Dummy = void,
typename enable_if<
_TCC<_Dummy>::template
_ConstructibleTuple<_T1, _T2>()
&& !_TCC<_Dummy>::template
_ImplicitlyConvertibleTuple<_T1, _T2>(),
bool>::type=false>
explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
const _T1& __a1, const _T2& __a2)
: _Inherited(__tag, __a, __a1, __a2) { }
template<typename _Alloc, typename _U1, typename _U2, typename
enable_if<_TMC::template
_MoveConstructibleTuple<_U1, _U2>()
&& _TMC::template
_ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
bool>::type = true>
tuple(allocator_arg_t __tag, const _Alloc& __a, _U1&& __a1, _U2&& __a2)
: _Inherited(__tag, __a, std::forward<_U1>(__a1),
std::forward<_U2>(__a2)) { }
template<typename _Alloc, typename _U1, typename _U2, typename
enable_if<_TMC::template
_MoveConstructibleTuple<_U1, _U2>()
&& !_TMC::template
_ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
bool>::type = false>
explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
_U1&& __a1, _U2&& __a2)
: _Inherited(__tag, __a, std::forward<_U1>(__a1),
std::forward<_U2>(__a2)) { }
template<typename _Alloc>
tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
: _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
template<typename _Alloc>
tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
: _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
template<typename _Alloc, typename _U1, typename _U2, typename
enable_if<_TMC::template
_ConstructibleTuple<_U1, _U2>()
&& _TMC::template
_ImplicitlyConvertibleTuple<_U1, _U2>(),
bool>::type = true>
tuple(allocator_arg_t __tag, const _Alloc& __a,
const tuple<_U1, _U2>& __in)
: _Inherited(__tag, __a,
static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in))
{ }
template<typename _Alloc, typename _U1, typename _U2, typename
enable_if<_TMC::template
_ConstructibleTuple<_U1, _U2>()
&& !_TMC::template
_ImplicitlyConvertibleTuple<_U1, _U2>(),
bool>::type = false>
explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
const tuple<_U1, _U2>& __in)
: _Inherited(__tag, __a,
static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in))
{ }
template<typename _Alloc, typename _U1, typename _U2, typename
enable_if<_TMC::template
_MoveConstructibleTuple<_U1, _U2>()
&& _TMC::template
_ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
bool>::type = true>
tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in)
: _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in))
{ }
template<typename _Alloc, typename _U1, typename _U2, typename
enable_if<_TMC::template
_MoveConstructibleTuple<_U1, _U2>()
&& !_TMC::template
_ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
bool>::type = false>
explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
tuple<_U1, _U2>&& __in)
: _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in))
{ }
template<typename _Alloc, typename _U1, typename _U2, typename
enable_if<_TMC::template
_ConstructibleTuple<_U1, _U2>()
&& _TMC::template
_ImplicitlyConvertibleTuple<_U1, _U2>(),
bool>::type = true>
tuple(allocator_arg_t __tag, const _Alloc& __a,
const pair<_U1, _U2>& __in)
: _Inherited(__tag, __a, __in.first, __in.second) { }
template<typename _Alloc, typename _U1, typename _U2, typename
enable_if<_TMC::template
_ConstructibleTuple<_U1, _U2>()
&& !_TMC::template
_ImplicitlyConvertibleTuple<_U1, _U2>(),
bool>::type = false>
explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
const pair<_U1, _U2>& __in)
: _Inherited(__tag, __a, __in.first, __in.second) { }
template<typename _Alloc, typename _U1, typename _U2, typename
enable_if<_TMC::template
_MoveConstructibleTuple<_U1, _U2>()
&& _TMC::template
_ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
bool>::type = true>
tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in)
: _Inherited(__tag, __a, std::forward<_U1>(__in.first),
std::forward<_U2>(__in.second)) { }
template<typename _Alloc, typename _U1, typename _U2, typename
enable_if<_TMC::template
_MoveConstructibleTuple<_U1, _U2>()
&& !_TMC::template
_ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
bool>::type = false>
explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
pair<_U1, _U2>&& __in)
: _Inherited(__tag, __a, std::forward<_U1>(__in.first),
std::forward<_U2>(__in.second)) { }
tuple&
operator=(const tuple& __in)
{
static_cast<_Inherited&>(*this) = __in;
return *this;
}
tuple&
operator=(tuple&& __in)
noexcept(is_nothrow_move_assignable<_Inherited>::value)
{
static_cast<_Inherited&>(*this) = std::move(__in);
return *this;
}
template<typename _U1, typename _U2>
tuple&
operator=(const tuple<_U1, _U2>& __in)
{
static_cast<_Inherited&>(*this) = __in;
return *this;
}
template<typename _U1, typename _U2>
tuple&
operator=(tuple<_U1, _U2>&& __in)
{
static_cast<_Inherited&>(*this) = std::move(__in);
return *this;
}
template<typename _U1, typename _U2>
tuple&
operator=(const pair<_U1, _U2>& __in)
{
this->_M_head(*this) = __in.first;
this->_M_tail(*this)._M_head(*this) = __in.second;
return *this;
}
template<typename _U1, typename _U2>
tuple&
operator=(pair<_U1, _U2>&& __in)
{
this->_M_head(*this) = std::forward<_U1>(__in.first);
this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in.second);
return *this;
}
void
swap(tuple& __in)
noexcept(noexcept(__in._M_swap(__in)))
{ _Inherited::_M_swap(__in); }
};
template<std::size_t __i, typename _Head, typename... _Tail>
struct tuple_element<__i, tuple<_Head, _Tail...> >
: tuple_element<__i - 1, tuple<_Tail...> > { };
template<typename _Head, typename... _Tail>
struct tuple_element<0, tuple<_Head, _Tail...> >
{
typedef _Head type;
};
template<typename... _Elements>
struct tuple_size<tuple<_Elements...>>
: public integral_constant<std::size_t, sizeof...(_Elements)> { };
template<std::size_t __i, typename _Head, typename... _Tail>
constexpr _Head&
__get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
{ return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
template<std::size_t __i, typename _Head, typename... _Tail>
constexpr const _Head&
__get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
{ return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
template<std::size_t __i, typename... _Elements>
constexpr __tuple_element_t<__i, tuple<_Elements...>>&
get(tuple<_Elements...>& __t) noexcept
{ return std::__get_helper<__i>(__t); }
template<std::size_t __i, typename... _Elements>
constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
get(const tuple<_Elements...>& __t) noexcept
{ return std::__get_helper<__i>(__t); }
template<std::size_t __i, typename... _Elements>
constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
get(tuple<_Elements...>&& __t) noexcept
{
typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type;
return std::forward<__element_type&&>(std::get<__i>(__t));
}
template<typename _Head, size_t __i, typename... _Tail>
constexpr _Head&
__get_helper2(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
{ return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
template<typename _Head, size_t __i, typename... _Tail>
constexpr const _Head&
__get_helper2(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
{ return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
template <typename _Tp, typename... _Types>
constexpr _Tp&
get(tuple<_Types...>& __t) noexcept
{ return std::__get_helper2<_Tp>(__t); }
template <typename _Tp, typename... _Types>
constexpr _Tp&&
get(tuple<_Types...>&& __t) noexcept
{ return std::forward<_Tp&&>(std::__get_helper2<_Tp>(__t)); }
template <typename _Tp, typename... _Types>
constexpr const _Tp&
get(const tuple<_Types...>& __t) noexcept
{ return std::__get_helper2<_Tp>(__t); }
template<typename _Tp, typename _Up, size_t __i, size_t __size>
struct __tuple_compare
{
static constexpr bool
__eq(const _Tp& __t, const _Up& __u)
{
return bool(std::get<__i>(__t) == std::get<__i>(__u))
&& __tuple_compare<_Tp, _Up, __i + 1, __size>::__eq(__t, __u);
}
static constexpr bool
__less(const _Tp& __t, const _Up& __u)
{
return bool(std::get<__i>(__t) < std::get<__i>(__u))
|| (!bool(std::get<__i>(__u) < std::get<__i>(__t))
&& __tuple_compare<_Tp, _Up, __i + 1, __size>::__less(__t, __u));
}
};
template<typename _Tp, typename _Up, size_t __size>
struct __tuple_compare<_Tp, _Up, __size, __size>
{
static constexpr bool
__eq(const _Tp&, const _Up&) { return true; }
static constexpr bool
__less(const _Tp&, const _Up&) { return false; }
};
template<typename... _TElements, typename... _UElements>
constexpr bool
operator==(const tuple<_TElements...>& __t,
const tuple<_UElements...>& __u)
{
static_assert(sizeof...(_TElements) == sizeof...(_UElements),
"tuple objects can only be compared if they have equal sizes.");
using __compare = __tuple_compare<tuple<_TElements...>,
tuple<_UElements...>,
0, sizeof...(_TElements)>;
return __compare::__eq(__t, __u);
}
template<typename... _TElements, typename... _UElements>
constexpr bool
operator<(const tuple<_TElements...>& __t,
const tuple<_UElements...>& __u)
{
static_assert(sizeof...(_TElements) == sizeof...(_UElements),
"tuple objects can only be compared if they have equal sizes.");
using __compare = __tuple_compare<tuple<_TElements...>,
tuple<_UElements...>,
0, sizeof...(_TElements)>;
return __compare::__less(__t, __u);
}
template<typename... _TElements, typename... _UElements>
constexpr bool
operator!=(const tuple<_TElements...>& __t,
const tuple<_UElements...>& __u)
{ return !(__t == __u); }
template<typename... _TElements, typename... _UElements>
constexpr bool
operator>(const tuple<_TElements...>& __t,
const tuple<_UElements...>& __u)
{ return __u < __t; }
template<typename... _TElements, typename... _UElements>
constexpr bool
operator<=(const tuple<_TElements...>& __t,
const tuple<_UElements...>& __u)
{ return !(__u < __t); }
template<typename... _TElements, typename... _UElements>
constexpr bool
operator>=(const tuple<_TElements...>& __t,
const tuple<_UElements...>& __u)
{ return !(__t < __u); }
template<typename... _Elements>
constexpr tuple<typename __decay_and_strip<_Elements>::__type...>
make_tuple(_Elements&&... __args)
{
typedef tuple<typename __decay_and_strip<_Elements>::__type...>
__result_type;
return __result_type(std::forward<_Elements>(__args)...);
}
template<typename... _Elements>
constexpr tuple<_Elements&&...>
forward_as_tuple(_Elements&&... __args) noexcept
{ return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); }
template<typename... _Tps>
struct __is_tuple_like_impl<tuple<_Tps...>> : true_type
{ };
template<typename _Tp>
struct __is_tuple_like
: public __is_tuple_like_impl<typename std::remove_cv
<typename std::remove_reference<_Tp>::type>::type>::type
{ };
template<size_t, typename, typename, size_t>
struct __make_tuple_impl;
template<size_t _Idx, typename _Tuple, typename... _Tp, size_t _Nm>
struct __make_tuple_impl<_Idx, tuple<_Tp...>, _Tuple, _Nm>
: __make_tuple_impl<_Idx + 1,
tuple<_Tp..., __tuple_element_t<_Idx, _Tuple>>,
_Tuple, _Nm>
{ };
template<std::size_t _Nm, typename _Tuple, typename... _Tp>
struct __make_tuple_impl<_Nm, tuple<_Tp...>, _Tuple, _Nm>
{
typedef tuple<_Tp...> __type;
};
template<typename _Tuple>
struct __do_make_tuple
: __make_tuple_impl<0, tuple<>, _Tuple, std::tuple_size<_Tuple>::value>
{ };
template<typename _Tuple>
struct __make_tuple
: public __do_make_tuple<typename std::remove_cv
<typename std::remove_reference<_Tuple>::type>::type>
{ };
template<typename...>
struct __combine_tuples;
template<>
struct __combine_tuples<>
{
typedef tuple<> __type;
};
template<typename... _Ts>
struct __combine_tuples<tuple<_Ts...>>
{
typedef tuple<_Ts...> __type;
};
template<typename... _T1s, typename... _T2s, typename... _Rem>
struct __combine_tuples<tuple<_T1s...>, tuple<_T2s...>, _Rem...>
{
typedef typename __combine_tuples<tuple<_T1s..., _T2s...>,
_Rem...>::__type __type;
};
template<typename... _Tpls>
struct __tuple_cat_result
{
typedef typename __combine_tuples
<typename __make_tuple<_Tpls>::__type...>::__type __type;
};
template<typename...>
struct __make_1st_indices;
template<>
struct __make_1st_indices<>
{
typedef std::_Index_tuple<> __type;
};
template<typename _Tp, typename... _Tpls>
struct __make_1st_indices<_Tp, _Tpls...>
{
typedef typename std::_Build_index_tuple<std::tuple_size<
typename std::remove_reference<_Tp>::type>::value>::__type __type;
};
template<typename _Ret, typename _Indices, typename... _Tpls>
struct __tuple_concater;
template<typename _Ret, std::size_t... _Is, typename _Tp, typename... _Tpls>
struct __tuple_concater<_Ret, std::_Index_tuple<_Is...>, _Tp, _Tpls...>
{
template<typename... _Us>
static constexpr _Ret
_S_do(_Tp&& __tp, _Tpls&&... __tps, _Us&&... __us)
{
typedef typename __make_1st_indices<_Tpls...>::__type __idx;
typedef __tuple_concater<_Ret, __idx, _Tpls...> __next;
return __next::_S_do(std::forward<_Tpls>(__tps)...,
std::forward<_Us>(__us)...,
std::get<_Is>(std::forward<_Tp>(__tp))...);
}
};
template<typename _Ret>
struct __tuple_concater<_Ret, std::_Index_tuple<>>
{
template<typename... _Us>
static constexpr _Ret
_S_do(_Us&&... __us)
{
return _Ret(std::forward<_Us>(__us)...);
}
};
template<typename... _Tpls, typename = typename
enable_if<__and_<__is_tuple_like<_Tpls>...>::value>::type>
constexpr auto
tuple_cat(_Tpls&&... __tpls)
-> typename __tuple_cat_result<_Tpls...>::__type
{
typedef typename __tuple_cat_result<_Tpls...>::__type __ret;
typedef typename __make_1st_indices<_Tpls...>::__type __idx;
typedef __tuple_concater<__ret, __idx, _Tpls...> __concater;
return __concater::_S_do(std::forward<_Tpls>(__tpls)...);
}
template<typename... _Elements>
constexpr tuple<_Elements&...>
tie(_Elements&... __args) noexcept
{ return tuple<_Elements&...>(__args...); }
template<typename... _Elements>
inline void
swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y)
noexcept(noexcept(__x.swap(__y)))
{ __x.swap(__y); }
struct _Swallow_assign
{
template<class _Tp>
const _Swallow_assign&
operator=(const _Tp&) const
{ return *this; }
};
const _Swallow_assign ignore{};
template<typename... _Types, typename _Alloc>
struct uses_allocator<tuple<_Types...>, _Alloc> : true_type { };
template<class _T1, class _T2>
template<typename... _Args1, typename... _Args2>
inline
pair<_T1, _T2>::
pair(piecewise_construct_t,
tuple<_Args1...> __first, tuple<_Args2...> __second)
: pair(__first, __second,
typename _Build_index_tuple<sizeof...(_Args1)>::__type(),
typename _Build_index_tuple<sizeof...(_Args2)>::__type())
{ }
template<class _T1, class _T2>
template<typename... _Args1, std::size_t... _Indexes1,
typename... _Args2, std::size_t... _Indexes2>
inline
pair<_T1, _T2>::
pair(tuple<_Args1...>& __tuple1, tuple<_Args2...>& __tuple2,
_Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>)
: first(std::forward<_Args1>(std::get<_Indexes1>(__tuple1))...),
second(std::forward<_Args2>(std::get<_Indexes2>(__tuple2))...)
{ }
}
# 56 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/functional" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _MemberPointer>
class _Mem_fn;
template<typename _Tp, typename _Class>
_Mem_fn<_Tp _Class::*>
mem_fn(_Tp _Class::*) noexcept;
template<typename _Functor, typename = __void_t<>>
struct _Maybe_get_result_type
{ };
template<typename _Functor>
struct _Maybe_get_result_type<_Functor,
__void_t<typename _Functor::result_type>>
{ typedef typename _Functor::result_type result_type; };
template<typename _Functor>
struct _Weak_result_type_impl
: _Maybe_get_result_type<_Functor>
{ };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes...)>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes......)>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes...) const>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes......) const>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes...) volatile>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes......) volatile>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes...) const volatile>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes......) const volatile>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(&)(_ArgTypes...)>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(&)(_ArgTypes......)>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(*)(_ArgTypes...)>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(*)(_ArgTypes......)>
{ typedef _Res result_type; };
template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)>
{ typedef _Res result_type; };
template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......)>
{ typedef _Res result_type; };
template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) const>
{ typedef _Res result_type; };
template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) const>
{ typedef _Res result_type; };
template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) volatile>
{ typedef _Res result_type; };
template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) volatile>
{ typedef _Res result_type; };
template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)
const volatile>
{ typedef _Res result_type; };
template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......)
const volatile>
{ typedef _Res result_type; };
template<typename _Functor>
struct _Weak_result_type
: _Weak_result_type_impl<typename remove_cv<_Functor>::type>
{ };
template<typename _Tp, typename _Up = typename decay<_Tp>::type>
struct _Unwrap
{
using type = _Tp&&;
static constexpr _Tp&&
_S_fwd(_Tp& __t) noexcept { return static_cast<_Tp&&>(__t); }
};
template<typename _Tp, typename _Up>
struct _Unwrap<_Tp, reference_wrapper<_Up>>
{
using type = _Up&;
static _Up&
_S_fwd(const _Tp& __t) noexcept { __t.get(); }
};
template<typename _Tp>
inline typename _Unwrap<_Tp>::type
__invfwd(typename remove_reference<_Tp>::type& __t) noexcept
{ return _Unwrap<_Tp>::_S_fwd(__t); }
template<typename _Res, typename _Fn, typename... _Args>
inline _Res
__invoke_impl(__invoke_other, _Fn&& __f, _Args&&... __args)
noexcept(noexcept(std::forward<_Fn>(__f)(std::forward<_Args>(__args)...)))
{ return std::forward<_Fn>(__f)(std::forward<_Args>(__args)...); }
template<typename _Res, typename _MemFun, typename _Tp, typename... _Args>
inline _Res
__invoke_impl(__invoke_memfun_ref, _MemFun&& __f, _Tp&& __t,
_Args&&... __args)
noexcept(noexcept(
(__invfwd<_Tp>(__t).*__f)(std::forward<_Args>(__args)...)))
{ return (__invfwd<_Tp>(__t).*__f)(std::forward<_Args>(__args)...); }
template<typename _Res, typename _MemFun, typename _Tp, typename... _Args>
inline _Res
__invoke_impl(__invoke_memfun_deref, _MemFun&& __f, _Tp&& __t,
_Args&&... __args)
noexcept(noexcept(
((*std::forward<_Tp>(__t)).*__f)(std::forward<_Args>(__args)...)))
{
return ((*std::forward<_Tp>(__t)).*__f)(std::forward<_Args>(__args)...);
}
template<typename _Res, typename _MemFun, typename _Tp, typename... _Args>
inline _Res
__invoke_impl(__invoke_memobj_ref, _MemFun&& __f, _Tp&& __t)
noexcept(noexcept(__invfwd<_Tp>(__t).*__f))
{ return __invfwd<_Tp>(__t).*__f; }
template<typename _Res, typename _MemFun, typename _Tp, typename... _Args>
inline _Res
__invoke_impl(__invoke_memobj_deref, _MemFun&& __f, _Tp&& __t,
_Args&&... __args)
noexcept(noexcept((*std::forward<_Tp>(__t)).*__f))
{ return (*std::forward<_Tp>(__t)).*__f; }
template<typename _Callable, typename... _Args>
inline typename result_of<_Callable&&(_Args&&...)>::type
__invoke(_Callable&& __fn, _Args&&... __args)
{
using __result_of = result_of<_Callable&&(_Args&&...)>;
using __type = typename __result_of::type;
using __tag = typename __result_of::__invoke_type;
return std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn),
std::forward<_Args>(__args)...);
}
# 281 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/functional" 3
template<bool _Unary, bool _Binary, typename _Tp>
struct _Reference_wrapper_base_impl;
template<typename _Tp>
struct _Reference_wrapper_base_impl<false, false, _Tp>
: _Weak_result_type<_Tp>
{ };
template<typename _Tp>
struct _Reference_wrapper_base_impl<true, false, _Tp>
: _Weak_result_type<_Tp>
{
typedef typename _Tp::argument_type argument_type;
};
template<typename _Tp>
struct _Reference_wrapper_base_impl<false, true, _Tp>
: _Weak_result_type<_Tp>
{
typedef typename _Tp::first_argument_type first_argument_type;
typedef typename _Tp::second_argument_type second_argument_type;
};
template<typename _Tp>
struct _Reference_wrapper_base_impl<true, true, _Tp>
: _Weak_result_type<_Tp>
{
typedef typename _Tp::argument_type argument_type;
typedef typename _Tp::first_argument_type first_argument_type;
typedef typename _Tp::second_argument_type second_argument_type;
};
template<typename _Tp, typename = __void_t<>> struct __has_argument_type : false_type { }; template<typename _Tp> struct __has_argument_type<_Tp, __void_t<typename _Tp::argument_type>> : true_type { };
template<typename _Tp, typename = __void_t<>> struct __has_first_argument_type : false_type { }; template<typename _Tp> struct __has_first_argument_type<_Tp, __void_t<typename _Tp::first_argument_type>> : true_type { };
template<typename _Tp, typename = __void_t<>> struct __has_second_argument_type : false_type { }; template<typename _Tp> struct __has_second_argument_type<_Tp, __void_t<typename _Tp::second_argument_type>> : true_type { };
template<typename _Tp>
struct _Reference_wrapper_base
: _Reference_wrapper_base_impl<
__has_argument_type<_Tp>::value,
__has_first_argument_type<_Tp>::value
&& __has_second_argument_type<_Tp>::value,
_Tp>
{ };
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res(_T1)>
: unary_function<_T1, _Res>
{ };
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res(_T1) const>
: unary_function<_T1, _Res>
{ };
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res(_T1) volatile>
: unary_function<_T1, _Res>
{ };
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res(_T1) const volatile>
: unary_function<_T1, _Res>
{ };
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res(_T1, _T2)>
: binary_function<_T1, _T2, _Res>
{ };
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res(_T1, _T2) const>
: binary_function<_T1, _T2, _Res>
{ };
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res(_T1, _T2) volatile>
: binary_function<_T1, _T2, _Res>
{ };
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res(_T1, _T2) const volatile>
: binary_function<_T1, _T2, _Res>
{ };
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res(*)(_T1)>
: unary_function<_T1, _Res>
{ };
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res(*)(_T1, _T2)>
: binary_function<_T1, _T2, _Res>
{ };
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res (_T1::*)()>
: unary_function<_T1*, _Res>
{ };
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res (_T1::*)(_T2)>
: binary_function<_T1*, _T2, _Res>
{ };
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res (_T1::*)() const>
: unary_function<const _T1*, _Res>
{ };
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const>
: binary_function<const _T1*, _T2, _Res>
{ };
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res (_T1::*)() volatile>
: unary_function<volatile _T1*, _Res>
{ };
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res (_T1::*)(_T2) volatile>
: binary_function<volatile _T1*, _T2, _Res>
{ };
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res (_T1::*)() const volatile>
: unary_function<const volatile _T1*, _Res>
{ };
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const volatile>
: binary_function<const volatile _T1*, _T2, _Res>
{ };
template<typename _Tp>
class reference_wrapper
: public _Reference_wrapper_base<typename remove_cv<_Tp>::type>
{
_Tp* _M_data;
public:
typedef _Tp type;
reference_wrapper(_Tp& __indata) noexcept
: _M_data(std::__addressof(__indata))
{ }
reference_wrapper(_Tp&&) = delete;
reference_wrapper(const reference_wrapper&) = default;
reference_wrapper&
operator=(const reference_wrapper&) = default;
operator _Tp&() const noexcept
{ return this->get(); }
_Tp&
get() const noexcept
{ return *_M_data; }
template<typename... _Args>
typename result_of<_Tp&(_Args&&...)>::type
operator()(_Args&&... __args) const
{
return std::__invoke(get(), std::forward<_Args>(__args)...);
}
};
template<typename _Tp>
inline reference_wrapper<_Tp>
ref(_Tp& __t) noexcept
{ return reference_wrapper<_Tp>(__t); }
template<typename _Tp>
inline reference_wrapper<const _Tp>
cref(const _Tp& __t) noexcept
{ return reference_wrapper<const _Tp>(__t); }
template<typename _Tp>
void ref(const _Tp&&) = delete;
template<typename _Tp>
void cref(const _Tp&&) = delete;
template<typename _Tp>
inline reference_wrapper<_Tp>
ref(reference_wrapper<_Tp> __t) noexcept
{ return ref(__t.get()); }
template<typename _Tp>
inline reference_wrapper<const _Tp>
cref(reference_wrapper<_Tp> __t) noexcept
{ return cref(__t.get()); }
template<typename... _Types>
struct _Pack : integral_constant<size_t, sizeof...(_Types)>
{ };
template<typename _From, typename _To, bool = _From::value == _To::value>
struct _AllConvertible : false_type
{ };
template<typename... _From, typename... _To>
struct _AllConvertible<_Pack<_From...>, _Pack<_To...>, true>
: __and_<is_convertible<_From, _To>...>
{ };
template<typename _Tp1, typename _Tp2>
using _NotSame = __not_<is_same<typename std::decay<_Tp1>::type,
typename std::decay<_Tp2>::type>>;
template<typename _Res, typename... _ArgTypes>
struct _Maybe_unary_or_binary_function { };
template<typename _Res, typename _T1>
struct _Maybe_unary_or_binary_function<_Res, _T1>
: std::unary_function<_T1, _Res> { };
template<typename _Res, typename _T1, typename _T2>
struct _Maybe_unary_or_binary_function<_Res, _T1, _T2>
: std::binary_function<_T1, _T2, _Res> { };
template<typename _Signature>
struct _Mem_fn_traits;
template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Mem_fn_traits_base
{
using __result_type = _Res;
using __maybe_type
= _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>;
using __arity = integral_constant<size_t, sizeof...(_ArgTypes)>;
};
# 578 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/functional" 3
template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) > : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) > : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const > : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const > : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile > : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile > : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile > : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile > : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; };
template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) &> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) &> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const &> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const &> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile &> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile &> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile &> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile &> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; };
template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) &&> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) &&> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const &&> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const &&> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile &&> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile &&> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile &&> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile &&> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; };
template<typename _MemFunPtr,
bool __is_mem_fn = is_member_function_pointer<_MemFunPtr>::value>
class _Mem_fn_base
: public _Mem_fn_traits<_MemFunPtr>::__maybe_type
{
using _Traits = _Mem_fn_traits<_MemFunPtr>;
using _Arity = typename _Traits::__arity;
using _Varargs = typename _Traits::__vararg;
template<typename _Func, typename... _BoundArgs>
friend struct _Bind_check_arity;
_MemFunPtr _M_pmf;
public:
using result_type = typename _Traits::__result_type;
explicit constexpr
_Mem_fn_base(_MemFunPtr __pmf) noexcept : _M_pmf(__pmf) { }
template<typename... _Args>
auto
operator()(_Args&&... __args) const
noexcept(noexcept(
std::__invoke(_M_pmf, std::forward<_Args>(__args)...)))
-> decltype(std::__invoke(_M_pmf, std::forward<_Args>(__args)...))
{ return std::__invoke(_M_pmf, std::forward<_Args>(__args)...); }
};
template<typename _MemObjPtr>
class _Mem_fn_base<_MemObjPtr, false>
{
using _Arity = integral_constant<size_t, 0>;
using _Varargs = false_type;
template<typename _Func, typename... _BoundArgs>
friend struct _Bind_check_arity;
_MemObjPtr _M_pm;
public:
explicit constexpr
_Mem_fn_base(_MemObjPtr __pm) noexcept : _M_pm(__pm) { }
template<typename _Tp>
auto
operator()(_Tp&& __obj) const
noexcept(noexcept(std::__invoke(_M_pm, std::forward<_Tp>(__obj))))
-> decltype(std::__invoke(_M_pm, std::forward<_Tp>(__obj)))
{ return std::__invoke(_M_pm, std::forward<_Tp>(__obj)); }
};
template<typename _Res, typename _Class>
struct _Mem_fn<_Res _Class::*>
: _Mem_fn_base<_Res _Class::*>
{
using _Mem_fn_base<_Res _Class::*>::_Mem_fn_base;
};
# 654 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/functional" 3
template<typename _Tp, typename _Class>
inline _Mem_fn<_Tp _Class::*>
mem_fn(_Tp _Class::* __pm) noexcept
{
return _Mem_fn<_Tp _Class::*>(__pm);
}
# 669 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/functional" 3
template<typename _Tp>
struct is_bind_expression
: public false_type { };
# 680 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/functional" 3
template<typename _Tp>
struct is_placeholder
: public integral_constant<int, 0>
{ };
template<int _Num> struct _Placeholder { };
namespace placeholders
{
extern const _Placeholder<1> _1;
extern const _Placeholder<2> _2;
extern const _Placeholder<3> _3;
extern const _Placeholder<4> _4;
extern const _Placeholder<5> _5;
extern const _Placeholder<6> _6;
extern const _Placeholder<7> _7;
extern const _Placeholder<8> _8;
extern const _Placeholder<9> _9;
extern const _Placeholder<10> _10;
extern const _Placeholder<11> _11;
extern const _Placeholder<12> _12;
extern const _Placeholder<13> _13;
extern const _Placeholder<14> _14;
extern const _Placeholder<15> _15;
extern const _Placeholder<16> _16;
extern const _Placeholder<17> _17;
extern const _Placeholder<18> _18;
extern const _Placeholder<19> _19;
extern const _Placeholder<20> _20;
extern const _Placeholder<21> _21;
extern const _Placeholder<22> _22;
extern const _Placeholder<23> _23;
extern const _Placeholder<24> _24;
extern const _Placeholder<25> _25;
extern const _Placeholder<26> _26;
extern const _Placeholder<27> _27;
extern const _Placeholder<28> _28;
extern const _Placeholder<29> _29;
}
template<int _Num>
struct is_placeholder<_Placeholder<_Num> >
: public integral_constant<int, _Num>
{ };
template<int _Num>
struct is_placeholder<const _Placeholder<_Num> >
: public integral_constant<int, _Num>
{ };
template<std::size_t __i, typename _Tuple>
using _Safe_tuple_element_t
= typename enable_if<(__i < tuple_size<_Tuple>::value),
tuple_element<__i, _Tuple>>::type::type;
# 770 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/functional" 3
template<typename _Arg,
bool _IsBindExp = is_bind_expression<_Arg>::value,
bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)>
class _Mu;
template<typename _Tp>
class _Mu<reference_wrapper<_Tp>, false, false>
{
public:
template<typename _CVRef, typename _Tuple>
_Tp&
operator()(_CVRef& __arg, _Tuple&) const volatile
{ return __arg.get(); }
};
template<typename _Arg>
class _Mu<_Arg, true, false>
{
public:
template<typename _CVArg, typename... _Args>
auto
operator()(_CVArg& __arg,
tuple<_Args...>& __tuple) const volatile
-> decltype(__arg(declval<_Args>()...))
{
typedef typename _Build_index_tuple<sizeof...(_Args)>::__type
_Indexes;
return this->__call(__arg, __tuple, _Indexes());
}
private:
template<typename _CVArg, typename... _Args, std::size_t... _Indexes>
auto
__call(_CVArg& __arg, tuple<_Args...>& __tuple,
const _Index_tuple<_Indexes...>&) const volatile
-> decltype(__arg(declval<_Args>()...))
{
return __arg(std::forward<_Args>(std::get<_Indexes>(__tuple))...);
}
};
template<typename _Arg>
class _Mu<_Arg, false, true>
{
public:
template<typename _Tuple>
_Safe_tuple_element_t<(is_placeholder<_Arg>::value - 1), _Tuple>&&
operator()(const volatile _Arg&, _Tuple& __tuple) const volatile
{
using __type
= __tuple_element_t<(is_placeholder<_Arg>::value - 1), _Tuple>;
return std::forward<__type>(
::std::get<(is_placeholder<_Arg>::value - 1)>(__tuple));
}
};
template<typename _Arg>
class _Mu<_Arg, false, false>
{
public:
template<typename _CVArg, typename _Tuple>
_CVArg&&
operator()(_CVArg&& __arg, _Tuple&) const volatile
{ return std::forward<_CVArg>(__arg); }
};
template<typename _Tp>
struct _Maybe_wrap_member_pointer
{
typedef _Tp type;
static constexpr const _Tp&
__do_wrap(const _Tp& __x)
{ return __x; }
static constexpr _Tp&&
__do_wrap(_Tp&& __x)
{ return static_cast<_Tp&&>(__x); }
};
template<typename _Tp, typename _Class>
struct _Maybe_wrap_member_pointer<_Tp _Class::*>
{
typedef _Mem_fn<_Tp _Class::*> type;
static constexpr type
__do_wrap(_Tp _Class::* __pm)
{ return type(__pm); }
};
template<>
struct _Maybe_wrap_member_pointer<void>
{
typedef void type;
};
template<std::size_t _Ind, typename... _Tp>
inline auto
__volget(volatile tuple<_Tp...>& __tuple)
-> __tuple_element_t<_Ind, tuple<_Tp...>> volatile&
{ return std::get<_Ind>(const_cast<tuple<_Tp...>&>(__tuple)); }
template<std::size_t _Ind, typename... _Tp>
inline auto
__volget(const volatile tuple<_Tp...>& __tuple)
-> __tuple_element_t<_Ind, tuple<_Tp...>> const volatile&
{ return std::get<_Ind>(const_cast<const tuple<_Tp...>&>(__tuple)); }
template<typename _Signature>
struct _Bind;
template<typename _Functor, typename... _Bound_args>
class _Bind<_Functor(_Bound_args...)>
: public _Weak_result_type<_Functor>
{
typedef _Bind __self_type;
typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type
_Bound_indexes;
_Functor _M_f;
tuple<_Bound_args...> _M_bound_args;
template<typename _Result, typename... _Args, std::size_t... _Indexes>
_Result
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>)
{
return _M_f(_Mu<_Bound_args>()
(std::get<_Indexes>(_M_bound_args), __args)...);
}
template<typename _Result, typename... _Args, std::size_t... _Indexes>
_Result
__call_c(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const
{
return _M_f(_Mu<_Bound_args>()
(std::get<_Indexes>(_M_bound_args), __args)...);
}
template<typename _Result, typename... _Args, std::size_t... _Indexes>
_Result
__call_v(tuple<_Args...>&& __args,
_Index_tuple<_Indexes...>) volatile
{
return _M_f(_Mu<_Bound_args>()
(__volget<_Indexes>(_M_bound_args), __args)...);
}
template<typename _Result, typename... _Args, std::size_t... _Indexes>
_Result
__call_c_v(tuple<_Args...>&& __args,
_Index_tuple<_Indexes...>) const volatile
{
return _M_f(_Mu<_Bound_args>()
(__volget<_Indexes>(_M_bound_args), __args)...);
}
public:
template<typename... _Args>
explicit _Bind(const _Functor& __f, _Args&&... __args)
: _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
{ }
template<typename... _Args>
explicit _Bind(_Functor&& __f, _Args&&... __args)
: _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...)
{ }
_Bind(const _Bind&) = default;
_Bind(_Bind&& __b)
: _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args))
{ }
template<typename... _Args, typename _Result
= decltype( std::declval<_Functor&>()(
_Mu<_Bound_args>()( std::declval<_Bound_args&>(),
std::declval<tuple<_Args...>&>() )... ) )>
_Result
operator()(_Args&&... __args)
{
return this->__call<_Result>(
std::forward_as_tuple(std::forward<_Args>(__args)...),
_Bound_indexes());
}
template<typename... _Args, typename _Result
= decltype( std::declval<typename enable_if<(sizeof...(_Args) >= 0),
typename add_const<_Functor>::type&>::type>()(
_Mu<_Bound_args>()( std::declval<const _Bound_args&>(),
std::declval<tuple<_Args...>&>() )... ) )>
_Result
operator()(_Args&&... __args) const
{
return this->__call_c<_Result>(
std::forward_as_tuple(std::forward<_Args>(__args)...),
_Bound_indexes());
}
template<typename... _Args, typename _Result
= decltype( std::declval<typename enable_if<(sizeof...(_Args) >= 0),
typename add_volatile<_Functor>::type&>::type>()(
_Mu<_Bound_args>()( std::declval<volatile _Bound_args&>(),
std::declval<tuple<_Args...>&>() )... ) )>
_Result
operator()(_Args&&... __args) volatile
{
return this->__call_v<_Result>(
std::forward_as_tuple(std::forward<_Args>(__args)...),
_Bound_indexes());
}
template<typename... _Args, typename _Result
= decltype( std::declval<typename enable_if<(sizeof...(_Args) >= 0),
typename add_cv<_Functor>::type&>::type>()(
_Mu<_Bound_args>()( std::declval<const volatile _Bound_args&>(),
std::declval<tuple<_Args...>&>() )... ) )>
_Result
operator()(_Args&&... __args) const volatile
{
return this->__call_c_v<_Result>(
std::forward_as_tuple(std::forward<_Args>(__args)...),
_Bound_indexes());
}
};
template<typename _Result, typename _Signature>
struct _Bind_result;
template<typename _Result, typename _Functor, typename... _Bound_args>
class _Bind_result<_Result, _Functor(_Bound_args...)>
{
typedef _Bind_result __self_type;
typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type
_Bound_indexes;
_Functor _M_f;
tuple<_Bound_args...> _M_bound_args;
template<typename _Res>
struct __enable_if_void : enable_if<is_void<_Res>::value, int> { };
template<typename _Res>
struct __disable_if_void : enable_if<!is_void<_Res>::value, int> { };
template<typename _Res, typename... _Args, std::size_t... _Indexes>
_Result
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
typename __disable_if_void<_Res>::type = 0)
{
return _M_f(_Mu<_Bound_args>()
(std::get<_Indexes>(_M_bound_args), __args)...);
}
template<typename _Res, typename... _Args, std::size_t... _Indexes>
void
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
typename __enable_if_void<_Res>::type = 0)
{
_M_f(_Mu<_Bound_args>()
(std::get<_Indexes>(_M_bound_args), __args)...);
}
template<typename _Res, typename... _Args, std::size_t... _Indexes>
_Result
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
typename __disable_if_void<_Res>::type = 0) const
{
return _M_f(_Mu<_Bound_args>()
(std::get<_Indexes>(_M_bound_args), __args)...);
}
template<typename _Res, typename... _Args, std::size_t... _Indexes>
void
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
typename __enable_if_void<_Res>::type = 0) const
{
_M_f(_Mu<_Bound_args>()
(std::get<_Indexes>(_M_bound_args), __args)...);
}
template<typename _Res, typename... _Args, std::size_t... _Indexes>
_Result
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
typename __disable_if_void<_Res>::type = 0) volatile
{
return _M_f(_Mu<_Bound_args>()
(__volget<_Indexes>(_M_bound_args), __args)...);
}
template<typename _Res, typename... _Args, std::size_t... _Indexes>
void
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
typename __enable_if_void<_Res>::type = 0) volatile
{
_M_f(_Mu<_Bound_args>()
(__volget<_Indexes>(_M_bound_args), __args)...);
}
template<typename _Res, typename... _Args, std::size_t... _Indexes>
_Result
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
typename __disable_if_void<_Res>::type = 0) const volatile
{
return _M_f(_Mu<_Bound_args>()
(__volget<_Indexes>(_M_bound_args), __args)...);
}
template<typename _Res, typename... _Args, std::size_t... _Indexes>
void
__call(tuple<_Args...>&& __args,
_Index_tuple<_Indexes...>,
typename __enable_if_void<_Res>::type = 0) const volatile
{
_M_f(_Mu<_Bound_args>()
(__volget<_Indexes>(_M_bound_args), __args)...);
}
public:
typedef _Result result_type;
template<typename... _Args>
explicit _Bind_result(const _Functor& __f, _Args&&... __args)
: _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
{ }
template<typename... _Args>
explicit _Bind_result(_Functor&& __f, _Args&&... __args)
: _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...)
{ }
_Bind_result(const _Bind_result&) = default;
_Bind_result(_Bind_result&& __b)
: _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args))
{ }
template<typename... _Args>
result_type
operator()(_Args&&... __args)
{
return this->__call<_Result>(
std::forward_as_tuple(std::forward<_Args>(__args)...),
_Bound_indexes());
}
template<typename... _Args>
result_type
operator()(_Args&&... __args) const
{
return this->__call<_Result>(
std::forward_as_tuple(std::forward<_Args>(__args)...),
_Bound_indexes());
}
template<typename... _Args>
result_type
operator()(_Args&&... __args) volatile
{
return this->__call<_Result>(
std::forward_as_tuple(std::forward<_Args>(__args)...),
_Bound_indexes());
}
template<typename... _Args>
result_type
operator()(_Args&&... __args) const volatile
{
return this->__call<_Result>(
std::forward_as_tuple(std::forward<_Args>(__args)...),
_Bound_indexes());
}
};
template<typename _Signature>
struct is_bind_expression<_Bind<_Signature> >
: public true_type { };
template<typename _Signature>
struct is_bind_expression<const _Bind<_Signature> >
: public true_type { };
template<typename _Signature>
struct is_bind_expression<volatile _Bind<_Signature> >
: public true_type { };
template<typename _Signature>
struct is_bind_expression<const volatile _Bind<_Signature>>
: public true_type { };
template<typename _Result, typename _Signature>
struct is_bind_expression<_Bind_result<_Result, _Signature>>
: public true_type { };
template<typename _Result, typename _Signature>
struct is_bind_expression<const _Bind_result<_Result, _Signature>>
: public true_type { };
template<typename _Result, typename _Signature>
struct is_bind_expression<volatile _Bind_result<_Result, _Signature>>
: public true_type { };
template<typename _Result, typename _Signature>
struct is_bind_expression<const volatile _Bind_result<_Result, _Signature>>
: public true_type { };
template<typename _Func, typename... _BoundArgs>
struct _Bind_check_arity { };
template<typename _Ret, typename... _Args, typename... _BoundArgs>
struct _Bind_check_arity<_Ret (*)(_Args...), _BoundArgs...>
{
static_assert(sizeof...(_BoundArgs) == sizeof...(_Args),
"Wrong number of arguments for function");
};
template<typename _Ret, typename... _Args, typename... _BoundArgs>
struct _Bind_check_arity<_Ret (*)(_Args......), _BoundArgs...>
{
static_assert(sizeof...(_BoundArgs) >= sizeof...(_Args),
"Wrong number of arguments for function");
};
template<typename _Tp, typename _Class, typename... _BoundArgs>
struct _Bind_check_arity<_Tp _Class::*, _BoundArgs...>
{
using _Arity = typename _Mem_fn<_Tp _Class::*>::_Arity;
using _Varargs = typename _Mem_fn<_Tp _Class::*>::_Varargs;
static_assert(_Varargs::value
? sizeof...(_BoundArgs) >= _Arity::value + 1
: sizeof...(_BoundArgs) == _Arity::value + 1,
"Wrong number of arguments for pointer-to-member");
};
template<typename _Tp, typename _Tp2 = typename decay<_Tp>::type>
using __is_socketlike = __or_<is_integral<_Tp2>, is_enum<_Tp2>>;
template<bool _SocketLike, typename _Func, typename... _BoundArgs>
struct _Bind_helper
: _Bind_check_arity<typename decay<_Func>::type, _BoundArgs...>
{
typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type>
__maybe_type;
typedef typename __maybe_type::type __func_type;
typedef _Bind<__func_type(typename decay<_BoundArgs>::type...)> type;
};
template<typename _Func, typename... _BoundArgs>
struct _Bind_helper<true, _Func, _BoundArgs...>
{ };
template<typename _Func, typename... _BoundArgs>
inline typename
_Bind_helper<__is_socketlike<_Func>::value, _Func, _BoundArgs...>::type
bind(_Func&& __f, _BoundArgs&&... __args)
{
typedef _Bind_helper<false, _Func, _BoundArgs...> __helper_type;
typedef typename __helper_type::__maybe_type __maybe_type;
typedef typename __helper_type::type __result_type;
return __result_type(__maybe_type::__do_wrap(std::forward<_Func>(__f)),
std::forward<_BoundArgs>(__args)...);
}
template<typename _Result, typename _Func, typename... _BoundArgs>
struct _Bindres_helper
: _Bind_check_arity<typename decay<_Func>::type, _BoundArgs...>
{
typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type>
__maybe_type;
typedef typename __maybe_type::type __functor_type;
typedef _Bind_result<_Result,
__functor_type(typename decay<_BoundArgs>::type...)>
type;
};
template<typename _Result, typename _Func, typename... _BoundArgs>
inline
typename _Bindres_helper<_Result, _Func, _BoundArgs...>::type
bind(_Func&& __f, _BoundArgs&&... __args)
{
typedef _Bindres_helper<_Result, _Func, _BoundArgs...> __helper_type;
typedef typename __helper_type::__maybe_type __maybe_type;
typedef typename __helper_type::type __result_type;
return __result_type(__maybe_type::__do_wrap(std::forward<_Func>(__f)),
std::forward<_BoundArgs>(__args)...);
}
template<typename _Signature>
struct _Bind_simple;
template<typename _Callable, typename... _Args>
struct _Bind_simple<_Callable(_Args...)>
{
typedef typename result_of<_Callable(_Args...)>::type result_type;
template<typename _Tp, typename... _Up>
explicit
_Bind_simple(_Tp&& __f, _Up&&... __args)
: _M_bound(std::forward<_Tp>(__f), std::forward<_Up>(__args)...)
{ }
_Bind_simple(const _Bind_simple&) = default;
_Bind_simple(_Bind_simple&&) = default;
result_type
operator()()
{
typedef typename _Build_index_tuple<sizeof...(_Args)>::__type _Indices;
return _M_invoke(_Indices());
}
private:
template<std::size_t... _Indices>
typename result_of<_Callable(_Args...)>::type
_M_invoke(_Index_tuple<_Indices...>)
{
return std::forward<_Callable>(std::get<0>(_M_bound))(
std::forward<_Args>(std::get<_Indices+1>(_M_bound))...);
}
std::tuple<_Callable, _Args...> _M_bound;
};
template<typename _Func, typename... _BoundArgs>
struct _Bind_simple_helper
: _Bind_check_arity<typename decay<_Func>::type, _BoundArgs...>
{
typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type>
__maybe_type;
typedef typename __maybe_type::type __func_type;
typedef _Bind_simple<__func_type(typename decay<_BoundArgs>::type...)>
__type;
};
template<typename _Callable, typename... _Args>
typename _Bind_simple_helper<_Callable, _Args...>::__type
__bind_simple(_Callable&& __callable, _Args&&... __args)
{
typedef _Bind_simple_helper<_Callable, _Args...> __helper_type;
typedef typename __helper_type::__maybe_type __maybe_type;
typedef typename __helper_type::__type __result_type;
return __result_type(
__maybe_type::__do_wrap( std::forward<_Callable>(__callable)),
std::forward<_Args>(__args)...);
}
class bad_function_call : public std::exception
{
public:
virtual ~bad_function_call() noexcept;
const char* what() const noexcept;
};
template<typename _Tp>
struct __is_location_invariant
: is_trivially_copyable<_Tp>::type
{ };
class _Undefined_class;
union _Nocopy_types
{
void* _M_object;
const void* _M_const_object;
void (*_M_function_pointer)();
void (_Undefined_class::*_M_member_pointer)();
};
union _Any_data
{
void* _M_access() { return &_M_pod_data[0]; }
const void* _M_access() const { return &_M_pod_data[0]; }
template<typename _Tp>
_Tp&
_M_access()
{ return *static_cast<_Tp*>(_M_access()); }
template<typename _Tp>
const _Tp&
_M_access() const
{ return *static_cast<const _Tp*>(_M_access()); }
_Nocopy_types _M_unused;
char _M_pod_data[sizeof(_Nocopy_types)];
};
enum _Manager_operation
{
__get_type_info,
__get_functor_ptr,
__clone_functor,
__destroy_functor
};
template<typename _Tp>
struct _Simple_type_wrapper
{
_Simple_type_wrapper(_Tp __value) : __value(__value) { }
_Tp __value;
};
template<typename _Tp>
struct __is_location_invariant<_Simple_type_wrapper<_Tp> >
: __is_location_invariant<_Tp>
{ };
template<typename _Functor>
inline _Functor&
__callable_functor(_Functor& __f)
{ return __f; }
template<typename _Member, typename _Class>
inline _Mem_fn<_Member _Class::*>
__callable_functor(_Member _Class::* &__p)
{ return std::mem_fn(__p); }
template<typename _Member, typename _Class>
inline _Mem_fn<_Member _Class::*>
__callable_functor(_Member _Class::* const &__p)
{ return std::mem_fn(__p); }
template<typename _Member, typename _Class>
inline _Mem_fn<_Member _Class::*>
__callable_functor(_Member _Class::* volatile &__p)
{ return std::mem_fn(__p); }
template<typename _Member, typename _Class>
inline _Mem_fn<_Member _Class::*>
__callable_functor(_Member _Class::* const volatile &__p)
{ return std::mem_fn(__p); }
template<typename _Signature>
class function;
class _Function_base
{
public:
static const std::size_t _M_max_size = sizeof(_Nocopy_types);
static const std::size_t _M_max_align = __alignof__(_Nocopy_types);
template<typename _Functor>
class _Base_manager
{
protected:
static const bool __stored_locally =
(__is_location_invariant<_Functor>::value
&& sizeof(_Functor) <= _M_max_size
&& __alignof__(_Functor) <= _M_max_align
&& (_M_max_align % __alignof__(_Functor) == 0));
typedef integral_constant<bool, __stored_locally> _Local_storage;
static _Functor*
_M_get_pointer(const _Any_data& __source)
{
const _Functor* __ptr =
__stored_locally? std::__addressof(__source._M_access<_Functor>())
: __source._M_access<_Functor*>();
return const_cast<_Functor*>(__ptr);
}
static void
_M_clone(_Any_data& __dest, const _Any_data& __source, true_type)
{
new (__dest._M_access()) _Functor(__source._M_access<_Functor>());
}
static void
_M_clone(_Any_data& __dest, const _Any_data& __source, false_type)
{
__dest._M_access<_Functor*>() =
new _Functor(*__source._M_access<_Functor*>());
}
static void
_M_destroy(_Any_data& __victim, true_type)
{
__victim._M_access<_Functor>().~_Functor();
}
static void
_M_destroy(_Any_data& __victim, false_type)
{
delete __victim._M_access<_Functor*>();
}
public:
static bool
_M_manager(_Any_data& __dest, const _Any_data& __source,
_Manager_operation __op)
{
switch (__op)
{
case __get_type_info:
__dest._M_access<const type_info*>() = &typeid(_Functor);
break;
case __get_functor_ptr:
__dest._M_access<_Functor*>() = _M_get_pointer(__source);
break;
case __clone_functor:
_M_clone(__dest, __source, _Local_storage());
break;
case __destroy_functor:
_M_destroy(__dest, _Local_storage());
break;
}
return false;
}
static void
_M_init_functor(_Any_data& __functor, _Functor&& __f)
{ _M_init_functor(__functor, std::move(__f), _Local_storage()); }
template<typename _Signature>
static bool
_M_not_empty_function(const function<_Signature>& __f)
{ return static_cast<bool>(__f); }
template<typename _Tp>
static bool
_M_not_empty_function(_Tp* __fp)
{ return __fp != nullptr; }
template<typename _Class, typename _Tp>
static bool
_M_not_empty_function(_Tp _Class::* __mp)
{ return __mp != nullptr; }
template<typename _Tp>
static bool
_M_not_empty_function(const _Tp&)
{ return true; }
private:
static void
_M_init_functor(_Any_data& __functor, _Functor&& __f, true_type)
{ new (__functor._M_access()) _Functor(std::move(__f)); }
static void
_M_init_functor(_Any_data& __functor, _Functor&& __f, false_type)
{ __functor._M_access<_Functor*>() = new _Functor(std::move(__f)); }
};
template<typename _Functor>
class _Ref_manager : public _Base_manager<_Functor*>
{
typedef _Function_base::_Base_manager<_Functor*> _Base;
public:
static bool
_M_manager(_Any_data& __dest, const _Any_data& __source,
_Manager_operation __op)
{
switch (__op)
{
case __get_type_info:
__dest._M_access<const type_info*>() = &typeid(_Functor);
break;
case __get_functor_ptr:
__dest._M_access<_Functor*>() = *_Base::_M_get_pointer(__source);
return is_const<_Functor>::value;
break;
default:
_Base::_M_manager(__dest, __source, __op);
}
return false;
}
static void
_M_init_functor(_Any_data& __functor, reference_wrapper<_Functor> __f)
{
_Base::_M_init_functor(__functor, std::__addressof(__f.get()));
}
};
_Function_base() : _M_manager(nullptr) { }
~_Function_base()
{
if (_M_manager)
_M_manager(_M_functor, _M_functor, __destroy_functor);
}
bool _M_empty() const { return !_M_manager; }
typedef bool (*_Manager_type)(_Any_data&, const _Any_data&,
_Manager_operation);
_Any_data _M_functor;
_Manager_type _M_manager;
};
template<typename _Signature, typename _Functor>
class _Function_handler;
template<typename _Res, typename _Functor, typename... _ArgTypes>
class _Function_handler<_Res(_ArgTypes...), _Functor>
: public _Function_base::_Base_manager<_Functor>
{
typedef _Function_base::_Base_manager<_Functor> _Base;
public:
static _Res
_M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
{
return (*_Base::_M_get_pointer(__functor))(
std::forward<_ArgTypes>(__args)...);
}
};
template<typename _Functor, typename... _ArgTypes>
class _Function_handler<void(_ArgTypes...), _Functor>
: public _Function_base::_Base_manager<_Functor>
{
typedef _Function_base::_Base_manager<_Functor> _Base;
public:
static void
_M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
{
(*_Base::_M_get_pointer(__functor))(
std::forward<_ArgTypes>(__args)...);
}
};
template<typename _Res, typename _Functor, typename... _ArgTypes>
class _Function_handler<_Res(_ArgTypes...), reference_wrapper<_Functor> >
: public _Function_base::_Ref_manager<_Functor>
{
typedef _Function_base::_Ref_manager<_Functor> _Base;
public:
static _Res
_M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
{
return std::__callable_functor(**_Base::_M_get_pointer(__functor))(
std::forward<_ArgTypes>(__args)...);
}
};
template<typename _Functor, typename... _ArgTypes>
class _Function_handler<void(_ArgTypes...), reference_wrapper<_Functor> >
: public _Function_base::_Ref_manager<_Functor>
{
typedef _Function_base::_Ref_manager<_Functor> _Base;
public:
static void
_M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
{
std::__callable_functor(**_Base::_M_get_pointer(__functor))(
std::forward<_ArgTypes>(__args)...);
}
};
template<typename _Class, typename _Member, typename _Res,
typename... _ArgTypes>
class _Function_handler<_Res(_ArgTypes...), _Member _Class::*>
: public _Function_handler<void(_ArgTypes...), _Member _Class::*>
{
typedef _Function_handler<void(_ArgTypes...), _Member _Class::*>
_Base;
public:
static _Res
_M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
{
return std::mem_fn(_Base::_M_get_pointer(__functor)->__value)(
std::forward<_ArgTypes>(__args)...);
}
};
template<typename _Class, typename _Member, typename... _ArgTypes>
class _Function_handler<void(_ArgTypes...), _Member _Class::*>
: public _Function_base::_Base_manager<
_Simple_type_wrapper< _Member _Class::* > >
{
typedef _Member _Class::* _Functor;
typedef _Simple_type_wrapper<_Functor> _Wrapper;
typedef _Function_base::_Base_manager<_Wrapper> _Base;
public:
static bool
_M_manager(_Any_data& __dest, const _Any_data& __source,
_Manager_operation __op)
{
switch (__op)
{
case __get_type_info:
__dest._M_access<const type_info*>() = &typeid(_Functor);
break;
case __get_functor_ptr:
__dest._M_access<_Functor*>() =
&_Base::_M_get_pointer(__source)->__value;
break;
default:
_Base::_M_manager(__dest, __source, __op);
}
return false;
}
static void
_M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
{
std::mem_fn(_Base::_M_get_pointer(__functor)->__value)(
std::forward<_ArgTypes>(__args)...);
}
};
template<typename _From, typename _To>
using __check_func_return_type
= __or_<is_void<_To>, is_same<_From, _To>, is_convertible<_From, _To>>;
template<typename _Res, typename... _ArgTypes>
class function<_Res(_ArgTypes...)>
: public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>,
private _Function_base
{
typedef _Res _Signature_type(_ArgTypes...);
template<typename _Func,
typename _Res2 = typename result_of<_Func&(_ArgTypes...)>::type>
struct _Callable : __check_func_return_type<_Res2, _Res> { };
template<typename _Tp>
struct _Callable<function, _Tp> : false_type { };
template<typename _Cond, typename _Tp>
using _Requires = typename enable_if<_Cond::value, _Tp>::type;
public:
typedef _Res result_type;
function() noexcept
: _Function_base() { }
function(nullptr_t) noexcept
: _Function_base() { }
# 1888 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/functional" 3
function(const function& __x);
# 1897 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/functional" 3
function(function&& __x) : _Function_base()
{
__x.swap(*this);
}
# 1920 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/functional" 3
template<typename _Functor,
typename = _Requires<__not_<is_same<_Functor, function>>, void>,
typename = _Requires<_Callable<_Functor>, void>>
function(_Functor);
# 1937 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/functional" 3
function&
operator=(const function& __x)
{
function(__x).swap(*this);
return *this;
}
# 1955 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/functional" 3
function&
operator=(function&& __x)
{
function(std::move(__x)).swap(*this);
return *this;
}
# 1969 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/functional" 3
function&
operator=(nullptr_t) noexcept
{
if (_M_manager)
{
_M_manager(_M_functor, _M_functor, __destroy_functor);
_M_manager = nullptr;
_M_invoker = nullptr;
}
return *this;
}
# 1997 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/functional" 3
template<typename _Functor>
_Requires<_Callable<typename decay<_Functor>::type>, function&>
operator=(_Functor&& __f)
{
function(std::forward<_Functor>(__f)).swap(*this);
return *this;
}
template<typename _Functor>
function&
operator=(reference_wrapper<_Functor> __f) noexcept
{
function(__f).swap(*this);
return *this;
}
# 2023 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/functional" 3
void swap(function& __x)
{
std::swap(_M_functor, __x._M_functor);
std::swap(_M_manager, __x._M_manager);
std::swap(_M_invoker, __x._M_invoker);
}
# 2051 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/functional" 3
explicit operator bool() const noexcept
{ return !_M_empty(); }
# 2064 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/functional" 3
_Res operator()(_ArgTypes... __args) const;
# 2077 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/functional" 3
const type_info& target_type() const noexcept;
# 2088 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/functional" 3
template<typename _Functor> _Functor* target() noexcept;
template<typename _Functor> const _Functor* target() const noexcept;
private:
using _Invoker_type = _Res (*)(const _Any_data&, _ArgTypes&&...);
_Invoker_type _M_invoker;
};
template<typename _Res, typename... _ArgTypes>
function<_Res(_ArgTypes...)>::
function(const function& __x)
: _Function_base()
{
if (static_cast<bool>(__x))
{
__x._M_manager(_M_functor, __x._M_functor, __clone_functor);
_M_invoker = __x._M_invoker;
_M_manager = __x._M_manager;
}
}
template<typename _Res, typename... _ArgTypes>
template<typename _Functor, typename, typename>
function<_Res(_ArgTypes...)>::
function(_Functor __f)
: _Function_base()
{
typedef _Function_handler<_Signature_type, _Functor> _My_handler;
if (_My_handler::_M_not_empty_function(__f))
{
_My_handler::_M_init_functor(_M_functor, std::move(__f));
_M_invoker = &_My_handler::_M_invoke;
_M_manager = &_My_handler::_M_manager;
}
}
template<typename _Res, typename... _ArgTypes>
_Res
function<_Res(_ArgTypes...)>::
operator()(_ArgTypes... __args) const
{
if (_M_empty())
__throw_bad_function_call();
return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...);
}
template<typename _Res, typename... _ArgTypes>
const type_info&
function<_Res(_ArgTypes...)>::
target_type() const noexcept
{
if (_M_manager)
{
_Any_data __typeinfo_result;
_M_manager(__typeinfo_result, _M_functor, __get_type_info);
return *__typeinfo_result._M_access<const type_info*>();
}
else
return typeid(void);
}
template<typename _Res, typename... _ArgTypes>
template<typename _Functor>
_Functor*
function<_Res(_ArgTypes...)>::
target() noexcept
{
if (typeid(_Functor) == target_type() && _M_manager)
{
_Any_data __ptr;
if (_M_manager(__ptr, _M_functor, __get_functor_ptr)
&& !is_const<_Functor>::value)
return 0;
else
return __ptr._M_access<_Functor*>();
}
else
return 0;
}
template<typename _Res, typename... _ArgTypes>
template<typename _Functor>
const _Functor*
function<_Res(_ArgTypes...)>::
target() const noexcept
{
if (typeid(_Functor) == target_type() && _M_manager)
{
_Any_data __ptr;
_M_manager(__ptr, _M_functor, __get_functor_ptr);
return __ptr._M_access<const _Functor*>();
}
else
return 0;
}
# 2200 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/functional" 3
template<typename _Res, typename... _Args>
inline bool
operator==(const function<_Res(_Args...)>& __f, nullptr_t) noexcept
{ return !static_cast<bool>(__f); }
template<typename _Res, typename... _Args>
inline bool
operator==(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
{ return !static_cast<bool>(__f); }
# 2218 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/functional" 3
template<typename _Res, typename... _Args>
inline bool
operator!=(const function<_Res(_Args...)>& __f, nullptr_t) noexcept
{ return static_cast<bool>(__f); }
template<typename _Res, typename... _Args>
inline bool
operator!=(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
{ return static_cast<bool>(__f); }
# 2236 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/functional" 3
template<typename _Res, typename... _Args>
inline void
swap(function<_Res(_Args...)>& __x, function<_Res(_Args...)>& __y)
{ __x.swap(__y); }
}
# 224 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h" 2
# 292 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
# 292 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
class half;
namespace detail
{
# 311 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
template<bool,typename T,typename> struct conditional { typedef T type; };
template<typename T,typename F> struct conditional<false,T,F> { typedef F type; };
template<bool> struct bool_type {};
typedef bool_type<true> true_type;
typedef bool_type<false> false_type;
template<typename> struct is_float : false_type {};
template<typename T> struct is_float<const T> : is_float<T> {};
template<typename T> struct is_float<volatile T> : is_float<T> {};
template<typename T> struct is_float<const volatile T> : is_float<T> {};
template<> struct is_float<float> : true_type {};
template<> struct is_float<double> : true_type {};
template<> struct is_float<long double> : true_type {};
typedef std::uint_least16_t uint16;
typedef std::uint_least32_t uint32;
typedef std::int_fast32_t int17;
# 350 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
struct binary_t {};
constexpr binary_t binary = binary_t();
struct expr
{
explicit constexpr expr(float f) : value_(f) {}
constexpr operator float() const { return value_; }
private:
float value_;
};
template<typename T,typename,typename=void,typename=void> struct enable {};
template<typename T> struct enable<T,half,void,void> { typedef T type; };
template<typename T> struct enable<T,float,void,void> { typedef T type; };
template<typename T> struct enable<T,double,void,void> { typedef T type; };
template<typename T> struct enable<T,long long,void,void> { typedef T type; };
template<typename T> struct enable<T,unsigned long long,void,void> { typedef T type; };
template<typename T> struct enable<T,long,void,void> { typedef T type; };
template<typename T> struct enable<T,unsigned long,void,void> { typedef T type; };
template<typename T> struct enable<T,int,void,void> { typedef T type; };
template<typename T> struct enable<T,unsigned int,void,void> { typedef T type; };
template<typename T> struct enable<T,short,void,void> { typedef T type; };
template<typename T> struct enable<T,unsigned short,void,void> { typedef T type; };
template<typename T> struct enable<T,char,void,void> { typedef T type; };
template<typename T> struct enable<T,unsigned char,void,void> { typedef T type; };
template<typename T> struct enable<T,expr,void,void> { typedef T type; };
template<typename T> struct enable<T,half,half,void> { typedef T type; };
template<typename T> struct enable<T,half,long long,void> { typedef T type; };
template<typename T> struct enable<T,half,unsigned long long,void> { typedef T type; };
template<typename T> struct enable<T,half,long,void> { typedef T type; };
template<typename T> struct enable<T,half,unsigned long,void> { typedef T type; };
template<typename T> struct enable<T,half,int,void> { typedef T type; };
template<typename T> struct enable<T,half,unsigned int,void> { typedef T type; };
template<typename T> struct enable<T,half,short,void> { typedef T type; };
template<typename T> struct enable<T,half,unsigned short,void> { typedef T type; };
template<typename T> struct enable<T,half,char,void> { typedef T type; };
template<typename T> struct enable<T,half,unsigned char,void> { typedef T type; };
template<typename T> struct enable<T,float,half,void> { typedef float type; };
template<typename T> struct enable<T,half,float,void> { typedef float type; };
template<typename T> struct enable<T,double,half,void> { typedef double type; };
template<typename T> struct enable<T,half,double,void> { typedef double type; };
template<typename T> struct enable<T,half,expr,void> { typedef T type; };
template<typename T> struct enable<T,expr,half,void> { typedef T type; };
template<typename T> struct enable<T,expr,expr,void> { typedef T type; };
template<typename T> struct enable<T,half,half,half> { typedef T type; };
template<typename T> struct enable<T,half,half,expr> { typedef T type; };
template<typename T> struct enable<T,half,expr,half> { typedef T type; };
template<typename T> struct enable<T,half,expr,expr> { typedef T type; };
template<typename T> struct enable<T,expr,half,half> { typedef T type; };
template<typename T> struct enable<T,expr,half,expr> { typedef T type; };
template<typename T> struct enable<T,expr,expr,half> { typedef T type; };
template<typename T> struct enable<T,expr,expr,expr> { typedef T type; };
template<typename T,typename U> struct result : enable<expr,T,U> {};
template<> struct result<half,half> { typedef half type; };
# 434 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
template<typename T> bool builtin_isinf(T arg)
{
return std::isinf(arg);
}
template<typename T> bool builtin_isnan(T arg)
{
return std::isnan(arg);
}
template<typename T> bool builtin_signbit(T arg)
{
return std::signbit(arg);
}
# 484 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
template<std::float_round_style R> uint16 float2half_impl(float value, true_type)
{
static_assert(std::numeric_limits<float>::is_iec559, "float to half conversion needs IEEE 754 conformant 'float' type");
static_assert(sizeof(uint32)==sizeof(float), "float to half conversion needs unsigned integer type of exactly the size of a 'float'");
static const uint16 base_table[512] = {
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080, 0x0100,
0x0200, 0x0400, 0x0800, 0x0C00, 0x1000, 0x1400, 0x1800, 0x1C00, 0x2000, 0x2400, 0x2800, 0x2C00, 0x3000, 0x3400, 0x3800, 0x3C00,
0x4000, 0x4400, 0x4800, 0x4C00, 0x5000, 0x5400, 0x5800, 0x5C00, 0x6000, 0x6400, 0x6800, 0x6C00, 0x7000, 0x7400, 0x7800, 0x7C00,
0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00,
0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00,
0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00,
0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00,
0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00,
0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00,
0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00,
0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8001, 0x8002, 0x8004, 0x8008, 0x8010, 0x8020, 0x8040, 0x8080, 0x8100,
0x8200, 0x8400, 0x8800, 0x8C00, 0x9000, 0x9400, 0x9800, 0x9C00, 0xA000, 0xA400, 0xA800, 0xAC00, 0xB000, 0xB400, 0xB800, 0xBC00,
0xC000, 0xC400, 0xC800, 0xCC00, 0xD000, 0xD400, 0xD800, 0xDC00, 0xE000, 0xE400, 0xE800, 0xEC00, 0xF000, 0xF400, 0xF800, 0xFC00,
0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00,
0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00,
0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00,
0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00,
0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00,
0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00,
0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00 };
static const unsigned char shift_table[512] = {
24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
24, 24, 24, 24, 24, 24, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 13,
24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
24, 24, 24, 24, 24, 24, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 13 };
uint32 bits;
std::memcpy(&bits, &value, sizeof(float));
uint16 hbits = base_table[bits>>23] + static_cast<uint16>((bits&0x7FFFFF)>>shift_table[bits>>23]);
if(R == std::round_to_nearest)
hbits += (((bits&0x7FFFFF)>>(shift_table[bits>>23]-1))|(((bits>>23)&0xFF)==102)) & ((hbits&0x7C00)!=0x7C00)
& (((((static_cast<uint32>(1)<<(shift_table[bits>>23]-1))-1)&bits)!=0)|hbits)
;
else if(R == std::round_toward_zero)
hbits -= ((hbits&0x7FFF)==0x7C00) & ~shift_table[bits>>23];
else if(R == std::round_toward_infinity)
hbits += ((((bits&0x7FFFFF&((static_cast<uint32>(1)<<(shift_table[bits>>23]))-1))!=0)|(((bits>>23)<=102)&
((bits>>23)!=0)))&(hbits<0x7C00)) - ((hbits==0xFC00)&((bits>>23)!=511));
else if(R == std::round_toward_neg_infinity)
hbits += ((((bits&0x7FFFFF&((static_cast<uint32>(1)<<(shift_table[bits>>23]))-1))!=0)|(((bits>>23)<=358)&
((bits>>23)!=256)))&(hbits<0xFC00)&(hbits>>15)) - ((hbits==0x7C00)&((bits>>23)!=255));
return hbits;
}
template<std::float_round_style R> uint16 float2half_impl(float value, false_type)
{
uint16 hbits = builtin_signbit(value) << 15;
if(value == 0.0f)
return hbits;
if(builtin_isnan(value))
return hbits | 0x7FFF;
if(builtin_isinf(value))
return hbits | 0x7C00;
int exp;
std::frexp(value, &exp);
if(exp > 16)
{
if(R == std::round_toward_zero)
return hbits | 0x7BFF;
else if(R == std::round_toward_infinity)
return hbits | 0x7C00 - (hbits>>15);
else if(R == std::round_toward_neg_infinity)
return hbits | 0x7BFF + (hbits>>15);
return hbits | 0x7C00;
}
if(exp < -13)
value = std::ldexp(value, 24);
else
{
value = std::ldexp(value, 11-exp);
hbits |= ((exp+14)<<10);
}
int ival = static_cast<int>(value);
hbits |= static_cast<uint16>(std::abs(ival)&0x3FF);
if(R == std::round_to_nearest)
{
float diff = std::abs(value-static_cast<float>(ival));
hbits += (diff>0.5f) | ((diff==0.5f)&hbits);
}
else if(R == std::round_toward_infinity)
hbits += value > static_cast<float>(ival);
else if(R == std::round_toward_neg_infinity)
hbits += value < static_cast<float>(ival);
return hbits;
}
template<std::float_round_style R> uint16 float2half(float value)
{
return float2half_impl<R>(value, bool_type<std::numeric_limits<float>::is_iec559&&sizeof(uint32)==sizeof(float)>());
}
template<std::float_round_style R,bool S,typename T> uint16 int2half_impl(T value)
{
if(S)
value = -value;
uint16 bits = S << 15;
if(value > 65504)
{
if(R == std::round_toward_infinity)
bits |= 0x7C00 - S;
else if(R == std::round_toward_neg_infinity)
bits |= 0x7BFF + S;
else
bits |= 0x7BFF + (R!=std::round_toward_zero);
}
else if(value)
{
unsigned int m = value, exp = 25;
for(; m<0x400; m<<=1,--exp) ;
for(; m>0x7FF; m>>=1,++exp) ;
bits |= (exp<<10) | (m&0x3FF);
if(exp > 25)
{
if(R == std::round_to_nearest)
bits += (value>>(exp-26)) & 1
& (((((1<<(exp-26))-1)&value)!=0)|bits)
;
else if(R == std::round_toward_infinity)
bits += ((value&((1<<(exp-25))-1))!=0) & !S;
else if(R == std::round_toward_neg_infinity)
bits += ((value&((1<<(exp-25))-1))!=0) & S;
}
}
return bits;
}
template<std::float_round_style R,typename T> uint16 int2half(T value)
{
return (value<0) ? int2half_impl<R,true>(value) : int2half_impl<R,false>(value);
}
inline float half2float_impl(uint16 value, true_type)
{
static_assert(std::numeric_limits<float>::is_iec559, "half to float conversion needs IEEE 754 conformant 'float' type");
static_assert(sizeof(uint32)==sizeof(float), "half to float conversion needs unsigned integer type of exactly the size of a 'float'");
static const uint32 mantissa_table[2048] = {
0x00000000, 0x33800000, 0x34000000, 0x34400000, 0x34800000, 0x34A00000, 0x34C00000, 0x34E00000, 0x35000000, 0x35100000, 0x35200000, 0x35300000, 0x35400000, 0x35500000, 0x35600000, 0x35700000,
0x35800000, 0x35880000, 0x35900000, 0x35980000, 0x35A00000, 0x35A80000, 0x35B00000, 0x35B80000, 0x35C00000, 0x35C80000, 0x35D00000, 0x35D80000, 0x35E00000, 0x35E80000, 0x35F00000, 0x35F80000,
0x36000000, 0x36040000, 0x36080000, 0x360C0000, 0x36100000, 0x36140000, 0x36180000, 0x361C0000, 0x36200000, 0x36240000, 0x36280000, 0x362C0000, 0x36300000, 0x36340000, 0x36380000, 0x363C0000,
0x36400000, 0x36440000, 0x36480000, 0x364C0000, 0x36500000, 0x36540000, 0x36580000, 0x365C0000, 0x36600000, 0x36640000, 0x36680000, 0x366C0000, 0x36700000, 0x36740000, 0x36780000, 0x367C0000,
0x36800000, 0x36820000, 0x36840000, 0x36860000, 0x36880000, 0x368A0000, 0x368C0000, 0x368E0000, 0x36900000, 0x36920000, 0x36940000, 0x36960000, 0x36980000, 0x369A0000, 0x369C0000, 0x369E0000,
0x36A00000, 0x36A20000, 0x36A40000, 0x36A60000, 0x36A80000, 0x36AA0000, 0x36AC0000, 0x36AE0000, 0x36B00000, 0x36B20000, 0x36B40000, 0x36B60000, 0x36B80000, 0x36BA0000, 0x36BC0000, 0x36BE0000,
0x36C00000, 0x36C20000, 0x36C40000, 0x36C60000, 0x36C80000, 0x36CA0000, 0x36CC0000, 0x36CE0000, 0x36D00000, 0x36D20000, 0x36D40000, 0x36D60000, 0x36D80000, 0x36DA0000, 0x36DC0000, 0x36DE0000,
0x36E00000, 0x36E20000, 0x36E40000, 0x36E60000, 0x36E80000, 0x36EA0000, 0x36EC0000, 0x36EE0000, 0x36F00000, 0x36F20000, 0x36F40000, 0x36F60000, 0x36F80000, 0x36FA0000, 0x36FC0000, 0x36FE0000,
0x37000000, 0x37010000, 0x37020000, 0x37030000, 0x37040000, 0x37050000, 0x37060000, 0x37070000, 0x37080000, 0x37090000, 0x370A0000, 0x370B0000, 0x370C0000, 0x370D0000, 0x370E0000, 0x370F0000,
0x37100000, 0x37110000, 0x37120000, 0x37130000, 0x37140000, 0x37150000, 0x37160000, 0x37170000, 0x37180000, 0x37190000, 0x371A0000, 0x371B0000, 0x371C0000, 0x371D0000, 0x371E0000, 0x371F0000,
0x37200000, 0x37210000, 0x37220000, 0x37230000, 0x37240000, 0x37250000, 0x37260000, 0x37270000, 0x37280000, 0x37290000, 0x372A0000, 0x372B0000, 0x372C0000, 0x372D0000, 0x372E0000, 0x372F0000,
0x37300000, 0x37310000, 0x37320000, 0x37330000, 0x37340000, 0x37350000, 0x37360000, 0x37370000, 0x37380000, 0x37390000, 0x373A0000, 0x373B0000, 0x373C0000, 0x373D0000, 0x373E0000, 0x373F0000,
0x37400000, 0x37410000, 0x37420000, 0x37430000, 0x37440000, 0x37450000, 0x37460000, 0x37470000, 0x37480000, 0x37490000, 0x374A0000, 0x374B0000, 0x374C0000, 0x374D0000, 0x374E0000, 0x374F0000,
0x37500000, 0x37510000, 0x37520000, 0x37530000, 0x37540000, 0x37550000, 0x37560000, 0x37570000, 0x37580000, 0x37590000, 0x375A0000, 0x375B0000, 0x375C0000, 0x375D0000, 0x375E0000, 0x375F0000,
0x37600000, 0x37610000, 0x37620000, 0x37630000, 0x37640000, 0x37650000, 0x37660000, 0x37670000, 0x37680000, 0x37690000, 0x376A0000, 0x376B0000, 0x376C0000, 0x376D0000, 0x376E0000, 0x376F0000,
0x37700000, 0x37710000, 0x37720000, 0x37730000, 0x37740000, 0x37750000, 0x37760000, 0x37770000, 0x37780000, 0x37790000, 0x377A0000, 0x377B0000, 0x377C0000, 0x377D0000, 0x377E0000, 0x377F0000,
0x37800000, 0x37808000, 0x37810000, 0x37818000, 0x37820000, 0x37828000, 0x37830000, 0x37838000, 0x37840000, 0x37848000, 0x37850000, 0x37858000, 0x37860000, 0x37868000, 0x37870000, 0x37878000,
0x37880000, 0x37888000, 0x37890000, 0x37898000, 0x378A0000, 0x378A8000, 0x378B0000, 0x378B8000, 0x378C0000, 0x378C8000, 0x378D0000, 0x378D8000, 0x378E0000, 0x378E8000, 0x378F0000, 0x378F8000,
0x37900000, 0x37908000, 0x37910000, 0x37918000, 0x37920000, 0x37928000, 0x37930000, 0x37938000, 0x37940000, 0x37948000, 0x37950000, 0x37958000, 0x37960000, 0x37968000, 0x37970000, 0x37978000,
0x37980000, 0x37988000, 0x37990000, 0x37998000, 0x379A0000, 0x379A8000, 0x379B0000, 0x379B8000, 0x379C0000, 0x379C8000, 0x379D0000, 0x379D8000, 0x379E0000, 0x379E8000, 0x379F0000, 0x379F8000,
0x37A00000, 0x37A08000, 0x37A10000, 0x37A18000, 0x37A20000, 0x37A28000, 0x37A30000, 0x37A38000, 0x37A40000, 0x37A48000, 0x37A50000, 0x37A58000, 0x37A60000, 0x37A68000, 0x37A70000, 0x37A78000,
0x37A80000, 0x37A88000, 0x37A90000, 0x37A98000, 0x37AA0000, 0x37AA8000, 0x37AB0000, 0x37AB8000, 0x37AC0000, 0x37AC8000, 0x37AD0000, 0x37AD8000, 0x37AE0000, 0x37AE8000, 0x37AF0000, 0x37AF8000,
0x37B00000, 0x37B08000, 0x37B10000, 0x37B18000, 0x37B20000, 0x37B28000, 0x37B30000, 0x37B38000, 0x37B40000, 0x37B48000, 0x37B50000, 0x37B58000, 0x37B60000, 0x37B68000, 0x37B70000, 0x37B78000,
0x37B80000, 0x37B88000, 0x37B90000, 0x37B98000, 0x37BA0000, 0x37BA8000, 0x37BB0000, 0x37BB8000, 0x37BC0000, 0x37BC8000, 0x37BD0000, 0x37BD8000, 0x37BE0000, 0x37BE8000, 0x37BF0000, 0x37BF8000,
0x37C00000, 0x37C08000, 0x37C10000, 0x37C18000, 0x37C20000, 0x37C28000, 0x37C30000, 0x37C38000, 0x37C40000, 0x37C48000, 0x37C50000, 0x37C58000, 0x37C60000, 0x37C68000, 0x37C70000, 0x37C78000,
0x37C80000, 0x37C88000, 0x37C90000, 0x37C98000, 0x37CA0000, 0x37CA8000, 0x37CB0000, 0x37CB8000, 0x37CC0000, 0x37CC8000, 0x37CD0000, 0x37CD8000, 0x37CE0000, 0x37CE8000, 0x37CF0000, 0x37CF8000,
0x37D00000, 0x37D08000, 0x37D10000, 0x37D18000, 0x37D20000, 0x37D28000, 0x37D30000, 0x37D38000, 0x37D40000, 0x37D48000, 0x37D50000, 0x37D58000, 0x37D60000, 0x37D68000, 0x37D70000, 0x37D78000,
0x37D80000, 0x37D88000, 0x37D90000, 0x37D98000, 0x37DA0000, 0x37DA8000, 0x37DB0000, 0x37DB8000, 0x37DC0000, 0x37DC8000, 0x37DD0000, 0x37DD8000, 0x37DE0000, 0x37DE8000, 0x37DF0000, 0x37DF8000,
0x37E00000, 0x37E08000, 0x37E10000, 0x37E18000, 0x37E20000, 0x37E28000, 0x37E30000, 0x37E38000, 0x37E40000, 0x37E48000, 0x37E50000, 0x37E58000, 0x37E60000, 0x37E68000, 0x37E70000, 0x37E78000,
0x37E80000, 0x37E88000, 0x37E90000, 0x37E98000, 0x37EA0000, 0x37EA8000, 0x37EB0000, 0x37EB8000, 0x37EC0000, 0x37EC8000, 0x37ED0000, 0x37ED8000, 0x37EE0000, 0x37EE8000, 0x37EF0000, 0x37EF8000,
0x37F00000, 0x37F08000, 0x37F10000, 0x37F18000, 0x37F20000, 0x37F28000, 0x37F30000, 0x37F38000, 0x37F40000, 0x37F48000, 0x37F50000, 0x37F58000, 0x37F60000, 0x37F68000, 0x37F70000, 0x37F78000,
0x37F80000, 0x37F88000, 0x37F90000, 0x37F98000, 0x37FA0000, 0x37FA8000, 0x37FB0000, 0x37FB8000, 0x37FC0000, 0x37FC8000, 0x37FD0000, 0x37FD8000, 0x37FE0000, 0x37FE8000, 0x37FF0000, 0x37FF8000,
0x38000000, 0x38004000, 0x38008000, 0x3800C000, 0x38010000, 0x38014000, 0x38018000, 0x3801C000, 0x38020000, 0x38024000, 0x38028000, 0x3802C000, 0x38030000, 0x38034000, 0x38038000, 0x3803C000,
0x38040000, 0x38044000, 0x38048000, 0x3804C000, 0x38050000, 0x38054000, 0x38058000, 0x3805C000, 0x38060000, 0x38064000, 0x38068000, 0x3806C000, 0x38070000, 0x38074000, 0x38078000, 0x3807C000,
0x38080000, 0x38084000, 0x38088000, 0x3808C000, 0x38090000, 0x38094000, 0x38098000, 0x3809C000, 0x380A0000, 0x380A4000, 0x380A8000, 0x380AC000, 0x380B0000, 0x380B4000, 0x380B8000, 0x380BC000,
0x380C0000, 0x380C4000, 0x380C8000, 0x380CC000, 0x380D0000, 0x380D4000, 0x380D8000, 0x380DC000, 0x380E0000, 0x380E4000, 0x380E8000, 0x380EC000, 0x380F0000, 0x380F4000, 0x380F8000, 0x380FC000,
0x38100000, 0x38104000, 0x38108000, 0x3810C000, 0x38110000, 0x38114000, 0x38118000, 0x3811C000, 0x38120000, 0x38124000, 0x38128000, 0x3812C000, 0x38130000, 0x38134000, 0x38138000, 0x3813C000,
0x38140000, 0x38144000, 0x38148000, 0x3814C000, 0x38150000, 0x38154000, 0x38158000, 0x3815C000, 0x38160000, 0x38164000, 0x38168000, 0x3816C000, 0x38170000, 0x38174000, 0x38178000, 0x3817C000,
0x38180000, 0x38184000, 0x38188000, 0x3818C000, 0x38190000, 0x38194000, 0x38198000, 0x3819C000, 0x381A0000, 0x381A4000, 0x381A8000, 0x381AC000, 0x381B0000, 0x381B4000, 0x381B8000, 0x381BC000,
0x381C0000, 0x381C4000, 0x381C8000, 0x381CC000, 0x381D0000, 0x381D4000, 0x381D8000, 0x381DC000, 0x381E0000, 0x381E4000, 0x381E8000, 0x381EC000, 0x381F0000, 0x381F4000, 0x381F8000, 0x381FC000,
0x38200000, 0x38204000, 0x38208000, 0x3820C000, 0x38210000, 0x38214000, 0x38218000, 0x3821C000, 0x38220000, 0x38224000, 0x38228000, 0x3822C000, 0x38230000, 0x38234000, 0x38238000, 0x3823C000,
0x38240000, 0x38244000, 0x38248000, 0x3824C000, 0x38250000, 0x38254000, 0x38258000, 0x3825C000, 0x38260000, 0x38264000, 0x38268000, 0x3826C000, 0x38270000, 0x38274000, 0x38278000, 0x3827C000,
0x38280000, 0x38284000, 0x38288000, 0x3828C000, 0x38290000, 0x38294000, 0x38298000, 0x3829C000, 0x382A0000, 0x382A4000, 0x382A8000, 0x382AC000, 0x382B0000, 0x382B4000, 0x382B8000, 0x382BC000,
0x382C0000, 0x382C4000, 0x382C8000, 0x382CC000, 0x382D0000, 0x382D4000, 0x382D8000, 0x382DC000, 0x382E0000, 0x382E4000, 0x382E8000, 0x382EC000, 0x382F0000, 0x382F4000, 0x382F8000, 0x382FC000,
0x38300000, 0x38304000, 0x38308000, 0x3830C000, 0x38310000, 0x38314000, 0x38318000, 0x3831C000, 0x38320000, 0x38324000, 0x38328000, 0x3832C000, 0x38330000, 0x38334000, 0x38338000, 0x3833C000,
0x38340000, 0x38344000, 0x38348000, 0x3834C000, 0x38350000, 0x38354000, 0x38358000, 0x3835C000, 0x38360000, 0x38364000, 0x38368000, 0x3836C000, 0x38370000, 0x38374000, 0x38378000, 0x3837C000,
0x38380000, 0x38384000, 0x38388000, 0x3838C000, 0x38390000, 0x38394000, 0x38398000, 0x3839C000, 0x383A0000, 0x383A4000, 0x383A8000, 0x383AC000, 0x383B0000, 0x383B4000, 0x383B8000, 0x383BC000,
0x383C0000, 0x383C4000, 0x383C8000, 0x383CC000, 0x383D0000, 0x383D4000, 0x383D8000, 0x383DC000, 0x383E0000, 0x383E4000, 0x383E8000, 0x383EC000, 0x383F0000, 0x383F4000, 0x383F8000, 0x383FC000,
0x38400000, 0x38404000, 0x38408000, 0x3840C000, 0x38410000, 0x38414000, 0x38418000, 0x3841C000, 0x38420000, 0x38424000, 0x38428000, 0x3842C000, 0x38430000, 0x38434000, 0x38438000, 0x3843C000,
0x38440000, 0x38444000, 0x38448000, 0x3844C000, 0x38450000, 0x38454000, 0x38458000, 0x3845C000, 0x38460000, 0x38464000, 0x38468000, 0x3846C000, 0x38470000, 0x38474000, 0x38478000, 0x3847C000,
0x38480000, 0x38484000, 0x38488000, 0x3848C000, 0x38490000, 0x38494000, 0x38498000, 0x3849C000, 0x384A0000, 0x384A4000, 0x384A8000, 0x384AC000, 0x384B0000, 0x384B4000, 0x384B8000, 0x384BC000,
0x384C0000, 0x384C4000, 0x384C8000, 0x384CC000, 0x384D0000, 0x384D4000, 0x384D8000, 0x384DC000, 0x384E0000, 0x384E4000, 0x384E8000, 0x384EC000, 0x384F0000, 0x384F4000, 0x384F8000, 0x384FC000,
0x38500000, 0x38504000, 0x38508000, 0x3850C000, 0x38510000, 0x38514000, 0x38518000, 0x3851C000, 0x38520000, 0x38524000, 0x38528000, 0x3852C000, 0x38530000, 0x38534000, 0x38538000, 0x3853C000,
0x38540000, 0x38544000, 0x38548000, 0x3854C000, 0x38550000, 0x38554000, 0x38558000, 0x3855C000, 0x38560000, 0x38564000, 0x38568000, 0x3856C000, 0x38570000, 0x38574000, 0x38578000, 0x3857C000,
0x38580000, 0x38584000, 0x38588000, 0x3858C000, 0x38590000, 0x38594000, 0x38598000, 0x3859C000, 0x385A0000, 0x385A4000, 0x385A8000, 0x385AC000, 0x385B0000, 0x385B4000, 0x385B8000, 0x385BC000,
0x385C0000, 0x385C4000, 0x385C8000, 0x385CC000, 0x385D0000, 0x385D4000, 0x385D8000, 0x385DC000, 0x385E0000, 0x385E4000, 0x385E8000, 0x385EC000, 0x385F0000, 0x385F4000, 0x385F8000, 0x385FC000,
0x38600000, 0x38604000, 0x38608000, 0x3860C000, 0x38610000, 0x38614000, 0x38618000, 0x3861C000, 0x38620000, 0x38624000, 0x38628000, 0x3862C000, 0x38630000, 0x38634000, 0x38638000, 0x3863C000,
0x38640000, 0x38644000, 0x38648000, 0x3864C000, 0x38650000, 0x38654000, 0x38658000, 0x3865C000, 0x38660000, 0x38664000, 0x38668000, 0x3866C000, 0x38670000, 0x38674000, 0x38678000, 0x3867C000,
0x38680000, 0x38684000, 0x38688000, 0x3868C000, 0x38690000, 0x38694000, 0x38698000, 0x3869C000, 0x386A0000, 0x386A4000, 0x386A8000, 0x386AC000, 0x386B0000, 0x386B4000, 0x386B8000, 0x386BC000,
0x386C0000, 0x386C4000, 0x386C8000, 0x386CC000, 0x386D0000, 0x386D4000, 0x386D8000, 0x386DC000, 0x386E0000, 0x386E4000, 0x386E8000, 0x386EC000, 0x386F0000, 0x386F4000, 0x386F8000, 0x386FC000,
0x38700000, 0x38704000, 0x38708000, 0x3870C000, 0x38710000, 0x38714000, 0x38718000, 0x3871C000, 0x38720000, 0x38724000, 0x38728000, 0x3872C000, 0x38730000, 0x38734000, 0x38738000, 0x3873C000,
0x38740000, 0x38744000, 0x38748000, 0x3874C000, 0x38750000, 0x38754000, 0x38758000, 0x3875C000, 0x38760000, 0x38764000, 0x38768000, 0x3876C000, 0x38770000, 0x38774000, 0x38778000, 0x3877C000,
0x38780000, 0x38784000, 0x38788000, 0x3878C000, 0x38790000, 0x38794000, 0x38798000, 0x3879C000, 0x387A0000, 0x387A4000, 0x387A8000, 0x387AC000, 0x387B0000, 0x387B4000, 0x387B8000, 0x387BC000,
0x387C0000, 0x387C4000, 0x387C8000, 0x387CC000, 0x387D0000, 0x387D4000, 0x387D8000, 0x387DC000, 0x387E0000, 0x387E4000, 0x387E8000, 0x387EC000, 0x387F0000, 0x387F4000, 0x387F8000, 0x387FC000,
0x38000000, 0x38002000, 0x38004000, 0x38006000, 0x38008000, 0x3800A000, 0x3800C000, 0x3800E000, 0x38010000, 0x38012000, 0x38014000, 0x38016000, 0x38018000, 0x3801A000, 0x3801C000, 0x3801E000,
0x38020000, 0x38022000, 0x38024000, 0x38026000, 0x38028000, 0x3802A000, 0x3802C000, 0x3802E000, 0x38030000, 0x38032000, 0x38034000, 0x38036000, 0x38038000, 0x3803A000, 0x3803C000, 0x3803E000,
0x38040000, 0x38042000, 0x38044000, 0x38046000, 0x38048000, 0x3804A000, 0x3804C000, 0x3804E000, 0x38050000, 0x38052000, 0x38054000, 0x38056000, 0x38058000, 0x3805A000, 0x3805C000, 0x3805E000,
0x38060000, 0x38062000, 0x38064000, 0x38066000, 0x38068000, 0x3806A000, 0x3806C000, 0x3806E000, 0x38070000, 0x38072000, 0x38074000, 0x38076000, 0x38078000, 0x3807A000, 0x3807C000, 0x3807E000,
0x38080000, 0x38082000, 0x38084000, 0x38086000, 0x38088000, 0x3808A000, 0x3808C000, 0x3808E000, 0x38090000, 0x38092000, 0x38094000, 0x38096000, 0x38098000, 0x3809A000, 0x3809C000, 0x3809E000,
0x380A0000, 0x380A2000, 0x380A4000, 0x380A6000, 0x380A8000, 0x380AA000, 0x380AC000, 0x380AE000, 0x380B0000, 0x380B2000, 0x380B4000, 0x380B6000, 0x380B8000, 0x380BA000, 0x380BC000, 0x380BE000,
0x380C0000, 0x380C2000, 0x380C4000, 0x380C6000, 0x380C8000, 0x380CA000, 0x380CC000, 0x380CE000, 0x380D0000, 0x380D2000, 0x380D4000, 0x380D6000, 0x380D8000, 0x380DA000, 0x380DC000, 0x380DE000,
0x380E0000, 0x380E2000, 0x380E4000, 0x380E6000, 0x380E8000, 0x380EA000, 0x380EC000, 0x380EE000, 0x380F0000, 0x380F2000, 0x380F4000, 0x380F6000, 0x380F8000, 0x380FA000, 0x380FC000, 0x380FE000,
0x38100000, 0x38102000, 0x38104000, 0x38106000, 0x38108000, 0x3810A000, 0x3810C000, 0x3810E000, 0x38110000, 0x38112000, 0x38114000, 0x38116000, 0x38118000, 0x3811A000, 0x3811C000, 0x3811E000,
0x38120000, 0x38122000, 0x38124000, 0x38126000, 0x38128000, 0x3812A000, 0x3812C000, 0x3812E000, 0x38130000, 0x38132000, 0x38134000, 0x38136000, 0x38138000, 0x3813A000, 0x3813C000, 0x3813E000,
0x38140000, 0x38142000, 0x38144000, 0x38146000, 0x38148000, 0x3814A000, 0x3814C000, 0x3814E000, 0x38150000, 0x38152000, 0x38154000, 0x38156000, 0x38158000, 0x3815A000, 0x3815C000, 0x3815E000,
0x38160000, 0x38162000, 0x38164000, 0x38166000, 0x38168000, 0x3816A000, 0x3816C000, 0x3816E000, 0x38170000, 0x38172000, 0x38174000, 0x38176000, 0x38178000, 0x3817A000, 0x3817C000, 0x3817E000,
0x38180000, 0x38182000, 0x38184000, 0x38186000, 0x38188000, 0x3818A000, 0x3818C000, 0x3818E000, 0x38190000, 0x38192000, 0x38194000, 0x38196000, 0x38198000, 0x3819A000, 0x3819C000, 0x3819E000,
0x381A0000, 0x381A2000, 0x381A4000, 0x381A6000, 0x381A8000, 0x381AA000, 0x381AC000, 0x381AE000, 0x381B0000, 0x381B2000, 0x381B4000, 0x381B6000, 0x381B8000, 0x381BA000, 0x381BC000, 0x381BE000,
0x381C0000, 0x381C2000, 0x381C4000, 0x381C6000, 0x381C8000, 0x381CA000, 0x381CC000, 0x381CE000, 0x381D0000, 0x381D2000, 0x381D4000, 0x381D6000, 0x381D8000, 0x381DA000, 0x381DC000, 0x381DE000,
0x381E0000, 0x381E2000, 0x381E4000, 0x381E6000, 0x381E8000, 0x381EA000, 0x381EC000, 0x381EE000, 0x381F0000, 0x381F2000, 0x381F4000, 0x381F6000, 0x381F8000, 0x381FA000, 0x381FC000, 0x381FE000,
0x38200000, 0x38202000, 0x38204000, 0x38206000, 0x38208000, 0x3820A000, 0x3820C000, 0x3820E000, 0x38210000, 0x38212000, 0x38214000, 0x38216000, 0x38218000, 0x3821A000, 0x3821C000, 0x3821E000,
0x38220000, 0x38222000, 0x38224000, 0x38226000, 0x38228000, 0x3822A000, 0x3822C000, 0x3822E000, 0x38230000, 0x38232000, 0x38234000, 0x38236000, 0x38238000, 0x3823A000, 0x3823C000, 0x3823E000,
0x38240000, 0x38242000, 0x38244000, 0x38246000, 0x38248000, 0x3824A000, 0x3824C000, 0x3824E000, 0x38250000, 0x38252000, 0x38254000, 0x38256000, 0x38258000, 0x3825A000, 0x3825C000, 0x3825E000,
0x38260000, 0x38262000, 0x38264000, 0x38266000, 0x38268000, 0x3826A000, 0x3826C000, 0x3826E000, 0x38270000, 0x38272000, 0x38274000, 0x38276000, 0x38278000, 0x3827A000, 0x3827C000, 0x3827E000,
0x38280000, 0x38282000, 0x38284000, 0x38286000, 0x38288000, 0x3828A000, 0x3828C000, 0x3828E000, 0x38290000, 0x38292000, 0x38294000, 0x38296000, 0x38298000, 0x3829A000, 0x3829C000, 0x3829E000,
0x382A0000, 0x382A2000, 0x382A4000, 0x382A6000, 0x382A8000, 0x382AA000, 0x382AC000, 0x382AE000, 0x382B0000, 0x382B2000, 0x382B4000, 0x382B6000, 0x382B8000, 0x382BA000, 0x382BC000, 0x382BE000,
0x382C0000, 0x382C2000, 0x382C4000, 0x382C6000, 0x382C8000, 0x382CA000, 0x382CC000, 0x382CE000, 0x382D0000, 0x382D2000, 0x382D4000, 0x382D6000, 0x382D8000, 0x382DA000, 0x382DC000, 0x382DE000,
0x382E0000, 0x382E2000, 0x382E4000, 0x382E6000, 0x382E8000, 0x382EA000, 0x382EC000, 0x382EE000, 0x382F0000, 0x382F2000, 0x382F4000, 0x382F6000, 0x382F8000, 0x382FA000, 0x382FC000, 0x382FE000,
0x38300000, 0x38302000, 0x38304000, 0x38306000, 0x38308000, 0x3830A000, 0x3830C000, 0x3830E000, 0x38310000, 0x38312000, 0x38314000, 0x38316000, 0x38318000, 0x3831A000, 0x3831C000, 0x3831E000,
0x38320000, 0x38322000, 0x38324000, 0x38326000, 0x38328000, 0x3832A000, 0x3832C000, 0x3832E000, 0x38330000, 0x38332000, 0x38334000, 0x38336000, 0x38338000, 0x3833A000, 0x3833C000, 0x3833E000,
0x38340000, 0x38342000, 0x38344000, 0x38346000, 0x38348000, 0x3834A000, 0x3834C000, 0x3834E000, 0x38350000, 0x38352000, 0x38354000, 0x38356000, 0x38358000, 0x3835A000, 0x3835C000, 0x3835E000,
0x38360000, 0x38362000, 0x38364000, 0x38366000, 0x38368000, 0x3836A000, 0x3836C000, 0x3836E000, 0x38370000, 0x38372000, 0x38374000, 0x38376000, 0x38378000, 0x3837A000, 0x3837C000, 0x3837E000,
0x38380000, 0x38382000, 0x38384000, 0x38386000, 0x38388000, 0x3838A000, 0x3838C000, 0x3838E000, 0x38390000, 0x38392000, 0x38394000, 0x38396000, 0x38398000, 0x3839A000, 0x3839C000, 0x3839E000,
0x383A0000, 0x383A2000, 0x383A4000, 0x383A6000, 0x383A8000, 0x383AA000, 0x383AC000, 0x383AE000, 0x383B0000, 0x383B2000, 0x383B4000, 0x383B6000, 0x383B8000, 0x383BA000, 0x383BC000, 0x383BE000,
0x383C0000, 0x383C2000, 0x383C4000, 0x383C6000, 0x383C8000, 0x383CA000, 0x383CC000, 0x383CE000, 0x383D0000, 0x383D2000, 0x383D4000, 0x383D6000, 0x383D8000, 0x383DA000, 0x383DC000, 0x383DE000,
0x383E0000, 0x383E2000, 0x383E4000, 0x383E6000, 0x383E8000, 0x383EA000, 0x383EC000, 0x383EE000, 0x383F0000, 0x383F2000, 0x383F4000, 0x383F6000, 0x383F8000, 0x383FA000, 0x383FC000, 0x383FE000,
0x38400000, 0x38402000, 0x38404000, 0x38406000, 0x38408000, 0x3840A000, 0x3840C000, 0x3840E000, 0x38410000, 0x38412000, 0x38414000, 0x38416000, 0x38418000, 0x3841A000, 0x3841C000, 0x3841E000,
0x38420000, 0x38422000, 0x38424000, 0x38426000, 0x38428000, 0x3842A000, 0x3842C000, 0x3842E000, 0x38430000, 0x38432000, 0x38434000, 0x38436000, 0x38438000, 0x3843A000, 0x3843C000, 0x3843E000,
0x38440000, 0x38442000, 0x38444000, 0x38446000, 0x38448000, 0x3844A000, 0x3844C000, 0x3844E000, 0x38450000, 0x38452000, 0x38454000, 0x38456000, 0x38458000, 0x3845A000, 0x3845C000, 0x3845E000,
0x38460000, 0x38462000, 0x38464000, 0x38466000, 0x38468000, 0x3846A000, 0x3846C000, 0x3846E000, 0x38470000, 0x38472000, 0x38474000, 0x38476000, 0x38478000, 0x3847A000, 0x3847C000, 0x3847E000,
0x38480000, 0x38482000, 0x38484000, 0x38486000, 0x38488000, 0x3848A000, 0x3848C000, 0x3848E000, 0x38490000, 0x38492000, 0x38494000, 0x38496000, 0x38498000, 0x3849A000, 0x3849C000, 0x3849E000,
0x384A0000, 0x384A2000, 0x384A4000, 0x384A6000, 0x384A8000, 0x384AA000, 0x384AC000, 0x384AE000, 0x384B0000, 0x384B2000, 0x384B4000, 0x384B6000, 0x384B8000, 0x384BA000, 0x384BC000, 0x384BE000,
0x384C0000, 0x384C2000, 0x384C4000, 0x384C6000, 0x384C8000, 0x384CA000, 0x384CC000, 0x384CE000, 0x384D0000, 0x384D2000, 0x384D4000, 0x384D6000, 0x384D8000, 0x384DA000, 0x384DC000, 0x384DE000,
0x384E0000, 0x384E2000, 0x384E4000, 0x384E6000, 0x384E8000, 0x384EA000, 0x384EC000, 0x384EE000, 0x384F0000, 0x384F2000, 0x384F4000, 0x384F6000, 0x384F8000, 0x384FA000, 0x384FC000, 0x384FE000,
0x38500000, 0x38502000, 0x38504000, 0x38506000, 0x38508000, 0x3850A000, 0x3850C000, 0x3850E000, 0x38510000, 0x38512000, 0x38514000, 0x38516000, 0x38518000, 0x3851A000, 0x3851C000, 0x3851E000,
0x38520000, 0x38522000, 0x38524000, 0x38526000, 0x38528000, 0x3852A000, 0x3852C000, 0x3852E000, 0x38530000, 0x38532000, 0x38534000, 0x38536000, 0x38538000, 0x3853A000, 0x3853C000, 0x3853E000,
0x38540000, 0x38542000, 0x38544000, 0x38546000, 0x38548000, 0x3854A000, 0x3854C000, 0x3854E000, 0x38550000, 0x38552000, 0x38554000, 0x38556000, 0x38558000, 0x3855A000, 0x3855C000, 0x3855E000,
0x38560000, 0x38562000, 0x38564000, 0x38566000, 0x38568000, 0x3856A000, 0x3856C000, 0x3856E000, 0x38570000, 0x38572000, 0x38574000, 0x38576000, 0x38578000, 0x3857A000, 0x3857C000, 0x3857E000,
0x38580000, 0x38582000, 0x38584000, 0x38586000, 0x38588000, 0x3858A000, 0x3858C000, 0x3858E000, 0x38590000, 0x38592000, 0x38594000, 0x38596000, 0x38598000, 0x3859A000, 0x3859C000, 0x3859E000,
0x385A0000, 0x385A2000, 0x385A4000, 0x385A6000, 0x385A8000, 0x385AA000, 0x385AC000, 0x385AE000, 0x385B0000, 0x385B2000, 0x385B4000, 0x385B6000, 0x385B8000, 0x385BA000, 0x385BC000, 0x385BE000,
0x385C0000, 0x385C2000, 0x385C4000, 0x385C6000, 0x385C8000, 0x385CA000, 0x385CC000, 0x385CE000, 0x385D0000, 0x385D2000, 0x385D4000, 0x385D6000, 0x385D8000, 0x385DA000, 0x385DC000, 0x385DE000,
0x385E0000, 0x385E2000, 0x385E4000, 0x385E6000, 0x385E8000, 0x385EA000, 0x385EC000, 0x385EE000, 0x385F0000, 0x385F2000, 0x385F4000, 0x385F6000, 0x385F8000, 0x385FA000, 0x385FC000, 0x385FE000,
0x38600000, 0x38602000, 0x38604000, 0x38606000, 0x38608000, 0x3860A000, 0x3860C000, 0x3860E000, 0x38610000, 0x38612000, 0x38614000, 0x38616000, 0x38618000, 0x3861A000, 0x3861C000, 0x3861E000,
0x38620000, 0x38622000, 0x38624000, 0x38626000, 0x38628000, 0x3862A000, 0x3862C000, 0x3862E000, 0x38630000, 0x38632000, 0x38634000, 0x38636000, 0x38638000, 0x3863A000, 0x3863C000, 0x3863E000,
0x38640000, 0x38642000, 0x38644000, 0x38646000, 0x38648000, 0x3864A000, 0x3864C000, 0x3864E000, 0x38650000, 0x38652000, 0x38654000, 0x38656000, 0x38658000, 0x3865A000, 0x3865C000, 0x3865E000,
0x38660000, 0x38662000, 0x38664000, 0x38666000, 0x38668000, 0x3866A000, 0x3866C000, 0x3866E000, 0x38670000, 0x38672000, 0x38674000, 0x38676000, 0x38678000, 0x3867A000, 0x3867C000, 0x3867E000,
0x38680000, 0x38682000, 0x38684000, 0x38686000, 0x38688000, 0x3868A000, 0x3868C000, 0x3868E000, 0x38690000, 0x38692000, 0x38694000, 0x38696000, 0x38698000, 0x3869A000, 0x3869C000, 0x3869E000,
0x386A0000, 0x386A2000, 0x386A4000, 0x386A6000, 0x386A8000, 0x386AA000, 0x386AC000, 0x386AE000, 0x386B0000, 0x386B2000, 0x386B4000, 0x386B6000, 0x386B8000, 0x386BA000, 0x386BC000, 0x386BE000,
0x386C0000, 0x386C2000, 0x386C4000, 0x386C6000, 0x386C8000, 0x386CA000, 0x386CC000, 0x386CE000, 0x386D0000, 0x386D2000, 0x386D4000, 0x386D6000, 0x386D8000, 0x386DA000, 0x386DC000, 0x386DE000,
0x386E0000, 0x386E2000, 0x386E4000, 0x386E6000, 0x386E8000, 0x386EA000, 0x386EC000, 0x386EE000, 0x386F0000, 0x386F2000, 0x386F4000, 0x386F6000, 0x386F8000, 0x386FA000, 0x386FC000, 0x386FE000,
0x38700000, 0x38702000, 0x38704000, 0x38706000, 0x38708000, 0x3870A000, 0x3870C000, 0x3870E000, 0x38710000, 0x38712000, 0x38714000, 0x38716000, 0x38718000, 0x3871A000, 0x3871C000, 0x3871E000,
0x38720000, 0x38722000, 0x38724000, 0x38726000, 0x38728000, 0x3872A000, 0x3872C000, 0x3872E000, 0x38730000, 0x38732000, 0x38734000, 0x38736000, 0x38738000, 0x3873A000, 0x3873C000, 0x3873E000,
0x38740000, 0x38742000, 0x38744000, 0x38746000, 0x38748000, 0x3874A000, 0x3874C000, 0x3874E000, 0x38750000, 0x38752000, 0x38754000, 0x38756000, 0x38758000, 0x3875A000, 0x3875C000, 0x3875E000,
0x38760000, 0x38762000, 0x38764000, 0x38766000, 0x38768000, 0x3876A000, 0x3876C000, 0x3876E000, 0x38770000, 0x38772000, 0x38774000, 0x38776000, 0x38778000, 0x3877A000, 0x3877C000, 0x3877E000,
0x38780000, 0x38782000, 0x38784000, 0x38786000, 0x38788000, 0x3878A000, 0x3878C000, 0x3878E000, 0x38790000, 0x38792000, 0x38794000, 0x38796000, 0x38798000, 0x3879A000, 0x3879C000, 0x3879E000,
0x387A0000, 0x387A2000, 0x387A4000, 0x387A6000, 0x387A8000, 0x387AA000, 0x387AC000, 0x387AE000, 0x387B0000, 0x387B2000, 0x387B4000, 0x387B6000, 0x387B8000, 0x387BA000, 0x387BC000, 0x387BE000,
0x387C0000, 0x387C2000, 0x387C4000, 0x387C6000, 0x387C8000, 0x387CA000, 0x387CC000, 0x387CE000, 0x387D0000, 0x387D2000, 0x387D4000, 0x387D6000, 0x387D8000, 0x387DA000, 0x387DC000, 0x387DE000,
0x387E0000, 0x387E2000, 0x387E4000, 0x387E6000, 0x387E8000, 0x387EA000, 0x387EC000, 0x387EE000, 0x387F0000, 0x387F2000, 0x387F4000, 0x387F6000, 0x387F8000, 0x387FA000, 0x387FC000, 0x387FE000 };
static const uint32 exponent_table[64] = {
0x00000000, 0x00800000, 0x01000000, 0x01800000, 0x02000000, 0x02800000, 0x03000000, 0x03800000, 0x04000000, 0x04800000, 0x05000000, 0x05800000, 0x06000000, 0x06800000, 0x07000000, 0x07800000,
0x08000000, 0x08800000, 0x09000000, 0x09800000, 0x0A000000, 0x0A800000, 0x0B000000, 0x0B800000, 0x0C000000, 0x0C800000, 0x0D000000, 0x0D800000, 0x0E000000, 0x0E800000, 0x0F000000, 0x47800000,
0x80000000, 0x80800000, 0x81000000, 0x81800000, 0x82000000, 0x82800000, 0x83000000, 0x83800000, 0x84000000, 0x84800000, 0x85000000, 0x85800000, 0x86000000, 0x86800000, 0x87000000, 0x87800000,
0x88000000, 0x88800000, 0x89000000, 0x89800000, 0x8A000000, 0x8A800000, 0x8B000000, 0x8B800000, 0x8C000000, 0x8C800000, 0x8D000000, 0x8D800000, 0x8E000000, 0x8E800000, 0x8F000000, 0xC7800000 };
static const unsigned short offset_table[64] = {
0, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024,
0, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024 };
uint32 bits = mantissa_table[offset_table[value>>10]+(value&0x3FF)] + exponent_table[value>>10];
float out;
std::memcpy(&out, &bits, sizeof(float));
return out;
}
inline float half2float_impl(uint16 value, false_type)
{
float out;
int abs = value & 0x7FFF;
if(abs > 0x7C00)
out = std::numeric_limits<float>::has_quiet_NaN ? std::numeric_limits<float>::quiet_NaN() : 0.0f;
else if(abs == 0x7C00)
out = std::numeric_limits<float>::has_infinity ? std::numeric_limits<float>::infinity() : std::numeric_limits<float>::max();
else if(abs > 0x3FF)
out = std::ldexp(static_cast<float>((value&0x3FF)|0x400), (abs>>10)-25);
else
out = std::ldexp(static_cast<float>(abs), -24);
return (value&0x8000) ? -out : out;
}
inline float half2float(uint16 value)
{
return half2float_impl(value, bool_type<std::numeric_limits<float>::is_iec559&&sizeof(uint32)==sizeof(float)>());
}
template<std::float_round_style R,bool E,typename T> T half2int_impl(uint16 value)
{
unsigned int e = value & 0x7FFF;
if(e >= 0x7C00)
return (value&0x8000) ? std::numeric_limits<T>::min() : std::numeric_limits<T>::max();
if(e < 0x3800)
{
if(R == std::round_toward_infinity)
return T(~(value>>15)&(e!=0));
else if(R == std::round_toward_neg_infinity)
return -T(value>0x8000);
return T();
}
int17 m = (value&0x3FF) | 0x400;
e >>= 10;
if(e < 25)
{
if(R == std::round_indeterminate || R == std::round_toward_zero)
m >>= 25 - e;
else
{
if(R == std::round_to_nearest)
m += (1<<(24-e)) - (~(m>>(25-e))&E);
else if(R == std::round_toward_infinity)
m += ((value>>15)-1) & ((1<<(25-e))-1U);
else if(R == std::round_toward_neg_infinity)
m += -(value>>15) & ((1<<(25-e))-1U);
m >>= 25 - e;
}
}
else
m <<= e - 25;
return static_cast<T>((value&0x8000) ? -m : m);
}
template<std::float_round_style R,typename T> T half2int(uint16 value) { return half2int_impl<R,1,T>(value); }
template<typename T> T half2int_up(uint16 value) { return half2int_impl<std::round_to_nearest,0,T>(value); }
template<std::float_round_style R,bool E> uint16 round_half_impl(uint16 value)
{
unsigned int e = value & 0x7FFF;
uint16 result = value;
if(e < 0x3C00)
{
result &= 0x8000;
if(R == std::round_to_nearest)
result |= 0x3C00U & -(e>=(0x3800+E));
else if(R == std::round_toward_infinity)
result |= 0x3C00U & -(~(value>>15)&(e!=0));
else if(R == std::round_toward_neg_infinity)
result |= 0x3C00U & -(value>0x8000);
}
else if(e < 0x6400)
{
e = 25 - (e>>10);
unsigned int mask = (1<<e) - 1;
if(R == std::round_to_nearest)
result += (1<<(e-1)) - (~(result>>e)&E);
else if(R == std::round_toward_infinity)
result += mask & ((value>>15)-1);
else if(R == std::round_toward_neg_infinity)
result += mask & -(value>>15);
result &= ~mask;
}
return result;
}
template<std::float_round_style R> uint16 round_half(uint16 value) { return round_half_impl<R,1>(value); }
inline uint16 round_half_up(uint16 value) { return round_half_impl<std::round_to_nearest,0>(value); }
struct functions;
template<typename> struct unary_specialized;
template<typename,typename> struct binary_specialized;
template<typename,typename,std::float_round_style> struct half_caster;
}
# 979 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
class half
{
friend struct detail::functions;
friend struct detail::unary_specialized<half>;
friend struct detail::binary_specialized<half,half>;
template<typename,typename,std::float_round_style> friend struct detail::half_caster;
friend struct std::numeric_limits<half>;
friend struct std::hash<half>;
public:
constexpr half() : data_() {}
half(detail::expr rhs) : data_(detail::float2half<round_style>(rhs)) {
xip_fpo_half_set_flt(rhs);
}
half(float rhs) : data_(detail::float2half<round_style>(rhs)) {
xip_fpo_half_set_flt(rhs);
}
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N>
half(const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& rhs) {
std::cout << "WARNING: explicit method ap_fixed::to_half() should be used to convert ap_fixed to half." << std::endl;
*this = rhs.to_half();
}
operator float() const {
return xip_fpo_half_get_flt();
}
half& operator=(detail::expr rhs) { return *this = static_cast<float>(rhs); }
template<typename T> typename detail::enable<half&,T>::type operator+=(T rhs) { return *this = *this + rhs; }
template<typename T> typename detail::enable<half&,T>::type operator-=(T rhs) { return *this = *this - rhs; }
template<typename T> typename detail::enable<half&,T>::type operator*=(T rhs) { return *this = *this * rhs; }
template<typename T> typename detail::enable<half&,T>::type operator/=(T rhs) { return *this = *this / rhs; }
# 1097 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
half& operator++() { return *this += 1.0f; }
half& operator--() { return *this -= 1.0f; }
half operator++(int) { half out(*this); ++*this; return out; }
half operator--(int) { half out(*this); --*this; return out; }
detail::uint16 get_bits() { return data_; }
void set_bits(detail::uint16 bits) { data_ = bits; }
xip_fpo_exc_t xip_fpo_get_data(xip_fpo_ptr op) const {
int exc = 0;
op->_xip_fpo_sign = ((data_ & 0x8000) ? -1 : 1);
op->_xip_fpo_exp = ((data_ & 0x7C00) >> 10) - 14;
*(op->_xip_fpo_d) = ((mp_limb_t)(data_ & 0x3FF) + (mp_limb_t)(0x400)) << (8*sizeof(*(op->_xip_fpo_d)) - 11);
if ((data_ & 0x7C00) == 0) {
exc |= 0x1;
xip_fpo_set_zero(op, op->_xip_fpo_sign);
} else if ((data_ & 0x7FFF) == 0x7C00) {
exc |= 0x2;
xip_fpo_set_inf(op, op->_xip_fpo_sign);
} else if ((data_ & 0x7FFF) > 0x7C00) {
exc |= 0x4;
xip_fpo_set_nan(op);
}
return exc;
}
float xip_fpo_half_get_flt() const {
xip_fpo_t op;
xip_fpo_init2(op, 5, 11);
xip_fpo_exc_t exc = xip_fpo_get_data(op);
float res;
if (exc & 0x1) {
res = (op->_xip_fpo_sign > 0 ? 0.0f : -0.0f);
} else if (exc & 0x2) {
res = (op->_xip_fpo_sign > 0 ? std::numeric_limits<float>::infinity() : -std::numeric_limits<float>::infinity());
} else if (exc & 0x4) {
res = std::numeric_limits<float>::quiet_NaN();
} else {
res = xip_fpo_get_flt(op);
}
xip_fpo_clear(op);
return res;
}
void xip_fpo_set_data(xip_fpo_ptr op) {
mpfr_t fr;
(fr)->_mpfr_prec = (op)->_xip_fpo_mant_prec; (fr)->_mpfr_sign = (op)->_xip_fpo_sign; (fr)->_mpfr_exp = (op)->_xip_fpo_exp; (fr)->_mpfr_d = (op)->_xip_fpo_d;;
data_ = 0;
data_ |= (op->_xip_fpo_sign == 1 ? 0 : 1) << 15;
if (((fr)->_mpfr_exp == ((mpfr_exp_t)((~((~(mpfr_ulong)0)>>1))+1)))) {
data_ &= 0x8000;
} else if (((fr)->_mpfr_exp == ((mpfr_exp_t)((~((~(mpfr_ulong)0)>>1))+3)))) {
data_ |= 0x7C00;
} else if (((fr)->_mpfr_exp == ((mpfr_exp_t)((~((~(mpfr_ulong)0)>>1))+2)))) {
data_ |= 0x7E00;
} else {
data_ |= (op->_xip_fpo_exp + 14) << 10;
data_ |= (*(op->_xip_fpo_d) << 1) >> (8*sizeof(*(op->_xip_fpo_d)) - 10);
}
}
void xip_fpo_half_set_flt(float rhs) {
xip_fpo_t op;
xip_fpo_init2(op, 5, 11);
xip_fpo_set_flt(op, rhs);
xip_fpo_set_data(op);
xip_fpo_clear(op);
}
private:
static const std::float_round_style round_style = (std::float_round_style)(1);
constexpr half(detail::binary_t, detail::uint16 bits) : data_(bits) {}
detail::uint16 data_;
};
template<typename F>
half math_function_1arg(F f, half x) {
half res;
xip_fpo_t rop, xop;
xip_fpo_inits2(5, 11, rop, xop, (xip_fpo_ptr)0);
x.xip_fpo_get_data(xop);
f(rop, xop);
res.xip_fpo_set_data(rop);
xip_fpo_clears(rop, xop, (xip_fpo_ptr)0);
return res;
}
template<typename F>
half binary_operator(F f, half x, half y) {
half res;
xip_fpo_t op, xop, yop;
xip_fpo_inits2(5, 11, op, xop, yop, (xip_fpo_ptr)0);
x.xip_fpo_get_data(xop);
y.xip_fpo_get_data(yop);
f(op, xop, yop);
res.xip_fpo_set_data(op);
xip_fpo_clears(op, xop, yop, (xip_fpo_ptr)0);
return res;
}
template<typename F>
bool binary_operator_compare(F f, half x, half y) {
int res;
xip_fpo_t xop, yop;
xip_fpo_inits2(5, 11, xop, yop, (xip_fpo_ptr)0);
x.xip_fpo_get_data(xop);
y.xip_fpo_get_data(yop);
f(&res, xop, yop);
xip_fpo_clears(xop, yop, (xip_fpo_ptr)0);
return res;
}
# 1248 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
namespace literal
{
inline half operator "" _h(long double value) { return half(static_cast<float>(value)); }
}
namespace detail
{
struct functions
{
# 1273 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
template<typename T1, typename T2>
static half plus(T1 x, T2 y) { return binary_operator(xip_fpo_add, x, y); }
static float plus(float x, half y) { return xil_fpo_add_flt(x,y); }
static float plus(half x, float y) { return xil_fpo_add_flt(x,y); }
static double plus(double x, half y) { return xil_fpo_add_d(x,y); }
static double plus(half x, double y) { return xil_fpo_add_d(x,y); }
# 1289 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
template<typename T1, typename T2>
static half minus(T1 x, T2 y) { return binary_operator(xip_fpo_sub, x, y); }
static float minus(float x, half y) { return xil_fpo_sub_flt(x,y); }
static float minus(half x, float y) { return xil_fpo_sub_flt(x,y); }
static double minus(double x, half y) { return xil_fpo_sub_d(x,y); }
static double minus(half x, double y) { return xil_fpo_sub_d(x,y); }
# 1305 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
template<typename T1, typename T2>
static half multiplies(T1 x, T2 y) { return binary_operator(xip_fpo_mul, x, y); }
static float multiplies(float x, half y) { return xil_fpo_mul_flt(x,y); }
static float multiplies(half x, float y) { return xil_fpo_mul_flt(x,y); }
static double multiplies(double x, half y) { return xil_fpo_mul_d(x,y); }
static double multiplies(half x, double y) { return xil_fpo_mul_d(x,y); }
# 1321 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
template<typename T1, typename T2>
static half divides(T1 x, T2 y) { return binary_operator(xip_fpo_div, x, y); }
static float divides(float x, half y) { return xil_fpo_div_flt(x,y); }
static float divides(half x, float y) { return xil_fpo_div_flt(x,y); }
static double divides(double x, half y) { return xil_fpo_div_d(x,y); }
static double divides(half x, double y) { return xil_fpo_div_d(x,y); }
template<typename charT,typename traits> static std::basic_ostream<charT,traits>& write(std::basic_ostream<charT,traits> &out, float arg) { return out << arg; }
template<typename charT,typename traits> static std::basic_istream<charT,traits>& read(std::basic_istream<charT,traits> &in, half &arg)
{
float f;
if(in >> f)
arg = f;
return in;
}
static expr fmod(float x, float y) { return expr(std::fmod(x, y)); }
static expr remainder(float x, float y)
{
return expr(std::remainder(x, y));
# 1381 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
}
static expr remquo(float x, float y, int *quo)
{
return expr(std::remquo(x, y, quo));
# 1428 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
}
static expr fdim(float x, float y)
{
return expr(std::fdim(x, y));
}
static expr maxmag(float x, float y)
{
if (fabs(y)>fabs(x)) return expr(y);
else return expr(x);
}
static expr minmag(float x, float y)
{
if (fabs(y)<fabs(x)) return expr(y);
else return expr(x);
}
static expr fma(float x, float y, float z)
{
return expr(x*y+z);
}
static half nanh(const char*) { return half(binary, 0x7FFF); }
static expr exp(float arg) { return expr(std::exp(arg)); }
static expr expm1(float arg)
{
return expr(std::expm1(arg));
}
static expr exp2(float arg)
{
return expr(std::exp2(arg));
}
static expr log(float arg) { return expr(std::log(arg)); }
static expr log10(float arg) { return expr(std::log10(arg)); }
static expr log1p(float arg)
{
return expr(std::log1p(arg));
}
static expr log2(float arg)
{
return expr(std::log2(arg));
}
static expr logb(float arg)
{
return expr(std::logb(arg));
}
static expr sqrt(float arg) { return expr(std::sqrt(arg)); }
static expr cbrt(float arg)
{
return expr(std::cbrt(arg));
}
static expr hypot(float x, float y)
{
return expr(std::hypot(x, y));
}
static expr pow(float base, float exp) { return expr(std::pow(base, exp)); }
static expr powr(float base, float exp) { return expr(std::pow(base, exp)); }
static expr pown(float base, int exp) { return expr(std::pow(base, exp)); }
static expr rootn(float base, int exp) { return expr(std::pow(base, float(float(1)/float(exp)))); }
static expr sin(float arg) { return expr(std::sin(arg)); }
static expr cos(float arg) { return expr(std::cos(arg)); }
static expr tan(float arg) { return expr(std::tan(arg)); }
static expr asin(float arg) { return expr(std::asin(arg)); }
static expr acos(float arg) { return expr(std::acos(arg)); }
static expr atan(float arg) { return expr(std::atan(arg)); }
static expr atan2(float x, float y) { return expr(std::atan2(x, y)); }
static expr sinh(float arg) { return expr(std::sinh(arg)); }
static expr cosh(float arg) { return expr(std::cosh(arg)); }
static expr tanh(float arg) { return expr(std::tanh(arg)); }
static expr asinh(float arg)
{
return expr(std::asinh(arg));
}
static expr acosh(float arg)
{
return expr(std::acosh(arg));
}
static expr atanh(float arg)
{
return expr(std::atanh(arg));
}
static expr erf(float arg)
{
return expr(std::erf(arg));
}
static expr erfc(float arg)
{
return expr(std::erfc(arg));
}
static expr lgamma(float arg)
{
return expr(std::lgamma(arg));
# 1721 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
}
static expr tgamma(float arg)
{
return expr(std::tgamma(arg));
# 1748 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
}
static half floor(half arg) { return half(binary, round_half<std::round_toward_neg_infinity>(arg.data_)); }
static half ceil(half arg) { return half(binary, round_half<std::round_toward_infinity>(arg.data_)); }
static half trunc(half arg) { return half(binary, round_half<std::round_toward_zero>(arg.data_)); }
static half round(half arg) { return half(binary, round_half_up(arg.data_)); }
static long lround(half arg) { return detail::half2int_up<long>(arg.data_); }
static half rint(half arg) { return half(binary, round_half<half::round_style>(arg.data_)); }
static long lrint(half arg) { return detail::half2int<half::round_style,long>(arg.data_); }
static long long llround(half arg) { return detail::half2int_up<long long>(arg.data_); }
static long long llrint(half arg) { return detail::half2int<half::round_style,long long>(arg.data_); }
static half frexp(half arg, int *exp)
{
unsigned int m = arg.data_ & 0x7FFF;
if(m >= 0x7C00 || !m)
return *exp = 0, arg;
int e = m >> 10;
if(!e)
for(m<<=1; m<0x400; m<<=1,--e) ;
return *exp = e-14, half(binary, static_cast<uint16>((arg.data_&0x8000)|0x3800|(m&0x3FF)));
}
static half modf(half arg, half *iptr)
{
unsigned int e = arg.data_ & 0x7C00;
if(e > 0x6000)
return *iptr = arg, (e==0x7C00&&(arg.data_&0x3FF)) ? arg : half(binary, arg.data_&0x8000);
if(e < 0x3C00)
return iptr->data_ = arg.data_ & 0x8000, arg;
e >>= 10;
unsigned int mask = (1<<(25-e)) - 1, m = arg.data_ & mask;
iptr->data_ = arg.data_ & ~mask;
if(!m)
return half(binary, arg.data_&0x8000);
for(; m<0x400; m<<=1,--e) ;
return half(binary, static_cast<uint16>((arg.data_&0x8000)|(e<<10)|(m&0x3FF)));
}
static half scalbln(half arg, long exp)
{
long e = arg.data_ & 0x7C00;
if(e == 0x7C00)
return arg;
unsigned int m = arg.data_ & 0x3FF;
if(e >>= 10)
m |= 0x400;
else
{
if(!m)
return arg;
for(m<<=1; m<0x400; m<<=1,--e) ;
}
e += exp;
uint16 value = arg.data_ & 0x8000;
if(e > 30)
{
if(half::round_style == std::round_toward_zero)
value |= 0x7BFF;
else if(half::round_style == std::round_toward_infinity)
value |= 0x7C00 - (value>>15);
else if(half::round_style == std::round_toward_neg_infinity)
value |= 0x7BFF + (value>>15);
else
value |= 0x7C00;
}
else if(e > 0)
value |= (e<<10) | (m&0x3FF);
else if(e > -11)
{
if(half::round_style == std::round_to_nearest)
{
m += 1 << -e;
m -= (m>>(1-e)) & 1;
}
else if(half::round_style == std::round_toward_infinity)
m += ((value>>15)-1) & ((1<<(1-e))-1U);
else if(half::round_style == std::round_toward_neg_infinity)
m += -(value>>15) & ((1<<(1-e))-1U);
value |= m >> (1-e);
}
else if(half::round_style == std::round_toward_infinity)
value |= ((value>>15)-1) & 1;
else if(half::round_style == std::round_toward_neg_infinity)
value |= value >> 15;
return half(binary, value);
}
static int ilogb(half arg)
{
int exp = arg.data_ & 0x7FFF;
if(!exp)
return
# 1894 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h" 3 4
(-2147483647 - 1)
# 1894 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
;
if(exp < 0x7C00)
{
if(!(exp>>=10))
for(unsigned int m=(arg.data_&0x3FF); m<0x200; m<<=1,--exp) ;
return exp - 15;
}
if(exp > 0x7C00)
return
# 1902 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h" 3 4
(-2147483647 - 1)
# 1902 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
;
return 0x7fffffff;
}
static half nextafter(half from, half to)
{
uint16 fabs = from.data_ & 0x7FFF, tabs = to.data_ & 0x7FFF;
if(fabs > 0x7C00)
return from;
if(tabs > 0x7C00 || from.data_ == to.data_ || !(fabs|tabs))
return to;
if(!fabs)
return half(binary, (to.data_&0x8000)+1);
bool lt = (signbit(from) ? (static_cast<int17>(0x8000)-from.data_) : static_cast<int17>(from.data_)) <
(signbit(to) ? (static_cast<int17>(0x8000)-to.data_) : static_cast<int17>(to.data_));
return half(binary, from.data_+(((from.data_>>15)^static_cast<uint16>(lt))<<1)-1);
}
static half nexttoward(half from, long double to)
{
if(isnan(from))
return from;
long double lfrom = static_cast<long double>(from);
if(builtin_isnan(to) || lfrom == to)
return half(static_cast<float>(to));
if(!(from.data_&0x7FFF))
return half(binary, (static_cast<detail::uint16>(builtin_signbit(to))<<15)+1);
return half(binary, from.data_+(((from.data_>>15)^static_cast<uint16>(lfrom<to))<<1)-1);
}
static half copysign(half x, half y) { return half(binary, x.data_^((x.data_^y.data_)&0x8000)); }
static int fpclassify(half arg)
{
unsigned int abs = arg.data_ & 0x7FFF;
if(abs > 0x7C00)
return
# 1953 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h" 3 4
0
# 1953 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
;
if(abs == 0x7C00)
return
# 1955 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h" 3 4
1
# 1955 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
;
if(abs > 0x3FF)
return
# 1957 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h" 3 4
4
# 1957 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
;
return abs ?
# 1958 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h" 3 4
3
# 1958 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
:
# 1958 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h" 3 4
2
# 1958 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
;
}
static bool isfinite(half arg) { return (arg.data_&0x7C00) != 0x7C00; }
static bool isinf(half arg) { return (arg.data_&0x7FFF) == 0x7C00; }
static bool isnan(half arg) { return (arg.data_&0x7FFF) > 0x7C00; }
static bool isnormal(half arg) { return ((arg.data_&0x7C00)!=0) & ((arg.data_&0x7C00)!=0x7C00); }
static bool signbit(half arg) { return (arg.data_&0x8000) != 0; }
# 1999 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
template<typename T1, typename T2>
static bool isequal(T1 x, T2 y) { return binary_operator_compare(xip_fpo_equal, x, y); }
static bool isequal(float x, half y) { return xil_fpo_equal_flt(x,y); }
static bool isequal(half x, float y) { return xil_fpo_equal_flt(x,y); }
static bool isequal(double x, half y) { return xil_fpo_equal_d(x,y); }
static bool isequal(half x, double y) { return xil_fpo_equal_d(x,y); }
# 2015 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
template<typename T1, typename T2>
static bool isnotequal(T1 x, T2 y) { return binary_operator_compare(xip_fpo_notequal, x, y); }
static bool isnotequal(float x, half y) { return xil_fpo_notequal_flt(x,y); }
static bool isnotequal(half x, float y) { return xil_fpo_notequal_flt(x,y); }
static bool isnotequal(double x, half y) { return xil_fpo_notequal_d(x,y); }
static bool isnotequal(half x, double y) { return xil_fpo_notequal_d(x,y); }
# 2032 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
template<typename T1, typename T2>
static bool isgreater(T1 x, T2 y) { return binary_operator_compare(xip_fpo_greater, x, y); }
static bool isgreater(float x, half y) { return xil_fpo_greater_flt(x,y); }
static bool isgreater(half x, float y) { return xil_fpo_greater_flt(x,y); }
static bool isgreater(double x, half y) { return xil_fpo_greater_d(x,y); }
static bool isgreater(half x, double y) { return xil_fpo_greater_d(x,y); }
# 2049 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
template<typename T1, typename T2>
static bool isgreaterequal(T1 x, T2 y) { return binary_operator_compare(xip_fpo_greaterequal, x, y); }
static bool isgreaterequal(float x, half y) { return xil_fpo_greaterequal_flt(x,y); }
static bool isgreaterequal(half x, float y) { return xil_fpo_greaterequal_flt(x,y); }
static bool isgreaterequal(double x, half y) { return xil_fpo_greaterequal_d(x,y); }
static bool isgreaterequal(half x, double y) { return xil_fpo_greaterequal_d(x,y); }
# 2066 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
template<typename T1, typename T2>
static bool isless(T1 x, T2 y) { return binary_operator_compare(xip_fpo_less, x, y); }
static bool isless(float x, half y) { return xil_fpo_less_flt(x,y); }
static bool isless(half x, float y) { return xil_fpo_less_flt(x,y); }
static bool isless(double x, half y) { return xil_fpo_less_d(x,y); }
static bool isless(half x, double y) { return xil_fpo_less_d(x,y); }
# 2083 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
template<typename T1, typename T2>
static bool islessequal(T1 x, T2 y) { return binary_operator_compare(xip_fpo_lessequal, x, y); }
static bool islessequal(float x, half y) { return xil_fpo_lessequal_flt(x,y); }
static bool islessequal(half x, float y) { return xil_fpo_lessequal_flt(x,y); }
static bool islessequal(double x, half y) { return xil_fpo_lessequal_d(x,y); }
static bool islessequal(half x, double y) { return xil_fpo_lessequal_d(x,y); }
static bool islessgreater(half x, half y)
{
if(isnan(x) || isnan(y))
return false;
return isless(x, y) || isgreater(x, y);
}
static bool isunordered(half x, half y) { return isnan(x) || isnan(y); }
private:
static double erf(double arg)
{
if(builtin_isinf(arg))
return (arg<0.0) ? -1.0 : 1.0;
double x2 = static_cast<double>(arg) * static_cast<double>(arg), ax2 = 0.147 * x2;
double value = std::sqrt(1.0-std::exp(-x2*(1.2732395447351626861510701069801+ax2)/(1.0+ax2)));
return builtin_signbit(arg) ? -value : value;
}
static double lgamma(double arg)
{
double v = 1.0;
for(; arg<8.0; ++arg) v *= arg;
double w = 1.0 / (arg * arg);
return (((((((-0.02955065359477124183006535947712*w+0.00641025641025641025641025641026)*w+
-0.00191752691752691752691752691753)*w+8.4175084175084175084175084175084e-4)*w+
-5.952380952380952380952380952381e-4)*w+7.9365079365079365079365079365079e-4)*w+
-0.00277777777777777777777777777778)*w+0.08333333333333333333333333333333)/arg +
0.91893853320467274178032973640562 - std::log(v) - arg + (arg-0.5) * std::log(arg);
}
};
template<typename T> struct unary_specialized
{
static constexpr half negate(half arg) { return half(binary, arg.data_^0x8000); }
static half fabs(half arg) { return half(binary, arg.data_&0x7FFF); }
};
template<> struct unary_specialized<expr>
{
static constexpr expr negate(float arg) { return expr(-arg); }
static expr fabs(float arg) { return expr(std::fabs(arg)); }
};
template<typename T,typename U> struct binary_specialized
{
static expr fmin(float x, float y)
{
return expr(std::fmin(x, y));
}
static expr fmax(float x, float y)
{
return expr(std::fmax(x, y));
}
};
template<> struct binary_specialized<half,half>
{
static half fmin(half x, half y)
{
if(functions::isnan(x))
return y;
if(functions::isnan(y))
return x;
return ((functions::signbit(x) ? (static_cast<int17>(0x8000)-x.data_) : static_cast<int17>(x.data_)) >
(functions::signbit(y) ? (static_cast<int17>(0x8000)-y.data_) : static_cast<int17>(y.data_))) ? y : x;
}
static half fmax(half x, half y)
{
if(functions::isnan(x))
return y;
if(functions::isnan(y))
return x;
return ((functions::signbit(x) ? (static_cast<int17>(0x8000)-x.data_) : static_cast<int17>(x.data_)) <
(functions::signbit(y) ? (static_cast<int17>(0x8000)-y.data_) : static_cast<int17>(y.data_))) ? y : x;
}
};
template<typename T,typename U,std::float_round_style R=(std::float_round_style)(1)> struct half_caster {};
template<typename U,std::float_round_style R> struct half_caster<half,U,R>
{
typedef half type;
static half cast(U arg) { return cast_impl(arg, is_float<U>()); };
private:
static half cast_impl(U arg, true_type) { return half(binary, float2half<R>(static_cast<float>(arg))); }
static half cast_impl(U arg, false_type) { return half(binary, int2half<R>(arg)); }
};
template<typename T,std::float_round_style R> struct half_caster<T,half,R>
{
typedef T type;
template<typename U> static T cast(U arg) { return cast_impl(arg, is_float<T>()); }
private:
static T cast_impl(float arg, true_type) { return static_cast<T>(arg); }
static T cast_impl(half arg, false_type) { return half2int<R,T>(arg.data_); }
};
template<typename T,std::float_round_style R> struct half_caster<T,expr,R> : public half_caster<T,half,R> {};
template<std::float_round_style R> struct half_caster<half,half,R>
{
typedef half type;
static half cast(half arg) { return arg; }
};
template<std::float_round_style R> struct half_caster<half,expr,R> : public half_caster<half,half,R> {};
# 2269 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
template<typename T,typename U> typename enable<bool,T,U>::type operator==(T x, U y) { return functions::isequal(x, y); }
template<typename T,typename U> typename enable<bool,T,U>::type operator!=(T x, U y) { return functions::isnotequal(x, y); }
template<typename T,typename U> typename enable<bool,T,U>::type operator<(T x, U y) { return functions::isless(x, y); }
template<typename T,typename U> typename enable<bool,T,U>::type operator>(T x, U y) { return functions::isgreater(x, y); }
template<typename T,typename U> typename enable<bool,T,U>::type operator<=(T x, U y) { return functions::islessequal(x, y); }
template<typename T,typename U> typename enable<bool,T,U>::type operator>=(T x, U y) { return functions::isgreaterequal(x, y); }
# 2317 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
template<typename T,typename U> typename enable<half,T,U>::type operator+(T x, U y) { return functions::plus(x, y); }
# 2327 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
template<typename T,typename U> typename enable<half,T,U>::type operator-(T x, U y) { return functions::minus(x, y); }
# 2337 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
template<typename T,typename U> typename enable<half,T,U>::type operator*(T x, U y) { return functions::multiplies(x, y); }
# 2347 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
template<typename T,typename U> typename enable<half,T,U>::type operator/(T x, U y) { return functions::divides(x, y); }
template<typename T> constexpr typename enable<T,T>::type operator+(T arg) { return arg; }
template<typename T> constexpr typename enable<T,T>::type operator-(T arg) { return unary_specialized<T>::negate(arg); }
# 2368 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
template<typename T,typename charT,typename traits> typename enable<std::basic_ostream<charT,traits>&,T>::type
operator<<(std::basic_ostream<charT,traits> &out, T arg) { return functions::write(out, arg); }
template<typename charT,typename traits> std::basic_istream<charT,traits>&
operator>>(std::basic_istream<charT,traits> &in, half &arg) { return functions::read(in, arg); }
# 2386 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
inline half abs(half arg) { return unary_specialized<half>::fabs(arg); }
inline expr abs(expr arg) { return unary_specialized<expr>::fabs(arg); }
inline half fabs(half arg) { return unary_specialized<half>::fabs(arg); }
inline expr fabs(expr arg) { return unary_specialized<expr>::fabs(arg); }
inline expr fmod(half x, half y) { return functions::fmod(x, y); }
inline expr fmod(half x, expr y) { return functions::fmod(x, y); }
inline expr fmod(expr x, half y) { return functions::fmod(x, y); }
inline expr fmod(expr x, expr y) { return functions::fmod(x, y); }
inline expr remainder(half x, half y) { return functions::remainder(x, y); }
inline expr remainder(half x, expr y) { return functions::remainder(x, y); }
inline expr remainder(expr x, half y) { return functions::remainder(x, y); }
inline expr remainder(expr x, expr y) { return functions::remainder(x, y); }
inline expr remquo(half x, half y, int *quo) { return functions::remquo(x, y, quo); }
inline expr remquo(half x, expr y, int *quo) { return functions::remquo(x, y, quo); }
inline expr remquo(expr x, half y, int *quo) { return functions::remquo(x, y, quo); }
inline expr remquo(expr x, expr y, int *quo) { return functions::remquo(x, y, quo); }
inline expr fma(half x, half y, half z) { return functions::fma(x, y, z); }
inline expr fma(half x, half y, expr z) { return functions::fma(x, y, z); }
inline expr fma(half x, expr y, half z) { return functions::fma(x, y, z); }
inline expr fma(half x, expr y, expr z) { return functions::fma(x, y, z); }
inline expr fma(expr x, half y, half z) { return functions::fma(x, y, z); }
inline expr fma(expr x, half y, expr z) { return functions::fma(x, y, z); }
inline expr fma(expr x, expr y, half z) { return functions::fma(x, y, z); }
inline expr fma(expr x, expr y, expr z) { return functions::fma(x, y, z); }
inline expr mad(half x, half y, half z) { return functions::fma(x, y, z); }
inline expr mad(half x, half y, expr z) { return functions::fma(x, y, z); }
inline expr mad(half x, expr y, half z) { return functions::fma(x, y, z); }
inline expr mad(half x, expr y, expr z) { return functions::fma(x, y, z); }
inline expr mad(expr x, half y, half z) { return functions::fma(x, y, z); }
inline expr mad(expr x, half y, expr z) { return functions::fma(x, y, z); }
inline expr mad(expr x, expr y, half z) { return functions::fma(x, y, z); }
inline expr mad(expr x, expr y, expr z) { return functions::fma(x, y, z); }
inline half fmax(half x, half y) { return binary_specialized<half,half>::fmax(x, y); }
inline expr fmax(half x, expr y) { return binary_specialized<half,expr>::fmax(x, y); }
inline expr fmax(expr x, half y) { return binary_specialized<expr,half>::fmax(x, y); }
inline expr fmax(expr x, expr y) { return binary_specialized<expr,expr>::fmax(x, y); }
inline half fmin(half x, half y) { return binary_specialized<half,half>::fmin(x, y); }
inline expr fmin(half x, expr y) { return binary_specialized<half,expr>::fmin(x, y); }
inline expr fmin(expr x, half y) { return binary_specialized<expr,half>::fmin(x, y); }
inline expr fmin(expr x, expr y) { return binary_specialized<expr,expr>::fmin(x, y); }
inline expr fdim(half x, half y) { return functions::fdim(x, y); }
inline expr fdim(half x, expr y) { return functions::fdim(x, y); }
inline expr fdim(expr x, half y) { return functions::fdim(x, y); }
inline expr fdim(expr x, expr y) { return functions::fdim(x, y); }
inline expr maxmag(half x, half y) { return functions::maxmag(x, y); }
inline expr maxmag(half x, expr y) { return functions::maxmag(x, y); }
inline expr maxmag(expr x, half y) { return functions::maxmag(x, y); }
inline expr maxmag(expr x, expr y) { return functions::maxmag(x, y); }
inline expr minmag(half x, half y) { return functions::minmag(x, y); }
inline expr minmag(half x, expr y) { return functions::minmag(x, y); }
inline expr minmag(expr x, half y) { return functions::minmag(x, y); }
inline expr minmag(expr x, expr y) { return functions::minmag(x, y); }
inline half nanh(const char *arg) { return functions::nanh(arg); }
# 2504 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
inline expr exp(half arg) { return functions::exp(arg); }
inline expr exp(expr arg) { return functions::exp(arg); }
inline expr expm1(half arg) { return functions::expm1(arg); }
inline expr expm1(expr arg) { return functions::expm1(arg); }
inline expr exp2(half arg) { return functions::exp2(arg); }
inline expr exp2(expr arg) { return functions::exp2(arg); }
inline expr log(half arg) { return functions::log(arg); }
inline expr log(expr arg) { return functions::log(arg); }
inline expr log10(half arg) { return functions::log10(arg); }
inline expr log10(expr arg) { return functions::log10(arg); }
inline expr log1p(half arg) { return functions::log1p(arg); }
inline expr log1p(expr arg) { return functions::log1p(arg); }
inline expr log2(half arg) { return functions::log2(arg); }
inline expr log2(expr arg) { return functions::log2(arg); }
# 2560 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
inline half sqrt(half arg) { return math_function_1arg(xip_fpo_sqrt, arg); }
inline expr sqrt(expr arg) { return functions::sqrt(arg); }
inline expr cbrt(half arg) { return functions::cbrt(arg); }
inline expr cbrt(expr arg) { return functions::cbrt(arg); }
inline expr hypot(half x, half y) { return functions::hypot(x, y); }
inline expr hypot(half x, expr y) { return functions::hypot(x, y); }
inline expr hypot(expr x, half y) { return functions::hypot(x, y); }
inline expr hypot(expr x, expr y) { return functions::hypot(x, y); }
inline expr pow(half base, half exp) { return functions::pow(base, exp); }
inline expr pow(half base, expr exp) { return functions::pow(base, exp); }
inline expr pow(expr base, half exp) { return functions::pow(base, exp); }
inline expr pow(expr base, expr exp) { return functions::pow(base, exp); }
inline expr powr(half base, half exp) { return functions::powr(base, exp); }
inline expr powr(half base, expr exp) { return functions::powr(base, exp); }
inline expr powr(expr base, half exp) { return functions::powr(base, exp); }
inline expr powr(expr base, expr exp) { return functions::powr(base, exp); }
inline expr pown(half base, int exp) { return functions::pown(base, exp); }
inline expr pown(expr base, int exp) { return functions::pown(base, exp); }
# 2605 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
inline expr sin(half arg) { return functions::sin(arg); }
inline expr sin(expr arg) { return functions::sin(arg); }
inline expr cos(half arg) { return functions::cos(arg); }
inline expr cos(expr arg) { return functions::cos(arg); }
inline expr tan(half arg) { return functions::tan(arg); }
inline expr tan(expr arg) { return functions::tan(arg); }
inline expr asin(half arg) { return functions::asin(arg); }
inline expr asin(expr arg) { return functions::asin(arg); }
inline expr acos(half arg) { return functions::acos(arg); }
inline expr acos(expr arg) { return functions::acos(arg); }
inline expr atan(half arg) { return functions::atan(arg); }
inline expr atan(expr arg) { return functions::atan(arg); }
inline expr atan2(half x, half y) { return functions::atan2(x, y); }
inline expr atan2(half x, expr y) { return functions::atan2(x, y); }
inline expr atan2(expr x, half y) { return functions::atan2(x, y); }
inline expr atan2(expr x, expr y) { return functions::atan2(x, y); }
# 2661 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
inline expr sinh(half arg) { return functions::sinh(arg); }
inline expr sinh(expr arg) { return functions::sinh(arg); }
inline expr cosh(half arg) { return functions::cosh(arg); }
inline expr cosh(expr arg) { return functions::cosh(arg); }
inline expr tanh(half arg) { return functions::tanh(arg); }
inline expr tanh(expr arg) { return functions::tanh(arg); }
inline expr asinh(half arg) { return functions::asinh(arg); }
inline expr asinh(expr arg) { return functions::asinh(arg); }
inline expr acosh(half arg) { return functions::acosh(arg); }
inline expr acosh(expr arg) { return functions::acosh(arg); }
inline expr atanh(half arg) { return functions::atanh(arg); }
inline expr atanh(expr arg) { return functions::atanh(arg); }
# 2707 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
inline expr erf(half arg) { return functions::erf(arg); }
inline expr erf(expr arg) { return functions::erf(arg); }
inline expr erfc(half arg) { return functions::erfc(arg); }
inline expr erfc(expr arg) { return functions::erfc(arg); }
inline expr lgamma_r(half arg, int *signgamp) { return functions::lgamma(arg); }
inline expr lgamma_r(expr arg, int *signgamp) { return functions::lgamma(arg); }
inline expr lgamma(half arg) { return functions::lgamma(arg); }
inline expr lgamma(expr arg) { return functions::lgamma(arg); }
inline expr tgamma(half arg) { return functions::tgamma(arg); }
inline expr tgamma(expr arg) { return functions::tgamma(arg); }
# 2741 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
inline half ceil(half arg) { return functions::ceil(arg); }
inline half ceil(expr arg) { return functions::ceil(arg); }
inline half floor(half arg) { return functions::floor(arg); }
inline half floor(expr arg) { return functions::floor(arg); }
inline half trunc(half arg) { return functions::trunc(arg); }
inline half trunc(expr arg) { return functions::trunc(arg); }
inline half round(half arg) { return functions::round(arg); }
inline half round(expr arg) { return functions::round(arg); }
inline long lround(half arg) { return functions::lround(arg); }
inline long lround(expr arg) { return functions::lround(arg); }
inline half nearbyint(half arg) { return functions::rint(arg); }
inline half nearbyint(expr arg) { return functions::rint(arg); }
inline half rint(half arg) { return functions::rint(arg); }
inline half rint(expr arg) { return functions::rint(arg); }
inline long lrint(half arg) { return functions::lrint(arg); }
inline long lrint(expr arg) { return functions::lrint(arg); }
inline long long llround(half arg) { return functions::llround(arg); }
inline long long llround(expr arg) { return functions::llround(arg); }
inline long long llrint(half arg) { return functions::llrint(arg); }
inline long long llrint(expr arg) { return functions::llrint(arg); }
# 2817 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
inline half frexp(half arg, int *exp) { return functions::frexp(arg, exp); }
inline half frexp(expr arg, int *exp) { return functions::frexp(arg, exp); }
inline half ldexp(half arg, int exp) { return functions::scalbln(arg, exp); }
inline half ldexp(expr arg, int exp) { return functions::scalbln(arg, exp); }
inline half modf(half arg, half *iptr) { return functions::modf(arg, iptr); }
inline half modf(expr arg, half *iptr) { return functions::modf(arg, iptr); }
inline half scalbn(half arg, int exp) { return functions::scalbln(arg, exp); }
inline half scalbn(expr arg, int exp) { return functions::scalbln(arg, exp); }
inline half scalbln(half arg, long exp) { return functions::scalbln(arg, exp); }
inline half scalbln(expr arg, long exp) { return functions::scalbln(arg, exp); }
# 2859 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
inline int ilogb(half arg) { return functions::ilogb(arg); }
inline int ilogb(expr arg) { return functions::ilogb(arg); }
inline half logb(half arg) { return functions::logb(arg); }
inline half logb(expr arg) { return functions::logb(arg); }
inline half nextafter(half from, half to) { return functions::nextafter(from, to); }
inline half nextafter(half from, expr to) { return functions::nextafter(from, to); }
inline half nextafter(expr from, half to) { return functions::nextafter(from, to); }
inline half nextafter(expr from, expr to) { return functions::nextafter(from, to); }
inline half nexttoward(half from, long double to) { return functions::nexttoward(from, to); }
inline half nexttoward(expr from, long double to) { return functions::nexttoward(from, to); }
inline half copysign(half x, half y) { return functions::copysign(x, y); }
inline half copysign(half x, expr y) { return functions::copysign(x, y); }
inline half copysign(expr x, half y) { return functions::copysign(x, y); }
inline half copysign(expr x, expr y) { return functions::copysign(x, y); }
# 2910 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
inline int fpclassify(half arg) { return functions::fpclassify(arg); }
inline int fpclassify(expr arg) { return functions::fpclassify(arg); }
inline bool isfinite(half arg) { return functions::isfinite(arg); }
inline bool isfinite(expr arg) { return functions::isfinite(arg); }
inline bool isinf(half arg) { return functions::isinf(arg); }
inline bool isinf(expr arg) { return functions::isinf(arg); }
inline bool isnan(half arg) { return functions::isnan(arg); }
inline bool isnan(expr arg) { return functions::isnan(arg); }
inline bool isnormal(half arg) { return functions::isnormal(arg); }
inline bool isnormal(expr arg) { return functions::isnormal(arg); }
inline bool signbit(half arg) { return functions::signbit(arg); }
inline bool signbit(expr arg) { return functions::signbit(arg); }
# 2963 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
inline bool isgreater(half x, half y) { return functions::isgreater(x, y); }
inline bool isgreater(half x, expr y) { return functions::isgreater(x, y); }
inline bool isgreater(expr x, half y) { return functions::isgreater(x, y); }
inline bool isgreater(expr x, expr y) { return functions::isgreater(x, y); }
inline bool isgreaterequal(half x, half y) { return functions::isgreaterequal(x, y); }
inline bool isgreaterequal(half x, expr y) { return functions::isgreaterequal(x, y); }
inline bool isgreaterequal(expr x, half y) { return functions::isgreaterequal(x, y); }
inline bool isgreaterequal(expr x, expr y) { return functions::isgreaterequal(x, y); }
inline bool isless(half x, half y) { return functions::isless(x, y); }
inline bool isless(half x, expr y) { return functions::isless(x, y); }
inline bool isless(expr x, half y) { return functions::isless(x, y); }
inline bool isless(expr x, expr y) { return functions::isless(x, y); }
inline bool islessequal(half x, half y) { return functions::islessequal(x, y); }
inline bool islessequal(half x, expr y) { return functions::islessequal(x, y); }
inline bool islessequal(expr x, half y) { return functions::islessequal(x, y); }
inline bool islessequal(expr x, expr y) { return functions::islessequal(x, y); }
inline bool islessgreater(half x, half y) { return functions::islessgreater(x, y); }
inline bool islessgreater(half x, expr y) { return functions::islessgreater(x, y); }
inline bool islessgreater(expr x, half y) { return functions::islessgreater(x, y); }
inline bool islessgreater(expr x, expr y) { return functions::islessgreater(x, y); }
inline bool isunordered(half x, half y) { return functions::isunordered(x, y); }
inline bool isunordered(half x, expr y) { return functions::isunordered(x, y); }
inline bool isunordered(expr x, half y) { return functions::isunordered(x, y); }
inline bool isunordered(expr x, expr y) { return functions::isunordered(x, y); }
# 3040 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
template<typename T,typename U> typename half_caster<T,U>::type half_cast(U arg) { return half_caster<T,U>::cast(arg); }
# 3057 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
template<typename T,std::float_round_style R,typename U> typename half_caster<T,U,R>::type half_cast(U arg)
{ return half_caster<T,U,R>::cast(arg); }
}
using detail::operator==;
using detail::operator!=;
using detail::operator<;
using detail::operator>;
using detail::operator<=;
using detail::operator>=;
using detail::operator+;
using detail::operator-;
using detail::operator*;
using detail::operator/;
using detail::operator<<;
using detail::operator>>;
# 3135 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
using detail::fpclassify;
using detail::isfinite;
using detail::isinf;
using detail::isnan;
using detail::isnormal;
using detail::signbit;
using detail::isgreater;
using detail::isgreaterequal;
using detail::isless;
using detail::islessequal;
using detail::islessgreater;
using detail::isunordered;
using detail::half_cast;
namespace std
{
template<> struct numeric_limits<half> : public numeric_limits<float>
{
public:
static constexpr bool is_signed = true;
static constexpr bool is_exact = false;
static constexpr bool is_modulo = false;
static constexpr bool is_iec559 = true;
static constexpr bool has_infinity = true;
static constexpr bool has_quiet_NaN = true;
static constexpr float_denorm_style has_denorm = denorm_present;
static constexpr float_round_style round_style = (std::numeric_limits<float>::round_style==
half::round_style) ? half::round_style : round_indeterminate;
static constexpr int digits = 11;
static constexpr int digits10 = 3;
static constexpr int max_digits10 = 5;
static constexpr int radix = 2;
static constexpr int min_exponent = -13;
static constexpr int min_exponent10 = -4;
static constexpr int max_exponent = 16;
static constexpr int max_exponent10 = 4;
static constexpr half min() noexcept { return half(detail::binary, 0x0400); }
static constexpr half lowest() noexcept { return half(detail::binary, 0xFBFF); }
static constexpr half max() noexcept { return half(detail::binary, 0x7BFF); }
static constexpr half epsilon() noexcept { return half(detail::binary, 0x1400); }
static constexpr half round_error() noexcept
{ return half(detail::binary, (round_style==std::round_to_nearest) ? 0x3800 : 0x3C00); }
static constexpr half infinity() noexcept { return half(detail::binary, 0x7C00); }
static constexpr half quiet_NaN() noexcept { return half(detail::binary, 0x7FFF); }
static constexpr half signaling_NaN() noexcept { return half(detail::binary, 0x7DFF); }
static constexpr half denorm_min() noexcept { return half(detail::binary, 0x0001); }
};
template<> struct hash<half>
{
typedef half argument_type;
typedef size_t result_type;
result_type operator()(argument_type arg) const
{ return hash<detail::uint16>()(static_cast<unsigned int>(arg.data_)&-(arg.data_!=0x8000)); }
};
}
# 3274 "/data/tools/Xilinx/Vivado/2019.1/include/hls_half.h"
extern half half_nan(const char *tagp);
extern half half_atan(half t);
extern half half_atan2(half y, half x);
extern half half_copysign(half x, half y);
extern half half_fabs(half x);
extern half half_abs(half x);
extern half half_fma(half x, half y, half z);
extern half half_mad(half x, half y, half z);
extern half half_frexp (half x, int* exp);
extern half half_ldexp (half x, int exp);
extern half half_fmax(half x, half y);
extern half half_fmin(half x, half y);
extern half half_asin(half t_in);
extern half half_acos(half t_in);
extern half half_sin(half t_in);
extern half half_cos(half t_in);
extern void half_sincos(half x, half *sin, half *cos);
extern half half_sinh(half t_in);
extern half half_cosh(half t_in);
extern half half_sinpi(half t_in);
extern half half_cospi(half t_in);
extern half half_recip(half x);
extern half half_sqrt(half x);
extern half half_rsqrt(half x);
extern half half_cbrt(half x);
extern half half_hypot(half x, half y);
extern half half_log(half x);
extern half half_log10(half x);
extern half half_log2(half x);
extern half half_logb(half x);
extern half half_log1p(half x);
extern int half_ilogb(half x);
extern half half_exp(half x);
extern half half_exp10(half x);
extern half half_exp2(half x);
extern half half_expm1(half x);
extern half half_pow(half x, half y);
extern half half_powr(half x, half y);
extern half half_pown(half x, int y);
extern half half_rootn(half x, int y);
extern half half_floor(half x);
extern half half_ceil(half x);
extern half half_trunc(half x);
extern half half_round(half x);
extern half half_nearbyint(half x);
extern half half_rint(half x);
extern long int half_lrint(half x);
extern long long int half_llrint(half x);
extern long int half_lround(half x);
extern long long int half_llround(half x);
extern half half_modf(half x, half *intpart);
extern half half_fract(half x, half *intpart);
extern half half_nextafter(half x, half y);
extern half half_fmod(half x, half y);
extern half half_remainder(half x, half y);
extern half half_remquo(half x, half y, int* quo);
extern half half_divide(half x, half y);
# 91 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 2
# 101 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
namespace AESL_std {
template <class DataType>
DataType inline min(DataType a, DataType b) {
return (a >= b) ? b : a;
}
template <class DataType>
DataType inline max(DataType a, DataType b) {
return (a >= b) ? a : b;
}
}
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/math.h" 1 3
# 115 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 2
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cassert" 1 3
# 41 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cassert" 3
# 42 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cassert" 3
# 1 "/usr/include/assert.h" 1 3 4
# 65 "/usr/include/assert.h" 3 4
# 65 "/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__));
}
# 44 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cassert" 2 3
# 117 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 2
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 1 3
# 39 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 3
# 40 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 3
# 118 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 2
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstring" 1 3
# 39 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstring" 3
# 40 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstring" 3
# 119 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 2
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iomanip" 1 3
# 36 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iomanip" 3
# 37 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iomanip" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/locale" 1 3
# 36 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/locale" 3
# 37 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/locale" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 1 3
# 37 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
# 38 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ctime" 1 3
# 39 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ctime" 3
# 40 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ctime" 3
# 58 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ctime" 3
namespace std
{
using ::clock_t;
using ::time_t;
using ::tm;
using ::clock;
using ::difftime;
using ::mktime;
using ::time;
using ::asctime;
using ::ctime;
using ::gmtime;
using ::localtime;
using ::strftime;
}
# 40 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 52 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
class time_base
{
public:
enum dateorder { no_order, dmy, mdy, ymd, ydm };
};
template<typename _CharT>
struct __timepunct_cache : public locale::facet
{
static const _CharT* _S_timezones[14];
const _CharT* _M_date_format;
const _CharT* _M_date_era_format;
const _CharT* _M_time_format;
const _CharT* _M_time_era_format;
const _CharT* _M_date_time_format;
const _CharT* _M_date_time_era_format;
const _CharT* _M_am;
const _CharT* _M_pm;
const _CharT* _M_am_pm_format;
const _CharT* _M_day1;
const _CharT* _M_day2;
const _CharT* _M_day3;
const _CharT* _M_day4;
const _CharT* _M_day5;
const _CharT* _M_day6;
const _CharT* _M_day7;
const _CharT* _M_aday1;
const _CharT* _M_aday2;
const _CharT* _M_aday3;
const _CharT* _M_aday4;
const _CharT* _M_aday5;
const _CharT* _M_aday6;
const _CharT* _M_aday7;
const _CharT* _M_month01;
const _CharT* _M_month02;
const _CharT* _M_month03;
const _CharT* _M_month04;
const _CharT* _M_month05;
const _CharT* _M_month06;
const _CharT* _M_month07;
const _CharT* _M_month08;
const _CharT* _M_month09;
const _CharT* _M_month10;
const _CharT* _M_month11;
const _CharT* _M_month12;
const _CharT* _M_amonth01;
const _CharT* _M_amonth02;
const _CharT* _M_amonth03;
const _CharT* _M_amonth04;
const _CharT* _M_amonth05;
const _CharT* _M_amonth06;
const _CharT* _M_amonth07;
const _CharT* _M_amonth08;
const _CharT* _M_amonth09;
const _CharT* _M_amonth10;
const _CharT* _M_amonth11;
const _CharT* _M_amonth12;
bool _M_allocated;
__timepunct_cache(size_t __refs = 0) : facet(__refs),
_M_date_format(0), _M_date_era_format(0), _M_time_format(0),
_M_time_era_format(0), _M_date_time_format(0),
_M_date_time_era_format(0), _M_am(0), _M_pm(0),
_M_am_pm_format(0), _M_day1(0), _M_day2(0), _M_day3(0),
_M_day4(0), _M_day5(0), _M_day6(0), _M_day7(0),
_M_aday1(0), _M_aday2(0), _M_aday3(0), _M_aday4(0),
_M_aday5(0), _M_aday6(0), _M_aday7(0), _M_month01(0),
_M_month02(0), _M_month03(0), _M_month04(0), _M_month05(0),
_M_month06(0), _M_month07(0), _M_month08(0), _M_month09(0),
_M_month10(0), _M_month11(0), _M_month12(0), _M_amonth01(0),
_M_amonth02(0), _M_amonth03(0), _M_amonth04(0),
_M_amonth05(0), _M_amonth06(0), _M_amonth07(0),
_M_amonth08(0), _M_amonth09(0), _M_amonth10(0),
_M_amonth11(0), _M_amonth12(0), _M_allocated(false)
{ }
~__timepunct_cache();
private:
__timepunct_cache&
operator=(const __timepunct_cache&);
explicit
__timepunct_cache(const __timepunct_cache&);
};
template<typename _CharT>
__timepunct_cache<_CharT>::~__timepunct_cache()
{
if (_M_allocated)
{
}
}
template<>
const char*
__timepunct_cache<char>::_S_timezones[14];
template<>
const wchar_t*
__timepunct_cache<wchar_t>::_S_timezones[14];
template<typename _CharT>
const _CharT* __timepunct_cache<_CharT>::_S_timezones[14];
template<typename _CharT>
class __timepunct : public locale::facet
{
public:
typedef _CharT __char_type;
typedef __timepunct_cache<_CharT> __cache_type;
protected:
__cache_type* _M_data;
__c_locale _M_c_locale_timepunct;
const char* _M_name_timepunct;
public:
static locale::id id;
explicit
__timepunct(size_t __refs = 0);
explicit
__timepunct(__cache_type* __cache, size_t __refs = 0);
# 206 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
explicit
__timepunct(__c_locale __cloc, const char* __s, size_t __refs = 0);
void
_M_put(_CharT* __s, size_t __maxlen, const _CharT* __format,
const tm* __tm) const throw ();
void
_M_date_formats(const _CharT** __date) const
{
__date[0] = _M_data->_M_date_format;
__date[1] = _M_data->_M_date_era_format;
}
void
_M_time_formats(const _CharT** __time) const
{
__time[0] = _M_data->_M_time_format;
__time[1] = _M_data->_M_time_era_format;
}
void
_M_date_time_formats(const _CharT** __dt) const
{
__dt[0] = _M_data->_M_date_time_format;
__dt[1] = _M_data->_M_date_time_era_format;
}
void
_M_am_pm_format(const _CharT* __ampm) const
{ __ampm = _M_data->_M_am_pm_format; }
void
_M_am_pm(const _CharT** __ampm) const
{
__ampm[0] = _M_data->_M_am;
__ampm[1] = _M_data->_M_pm;
}
void
_M_days(const _CharT** __days) const
{
__days[0] = _M_data->_M_day1;
__days[1] = _M_data->_M_day2;
__days[2] = _M_data->_M_day3;
__days[3] = _M_data->_M_day4;
__days[4] = _M_data->_M_day5;
__days[5] = _M_data->_M_day6;
__days[6] = _M_data->_M_day7;
}
void
_M_days_abbreviated(const _CharT** __days) const
{
__days[0] = _M_data->_M_aday1;
__days[1] = _M_data->_M_aday2;
__days[2] = _M_data->_M_aday3;
__days[3] = _M_data->_M_aday4;
__days[4] = _M_data->_M_aday5;
__days[5] = _M_data->_M_aday6;
__days[6] = _M_data->_M_aday7;
}
void
_M_months(const _CharT** __months) const
{
__months[0] = _M_data->_M_month01;
__months[1] = _M_data->_M_month02;
__months[2] = _M_data->_M_month03;
__months[3] = _M_data->_M_month04;
__months[4] = _M_data->_M_month05;
__months[5] = _M_data->_M_month06;
__months[6] = _M_data->_M_month07;
__months[7] = _M_data->_M_month08;
__months[8] = _M_data->_M_month09;
__months[9] = _M_data->_M_month10;
__months[10] = _M_data->_M_month11;
__months[11] = _M_data->_M_month12;
}
void
_M_months_abbreviated(const _CharT** __months) const
{
__months[0] = _M_data->_M_amonth01;
__months[1] = _M_data->_M_amonth02;
__months[2] = _M_data->_M_amonth03;
__months[3] = _M_data->_M_amonth04;
__months[4] = _M_data->_M_amonth05;
__months[5] = _M_data->_M_amonth06;
__months[6] = _M_data->_M_amonth07;
__months[7] = _M_data->_M_amonth08;
__months[8] = _M_data->_M_amonth09;
__months[9] = _M_data->_M_amonth10;
__months[10] = _M_data->_M_amonth11;
__months[11] = _M_data->_M_amonth12;
}
protected:
virtual
~__timepunct();
void
_M_initialize_timepunct(__c_locale __cloc = 0);
};
template<typename _CharT>
locale::id __timepunct<_CharT>::id;
template<>
void
__timepunct<char>::_M_initialize_timepunct(__c_locale __cloc);
template<>
void
__timepunct<char>::_M_put(char*, size_t, const char*, const tm*) const throw ();
template<>
void
__timepunct<wchar_t>::_M_initialize_timepunct(__c_locale __cloc);
template<>
void
__timepunct<wchar_t>::_M_put(wchar_t*, size_t, const wchar_t*,
const tm*) const throw ();
}
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/time_members.h" 1 3
# 37 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/time_members.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT>
__timepunct<_CharT>::__timepunct(size_t __refs)
: facet(__refs), _M_data(0), _M_c_locale_timepunct(0),
_M_name_timepunct(_S_get_c_name())
{ _M_initialize_timepunct(); }
template<typename _CharT>
__timepunct<_CharT>::__timepunct(__cache_type* __cache, size_t __refs)
: facet(__refs), _M_data(__cache), _M_c_locale_timepunct(0),
_M_name_timepunct(_S_get_c_name())
{ _M_initialize_timepunct(); }
template<typename _CharT>
__timepunct<_CharT>::__timepunct(__c_locale __cloc, const char* __s,
size_t __refs)
: facet(__refs), _M_data(0), _M_c_locale_timepunct(0),
_M_name_timepunct(0)
{
if (__builtin_strcmp(__s, _S_get_c_name()) != 0)
{
const size_t __len = __builtin_strlen(__s) + 1;
char* __tmp = new char[__len];
__builtin_memcpy(__tmp, __s, __len);
_M_name_timepunct = __tmp;
}
else
_M_name_timepunct = _S_get_c_name();
try
{ _M_initialize_timepunct(__cloc); }
catch(...)
{
if (_M_name_timepunct != _S_get_c_name())
delete [] _M_name_timepunct;
throw;
}
}
template<typename _CharT>
__timepunct<_CharT>::~__timepunct()
{
if (_M_name_timepunct != _S_get_c_name())
delete [] _M_name_timepunct;
delete _M_data;
_S_destroy_c_locale(_M_c_locale_timepunct);
}
}
# 345 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
namespace __cxx11 {
# 365 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
template<typename _CharT, typename _InIter>
class time_get : public locale::facet, public time_base
{
public:
typedef _CharT char_type;
typedef _InIter iter_type;
static locale::id id;
# 386 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
explicit
time_get(size_t __refs = 0)
: facet (__refs) { }
# 403 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
dateorder
date_order() const
{ return this->do_date_order(); }
# 427 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
iter_type
get_time(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, tm* __tm) const
{ return this->do_get_time(__beg, __end, __io, __err, __tm); }
# 452 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
iter_type
get_date(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, tm* __tm) const
{ return this->do_get_date(__beg, __end, __io, __err, __tm); }
# 480 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
iter_type
get_weekday(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, tm* __tm) const
{ return this->do_get_weekday(__beg, __end, __io, __err, __tm); }
# 509 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
iter_type
get_monthname(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, tm* __tm) const
{ return this->do_get_monthname(__beg, __end, __io, __err, __tm); }
# 535 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
iter_type
get_year(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, tm* __tm) const
{ return this->do_get_year(__beg, __end, __io, __err, __tm); }
# 556 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
inline
iter_type get(iter_type __s, iter_type __end, ios_base& __io,
ios_base::iostate& __err, tm* __tm, char __format,
char __modifier = 0) const
{
return this->do_get(__s, __end, __io, __err, __tm, __format,
__modifier);
}
# 583 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
iter_type get(iter_type __s, iter_type __end, ios_base& __io,
ios_base::iostate& __err, tm* __tm, const char_type* __fmt,
const char_type* __fmtend) const;
protected:
virtual
~time_get() { }
# 603 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
virtual dateorder
do_date_order() const;
# 621 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
virtual iter_type
do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, tm* __tm) const;
# 640 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
virtual iter_type
do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, tm* __tm) const;
# 659 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
virtual iter_type
do_get_weekday(iter_type __beg, iter_type __end, ios_base&,
ios_base::iostate& __err, tm* __tm) const;
# 678 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
virtual iter_type
do_get_monthname(iter_type __beg, iter_type __end, ios_base&,
ios_base::iostate& __err, tm* __tm) const;
# 697 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
virtual iter_type
do_get_year(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, tm* __tm) const;
# 720 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
virtual
iter_type
do_get(iter_type __s, iter_type __end, ios_base& __f,
ios_base::iostate& __err, tm* __tm,
char __format, char __modifier) const;
iter_type
_M_extract_num(iter_type __beg, iter_type __end, int& __member,
int __min, int __max, size_t __len,
ios_base& __io, ios_base::iostate& __err) const;
iter_type
_M_extract_name(iter_type __beg, iter_type __end, int& __member,
const _CharT** __names, size_t __indexlen,
ios_base& __io, ios_base::iostate& __err) const;
iter_type
_M_extract_wday_or_month(iter_type __beg, iter_type __end, int& __member,
const _CharT** __names, size_t __indexlen,
ios_base& __io, ios_base::iostate& __err) const;
iter_type
_M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, tm* __tm,
const _CharT* __format) const;
};
template<typename _CharT, typename _InIter>
locale::id time_get<_CharT, _InIter>::id;
template<typename _CharT, typename _InIter>
class time_get_byname : public time_get<_CharT, _InIter>
{
public:
typedef _CharT char_type;
typedef _InIter iter_type;
explicit
time_get_byname(const char*, size_t __refs = 0)
: time_get<_CharT, _InIter>(__refs) { }
explicit
time_get_byname(const string& __s, size_t __refs = 0)
: time_get_byname(__s.c_str(), __refs) { }
protected:
virtual
~time_get_byname() { }
};
}
# 794 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
template<typename _CharT, typename _OutIter>
class time_put : public locale::facet
{
public:
typedef _CharT char_type;
typedef _OutIter iter_type;
static locale::id id;
# 815 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
explicit
time_put(size_t __refs = 0)
: facet(__refs) { }
# 834 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
iter_type
put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
const _CharT* __beg, const _CharT* __end) const;
# 854 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
iter_type
put(iter_type __s, ios_base& __io, char_type __fill,
const tm* __tm, char __format, char __mod = 0) const
{ return this->do_put(__s, __io, __fill, __tm, __format, __mod); }
protected:
virtual
~time_put()
{ }
# 881 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
virtual iter_type
do_put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
char __format, char __mod) const;
};
template<typename _CharT, typename _OutIter>
locale::id time_put<_CharT, _OutIter>::id;
template<typename _CharT, typename _OutIter>
class time_put_byname : public time_put<_CharT, _OutIter>
{
public:
typedef _CharT char_type;
typedef _OutIter iter_type;
explicit
time_put_byname(const char*, size_t __refs = 0)
: time_put<_CharT, _OutIter>(__refs)
{ };
explicit
time_put_byname(const string& __s, size_t __refs = 0)
: time_put_byname(__s.c_str(), __refs) { }
protected:
virtual
~time_put_byname() { }
};
# 926 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
class money_base
{
public:
enum part { none, space, symbol, sign, value };
struct pattern { char field[4]; };
static const pattern _S_default_pattern;
enum
{
_S_minus,
_S_zero,
_S_end = 11
};
static const char* _S_atoms;
__attribute__ ((__const__)) static pattern
_S_construct_pattern(char __precedes, char __space, char __posn) throw ();
};
template<typename _CharT, bool _Intl>
struct __moneypunct_cache : public locale::facet
{
const char* _M_grouping;
size_t _M_grouping_size;
bool _M_use_grouping;
_CharT _M_decimal_point;
_CharT _M_thousands_sep;
const _CharT* _M_curr_symbol;
size_t _M_curr_symbol_size;
const _CharT* _M_positive_sign;
size_t _M_positive_sign_size;
const _CharT* _M_negative_sign;
size_t _M_negative_sign_size;
int _M_frac_digits;
money_base::pattern _M_pos_format;
money_base::pattern _M_neg_format;
_CharT _M_atoms[money_base::_S_end];
bool _M_allocated;
__moneypunct_cache(size_t __refs = 0) : facet(__refs),
_M_grouping(0), _M_grouping_size(0), _M_use_grouping(false),
_M_decimal_point(_CharT()), _M_thousands_sep(_CharT()),
_M_curr_symbol(0), _M_curr_symbol_size(0),
_M_positive_sign(0), _M_positive_sign_size(0),
_M_negative_sign(0), _M_negative_sign_size(0),
_M_frac_digits(0),
_M_pos_format(money_base::pattern()),
_M_neg_format(money_base::pattern()), _M_allocated(false)
{ }
~__moneypunct_cache();
void
_M_cache(const locale& __loc);
private:
__moneypunct_cache&
operator=(const __moneypunct_cache&);
explicit
__moneypunct_cache(const __moneypunct_cache&);
};
template<typename _CharT, bool _Intl>
__moneypunct_cache<_CharT, _Intl>::~__moneypunct_cache()
{
if (_M_allocated)
{
delete [] _M_grouping;
delete [] _M_curr_symbol;
delete [] _M_positive_sign;
delete [] _M_negative_sign;
}
}
namespace __cxx11 {
# 1021 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
template<typename _CharT, bool _Intl>
class moneypunct : public locale::facet, public money_base
{
public:
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;
typedef __moneypunct_cache<_CharT, _Intl> __cache_type;
private:
__cache_type* _M_data;
public:
static const bool intl = _Intl;
static locale::id id;
# 1050 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
explicit
moneypunct(size_t __refs = 0)
: facet(__refs), _M_data(0)
{ _M_initialize_moneypunct(); }
# 1063 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
explicit
moneypunct(__cache_type* __cache, size_t __refs = 0)
: facet(__refs), _M_data(__cache)
{ _M_initialize_moneypunct(); }
# 1078 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
explicit
moneypunct(__c_locale __cloc, const char* __s, size_t __refs = 0)
: facet(__refs), _M_data(0)
{ _M_initialize_moneypunct(__cloc, __s); }
# 1092 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
char_type
decimal_point() const
{ return this->do_decimal_point(); }
# 1105 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
char_type
thousands_sep() const
{ return this->do_thousands_sep(); }
# 1135 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
string
grouping() const
{ return this->do_grouping(); }
# 1148 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
string_type
curr_symbol() const
{ return this->do_curr_symbol(); }
# 1165 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
string_type
positive_sign() const
{ return this->do_positive_sign(); }
# 1182 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
string_type
negative_sign() const
{ return this->do_negative_sign(); }
# 1198 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
int
frac_digits() const
{ return this->do_frac_digits(); }
# 1234 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
pattern
pos_format() const
{ return this->do_pos_format(); }
pattern
neg_format() const
{ return this->do_neg_format(); }
protected:
virtual
~moneypunct();
# 1256 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
virtual char_type
do_decimal_point() const
{ return _M_data->_M_decimal_point; }
# 1268 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
virtual char_type
do_thousands_sep() const
{ return _M_data->_M_thousands_sep; }
# 1281 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
virtual string
do_grouping() const
{ return _M_data->_M_grouping; }
# 1294 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
virtual string_type
do_curr_symbol() const
{ return _M_data->_M_curr_symbol; }
# 1307 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
virtual string_type
do_positive_sign() const
{ return _M_data->_M_positive_sign; }
# 1320 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
virtual string_type
do_negative_sign() const
{ return _M_data->_M_negative_sign; }
# 1334 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
virtual int
do_frac_digits() const
{ return _M_data->_M_frac_digits; }
# 1348 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
virtual pattern
do_pos_format() const
{ return _M_data->_M_pos_format; }
# 1362 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
virtual pattern
do_neg_format() const
{ return _M_data->_M_neg_format; }
void
_M_initialize_moneypunct(__c_locale __cloc = 0,
const char* __name = 0);
};
template<typename _CharT, bool _Intl>
locale::id moneypunct<_CharT, _Intl>::id;
template<typename _CharT, bool _Intl>
const bool moneypunct<_CharT, _Intl>::intl;
template<>
moneypunct<char, true>::~moneypunct();
template<>
moneypunct<char, false>::~moneypunct();
template<>
void
moneypunct<char, true>::_M_initialize_moneypunct(__c_locale, const char*);
template<>
void
moneypunct<char, false>::_M_initialize_moneypunct(__c_locale, const char*);
template<>
moneypunct<wchar_t, true>::~moneypunct();
template<>
moneypunct<wchar_t, false>::~moneypunct();
template<>
void
moneypunct<wchar_t, true>::_M_initialize_moneypunct(__c_locale,
const char*);
template<>
void
moneypunct<wchar_t, false>::_M_initialize_moneypunct(__c_locale,
const char*);
template<typename _CharT, bool _Intl>
class moneypunct_byname : public moneypunct<_CharT, _Intl>
{
public:
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;
static const bool intl = _Intl;
explicit
moneypunct_byname(const char* __s, size_t __refs = 0)
: moneypunct<_CharT, _Intl>(__refs)
{
if (__builtin_strcmp(__s, "C") != 0
&& __builtin_strcmp(__s, "POSIX") != 0)
{
__c_locale __tmp;
this->_S_create_c_locale(__tmp, __s);
this->_M_initialize_moneypunct(__tmp);
this->_S_destroy_c_locale(__tmp);
}
}
explicit
moneypunct_byname(const string& __s, size_t __refs = 0)
: moneypunct_byname(__s.c_str(), __refs) { }
protected:
virtual
~moneypunct_byname() { }
};
template<typename _CharT, bool _Intl>
const bool moneypunct_byname<_CharT, _Intl>::intl;
}
namespace __cxx11 {
# 1465 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
template<typename _CharT, typename _InIter>
class money_get : public locale::facet
{
public:
typedef _CharT char_type;
typedef _InIter iter_type;
typedef basic_string<_CharT> string_type;
static locale::id id;
# 1487 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
explicit
money_get(size_t __refs = 0) : facet(__refs) { }
# 1517 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
iter_type
get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
ios_base::iostate& __err, long double& __units) const
{ return this->do_get(__s, __end, __intl, __io, __err, __units); }
# 1548 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
iter_type
get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
ios_base::iostate& __err, string_type& __digits) const
{ return this->do_get(__s, __end, __intl, __io, __err, __digits); }
protected:
virtual
~money_get() { }
# 1572 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
virtual iter_type
do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
ios_base::iostate& __err, long double& __units) const;
# 1584 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
virtual iter_type
do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
ios_base::iostate& __err, string_type& __digits) const;
# 1596 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
template<bool _Intl>
iter_type
_M_extract(iter_type __s, iter_type __end, ios_base& __io,
ios_base::iostate& __err, string& __digits) const;
};
template<typename _CharT, typename _InIter>
locale::id money_get<_CharT, _InIter>::id;
# 1618 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
template<typename _CharT, typename _OutIter>
class money_put : public locale::facet
{
public:
typedef _CharT char_type;
typedef _OutIter iter_type;
typedef basic_string<_CharT> string_type;
static locale::id id;
# 1639 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
explicit
money_put(size_t __refs = 0) : facet(__refs) { }
# 1659 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
iter_type
put(iter_type __s, bool __intl, ios_base& __io,
char_type __fill, long double __units) const
{ return this->do_put(__s, __intl, __io, __fill, __units); }
# 1682 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
iter_type
put(iter_type __s, bool __intl, ios_base& __io,
char_type __fill, const string_type& __digits) const
{ return this->do_put(__s, __intl, __io, __fill, __digits); }
protected:
virtual
~money_put() { }
# 1717 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
virtual iter_type
do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
long double __units) const;
# 1741 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
virtual iter_type
do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
const string_type& __digits) const;
# 1753 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
template<bool _Intl>
iter_type
_M_insert(iter_type __s, ios_base& __io, char_type __fill,
const string_type& __digits) const;
};
template<typename _CharT, typename _OutIter>
locale::id money_put<_CharT, _OutIter>::id;
}
struct messages_base
{
typedef int catalog;
};
namespace __cxx11 {
# 1796 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
template<typename _CharT>
class messages : public locale::facet, public messages_base
{
public:
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;
protected:
__c_locale _M_c_locale_messages;
const char* _M_name_messages;
public:
static locale::id id;
# 1824 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
explicit
messages(size_t __refs = 0);
# 1838 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
explicit
messages(__c_locale __cloc, const char* __s, size_t __refs = 0);
# 1851 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
catalog
open(const basic_string<char>& __s, const locale& __loc) const
{ return this->do_open(__s, __loc); }
# 1869 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
catalog
open(const basic_string<char>&, const locale&, const char*) const;
# 1887 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
string_type
get(catalog __c, int __set, int __msgid, const string_type& __s) const
{ return this->do_get(__c, __set, __msgid, __s); }
# 1898 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
void
close(catalog __c) const
{ return this->do_close(__c); }
protected:
virtual
~messages();
# 1918 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
virtual catalog
do_open(const basic_string<char>&, const locale&) const;
# 1937 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
virtual string_type
do_get(catalog, int, int, const string_type& __dfault) const;
virtual void
do_close(catalog) const;
char*
_M_convert_to_char(const string_type& __msg) const
{
return reinterpret_cast<char*>(const_cast<_CharT*>(__msg.c_str()));
}
string_type
_M_convert_from_char(char*) const
{
return string_type();
}
};
template<typename _CharT>
locale::id messages<_CharT>::id;
template<>
string
messages<char>::do_get(catalog, int, int, const string&) const;
template<>
wstring
messages<wchar_t>::do_get(catalog, int, int, const wstring&) const;
template<typename _CharT>
class messages_byname : public messages<_CharT>
{
public:
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;
explicit
messages_byname(const char* __s, size_t __refs = 0);
explicit
messages_byname(const string& __s, size_t __refs = 0)
: messages_byname(__s.c_str(), __refs) { }
protected:
virtual
~messages_byname()
{ }
};
}
}
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/messages_members.h" 1 3
# 36 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/messages_members.h" 3
# 1 "/usr/include/libintl.h" 1 3 4
# 34 "/usr/include/libintl.h" 3 4
extern "C" {
extern char *gettext (const char *__msgid)
throw () __attribute__ ((__format_arg__ (1)));
extern char *dgettext (const char *__domainname, const char *__msgid)
throw () __attribute__ ((__format_arg__ (2)));
extern char *__dgettext (const char *__domainname, const char *__msgid)
throw () __attribute__ ((__format_arg__ (2)));
extern char *dcgettext (const char *__domainname,
const char *__msgid, int __category)
throw () __attribute__ ((__format_arg__ (2)));
extern char *__dcgettext (const char *__domainname,
const char *__msgid, int __category)
throw () __attribute__ ((__format_arg__ (2)));
extern char *ngettext (const char *__msgid1, const char *__msgid2,
unsigned long int __n)
throw () __attribute__ ((__format_arg__ (1))) __attribute__ ((__format_arg__ (2)));
extern char *dngettext (const char *__domainname, const char *__msgid1,
const char *__msgid2, unsigned long int __n)
throw () __attribute__ ((__format_arg__ (2))) __attribute__ ((__format_arg__ (3)));
extern char *dcngettext (const char *__domainname, const char *__msgid1,
const char *__msgid2, unsigned long int __n,
int __category)
throw () __attribute__ ((__format_arg__ (2))) __attribute__ ((__format_arg__ (3)));
extern char *textdomain (const char *__domainname) throw ();
extern char *bindtextdomain (const char *__domainname,
const char *__dirname) throw ();
extern char *bind_textdomain_codeset (const char *__domainname,
const char *__codeset) throw ();
# 121 "/usr/include/libintl.h" 3 4
}
# 37 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/messages_members.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT>
messages<_CharT>::messages(size_t __refs)
: facet(__refs), _M_c_locale_messages(_S_get_c_locale()),
_M_name_messages(_S_get_c_name())
{ }
template<typename _CharT>
messages<_CharT>::messages(__c_locale __cloc, const char* __s,
size_t __refs)
: facet(__refs), _M_c_locale_messages(0), _M_name_messages(0)
{
if (__builtin_strcmp(__s, _S_get_c_name()) != 0)
{
const size_t __len = __builtin_strlen(__s) + 1;
char* __tmp = new char[__len];
__builtin_memcpy(__tmp, __s, __len);
_M_name_messages = __tmp;
}
else
_M_name_messages = _S_get_c_name();
_M_c_locale_messages = _S_clone_c_locale(__cloc);
}
template<typename _CharT>
typename messages<_CharT>::catalog
messages<_CharT>::open(const basic_string<char>& __s, const locale& __loc,
const char* __dir) const
{
bindtextdomain(__s.c_str(), __dir);
return this->do_open(__s, __loc);
}
template<typename _CharT>
messages<_CharT>::~messages()
{
if (_M_name_messages != _S_get_c_name())
delete [] _M_name_messages;
_S_destroy_c_locale(_M_c_locale_messages);
}
template<typename _CharT>
typename messages<_CharT>::catalog
messages<_CharT>::do_open(const basic_string<char>& __s,
const locale&) const
{
textdomain(__s.c_str());
return 0;
}
template<typename _CharT>
void
messages<_CharT>::do_close(catalog) const
{ }
template<typename _CharT>
messages_byname<_CharT>::messages_byname(const char* __s, size_t __refs)
: messages<_CharT>(__refs)
{
if (this->_M_name_messages != locale::facet::_S_get_c_name())
{
delete [] this->_M_name_messages;
if (__builtin_strcmp(__s, locale::facet::_S_get_c_name()) != 0)
{
const size_t __len = __builtin_strlen(__s) + 1;
char* __tmp = new char[__len];
__builtin_memcpy(__tmp, __s, __len);
this->_M_name_messages = __tmp;
}
else
this->_M_name_messages = locale::facet::_S_get_c_name();
}
if (__builtin_strcmp(__s, "C") != 0
&& __builtin_strcmp(__s, "POSIX") != 0)
{
this->_S_destroy_c_locale(this->_M_c_locale_messages);
this->_S_create_c_locale(this->_M_c_locale_messages, __s);
}
}
template<>
typename messages<char>::catalog
messages<char>::do_open(const basic_string<char>&,
const locale&) const;
template<>
void
messages<char>::do_close(catalog) const;
template<>
typename messages<wchar_t>::catalog
messages<wchar_t>::do_open(const basic_string<char>&,
const locale&) const;
template<>
void
messages<wchar_t>::do_close(catalog) const;
}
# 2009 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/codecvt.h" 1 3
# 39 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/codecvt.h" 3
# 40 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/codecvt.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
class codecvt_base
{
public:
enum result
{
ok,
partial,
error,
noconv
};
};
# 67 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/codecvt.h" 3
template<typename _InternT, typename _ExternT, typename _StateT>
class __codecvt_abstract_base
: public locale::facet, public codecvt_base
{
public:
typedef codecvt_base::result result;
typedef _InternT intern_type;
typedef _ExternT extern_type;
typedef _StateT state_type;
# 115 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/codecvt.h" 3
result
out(state_type& __state, const intern_type* __from,
const intern_type* __from_end, const intern_type*& __from_next,
extern_type* __to, extern_type* __to_end,
extern_type*& __to_next) const
{
return this->do_out(__state, __from, __from_end, __from_next,
__to, __to_end, __to_next);
}
# 154 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/codecvt.h" 3
result
unshift(state_type& __state, extern_type* __to, extern_type* __to_end,
extern_type*& __to_next) const
{ return this->do_unshift(__state, __to,__to_end,__to_next); }
# 195 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/codecvt.h" 3
result
in(state_type& __state, const extern_type* __from,
const extern_type* __from_end, const extern_type*& __from_next,
intern_type* __to, intern_type* __to_end,
intern_type*& __to_next) const
{
return this->do_in(__state, __from, __from_end, __from_next,
__to, __to_end, __to_next);
}
int
encoding() const throw()
{ return this->do_encoding(); }
bool
always_noconv() const throw()
{ return this->do_always_noconv(); }
int
length(state_type& __state, const extern_type* __from,
const extern_type* __end, size_t __max) const
{ return this->do_length(__state, __from, __end, __max); }
int
max_length() const throw()
{ return this->do_max_length(); }
protected:
explicit
__codecvt_abstract_base(size_t __refs = 0) : locale::facet(__refs) { }
virtual
~__codecvt_abstract_base() { }
# 236 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/codecvt.h" 3
virtual result
do_out(state_type& __state, const intern_type* __from,
const intern_type* __from_end, const intern_type*& __from_next,
extern_type* __to, extern_type* __to_end,
extern_type*& __to_next) const = 0;
virtual result
do_unshift(state_type& __state, extern_type* __to,
extern_type* __to_end, extern_type*& __to_next) const = 0;
virtual result
do_in(state_type& __state, const extern_type* __from,
const extern_type* __from_end, const extern_type*& __from_next,
intern_type* __to, intern_type* __to_end,
intern_type*& __to_next) const = 0;
virtual int
do_encoding() const throw() = 0;
virtual bool
do_always_noconv() const throw() = 0;
virtual int
do_length(state_type&, const extern_type* __from,
const extern_type* __end, size_t __max) const = 0;
virtual int
do_max_length() const throw() = 0;
};
# 273 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/codecvt.h" 3
template<typename _InternT, typename _ExternT, typename _StateT>
class codecvt
: public __codecvt_abstract_base<_InternT, _ExternT, _StateT>
{
public:
typedef codecvt_base::result result;
typedef _InternT intern_type;
typedef _ExternT extern_type;
typedef _StateT state_type;
protected:
__c_locale _M_c_locale_codecvt;
public:
static locale::id id;
explicit
codecvt(size_t __refs = 0)
: __codecvt_abstract_base<_InternT, _ExternT, _StateT> (__refs),
_M_c_locale_codecvt(0)
{ }
explicit
codecvt(__c_locale __cloc, size_t __refs = 0);
protected:
virtual
~codecvt() { }
virtual result
do_out(state_type& __state, const intern_type* __from,
const intern_type* __from_end, const intern_type*& __from_next,
extern_type* __to, extern_type* __to_end,
extern_type*& __to_next) const;
virtual result
do_unshift(state_type& __state, extern_type* __to,
extern_type* __to_end, extern_type*& __to_next) const;
virtual result
do_in(state_type& __state, const extern_type* __from,
const extern_type* __from_end, const extern_type*& __from_next,
intern_type* __to, intern_type* __to_end,
intern_type*& __to_next) const;
virtual int
do_encoding() const throw();
virtual bool
do_always_noconv() const throw();
virtual int
do_length(state_type&, const extern_type* __from,
const extern_type* __end, size_t __max) const;
virtual int
do_max_length() const throw();
};
template<typename _InternT, typename _ExternT, typename _StateT>
locale::id codecvt<_InternT, _ExternT, _StateT>::id;
template<>
class codecvt<char, char, mbstate_t>
: public __codecvt_abstract_base<char, char, mbstate_t>
{
friend class messages<char>;
public:
typedef char intern_type;
typedef char extern_type;
typedef mbstate_t state_type;
protected:
__c_locale _M_c_locale_codecvt;
public:
static locale::id id;
explicit
codecvt(size_t __refs = 0);
explicit
codecvt(__c_locale __cloc, size_t __refs = 0);
protected:
virtual
~codecvt();
virtual result
do_out(state_type& __state, const intern_type* __from,
const intern_type* __from_end, const intern_type*& __from_next,
extern_type* __to, extern_type* __to_end,
extern_type*& __to_next) const;
virtual result
do_unshift(state_type& __state, extern_type* __to,
extern_type* __to_end, extern_type*& __to_next) const;
virtual result
do_in(state_type& __state, const extern_type* __from,
const extern_type* __from_end, const extern_type*& __from_next,
intern_type* __to, intern_type* __to_end,
intern_type*& __to_next) const;
virtual int
do_encoding() const throw();
virtual bool
do_always_noconv() const throw();
virtual int
do_length(state_type&, const extern_type* __from,
const extern_type* __end, size_t __max) const;
virtual int
do_max_length() const throw();
};
template<>
class codecvt<wchar_t, char, mbstate_t>
: public __codecvt_abstract_base<wchar_t, char, mbstate_t>
{
friend class messages<wchar_t>;
public:
typedef wchar_t intern_type;
typedef char extern_type;
typedef mbstate_t state_type;
protected:
__c_locale _M_c_locale_codecvt;
public:
static locale::id id;
explicit
codecvt(size_t __refs = 0);
explicit
codecvt(__c_locale __cloc, size_t __refs = 0);
protected:
virtual
~codecvt();
virtual result
do_out(state_type& __state, const intern_type* __from,
const intern_type* __from_end, const intern_type*& __from_next,
extern_type* __to, extern_type* __to_end,
extern_type*& __to_next) const;
virtual result
do_unshift(state_type& __state,
extern_type* __to, extern_type* __to_end,
extern_type*& __to_next) const;
virtual result
do_in(state_type& __state,
const extern_type* __from, const extern_type* __from_end,
const extern_type*& __from_next,
intern_type* __to, intern_type* __to_end,
intern_type*& __to_next) const;
virtual
int do_encoding() const throw();
virtual
bool do_always_noconv() const throw();
virtual
int do_length(state_type&, const extern_type* __from,
const extern_type* __end, size_t __max) const;
virtual int
do_max_length() const throw();
};
# 467 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/codecvt.h" 3
template<>
class codecvt<char16_t, char, mbstate_t>
: public __codecvt_abstract_base<char16_t, char, mbstate_t>
{
public:
typedef char16_t intern_type;
typedef char extern_type;
typedef mbstate_t state_type;
public:
static locale::id id;
explicit
codecvt(size_t __refs = 0)
: __codecvt_abstract_base<char16_t, char, mbstate_t>(__refs) { }
protected:
virtual
~codecvt();
virtual result
do_out(state_type& __state, const intern_type* __from,
const intern_type* __from_end, const intern_type*& __from_next,
extern_type* __to, extern_type* __to_end,
extern_type*& __to_next) const;
virtual result
do_unshift(state_type& __state,
extern_type* __to, extern_type* __to_end,
extern_type*& __to_next) const;
virtual result
do_in(state_type& __state,
const extern_type* __from, const extern_type* __from_end,
const extern_type*& __from_next,
intern_type* __to, intern_type* __to_end,
intern_type*& __to_next) const;
virtual
int do_encoding() const throw();
virtual
bool do_always_noconv() const throw();
virtual
int do_length(state_type&, const extern_type* __from,
const extern_type* __end, size_t __max) const;
virtual int
do_max_length() const throw();
};
template<>
class codecvt<char32_t, char, mbstate_t>
: public __codecvt_abstract_base<char32_t, char, mbstate_t>
{
public:
typedef char32_t intern_type;
typedef char extern_type;
typedef mbstate_t state_type;
public:
static locale::id id;
explicit
codecvt(size_t __refs = 0)
: __codecvt_abstract_base<char32_t, char, mbstate_t>(__refs) { }
protected:
virtual
~codecvt();
virtual result
do_out(state_type& __state, const intern_type* __from,
const intern_type* __from_end, const intern_type*& __from_next,
extern_type* __to, extern_type* __to_end,
extern_type*& __to_next) const;
virtual result
do_unshift(state_type& __state,
extern_type* __to, extern_type* __to_end,
extern_type*& __to_next) const;
virtual result
do_in(state_type& __state,
const extern_type* __from, const extern_type* __from_end,
const extern_type*& __from_next,
intern_type* __to, intern_type* __to_end,
intern_type*& __to_next) const;
virtual
int do_encoding() const throw();
virtual
bool do_always_noconv() const throw();
virtual
int do_length(state_type&, const extern_type* __from,
const extern_type* __end, size_t __max) const;
virtual int
do_max_length() const throw();
};
template<typename _InternT, typename _ExternT, typename _StateT>
class codecvt_byname : public codecvt<_InternT, _ExternT, _StateT>
{
public:
explicit
codecvt_byname(const char* __s, size_t __refs = 0)
: codecvt<_InternT, _ExternT, _StateT>(__refs)
{
if (__builtin_strcmp(__s, "C") != 0
&& __builtin_strcmp(__s, "POSIX") != 0)
{
this->_S_destroy_c_locale(this->_M_c_locale_codecvt);
this->_S_create_c_locale(this->_M_c_locale_codecvt, __s);
}
}
explicit
codecvt_byname(const string& __s, size_t __refs = 0)
: codecvt_byname(__s.c_str(), __refs) { }
protected:
virtual
~codecvt_byname() { }
};
template<>
class codecvt_byname<char16_t, char, mbstate_t>
: public codecvt<char16_t, char, mbstate_t>
{
public:
explicit
codecvt_byname(const char* __s, size_t __refs = 0)
: codecvt<char16_t, char, mbstate_t>(__refs) { }
explicit
codecvt_byname(const string& __s, size_t __refs = 0)
: codecvt_byname(__s.c_str(), __refs) { }
protected:
virtual
~codecvt_byname() { }
};
template<>
class codecvt_byname<char32_t, char, mbstate_t>
: public codecvt<char32_t, char, mbstate_t>
{
public:
explicit
codecvt_byname(const char* __s, size_t __refs = 0)
: codecvt<char32_t, char, mbstate_t>(__refs) { }
explicit
codecvt_byname(const string& __s, size_t __refs = 0)
: codecvt_byname(__s.c_str(), __refs) { }
protected:
virtual
~codecvt_byname() { }
};
extern template class codecvt_byname<char, char, mbstate_t>;
extern template
const codecvt<char, char, mbstate_t>&
use_facet<codecvt<char, char, mbstate_t> >(const locale&);
extern template
bool
has_facet<codecvt<char, char, mbstate_t> >(const locale&);
extern template class codecvt_byname<wchar_t, char, mbstate_t>;
extern template
const codecvt<wchar_t, char, mbstate_t>&
use_facet<codecvt<wchar_t, char, mbstate_t> >(const locale&);
extern template
bool
has_facet<codecvt<wchar_t, char, mbstate_t> >(const locale&);
extern template class codecvt_byname<char16_t, char, mbstate_t>;
extern template class codecvt_byname<char32_t, char, mbstate_t>;
}
# 2012 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.tcc" 1 3
# 33 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.tcc" 3
# 34 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, bool _Intl>
struct __use_cache<__moneypunct_cache<_CharT, _Intl> >
{
const __moneypunct_cache<_CharT, _Intl>*
operator() (const locale& __loc) const
{
const size_t __i = moneypunct<_CharT, _Intl>::id._M_id();
const locale::facet** __caches = __loc._M_impl->_M_caches;
if (!__caches[__i])
{
__moneypunct_cache<_CharT, _Intl>* __tmp = 0;
try
{
__tmp = new __moneypunct_cache<_CharT, _Intl>;
__tmp->_M_cache(__loc);
}
catch(...)
{
delete __tmp;
throw;
}
__loc._M_impl->_M_install_cache(__tmp, __i);
}
return static_cast<
const __moneypunct_cache<_CharT, _Intl>*>(__caches[__i]);
}
};
template<typename _CharT, bool _Intl>
void
__moneypunct_cache<_CharT, _Intl>::_M_cache(const locale& __loc)
{
const moneypunct<_CharT, _Intl>& __mp =
use_facet<moneypunct<_CharT, _Intl> >(__loc);
_M_decimal_point = __mp.decimal_point();
_M_thousands_sep = __mp.thousands_sep();
_M_frac_digits = __mp.frac_digits();
char* __grouping = 0;
_CharT* __curr_symbol = 0;
_CharT* __positive_sign = 0;
_CharT* __negative_sign = 0;
try
{
const string& __g = __mp.grouping();
_M_grouping_size = __g.size();
__grouping = new char[_M_grouping_size];
__g.copy(__grouping, _M_grouping_size);
_M_use_grouping = (_M_grouping_size
&& static_cast<signed char>(__grouping[0]) > 0
&& (__grouping[0]
!= __gnu_cxx::__numeric_traits<char>::__max));
const basic_string<_CharT>& __cs = __mp.curr_symbol();
_M_curr_symbol_size = __cs.size();
__curr_symbol = new _CharT[_M_curr_symbol_size];
__cs.copy(__curr_symbol, _M_curr_symbol_size);
const basic_string<_CharT>& __ps = __mp.positive_sign();
_M_positive_sign_size = __ps.size();
__positive_sign = new _CharT[_M_positive_sign_size];
__ps.copy(__positive_sign, _M_positive_sign_size);
const basic_string<_CharT>& __ns = __mp.negative_sign();
_M_negative_sign_size = __ns.size();
__negative_sign = new _CharT[_M_negative_sign_size];
__ns.copy(__negative_sign, _M_negative_sign_size);
_M_pos_format = __mp.pos_format();
_M_neg_format = __mp.neg_format();
const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
__ct.widen(money_base::_S_atoms,
money_base::_S_atoms + money_base::_S_end, _M_atoms);
_M_grouping = __grouping;
_M_curr_symbol = __curr_symbol;
_M_positive_sign = __positive_sign;
_M_negative_sign = __negative_sign;
_M_allocated = true;
}
catch(...)
{
delete [] __grouping;
delete [] __curr_symbol;
delete [] __positive_sign;
delete [] __negative_sign;
throw;
}
}
namespace __cxx11 {
template<typename _CharT, typename _InIter>
template<bool _Intl>
_InIter
money_get<_CharT, _InIter>::
_M_extract(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, string& __units) const
{
typedef char_traits<_CharT> __traits_type;
typedef typename string_type::size_type size_type;
typedef money_base::part part;
typedef __moneypunct_cache<_CharT, _Intl> __cache_type;
const locale& __loc = __io._M_getloc();
const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
__use_cache<__cache_type> __uc;
const __cache_type* __lc = __uc(__loc);
const char_type* __lit = __lc->_M_atoms;
bool __negative = false;
size_type __sign_size = 0;
const bool __mandatory_sign = (__lc->_M_positive_sign_size
&& __lc->_M_negative_sign_size);
string __grouping_tmp;
if (__lc->_M_use_grouping)
__grouping_tmp.reserve(32);
int __last_pos = 0;
int __n = 0;
bool __testvalid = true;
bool __testdecfound = false;
string __res;
__res.reserve(32);
const char_type* __lit_zero = __lit + money_base::_S_zero;
const money_base::pattern __p = __lc->_M_neg_format;
for (int __i = 0; __i < 4 && __testvalid; ++__i)
{
const part __which = static_cast<part>(__p.field[__i]);
switch (__which)
{
case money_base::symbol:
if (__io.flags() & ios_base::showbase || __sign_size > 1
|| __i == 0
|| (__i == 1 && (__mandatory_sign
|| (static_cast<part>(__p.field[0])
== money_base::sign)
|| (static_cast<part>(__p.field[2])
== money_base::space)))
|| (__i == 2 && ((static_cast<part>(__p.field[3])
== money_base::value)
|| (__mandatory_sign
&& (static_cast<part>(__p.field[3])
== money_base::sign)))))
{
const size_type __len = __lc->_M_curr_symbol_size;
size_type __j = 0;
for (; __beg != __end && __j < __len
&& *__beg == __lc->_M_curr_symbol[__j];
++__beg, (void)++__j);
if (__j != __len
&& (__j || __io.flags() & ios_base::showbase))
__testvalid = false;
}
break;
case money_base::sign:
if (__lc->_M_positive_sign_size && __beg != __end
&& *__beg == __lc->_M_positive_sign[0])
{
__sign_size = __lc->_M_positive_sign_size;
++__beg;
}
else if (__lc->_M_negative_sign_size && __beg != __end
&& *__beg == __lc->_M_negative_sign[0])
{
__negative = true;
__sign_size = __lc->_M_negative_sign_size;
++__beg;
}
else if (__lc->_M_positive_sign_size
&& !__lc->_M_negative_sign_size)
__negative = true;
else if (__mandatory_sign)
__testvalid = false;
break;
case money_base::value:
for (; __beg != __end; ++__beg)
{
const char_type __c = *__beg;
const char_type* __q = __traits_type::find(__lit_zero,
10, __c);
if (__q != 0)
{
__res += money_base::_S_atoms[__q - __lit];
++__n;
}
else if (__c == __lc->_M_decimal_point
&& !__testdecfound)
{
if (__lc->_M_frac_digits <= 0)
break;
__last_pos = __n;
__n = 0;
__testdecfound = true;
}
else if (__lc->_M_use_grouping
&& __c == __lc->_M_thousands_sep
&& !__testdecfound)
{
if (__n)
{
__grouping_tmp += static_cast<char>(__n);
__n = 0;
}
else
{
__testvalid = false;
break;
}
}
else
break;
}
if (__res.empty())
__testvalid = false;
break;
case money_base::space:
if (__beg != __end && __ctype.is(ctype_base::space, *__beg))
++__beg;
else
__testvalid = false;
case money_base::none:
if (__i != 3)
for (; __beg != __end
&& __ctype.is(ctype_base::space, *__beg); ++__beg);
break;
}
}
if (__sign_size > 1 && __testvalid)
{
const char_type* __sign = __negative ? __lc->_M_negative_sign
: __lc->_M_positive_sign;
size_type __i = 1;
for (; __beg != __end && __i < __sign_size
&& *__beg == __sign[__i]; ++__beg, (void)++__i);
if (__i != __sign_size)
__testvalid = false;
}
if (__testvalid)
{
if (__res.size() > 1)
{
const size_type __first = __res.find_first_not_of('0');
const bool __only_zeros = __first == string::npos;
if (__first)
__res.erase(0, __only_zeros ? __res.size() - 1 : __first);
}
if (__negative && __res[0] != '0')
__res.insert(__res.begin(), '-');
if (__grouping_tmp.size())
{
__grouping_tmp += static_cast<char>(__testdecfound ? __last_pos
: __n);
if (!std::__verify_grouping(__lc->_M_grouping,
__lc->_M_grouping_size,
__grouping_tmp))
__err |= ios_base::failbit;
}
if (__testdecfound && __n != __lc->_M_frac_digits)
__testvalid = false;
}
if (!__testvalid)
__err |= ios_base::failbit;
else
__units.swap(__res);
if (__beg == __end)
__err |= ios_base::eofbit;
return __beg;
}
# 367 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.tcc" 3
template<typename _CharT, typename _InIter>
_InIter
money_get<_CharT, _InIter>::
do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
ios_base::iostate& __err, long double& __units) const
{
string __str;
__beg = __intl ? _M_extract<true>(__beg, __end, __io, __err, __str)
: _M_extract<false>(__beg, __end, __io, __err, __str);
std::__convert_to_v(__str.c_str(), __units, __err, _S_get_c_locale());
return __beg;
}
template<typename _CharT, typename _InIter>
_InIter
money_get<_CharT, _InIter>::
do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
ios_base::iostate& __err, string_type& __digits) const
{
typedef typename string::size_type size_type;
const locale& __loc = __io._M_getloc();
const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
string __str;
__beg = __intl ? _M_extract<true>(__beg, __end, __io, __err, __str)
: _M_extract<false>(__beg, __end, __io, __err, __str);
const size_type __len = __str.size();
if (__len)
{
__digits.resize(__len);
__ctype.widen(__str.data(), __str.data() + __len, &__digits[0]);
}
return __beg;
}
template<typename _CharT, typename _OutIter>
template<bool _Intl>
_OutIter
money_put<_CharT, _OutIter>::
_M_insert(iter_type __s, ios_base& __io, char_type __fill,
const string_type& __digits) const
{
typedef typename string_type::size_type size_type;
typedef money_base::part part;
typedef __moneypunct_cache<_CharT, _Intl> __cache_type;
const locale& __loc = __io._M_getloc();
const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
__use_cache<__cache_type> __uc;
const __cache_type* __lc = __uc(__loc);
const char_type* __lit = __lc->_M_atoms;
const char_type* __beg = __digits.data();
money_base::pattern __p;
const char_type* __sign;
size_type __sign_size;
if (!(*__beg == __lit[money_base::_S_minus]))
{
__p = __lc->_M_pos_format;
__sign = __lc->_M_positive_sign;
__sign_size = __lc->_M_positive_sign_size;
}
else
{
__p = __lc->_M_neg_format;
__sign = __lc->_M_negative_sign;
__sign_size = __lc->_M_negative_sign_size;
if (__digits.size())
++__beg;
}
size_type __len = __ctype.scan_not(ctype_base::digit, __beg,
__beg + __digits.size()) - __beg;
if (__len)
{
string_type __value;
__value.reserve(2 * __len);
long __paddec = __len - __lc->_M_frac_digits;
if (__paddec > 0)
{
if (__lc->_M_frac_digits < 0)
__paddec = __len;
if (__lc->_M_grouping_size)
{
__value.assign(2 * __paddec, char_type());
_CharT* __vend =
std::__add_grouping(&__value[0], __lc->_M_thousands_sep,
__lc->_M_grouping,
__lc->_M_grouping_size,
__beg, __beg + __paddec);
__value.erase(__vend - &__value[0]);
}
else
__value.assign(__beg, __paddec);
}
if (__lc->_M_frac_digits > 0)
{
__value += __lc->_M_decimal_point;
if (__paddec >= 0)
__value.append(__beg + __paddec, __lc->_M_frac_digits);
else
{
__value.append(-__paddec, __lit[money_base::_S_zero]);
__value.append(__beg, __len);
}
}
const ios_base::fmtflags __f = __io.flags()
& ios_base::adjustfield;
__len = __value.size() + __sign_size;
__len += ((__io.flags() & ios_base::showbase)
? __lc->_M_curr_symbol_size : 0);
string_type __res;
__res.reserve(2 * __len);
const size_type __width = static_cast<size_type>(__io.width());
const bool __testipad = (__f == ios_base::internal
&& __len < __width);
for (int __i = 0; __i < 4; ++__i)
{
const part __which = static_cast<part>(__p.field[__i]);
switch (__which)
{
case money_base::symbol:
if (__io.flags() & ios_base::showbase)
__res.append(__lc->_M_curr_symbol,
__lc->_M_curr_symbol_size);
break;
case money_base::sign:
if (__sign_size)
__res += __sign[0];
break;
case money_base::value:
__res += __value;
break;
case money_base::space:
if (__testipad)
__res.append(__width - __len, __fill);
else
__res += __fill;
break;
case money_base::none:
if (__testipad)
__res.append(__width - __len, __fill);
break;
}
}
if (__sign_size > 1)
__res.append(__sign + 1, __sign_size - 1);
__len = __res.size();
if (__width > __len)
{
if (__f == ios_base::left)
__res.append(__width - __len, __fill);
else
__res.insert(0, __width - __len, __fill);
__len = __width;
}
__s = std::__write(__s, __res.data(), __len);
}
__io.width(0);
return __s;
}
# 573 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.tcc" 3
template<typename _CharT, typename _OutIter>
_OutIter
money_put<_CharT, _OutIter>::
do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
long double __units) const
{
const locale __loc = __io.getloc();
const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
int __cs_size = 64;
char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
int __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
"%.*Lf", 0, __units);
if (__len >= __cs_size)
{
__cs_size = __len + 1;
__cs = static_cast<char*>(__builtin_alloca(__cs_size));
__len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
"%.*Lf", 0, __units);
}
# 605 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.tcc" 3
string_type __digits(__len, char_type());
__ctype.widen(__cs, __cs + __len, &__digits[0]);
return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
: _M_insert<false>(__s, __io, __fill, __digits);
}
template<typename _CharT, typename _OutIter>
_OutIter
money_put<_CharT, _OutIter>::
do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
const string_type& __digits) const
{ return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
: _M_insert<false>(__s, __io, __fill, __digits); }
}
template<typename _CharT, typename _InIter>
time_base::dateorder
time_get<_CharT, _InIter>::do_date_order() const
{ return time_base::no_order; }
template<typename _CharT, typename _InIter>
_InIter
time_get<_CharT, _InIter>::
_M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, tm* __tm,
const _CharT* __format) const
{
const locale& __loc = __io._M_getloc();
const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
const size_t __len = char_traits<_CharT>::length(__format);
ios_base::iostate __tmperr = ios_base::goodbit;
size_t __i = 0;
for (; __beg != __end && __i < __len && !__tmperr; ++__i)
{
if (__ctype.narrow(__format[__i], 0) == '%')
{
char __c = __ctype.narrow(__format[++__i], 0);
int __mem = 0;
if (__c == 'E' || __c == 'O')
__c = __ctype.narrow(__format[++__i], 0);
switch (__c)
{
const char* __cs;
_CharT __wcs[10];
case 'a':
const char_type* __days1[7];
__tp._M_days_abbreviated(__days1);
__beg = _M_extract_name(__beg, __end, __tm->tm_wday, __days1,
7, __io, __tmperr);
break;
case 'A':
const char_type* __days2[7];
__tp._M_days(__days2);
__beg = _M_extract_name(__beg, __end, __tm->tm_wday, __days2,
7, __io, __tmperr);
break;
case 'h':
case 'b':
const char_type* __months1[12];
__tp._M_months_abbreviated(__months1);
__beg = _M_extract_name(__beg, __end, __tm->tm_mon,
__months1, 12, __io, __tmperr);
break;
case 'B':
const char_type* __months2[12];
__tp._M_months(__months2);
__beg = _M_extract_name(__beg, __end, __tm->tm_mon,
__months2, 12, __io, __tmperr);
break;
case 'c':
const char_type* __dt[2];
__tp._M_date_time_formats(__dt);
__beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
__tm, __dt[0]);
break;
case 'd':
__beg = _M_extract_num(__beg, __end, __tm->tm_mday, 1, 31, 2,
__io, __tmperr);
break;
case 'e':
if (__ctype.is(ctype_base::space, *__beg))
__beg = _M_extract_num(++__beg, __end, __tm->tm_mday, 1, 9,
1, __io, __tmperr);
else
__beg = _M_extract_num(__beg, __end, __tm->tm_mday, 10, 31,
2, __io, __tmperr);
break;
case 'D':
__cs = "%m/%d/%y";
__ctype.widen(__cs, __cs + 9, __wcs);
__beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
__tm, __wcs);
break;
case 'H':
__beg = _M_extract_num(__beg, __end, __tm->tm_hour, 0, 23, 2,
__io, __tmperr);
break;
case 'I':
__beg = _M_extract_num(__beg, __end, __tm->tm_hour, 1, 12, 2,
__io, __tmperr);
break;
case 'm':
__beg = _M_extract_num(__beg, __end, __mem, 1, 12, 2,
__io, __tmperr);
if (!__tmperr)
__tm->tm_mon = __mem - 1;
break;
case 'M':
__beg = _M_extract_num(__beg, __end, __tm->tm_min, 0, 59, 2,
__io, __tmperr);
break;
case 'n':
if (__ctype.narrow(*__beg, 0) == '\n')
++__beg;
else
__tmperr |= ios_base::failbit;
break;
case 'R':
__cs = "%H:%M";
__ctype.widen(__cs, __cs + 6, __wcs);
__beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
__tm, __wcs);
break;
case 'S':
__beg = _M_extract_num(__beg, __end, __tm->tm_sec, 0, 60, 2,
__io, __tmperr);
break;
case 't':
if (__ctype.narrow(*__beg, 0) == '\t')
++__beg;
else
__tmperr |= ios_base::failbit;
break;
case 'T':
__cs = "%H:%M:%S";
__ctype.widen(__cs, __cs + 9, __wcs);
__beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
__tm, __wcs);
break;
case 'x':
const char_type* __dates[2];
__tp._M_date_formats(__dates);
__beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
__tm, __dates[0]);
break;
case 'X':
const char_type* __times[2];
__tp._M_time_formats(__times);
__beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
__tm, __times[0]);
break;
case 'y':
case 'C':
case 'Y':
__beg = _M_extract_num(__beg, __end, __mem, 0, 9999, 4,
__io, __tmperr);
if (!__tmperr)
__tm->tm_year = __mem < 0 ? __mem + 100 : __mem - 1900;
break;
case 'Z':
if (__ctype.is(ctype_base::upper, *__beg))
{
int __tmp;
__beg = _M_extract_name(__beg, __end, __tmp,
__timepunct_cache<_CharT>::_S_timezones,
14, __io, __tmperr);
if (__beg != __end && !__tmperr && __tmp == 0
&& (*__beg == __ctype.widen('-')
|| *__beg == __ctype.widen('+')))
{
__beg = _M_extract_num(__beg, __end, __tmp, 0, 23, 2,
__io, __tmperr);
__beg = _M_extract_num(__beg, __end, __tmp, 0, 59, 2,
__io, __tmperr);
}
}
else
__tmperr |= ios_base::failbit;
break;
default:
__tmperr |= ios_base::failbit;
}
}
else
{
if (__format[__i] == *__beg)
++__beg;
else
__tmperr |= ios_base::failbit;
}
}
if (__tmperr || __i != __len)
__err |= ios_base::failbit;
return __beg;
}
template<typename _CharT, typename _InIter>
_InIter
time_get<_CharT, _InIter>::
_M_extract_num(iter_type __beg, iter_type __end, int& __member,
int __min, int __max, size_t __len,
ios_base& __io, ios_base::iostate& __err) const
{
const locale& __loc = __io._M_getloc();
const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
int __mult = __len == 2 ? 10 : (__len == 4 ? 1000 : 1);
++__min;
size_t __i = 0;
int __value = 0;
for (; __beg != __end && __i < __len; ++__beg, (void)++__i)
{
const char __c = __ctype.narrow(*__beg, '*');
if (__c >= '0' && __c <= '9')
{
__value = __value * 10 + (__c - '0');
const int __valuec = __value * __mult;
if (__valuec > __max || __valuec + __mult < __min)
break;
__mult /= 10;
}
else
break;
}
if (__i == __len)
__member = __value;
else if (__len == 4 && __i == 2)
__member = __value - 100;
else
__err |= ios_base::failbit;
return __beg;
}
template<typename _CharT, typename _InIter>
_InIter
time_get<_CharT, _InIter>::
_M_extract_name(iter_type __beg, iter_type __end, int& __member,
const _CharT** __names, size_t __indexlen,
ios_base& __io, ios_base::iostate& __err) const
{
typedef char_traits<_CharT> __traits_type;
const locale& __loc = __io._M_getloc();
const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
int* __matches = static_cast<int*>(__builtin_alloca(sizeof(int)
* __indexlen));
size_t __nmatches = 0;
size_t __pos = 0;
bool __testvalid = true;
const char_type* __name;
if (__beg != __end)
{
const char_type __c = *__beg;
for (size_t __i1 = 0; __i1 < __indexlen; ++__i1)
if (__c == __names[__i1][0]
|| __c == __ctype.toupper(__names[__i1][0]))
__matches[__nmatches++] = __i1;
}
while (__nmatches > 1)
{
size_t __minlen = __traits_type::length(__names[__matches[0]]);
for (size_t __i2 = 1; __i2 < __nmatches; ++__i2)
__minlen = std::min(__minlen,
__traits_type::length(__names[__matches[__i2]]));
++__beg;
++__pos;
if (__pos < __minlen && __beg != __end)
for (size_t __i3 = 0; __i3 < __nmatches;)
{
__name = __names[__matches[__i3]];
if (!(__name[__pos] == *__beg))
__matches[__i3] = __matches[--__nmatches];
else
++__i3;
}
else
break;
}
if (__nmatches == 1)
{
++__beg;
++__pos;
__name = __names[__matches[0]];
const size_t __len = __traits_type::length(__name);
while (__pos < __len && __beg != __end && __name[__pos] == *__beg)
++__beg, (void)++__pos;
if (__len == __pos)
__member = __matches[0];
else
__testvalid = false;
}
else
__testvalid = false;
if (!__testvalid)
__err |= ios_base::failbit;
return __beg;
}
template<typename _CharT, typename _InIter>
_InIter
time_get<_CharT, _InIter>::
_M_extract_wday_or_month(iter_type __beg, iter_type __end, int& __member,
const _CharT** __names, size_t __indexlen,
ios_base& __io, ios_base::iostate& __err) const
{
typedef char_traits<_CharT> __traits_type;
const locale& __loc = __io._M_getloc();
const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
int* __matches = static_cast<int*>(__builtin_alloca(2 * sizeof(int)
* __indexlen));
size_t __nmatches = 0;
size_t* __matches_lengths = 0;
size_t __pos = 0;
if (__beg != __end)
{
const char_type __c = *__beg;
for (size_t __i = 0; __i < 2 * __indexlen; ++__i)
if (__c == __names[__i][0]
|| __c == __ctype.toupper(__names[__i][0]))
__matches[__nmatches++] = __i;
}
if (__nmatches)
{
++__beg;
++__pos;
__matches_lengths
= static_cast<size_t*>(__builtin_alloca(sizeof(size_t)
* __nmatches));
for (size_t __i = 0; __i < __nmatches; ++__i)
__matches_lengths[__i]
= __traits_type::length(__names[__matches[__i]]);
}
for (; __beg != __end; ++__beg, (void)++__pos)
{
size_t __nskipped = 0;
const char_type __c = *__beg;
for (size_t __i = 0; __i < __nmatches;)
{
const char_type* __name = __names[__matches[__i]];
if (__pos >= __matches_lengths[__i])
++__nskipped, ++__i;
else if (!(__name[__pos] == __c))
{
--__nmatches;
__matches[__i] = __matches[__nmatches];
__matches_lengths[__i] = __matches_lengths[__nmatches];
}
else
++__i;
}
if (__nskipped == __nmatches)
break;
}
if ((__nmatches == 1 && __matches_lengths[0] == __pos)
|| (__nmatches == 2 && (__matches_lengths[0] == __pos
|| __matches_lengths[1] == __pos)))
__member = (__matches[0] >= __indexlen
? __matches[0] - __indexlen : __matches[0]);
else
__err |= ios_base::failbit;
return __beg;
}
template<typename _CharT, typename _InIter>
_InIter
time_get<_CharT, _InIter>::
do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, tm* __tm) const
{
const locale& __loc = __io._M_getloc();
const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
const char_type* __times[2];
__tp._M_time_formats(__times);
__beg = _M_extract_via_format(__beg, __end, __io, __err,
__tm, __times[0]);
if (__beg == __end)
__err |= ios_base::eofbit;
return __beg;
}
template<typename _CharT, typename _InIter>
_InIter
time_get<_CharT, _InIter>::
do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, tm* __tm) const
{
const locale& __loc = __io._M_getloc();
const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
const char_type* __dates[2];
__tp._M_date_formats(__dates);
__beg = _M_extract_via_format(__beg, __end, __io, __err,
__tm, __dates[0]);
if (__beg == __end)
__err |= ios_base::eofbit;
return __beg;
}
template<typename _CharT, typename _InIter>
_InIter
time_get<_CharT, _InIter>::
do_get_weekday(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, tm* __tm) const
{
const locale& __loc = __io._M_getloc();
const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
const char_type* __days[14];
__tp._M_days_abbreviated(__days);
__tp._M_days(__days + 7);
int __tmpwday;
ios_base::iostate __tmperr = ios_base::goodbit;
__beg = _M_extract_wday_or_month(__beg, __end, __tmpwday, __days, 7,
__io, __tmperr);
if (!__tmperr)
__tm->tm_wday = __tmpwday;
else
__err |= ios_base::failbit;
if (__beg == __end)
__err |= ios_base::eofbit;
return __beg;
}
template<typename _CharT, typename _InIter>
_InIter
time_get<_CharT, _InIter>::
do_get_monthname(iter_type __beg, iter_type __end,
ios_base& __io, ios_base::iostate& __err, tm* __tm) const
{
const locale& __loc = __io._M_getloc();
const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
const char_type* __months[24];
__tp._M_months_abbreviated(__months);
__tp._M_months(__months + 12);
int __tmpmon;
ios_base::iostate __tmperr = ios_base::goodbit;
__beg = _M_extract_wday_or_month(__beg, __end, __tmpmon, __months, 12,
__io, __tmperr);
if (!__tmperr)
__tm->tm_mon = __tmpmon;
else
__err |= ios_base::failbit;
if (__beg == __end)
__err |= ios_base::eofbit;
return __beg;
}
template<typename _CharT, typename _InIter>
_InIter
time_get<_CharT, _InIter>::
do_get_year(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, tm* __tm) const
{
const locale& __loc = __io._M_getloc();
const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
int __tmpyear;
ios_base::iostate __tmperr = ios_base::goodbit;
__beg = _M_extract_num(__beg, __end, __tmpyear, 0, 9999, 4,
__io, __tmperr);
if (!__tmperr)
__tm->tm_year = __tmpyear < 0 ? __tmpyear + 100 : __tmpyear - 1900;
else
__err |= ios_base::failbit;
if (__beg == __end)
__err |= ios_base::eofbit;
return __beg;
}
template<typename _CharT, typename _InIter>
inline
_InIter
time_get<_CharT, _InIter>::
get(iter_type __s, iter_type __end, ios_base& __io,
ios_base::iostate& __err, tm* __tm, const char_type* __fmt,
const char_type* __fmtend) const
{
const locale& __loc = __io._M_getloc();
ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
__err = ios_base::goodbit;
while (__fmt != __fmtend &&
__err == ios_base::goodbit)
{
if (__s == __end)
{
__err = ios_base::eofbit | ios_base::failbit;
break;
}
else if (__ctype.narrow(*__fmt, 0) == '%')
{
char __format;
char __mod = 0;
if (++__fmt == __fmtend)
{
__err = ios_base::failbit;
break;
}
const char __c = __ctype.narrow(*__fmt, 0);
if (__c != 'E' && __c != 'O')
__format = __c;
else if (++__fmt != __fmtend)
{
__mod = __c;
__format = __ctype.narrow(*__fmt, 0);
}
else
{
__err = ios_base::failbit;
break;
}
__s = this->do_get(__s, __end, __io, __err, __tm, __format,
__mod);
++__fmt;
}
else if (__ctype.is(ctype_base::space, *__fmt))
{
++__fmt;
while (__fmt != __fmtend &&
__ctype.is(ctype_base::space, *__fmt))
++__fmt;
while (__s != __end &&
__ctype.is(ctype_base::space, *__s))
++__s;
}
else if (__ctype.tolower(*__s) == __ctype.tolower(*__fmt) ||
__ctype.toupper(*__s) == __ctype.toupper(*__fmt))
{
++__s;
++__fmt;
}
else
{
__err = ios_base::failbit;
break;
}
}
return __s;
}
template<typename _CharT, typename _InIter>
inline
_InIter
time_get<_CharT, _InIter>::
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, tm* __tm,
char __format, char __mod) const
{
const locale& __loc = __io._M_getloc();
ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
__err = ios_base::goodbit;
char_type __fmt[4];
__fmt[0] = __ctype.widen('%');
if (!__mod)
{
__fmt[1] = __format;
__fmt[2] = char_type();
}
else
{
__fmt[1] = __mod;
__fmt[2] = __format;
__fmt[3] = char_type();
}
__beg = _M_extract_via_format(__beg, __end, __io, __err, __tm, __fmt);
if (__beg == __end)
__err |= ios_base::eofbit;
return __beg;
}
template<typename _CharT, typename _OutIter>
_OutIter
time_put<_CharT, _OutIter>::
put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
const _CharT* __beg, const _CharT* __end) const
{
const locale& __loc = __io._M_getloc();
ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
for (; __beg != __end; ++__beg)
if (__ctype.narrow(*__beg, 0) != '%')
{
*__s = *__beg;
++__s;
}
else if (++__beg != __end)
{
char __format;
char __mod = 0;
const char __c = __ctype.narrow(*__beg, 0);
if (__c != 'E' && __c != 'O')
__format = __c;
else if (++__beg != __end)
{
__mod = __c;
__format = __ctype.narrow(*__beg, 0);
}
else
break;
__s = this->do_put(__s, __io, __fill, __tm, __format, __mod);
}
else
break;
return __s;
}
template<typename _CharT, typename _OutIter>
_OutIter
time_put<_CharT, _OutIter>::
do_put(iter_type __s, ios_base& __io, char_type, const tm* __tm,
char __format, char __mod) const
{
const locale& __loc = __io._M_getloc();
ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
__timepunct<_CharT> const& __tp = use_facet<__timepunct<_CharT> >(__loc);
const size_t __maxlen = 128;
char_type __res[__maxlen];
char_type __fmt[4];
__fmt[0] = __ctype.widen('%');
if (!__mod)
{
__fmt[1] = __format;
__fmt[2] = char_type();
}
else
{
__fmt[1] = __mod;
__fmt[2] = __format;
__fmt[3] = char_type();
}
__tp._M_put(__res, __maxlen, __fmt, __tm);
return std::__write(__s, __res, char_traits<char_type>::length(__res));
}
extern template class moneypunct<char, false>;
extern template class moneypunct<char, true>;
extern template class moneypunct_byname<char, false>;
extern template class moneypunct_byname<char, true>;
extern template class __cxx11:: money_get<char>;
extern template class __cxx11:: money_put<char>;
extern template class __timepunct<char>;
extern template class time_put<char>;
extern template class time_put_byname<char>;
extern template class time_get<char>;
extern template class time_get_byname<char>;
extern template class messages<char>;
extern template class messages_byname<char>;
extern template
const moneypunct<char, true>&
use_facet<moneypunct<char, true> >(const locale&);
extern template
const moneypunct<char, false>&
use_facet<moneypunct<char, false> >(const locale&);
extern template
const money_put<char>&
use_facet<money_put<char> >(const locale&);
extern template
const money_get<char>&
use_facet<money_get<char> >(const locale&);
extern template
const __timepunct<char>&
use_facet<__timepunct<char> >(const locale&);
extern template
const time_put<char>&
use_facet<time_put<char> >(const locale&);
extern template
const time_get<char>&
use_facet<time_get<char> >(const locale&);
extern template
const messages<char>&
use_facet<messages<char> >(const locale&);
extern template
bool
has_facet<moneypunct<char> >(const locale&);
extern template
bool
has_facet<money_put<char> >(const locale&);
extern template
bool
has_facet<money_get<char> >(const locale&);
extern template
bool
has_facet<__timepunct<char> >(const locale&);
extern template
bool
has_facet<time_put<char> >(const locale&);
extern template
bool
has_facet<time_get<char> >(const locale&);
extern template
bool
has_facet<messages<char> >(const locale&);
extern template class moneypunct<wchar_t, false>;
extern template class moneypunct<wchar_t, true>;
extern template class moneypunct_byname<wchar_t, false>;
extern template class moneypunct_byname<wchar_t, true>;
extern template class __cxx11:: money_get<wchar_t>;
extern template class __cxx11:: money_put<wchar_t>;
extern template class __timepunct<wchar_t>;
extern template class time_put<wchar_t>;
extern template class time_put_byname<wchar_t>;
extern template class time_get<wchar_t>;
extern template class time_get_byname<wchar_t>;
extern template class messages<wchar_t>;
extern template class messages_byname<wchar_t>;
extern template
const moneypunct<wchar_t, true>&
use_facet<moneypunct<wchar_t, true> >(const locale&);
extern template
const moneypunct<wchar_t, false>&
use_facet<moneypunct<wchar_t, false> >(const locale&);
extern template
const money_put<wchar_t>&
use_facet<money_put<wchar_t> >(const locale&);
extern template
const money_get<wchar_t>&
use_facet<money_get<wchar_t> >(const locale&);
extern template
const __timepunct<wchar_t>&
use_facet<__timepunct<wchar_t> >(const locale&);
extern template
const time_put<wchar_t>&
use_facet<time_put<wchar_t> >(const locale&);
extern template
const time_get<wchar_t>&
use_facet<time_get<wchar_t> >(const locale&);
extern template
const messages<wchar_t>&
use_facet<messages<wchar_t> >(const locale&);
extern template
bool
has_facet<moneypunct<wchar_t> >(const locale&);
extern template
bool
has_facet<money_put<wchar_t> >(const locale&);
extern template
bool
has_facet<money_get<wchar_t> >(const locale&);
extern template
bool
has_facet<__timepunct<wchar_t> >(const locale&);
extern template
bool
has_facet<time_put<wchar_t> >(const locale&);
extern template
bool
has_facet<time_get<wchar_t> >(const locale&);
extern template
bool
has_facet<messages<wchar_t> >(const locale&);
}
# 2014 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 2 3
# 42 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/locale" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_conv.h" 1 3
# 38 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_conv.h" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stringfwd.h" 1 3
# 39 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_conv.h" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/allocator.h" 1 3
# 40 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_conv.h" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/codecvt.h" 1 3
# 41 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_conv.h" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/unique_ptr.h" 1 3
# 39 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/unique_ptr.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename> class auto_ptr;
template<typename _Tp>
struct default_delete
{
constexpr default_delete() noexcept = default;
template<typename _Up, typename = typename
enable_if<is_convertible<_Up*, _Tp*>::value>::type>
default_delete(const default_delete<_Up>&) noexcept { }
void
operator()(_Tp* __ptr) const
{
static_assert(!is_void<_Tp>::value,
"can't delete pointer to incomplete type");
static_assert(sizeof(_Tp)>0,
"can't delete pointer to incomplete type");
delete __ptr;
}
};
template<typename _Tp>
struct default_delete<_Tp[]>
{
public:
constexpr default_delete() noexcept = default;
# 99 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/unique_ptr.h" 3
template<typename _Up, typename = typename
enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value>::type>
default_delete(const default_delete<_Up[]>&) noexcept { }
template<typename _Up>
typename enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value>::type
operator()(_Up* __ptr) const
{
static_assert(sizeof(_Tp)>0,
"can't delete pointer to incomplete type");
delete [] __ptr;
}
};
template <typename _Tp, typename _Dp = default_delete<_Tp> >
class unique_ptr
{
class _Pointer
{
template<typename _Up>
static typename _Up::pointer __test(typename _Up::pointer*);
template<typename _Up>
static _Tp* __test(...);
typedef typename remove_reference<_Dp>::type _Del;
public:
typedef decltype(__test<_Del>(0)) type;
};
typedef std::tuple<typename _Pointer::type, _Dp> __tuple_type;
__tuple_type _M_t;
public:
typedef typename _Pointer::type pointer;
typedef _Tp element_type;
typedef _Dp deleter_type;
template<typename _Up, typename _Ep>
using __safe_conversion_up = __and_<
is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>,
__not_<is_array<_Up>>,
__or_<__and_<is_reference<deleter_type>,
is_same<deleter_type, _Ep>>,
__and_<__not_<is_reference<deleter_type>>,
is_convertible<_Ep, deleter_type>>
>
>;
constexpr unique_ptr() noexcept
: _M_t()
{ static_assert(!is_pointer<deleter_type>::value,
"constructed with null function pointer deleter"); }
explicit
unique_ptr(pointer __p) noexcept
: _M_t(__p, deleter_type())
{ static_assert(!is_pointer<deleter_type>::value,
"constructed with null function pointer deleter"); }
# 182 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/unique_ptr.h" 3
unique_ptr(pointer __p,
typename conditional<is_reference<deleter_type>::value,
deleter_type, const deleter_type&>::type __d) noexcept
: _M_t(__p, __d) { }
# 194 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/unique_ptr.h" 3
unique_ptr(pointer __p,
typename remove_reference<deleter_type>::type&& __d) noexcept
: _M_t(std::move(__p), std::move(__d))
{ static_assert(!std::is_reference<deleter_type>::value,
"rvalue deleter bound to reference"); }
constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }
unique_ptr(unique_ptr&& __u) noexcept
: _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { }
template<typename _Up, typename _Ep, typename = _Require<
__safe_conversion_up<_Up, _Ep>,
typename conditional<is_reference<_Dp>::value,
is_same<_Ep, _Dp>,
is_convertible<_Ep, _Dp>>::type>>
unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
: _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
{ }
template<typename _Up, typename = _Require<
is_convertible<_Up*, _Tp*>, is_same<_Dp, default_delete<_Tp>>>>
unique_ptr(auto_ptr<_Up>&& __u) noexcept;
~unique_ptr() noexcept
{
auto& __ptr = std::get<0>(_M_t);
if (__ptr != nullptr)
get_deleter()(__ptr);
__ptr = pointer();
}
# 248 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/unique_ptr.h" 3
unique_ptr&
operator=(unique_ptr&& __u) noexcept
{
reset(__u.release());
get_deleter() = std::forward<deleter_type>(__u.get_deleter());
return *this;
}
# 263 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/unique_ptr.h" 3
template<typename _Up, typename _Ep>
typename enable_if< __and_<
__safe_conversion_up<_Up, _Ep>,
is_assignable<deleter_type&, _Ep&&>
>::value,
unique_ptr&>::type
operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
{
reset(__u.release());
get_deleter() = std::forward<_Ep>(__u.get_deleter());
return *this;
}
unique_ptr&
operator=(nullptr_t) noexcept
{
reset();
return *this;
}
typename add_lvalue_reference<element_type>::type
operator*() const
{
;
return *get();
}
pointer
operator->() const noexcept
{
;
return get();
}
pointer
get() const noexcept
{ return std::get<0>(_M_t); }
deleter_type&
get_deleter() noexcept
{ return std::get<1>(_M_t); }
const deleter_type&
get_deleter() const noexcept
{ return std::get<1>(_M_t); }
explicit operator bool() const noexcept
{ return get() == pointer() ? false : true; }
pointer
release() noexcept
{
pointer __p = get();
std::get<0>(_M_t) = pointer();
return __p;
}
void
reset(pointer __p = pointer()) noexcept
{
using std::swap;
swap(std::get<0>(_M_t), __p);
if (__p != pointer())
get_deleter()(__p);
}
void
swap(unique_ptr& __u) noexcept
{
using std::swap;
swap(_M_t, __u._M_t);
}
unique_ptr(const unique_ptr&) = delete;
unique_ptr& operator=(const unique_ptr&) = delete;
};
template<typename _Tp, typename _Dp>
class unique_ptr<_Tp[], _Dp>
{
class _Pointer
{
template<typename _Up>
static typename _Up::pointer __test(typename _Up::pointer*);
template<typename _Up>
static _Tp* __test(...);
typedef typename remove_reference<_Dp>::type _Del;
public:
typedef decltype(__test<_Del>(0)) type;
};
typedef std::tuple<typename _Pointer::type, _Dp> __tuple_type;
__tuple_type _M_t;
template<typename _Up>
using __remove_cv = typename remove_cv<_Up>::type;
template<typename _Up>
using __is_derived_Tp
= __and_< is_base_of<_Tp, _Up>,
__not_<is_same<__remove_cv<_Tp>, __remove_cv<_Up>>> >;
public:
typedef typename _Pointer::type pointer;
typedef _Tp element_type;
typedef _Dp deleter_type;
template<typename _Up, typename _Ep,
typename _Up_up = unique_ptr<_Up, _Ep>,
typename _Up_element_type = typename _Up_up::element_type>
using __safe_conversion_up = __and_<
is_array<_Up>,
is_same<pointer, element_type*>,
is_same<typename _Up_up::pointer, _Up_element_type*>,
is_convertible<_Up_element_type(*)[], element_type(*)[]>,
__or_<__and_<is_reference<deleter_type>, is_same<deleter_type, _Ep>>,
__and_<__not_<is_reference<deleter_type>>,
is_convertible<_Ep, deleter_type>>>
>;
template<typename _Up>
using __safe_conversion_raw = __and_<
__or_<__or_<is_same<_Up, pointer>,
is_same<_Up, nullptr_t>>,
__and_<is_pointer<_Up>,
is_same<pointer, element_type*>,
is_convertible<
typename remove_pointer<_Up>::type(*)[],
element_type(*)[]>
>
>
>;
constexpr unique_ptr() noexcept
: _M_t()
{ static_assert(!std::is_pointer<deleter_type>::value,
"constructed with null function pointer deleter"); }
# 444 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/unique_ptr.h" 3
template<typename _Up,
typename = typename enable_if<
__safe_conversion_raw<_Up>::value, bool>::type>
explicit
unique_ptr(_Up __p) noexcept
: _M_t(__p, deleter_type())
{ static_assert(!is_pointer<deleter_type>::value,
"constructed with null function pointer deleter"); }
# 461 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/unique_ptr.h" 3
template<typename _Up,
typename = typename enable_if<
__safe_conversion_raw<_Up>::value, bool>::type>
unique_ptr(_Up __p,
typename conditional<is_reference<deleter_type>::value,
deleter_type, const deleter_type&>::type __d) noexcept
: _M_t(__p, __d) { }
# 477 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/unique_ptr.h" 3
template<typename _Up,
typename = typename enable_if<
__safe_conversion_raw<_Up>::value, bool>::type>
unique_ptr(_Up __p, typename
remove_reference<deleter_type>::type&& __d) noexcept
: _M_t(std::move(__p), std::move(__d))
{ static_assert(!is_reference<deleter_type>::value,
"rvalue deleter bound to reference"); }
unique_ptr(unique_ptr&& __u) noexcept
: _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { }
constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }
template<typename _Up, typename _Ep,
typename = _Require<__safe_conversion_up<_Up, _Ep>>>
unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
: _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
{ }
~unique_ptr()
{
auto& __ptr = std::get<0>(_M_t);
if (__ptr != nullptr)
get_deleter()(__ptr);
__ptr = pointer();
}
# 516 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/unique_ptr.h" 3
unique_ptr&
operator=(unique_ptr&& __u) noexcept
{
reset(__u.release());
get_deleter() = std::forward<deleter_type>(__u.get_deleter());
return *this;
}
# 531 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/unique_ptr.h" 3
template<typename _Up, typename _Ep>
typename
enable_if<__and_<__safe_conversion_up<_Up, _Ep>,
is_assignable<deleter_type&, _Ep&&>
>::value,
unique_ptr&>::type
operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
{
reset(__u.release());
get_deleter() = std::forward<_Ep>(__u.get_deleter());
return *this;
}
unique_ptr&
operator=(nullptr_t) noexcept
{
reset();
return *this;
}
typename std::add_lvalue_reference<element_type>::type
operator[](size_t __i) const
{
;
return get()[__i];
}
pointer
get() const noexcept
{ return std::get<0>(_M_t); }
deleter_type&
get_deleter() noexcept
{ return std::get<1>(_M_t); }
const deleter_type&
get_deleter() const noexcept
{ return std::get<1>(_M_t); }
explicit operator bool() const noexcept
{ return get() == pointer() ? false : true; }
pointer
release() noexcept
{
pointer __p = get();
std::get<0>(_M_t) = pointer();
return __p;
}
template <typename _Up,
typename = _Require<
__or_<is_same<_Up, pointer>,
__and_<is_same<pointer, element_type*>,
is_pointer<_Up>,
is_convertible<
typename remove_pointer<_Up>::type(*)[],
element_type(*)[]
>
>
>
>>
void
reset(_Up __p) noexcept
{
using std::swap;
swap(std::get<0>(_M_t), __p);
if (__p != nullptr)
get_deleter()(__p);
}
void reset(nullptr_t = nullptr) noexcept
{
reset(pointer());
}
void
swap(unique_ptr& __u) noexcept
{
using std::swap;
swap(_M_t, __u._M_t);
}
unique_ptr(const unique_ptr&) = delete;
unique_ptr& operator=(const unique_ptr&) = delete;
};
template<typename _Tp, typename _Dp>
inline void
swap(unique_ptr<_Tp, _Dp>& __x,
unique_ptr<_Tp, _Dp>& __y) noexcept
{ __x.swap(__y); }
template<typename _Tp, typename _Dp,
typename _Up, typename _Ep>
inline bool
operator==(const unique_ptr<_Tp, _Dp>& __x,
const unique_ptr<_Up, _Ep>& __y)
{ return __x.get() == __y.get(); }
template<typename _Tp, typename _Dp>
inline bool
operator==(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
{ return !__x; }
template<typename _Tp, typename _Dp>
inline bool
operator==(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
{ return !__x; }
template<typename _Tp, typename _Dp,
typename _Up, typename _Ep>
inline bool
operator!=(const unique_ptr<_Tp, _Dp>& __x,
const unique_ptr<_Up, _Ep>& __y)
{ return __x.get() != __y.get(); }
template<typename _Tp, typename _Dp>
inline bool
operator!=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
{ return (bool)__x; }
template<typename _Tp, typename _Dp>
inline bool
operator!=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
{ return (bool)__x; }
template<typename _Tp, typename _Dp,
typename _Up, typename _Ep>
inline bool
operator<(const unique_ptr<_Tp, _Dp>& __x,
const unique_ptr<_Up, _Ep>& __y)
{
typedef typename
std::common_type<typename unique_ptr<_Tp, _Dp>::pointer,
typename unique_ptr<_Up, _Ep>::pointer>::type _CT;
return std::less<_CT>()(__x.get(), __y.get());
}
template<typename _Tp, typename _Dp>
inline bool
operator<(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
{ return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
nullptr); }
template<typename _Tp, typename _Dp>
inline bool
operator<(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
{ return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
__x.get()); }
template<typename _Tp, typename _Dp,
typename _Up, typename _Ep>
inline bool
operator<=(const unique_ptr<_Tp, _Dp>& __x,
const unique_ptr<_Up, _Ep>& __y)
{ return !(__y < __x); }
template<typename _Tp, typename _Dp>
inline bool
operator<=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
{ return !(nullptr < __x); }
template<typename _Tp, typename _Dp>
inline bool
operator<=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
{ return !(__x < nullptr); }
template<typename _Tp, typename _Dp,
typename _Up, typename _Ep>
inline bool
operator>(const unique_ptr<_Tp, _Dp>& __x,
const unique_ptr<_Up, _Ep>& __y)
{ return (__y < __x); }
template<typename _Tp, typename _Dp>
inline bool
operator>(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
{ return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
__x.get()); }
template<typename _Tp, typename _Dp>
inline bool
operator>(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
{ return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
nullptr); }
template<typename _Tp, typename _Dp,
typename _Up, typename _Ep>
inline bool
operator>=(const unique_ptr<_Tp, _Dp>& __x,
const unique_ptr<_Up, _Ep>& __y)
{ return !(__x < __y); }
template<typename _Tp, typename _Dp>
inline bool
operator>=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
{ return !(__x < nullptr); }
template<typename _Tp, typename _Dp>
inline bool
operator>=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
{ return !(nullptr < __x); }
template<typename _Tp, typename _Dp>
struct hash<unique_ptr<_Tp, _Dp>>
: public __hash_base<size_t, unique_ptr<_Tp, _Dp>>
{
size_t
operator()(const unique_ptr<_Tp, _Dp>& __u) const noexcept
{
typedef unique_ptr<_Tp, _Dp> _UP;
return std::hash<typename _UP::pointer>()(__u.get());
}
};
template<typename _Tp>
struct _MakeUniq
{ typedef unique_ptr<_Tp> __single_object; };
template<typename _Tp>
struct _MakeUniq<_Tp[]>
{ typedef unique_ptr<_Tp[]> __array; };
template<typename _Tp, size_t _Bound>
struct _MakeUniq<_Tp[_Bound]>
{ struct __invalid_type { }; };
template<typename _Tp, typename... _Args>
inline typename _MakeUniq<_Tp>::__single_object
make_unique(_Args&&... __args)
{ return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }
template<typename _Tp>
inline typename _MakeUniq<_Tp>::__array
make_unique(size_t __num)
{ return unique_ptr<_Tp>(new remove_extent_t<_Tp>[__num]()); }
template<typename _Tp, typename... _Args>
inline typename _MakeUniq<_Tp>::__invalid_type
make_unique(_Args&&...) = delete;
}
# 42 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_conv.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _OutStr, typename _InChar, typename _Codecvt,
typename _State, typename _Fn>
bool
__do_str_codecvt(const _InChar* __first, const _InChar* __last,
_OutStr& __outstr, const _Codecvt& __cvt, _State& __state,
size_t& __count, _Fn __fn)
{
if (__first == __last)
{
__outstr.clear();
__count = 0;
return true;
}
size_t __outchars = 0;
auto __next = __first;
const auto __maxlen = __cvt.max_length() + 1;
codecvt_base::result __result;
do
{
__outstr.resize(__outstr.size() + (__last - __next) * __maxlen);
auto __outnext = &__outstr.front() + __outchars;
auto const __outlast = &__outstr.back() + 1;
__result = (__cvt.*__fn)(__state, __next, __last, __next,
__outnext, __outlast, __outnext);
__outchars = __outnext - &__outstr.front();
}
while (__result == codecvt_base::partial && __next != __last
&& (__outstr.size() - __outchars) < __maxlen);
if (__result == codecvt_base::error)
return false;
if (__result == codecvt_base::noconv)
{
__outstr.assign(__first, __last);
__count = __last - __first;
}
else
{
__outstr.resize(__outchars);
__count = __next - __first;
}
return true;
}
template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
inline bool
__str_codecvt_in(const char* __first, const char* __last,
basic_string<_CharT, _Traits, _Alloc>& __outstr,
const codecvt<_CharT, char, _State>& __cvt,
_State& __state, size_t& __count)
{
using _Codecvt = codecvt<_CharT, char, _State>;
using _ConvFn
= codecvt_base::result
(_Codecvt::*)(_State&, const char*, const char*, const char*&,
_CharT*, _CharT*, _CharT*&) const;
_ConvFn __fn = &codecvt<_CharT, char, _State>::in;
return __do_str_codecvt(__first, __last, __outstr, __cvt, __state,
__count, __fn);
}
template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
inline bool
__str_codecvt_in(const char* __first, const char* __last,
basic_string<_CharT, _Traits, _Alloc>& __outstr,
const codecvt<_CharT, char, _State>& __cvt)
{
_State __state = {};
size_t __n;
return __str_codecvt_in(__first, __last, __outstr, __cvt, __state, __n);
}
template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
inline bool
__str_codecvt_out(const _CharT* __first, const _CharT* __last,
basic_string<char, _Traits, _Alloc>& __outstr,
const codecvt<_CharT, char, _State>& __cvt,
_State& __state, size_t& __count)
{
using _Codecvt = codecvt<_CharT, char, _State>;
using _ConvFn
= codecvt_base::result
(_Codecvt::*)(_State&, const _CharT*, const _CharT*, const _CharT*&,
char*, char*, char*&) const;
_ConvFn __fn = &codecvt<_CharT, char, _State>::out;
return __do_str_codecvt(__first, __last, __outstr, __cvt, __state,
__count, __fn);
}
template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
inline bool
__str_codecvt_out(const _CharT* __first, const _CharT* __last,
basic_string<char, _Traits, _Alloc>& __outstr,
const codecvt<_CharT, char, _State>& __cvt)
{
_State __state = {};
size_t __n;
return __str_codecvt_out(__first, __last, __outstr, __cvt, __state, __n);
}
namespace __cxx11 {
template<typename _Codecvt, typename _Elem = wchar_t,
typename _Wide_alloc = allocator<_Elem>,
typename _Byte_alloc = allocator<char>>
class wstring_convert
{
public:
typedef basic_string<char, char_traits<char>, _Byte_alloc> byte_string;
typedef basic_string<_Elem, char_traits<_Elem>, _Wide_alloc> wide_string;
typedef typename _Codecvt::state_type state_type;
typedef typename wide_string::traits_type::int_type int_type;
explicit
wstring_convert(_Codecvt* __pcvt = new _Codecvt()) : _M_cvt(__pcvt)
{
if (!_M_cvt)
__throw_logic_error("wstring_convert");
}
# 195 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_conv.h" 3
wstring_convert(_Codecvt* __pcvt, state_type __state)
: _M_cvt(__pcvt), _M_state(__state), _M_with_cvtstate(true)
{
if (!_M_cvt)
__throw_logic_error("wstring_convert");
}
explicit
wstring_convert(const byte_string& __byte_err,
const wide_string& __wide_err = wide_string())
: _M_cvt(new _Codecvt),
_M_byte_err_string(__byte_err), _M_wide_err_string(__wide_err),
_M_with_strings(true)
{
if (!_M_cvt)
__throw_logic_error("wstring_convert");
}
~wstring_convert() = default;
wstring_convert(const wstring_convert&) = delete;
wstring_convert& operator=(const wstring_convert&) = delete;
wide_string
from_bytes(char __byte)
{
char __bytes[2] = { __byte };
return from_bytes(__bytes, __bytes+1);
}
wide_string
from_bytes(const char* __ptr)
{ return from_bytes(__ptr, __ptr+char_traits<char>::length(__ptr)); }
wide_string
from_bytes(const byte_string& __str)
{
auto __ptr = __str.data();
return from_bytes(__ptr, __ptr + __str.size());
}
wide_string
from_bytes(const char* __first, const char* __last)
{
if (!_M_with_cvtstate)
_M_state = state_type();
wide_string __out{ _M_wide_err_string.get_allocator() };
if (__str_codecvt_in(__first, __last, __out, *_M_cvt, _M_state,
_M_count))
return __out;
if (_M_with_strings)
return _M_wide_err_string;
__throw_range_error("wstring_convert::from_bytes");
}
byte_string
to_bytes(_Elem __wchar)
{
_Elem __wchars[2] = { __wchar };
return to_bytes(__wchars, __wchars+1);
}
byte_string
to_bytes(const _Elem* __ptr)
{
return to_bytes(__ptr, __ptr+wide_string::traits_type::length(__ptr));
}
byte_string
to_bytes(const wide_string& __wstr)
{
auto __ptr = __wstr.data();
return to_bytes(__ptr, __ptr + __wstr.size());
}
byte_string
to_bytes(const _Elem* __first, const _Elem* __last)
{
if (!_M_with_cvtstate)
_M_state = state_type();
byte_string __out{ _M_byte_err_string.get_allocator() };
if (__str_codecvt_out(__first, __last, __out, *_M_cvt, _M_state,
_M_count))
return __out;
if (_M_with_strings)
return _M_byte_err_string;
__throw_range_error("wstring_convert::to_bytes");
}
size_t converted() const noexcept { return _M_count; }
state_type state() const { return _M_state; }
private:
unique_ptr<_Codecvt> _M_cvt;
byte_string _M_byte_err_string;
wide_string _M_wide_err_string;
state_type _M_state = state_type();
size_t _M_count = 0;
bool _M_with_cvtstate = false;
bool _M_with_strings = false;
};
}
template<typename _Codecvt, typename _Elem = wchar_t,
typename _Tr = char_traits<_Elem>>
class wbuffer_convert : public basic_streambuf<_Elem, _Tr>
{
typedef basic_streambuf<_Elem, _Tr> _Wide_streambuf;
public:
typedef typename _Codecvt::state_type state_type;
# 333 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_conv.h" 3
explicit
wbuffer_convert(streambuf* __bytebuf = 0, _Codecvt* __pcvt = new _Codecvt,
state_type __state = state_type())
: _M_buf(__bytebuf), _M_cvt(__pcvt), _M_state(__state)
{
if (!_M_cvt)
__throw_logic_error("wbuffer_convert");
_M_always_noconv = _M_cvt->always_noconv();
if (_M_buf)
{
this->setp(_M_put_area, _M_put_area + _S_buffer_length);
this->setg(_M_get_area + _S_putback_length,
_M_get_area + _S_putback_length,
_M_get_area + _S_putback_length);
}
}
~wbuffer_convert() = default;
wbuffer_convert(const wbuffer_convert&) = delete;
wbuffer_convert& operator=(const wbuffer_convert&) = delete;
streambuf* rdbuf() const noexcept { return _M_buf; }
streambuf*
rdbuf(streambuf *__bytebuf) noexcept
{
auto __prev = _M_buf;
_M_buf = __bytebuf;
return __prev;
}
state_type state() const noexcept { return _M_state; }
protected:
int
sync()
{ return _M_buf && _M_conv_put() && _M_buf->pubsync() ? 0 : -1; }
typename _Wide_streambuf::int_type
overflow(typename _Wide_streambuf::int_type __out)
{
if (!_M_buf || !_M_conv_put())
return _Tr::eof();
else if (!_Tr::eq_int_type(__out, _Tr::eof()))
return this->sputc(__out);
return _Tr::not_eof(__out);
}
typename _Wide_streambuf::int_type
underflow()
{
if (!_M_buf)
return _Tr::eof();
if (this->gptr() < this->egptr() || (_M_buf && _M_conv_get()))
return _Tr::to_int_type(*this->gptr());
else
return _Tr::eof();
}
streamsize
xsputn(const typename _Wide_streambuf::char_type* __s, streamsize __n)
{
if (!_M_buf || __n == 0)
return 0;
streamsize __done = 0;
do
{
auto __nn = std::min<streamsize>(this->epptr() - this->pptr(),
__n - __done);
_Tr::copy(this->pptr(), __s + __done, __nn);
this->pbump(__nn);
__done += __nn;
} while (__done < __n && _M_conv_put());
return __done;
}
private:
bool
_M_conv_get()
{
const streamsize __pb1 = this->gptr() - this->eback();
const streamsize __pb2 = _S_putback_length;
const streamsize __npb = std::min(__pb1, __pb2);
_Tr::move(_M_get_area + _S_putback_length - __npb,
this->gptr() - __npb, __npb);
streamsize __nbytes = sizeof(_M_get_buf) - _M_unconv;
__nbytes = std::min(__nbytes, _M_buf->in_avail());
if (__nbytes < 1)
__nbytes == 1;
__nbytes = _M_buf->sgetn(_M_get_buf + _M_unconv, __nbytes);
if (__nbytes < 1)
return false;
__nbytes += _M_unconv;
_Elem* __outbuf = _M_get_area + _S_putback_length;
_Elem* __outnext = __outbuf;
const char* __bnext = _M_get_buf;
codecvt_base::result __result;
if (_M_always_noconv)
__result = codecvt_base::noconv;
else
{
_Elem* __outend = _M_get_area + _S_buffer_length;
__result = _M_cvt->in(_M_state,
__bnext, __bnext + __nbytes, __bnext,
__outbuf, __outend, __outnext);
}
if (__result == codecvt_base::noconv)
{
auto __get_buf = reinterpret_cast<const _Elem*>(_M_get_buf);
_Tr::copy(__outbuf, __get_buf, __nbytes);
_M_unconv = 0;
return true;
}
if ((_M_unconv = _M_get_buf + __nbytes - __bnext))
char_traits<char>::move(_M_get_buf, __bnext, _M_unconv);
this->setg(__outbuf, __outbuf, __outnext);
return __result != codecvt_base::error;
}
bool
_M_put(...)
{ return false; }
bool
_M_put(const char* __p, streamsize __n)
{
if (_M_buf->sputn(__p, __n) < __n)
return false;
}
bool
_M_conv_put()
{
_Elem* const __first = this->pbase();
const _Elem* const __last = this->pptr();
const streamsize __pending = __last - __first;
if (_M_always_noconv)
return _M_put(__first, __pending);
char __outbuf[2 * _S_buffer_length];
const _Elem* __next = __first;
const _Elem* __start;
do
{
__start = __next;
char* __outnext = __outbuf;
char* const __outlast = __outbuf + sizeof(__outbuf);
auto __result = _M_cvt->out(_M_state, __next, __last, __next,
__outnext, __outlast, __outnext);
if (__result == codecvt_base::error)
return false;
else if (__result == codecvt_base::noconv)
return _M_put(__next, __pending);
if (!_M_put(__outbuf, __outnext - __outbuf))
return false;
}
while (__next != __last && __next != __start);
if (__next != __last)
_Tr::move(__first, __next, __last - __next);
this->pbump(__first - __next);
return __next != __first;
}
streambuf* _M_buf;
unique_ptr<_Codecvt> _M_cvt;
state_type _M_state;
static const streamsize _S_buffer_length = 32;
static const streamsize _S_putback_length = 3;
_Elem _M_put_area[_S_buffer_length];
_Elem _M_get_area[_S_buffer_length];
streamsize _M_unconv = 0;
char _M_get_buf[_S_buffer_length-_S_putback_length];
bool _M_always_noconv;
};
}
# 44 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/locale" 2 3
# 44 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iomanip" 2 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/quoted_string.h" 1 3
# 33 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/quoted_string.h" 3
# 34 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/quoted_string.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
namespace __detail {
template<typename _String, typename _CharT>
struct _Quoted_string
{
static_assert(is_reference<_String>::value
|| is_pointer<_String>::value,
"String type must be pointer or reference");
_Quoted_string(_String __str, _CharT __del, _CharT __esc)
: _M_string(__str), _M_delim{__del}, _M_escape{__esc}
{ }
_Quoted_string&
operator=(_Quoted_string&) = delete;
_String _M_string;
_CharT _M_delim;
_CharT _M_escape;
};
template<typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const _Quoted_string<const _CharT*, _CharT>& __str)
{
std::basic_ostringstream<_CharT, _Traits> __ostr;
__ostr << __str._M_delim;
for (const _CharT* __c = __str._M_string; *__c; ++__c)
{
if (*__c == __str._M_delim || *__c == __str._M_escape)
__ostr << __str._M_escape;
__ostr << *__c;
}
__ostr << __str._M_delim;
return __os << __ostr.str();
}
template<typename _CharT, typename _Traits, typename _String>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const _Quoted_string<_String, _CharT>& __str)
{
std::basic_ostringstream<_CharT, _Traits> __ostr;
__ostr << __str._M_delim;
for (auto& __c : __str._M_string)
{
if (__c == __str._M_delim || __c == __str._M_escape)
__ostr << __str._M_escape;
__ostr << __c;
}
__ostr << __str._M_delim;
return __os << __ostr.str();
}
template<typename _CharT, typename _Traits, typename _Alloc>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
const _Quoted_string<basic_string<_CharT, _Traits, _Alloc>&,
_CharT>& __str)
{
_CharT __c;
__is >> __c;
if (!__is.good())
return __is;
if (__c != __str._M_delim)
{
__is.unget();
__is >> __str._M_string;
return __is;
}
__str._M_string.clear();
std::ios_base::fmtflags __flags
= __is.flags(__is.flags() & ~std::ios_base::skipws);
do
{
__is >> __c;
if (!__is.good())
break;
if (__c == __str._M_escape)
{
__is >> __c;
if (!__is.good())
break;
}
else if (__c == __str._M_delim)
break;
__str._M_string += __c;
}
while (true);
__is.setf(__flags);
return __is;
}
}
}
# 46 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iomanip" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
struct _Resetiosflags { ios_base::fmtflags _M_mask; };
# 65 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iomanip" 3
inline _Resetiosflags
resetiosflags(ios_base::fmtflags __mask)
{ return { __mask }; }
template<typename _CharT, typename _Traits>
inline basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, _Resetiosflags __f)
{
__is.setf(ios_base::fmtflags(0), __f._M_mask);
return __is;
}
template<typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, _Resetiosflags __f)
{
__os.setf(ios_base::fmtflags(0), __f._M_mask);
return __os;
}
struct _Setiosflags { ios_base::fmtflags _M_mask; };
# 95 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iomanip" 3
inline _Setiosflags
setiosflags(ios_base::fmtflags __mask)
{ return { __mask }; }
template<typename _CharT, typename _Traits>
inline basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, _Setiosflags __f)
{
__is.setf(__f._M_mask);
return __is;
}
template<typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, _Setiosflags __f)
{
__os.setf(__f._M_mask);
return __os;
}
struct _Setbase { int _M_base; };
# 126 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iomanip" 3
inline _Setbase
setbase(int __base)
{ return { __base }; }
template<typename _CharT, typename _Traits>
inline basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, _Setbase __f)
{
__is.setf(__f._M_base == 8 ? ios_base::oct :
__f._M_base == 10 ? ios_base::dec :
__f._M_base == 16 ? ios_base::hex :
ios_base::fmtflags(0), ios_base::basefield);
return __is;
}
template<typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, _Setbase __f)
{
__os.setf(__f._M_base == 8 ? ios_base::oct :
__f._M_base == 10 ? ios_base::dec :
__f._M_base == 16 ? ios_base::hex :
ios_base::fmtflags(0), ios_base::basefield);
return __os;
}
template<typename _CharT>
struct _Setfill { _CharT _M_c; };
# 163 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iomanip" 3
template<typename _CharT>
inline _Setfill<_CharT>
setfill(_CharT __c)
{ return { __c }; }
template<typename _CharT, typename _Traits>
inline basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, _Setfill<_CharT> __f)
{
__is.fill(__f._M_c);
return __is;
}
template<typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, _Setfill<_CharT> __f)
{
__os.fill(__f._M_c);
return __os;
}
struct _Setprecision { int _M_n; };
# 194 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iomanip" 3
inline _Setprecision
setprecision(int __n)
{ return { __n }; }
template<typename _CharT, typename _Traits>
inline basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, _Setprecision __f)
{
__is.precision(__f._M_n);
return __is;
}
template<typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, _Setprecision __f)
{
__os.precision(__f._M_n);
return __os;
}
struct _Setw { int _M_n; };
# 224 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iomanip" 3
inline _Setw
setw(int __n)
{ return { __n }; }
template<typename _CharT, typename _Traits>
inline basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, _Setw __f)
{
__is.width(__f._M_n);
return __is;
}
template<typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, _Setw __f)
{
__os.width(__f._M_n);
return __os;
}
template<typename _MoneyT>
struct _Get_money { _MoneyT& _M_mon; bool _M_intl; };
# 257 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iomanip" 3
template<typename _MoneyT>
inline _Get_money<_MoneyT>
get_money(_MoneyT& __mon, bool __intl = false)
{ return { __mon, __intl }; }
template<typename _CharT, typename _Traits, typename _MoneyT>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, _Get_money<_MoneyT> __f)
{
typename basic_istream<_CharT, _Traits>::sentry __cerb(__is, false);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
try
{
typedef istreambuf_iterator<_CharT, _Traits> _Iter;
typedef money_get<_CharT, _Iter> _MoneyGet;
const _MoneyGet& __mg = use_facet<_MoneyGet>(__is.getloc());
__mg.get(_Iter(__is.rdbuf()), _Iter(), __f._M_intl,
__is, __err, __f._M_mon);
}
catch(__cxxabiv1::__forced_unwind&)
{
__is._M_setstate(ios_base::badbit);
throw;
}
catch(...)
{ __is._M_setstate(ios_base::badbit); }
if (__err)
__is.setstate(__err);
}
return __is;
}
template<typename _MoneyT>
struct _Put_money { const _MoneyT& _M_mon; bool _M_intl; };
# 304 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iomanip" 3
template<typename _MoneyT>
inline _Put_money<_MoneyT>
put_money(const _MoneyT& __mon, bool __intl = false)
{ return { __mon, __intl }; }
template<typename _CharT, typename _Traits, typename _MoneyT>
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, _Put_money<_MoneyT> __f)
{
typename basic_ostream<_CharT, _Traits>::sentry __cerb(__os);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
try
{
typedef ostreambuf_iterator<_CharT, _Traits> _Iter;
typedef money_put<_CharT, _Iter> _MoneyPut;
const _MoneyPut& __mp = use_facet<_MoneyPut>(__os.getloc());
if (__mp.put(_Iter(__os.rdbuf()), __f._M_intl, __os,
__os.fill(), __f._M_mon).failed())
__err |= ios_base::badbit;
}
catch(__cxxabiv1::__forced_unwind&)
{
__os._M_setstate(ios_base::badbit);
throw;
}
catch(...)
{ __os._M_setstate(ios_base::badbit); }
if (__err)
__os.setstate(__err);
}
return __os;
}
template<typename _CharT>
struct _Put_time
{
const std::tm* _M_tmb;
const _CharT* _M_fmt;
};
# 356 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iomanip" 3
template<typename _CharT>
inline _Put_time<_CharT>
put_time(const std::tm* __tmb, const _CharT* __fmt)
{ return { __tmb, __fmt }; }
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, _Put_time<_CharT> __f)
{
typename basic_ostream<_CharT, _Traits>::sentry __cerb(__os);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
try
{
typedef ostreambuf_iterator<_CharT, _Traits> _Iter;
typedef time_put<_CharT, _Iter> _TimePut;
const _CharT* const __fmt_end = __f._M_fmt +
_Traits::length(__f._M_fmt);
const _TimePut& __mp = use_facet<_TimePut>(__os.getloc());
if (__mp.put(_Iter(__os.rdbuf()), __os, __os.fill(),
__f._M_tmb, __f._M_fmt, __fmt_end).failed())
__err |= ios_base::badbit;
}
catch(__cxxabiv1::__forced_unwind&)
{
__os._M_setstate(ios_base::badbit);
throw;
}
catch(...)
{ __os._M_setstate(ios_base::badbit); }
if (__err)
__os.setstate(__err);
}
return __os;
}
template<typename _CharT>
struct _Get_time
{
std::tm* _M_tmb;
const _CharT* _M_fmt;
};
# 411 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iomanip" 3
template<typename _CharT>
inline _Get_time<_CharT>
get_time(std::tm* __tmb, const _CharT* __fmt)
{ return { __tmb, __fmt }; }
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, _Get_time<_CharT> __f)
{
typename basic_istream<_CharT, _Traits>::sentry __cerb(__is, false);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
try
{
typedef istreambuf_iterator<_CharT, _Traits> _Iter;
typedef time_get<_CharT, _Iter> _TimeGet;
const _CharT* const __fmt_end = __f._M_fmt +
_Traits::length(__f._M_fmt);
const _TimeGet& __mg = use_facet<_TimeGet>(__is.getloc());
__mg.get(_Iter(__is.rdbuf()), _Iter(), __is,
__err, __f._M_tmb, __f._M_fmt, __fmt_end);
}
catch(__cxxabiv1::__forced_unwind&)
{
__is._M_setstate(ios_base::badbit);
throw;
}
catch(...)
{ __is._M_setstate(ios_base::badbit); }
if (__err)
__is.setstate(__err);
}
return __is;
}
# 459 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iomanip" 3
template<typename _CharT>
inline auto
quoted(const _CharT* __string,
_CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\'))
{
return __detail::_Quoted_string<const _CharT*, _CharT>(__string, __delim,
__escape);
}
template<typename _CharT, typename _Traits, typename _Alloc>
inline auto
quoted(const basic_string<_CharT, _Traits, _Alloc>& __string,
_CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\'))
{
return __detail::_Quoted_string<
const basic_string<_CharT, _Traits, _Alloc>&, _CharT>(
__string, __delim, __escape);
}
template<typename _CharT, typename _Traits, typename _Alloc>
inline auto
quoted(basic_string<_CharT, _Traits, _Alloc>& __string,
_CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\'))
{
return __detail::_Quoted_string<
basic_string<_CharT, _Traits, _Alloc>&, _CharT>(
__string, __delim, __escape);
}
# 496 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iomanip" 3
extern template ostream& operator<<(ostream&, _Setfill<char>);
extern template ostream& operator<<(ostream&, _Setiosflags);
extern template ostream& operator<<(ostream&, _Resetiosflags);
extern template ostream& operator<<(ostream&, _Setbase);
extern template ostream& operator<<(ostream&, _Setprecision);
extern template ostream& operator<<(ostream&, _Setw);
extern template istream& operator>>(istream&, _Setfill<char>);
extern template istream& operator>>(istream&, _Setiosflags);
extern template istream& operator>>(istream&, _Resetiosflags);
extern template istream& operator>>(istream&, _Setbase);
extern template istream& operator>>(istream&, _Setprecision);
extern template istream& operator>>(istream&, _Setw);
extern template wostream& operator<<(wostream&, _Setfill<wchar_t>);
extern template wostream& operator<<(wostream&, _Setiosflags);
extern template wostream& operator<<(wostream&, _Resetiosflags);
extern template wostream& operator<<(wostream&, _Setbase);
extern template wostream& operator<<(wostream&, _Setprecision);
extern template wostream& operator<<(wostream&, _Setw);
extern template wistream& operator>>(wistream&, _Setfill<wchar_t>);
extern template wistream& operator>>(wistream&, _Setiosflags);
extern template wistream& operator>>(wistream&, _Resetiosflags);
extern template wistream& operator>>(wistream&, _Setbase);
extern template wistream& operator>>(wistream&, _Setprecision);
extern template wistream& operator>>(wistream&, _Setw);
}
# 120 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 2
# 124 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
namespace ap_private_ops {
static inline uint32_t Hi_32(uint64_t Value) {
return static_cast<uint32_t>(Value >> 32);
}
static inline uint32_t Lo_32(uint64_t Value) {
return static_cast<uint32_t>(Value);
}
template <int _AP_W>
inline bool isNegative(const ap_private<_AP_W, false>& a) {
return false;
}
template <int _AP_W>
inline bool isNegative(const ap_private<_AP_W, true>& a) {
enum {
APINT_BITS_PER_WORD = 64,
_AP_N = (_AP_W + APINT_BITS_PER_WORD - 1) / APINT_BITS_PER_WORD
};
static const uint64_t sign_mask = 1ULL << ((_AP_W - 1) % APINT_BITS_PER_WORD);
return (sign_mask & a.get_pVal(_AP_N - 1)) != 0;
}
static inline unsigned CountLeadingZeros_32(uint32_t Value) {
unsigned Count;
if (Value == 0) return 32;
Count = __builtin_clz(Value);
# 175 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
return Count;
}
static inline unsigned CountLeadingZeros_64(uint64_t Value) {
unsigned Count;
if (!Value) return 64;
Count = __builtin_clzll(Value);
# 219 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
return Count;
}
static inline unsigned CountTrailingZeros_64(uint64_t Value) {
return (Value != 0) ? __builtin_ctzll(Value) : 64;
# 237 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
}
static inline unsigned CountPopulation_64(uint64_t Value) {
return __builtin_popcountll(Value);
}
static inline uint32_t countLeadingOnes_64(uint64_t __V, uint32_t skip) {
uint32_t Count = 0;
if (skip) (__V) <<= (skip);
while (__V && (__V & (1ULL << 63))) {
Count++;
(__V) <<= 1;
}
return Count;
}
static inline std::string oct2Bin(char oct) {
switch (oct) {
case '\0': {
return "";
}
case '.': {
return ".";
}
case '0': {
return "000";
}
case '1': {
return "001";
}
case '2': {
return "010";
}
case '3': {
return "011";
}
case '4': {
return "100";
}
case '5': {
return "101";
}
case '6': {
return "110";
}
case '7': {
return "111";
}
}
# 295 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 295 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
0 && "Invalid character in digit string"
# 295 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 295 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"0 && \"Invalid character in digit string\""
# 295 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 295, __PRETTY_FUNCTION__))
# 295 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
return "";
}
static inline std::string hex2Bin(char hex) {
switch (hex) {
case '\0': {
return "";
}
case '.': {
return ".";
}
case '0': {
return "0000";
}
case '1': {
return "0001";
}
case '2': {
return "0010";
}
case '3': {
return "0011";
}
case '4': {
return "0100";
}
case '5': {
return "0101";
}
case '6': {
return "0110";
}
case '7': {
return "0111";
}
case '8': {
return "1000";
}
case '9': {
return "1001";
}
case 'A':
case 'a': {
return "1010";
}
case 'B':
case 'b': {
return "1011";
}
case 'C':
case 'c': {
return "1100";
}
case 'D':
case 'd': {
return "1101";
}
case 'E':
case 'e': {
return "1110";
}
case 'F':
case 'f': {
return "1111";
}
}
# 362 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 362 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
0 && "Invalid character in digit string"
# 362 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 362 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"0 && \"Invalid character in digit string\""
# 362 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 362, __PRETTY_FUNCTION__))
# 362 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
return "";
}
static inline uint32_t decode_digit(char cdigit, int radix) {
uint32_t digit = 0;
if (radix == 16) {
if (!(((cdigit) >= '0' && (cdigit) <= '9') || ((cdigit) >= 'a' && (cdigit) <= 'f') || ((cdigit) >= 'A' && (cdigit) <= 'F')))
# 373 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 373 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
0 && "Invalid hex digit in string"
# 373 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 373 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"0 && \"Invalid hex digit in string\""
# 373 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 373, __PRETTY_FUNCTION__))
# 373 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
if (((cdigit) >= '0' && (cdigit) <= '9'))
digit = cdigit - '0';
else if (cdigit >= 'a')
digit = cdigit - 'a' + 10;
else if (cdigit >= 'A')
digit = cdigit - 'A' + 10;
else
# 381 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 381 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
0 && "huh? we shouldn't get here"
# 381 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 381 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"0 && \"huh? we shouldn't get here\""
# 381 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 381, __PRETTY_FUNCTION__))
# 381 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
} else if (((cdigit) >= '0' && (cdigit) <= '9')) {
digit = cdigit - '0';
} else {
# 385 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 385 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
0 && "Invalid character in digit string"
# 385 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 385 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"0 && \"Invalid character in digit string\""
# 385 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 385, __PRETTY_FUNCTION__))
# 385 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
}
return digit;
}
static inline std::string parseString(const std::string& input, unsigned char& radix) {
size_t len = input.length();
if (len == 0) {
if (radix == 0) radix = 10;
return input;
}
size_t startPos = 0;
while (input[startPos] == ' ' && startPos < len) startPos++;
while (input[len - 1] == ' ' && startPos < len) len--;
std::string val = input.substr(startPos, len - startPos);
len = val.length();
startPos = 0;
if (len < 2) {
if (radix == 0) radix = 10;
return val;
}
bool isNegative = false;
std::string ans;
if (val[0] == '-') {
ans = "-";
++startPos;
isNegative = true;
} else if (val[0] == '+')
++startPos;
if (len - startPos < 2) {
if (radix == 0) radix = 10;
return val;
}
if (val.substr(startPos, 2) == "0x" || val.substr(startPos, 2) == "0X") {
radix = 16;
startPos += 2;
} else if (val.substr(startPos, 2) == "0b" ||
val.substr(startPos, 2) == "0B") {
radix = 2;
startPos += 2;
} else if (val.substr(startPos, 2) == "0o" ||
val.substr(startPos, 2) == "0O") {
radix = 8;
startPos += 2;
} else if (radix == 0) {
radix = 10;
}
int exp = 0;
if (radix == 10) {
size_t expPos = val.find('e');
bool has_exponent = true;
if (expPos == std::string::npos) expPos = val.find('E');
if (expPos == std::string::npos) {
expPos = len;
has_exponent = false;
}
ans += val.substr(startPos, expPos - startPos);
if (has_exponent) {
std::istringstream iss(val.substr(expPos + 1, len - expPos - 1));
iss >> exp;
}
} else {
size_t expPos = val.find('p');
bool has_exponent = true;
if (expPos == std::string::npos) expPos = val.find('P');
if (expPos == std::string::npos) {
expPos = len;
has_exponent = false;
}
# 484 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 484 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
startPos <= expPos
# 484 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 484 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"startPos <= expPos"
# 484 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 484, __PRETTY_FUNCTION__))
# 484 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
for (size_t i = startPos; i < expPos; ++i) {
if (radix == 16) {
ans += hex2Bin(val[i]);
} else if (radix == 8) {
ans += oct2Bin(val[i]);
} else {
ans += val[i];
}
}
radix = 2;
if (has_exponent) {
std::istringstream iss(val.substr(expPos + 1, len - expPos - 1));
iss >> exp;
}
}
if (exp == 0) return ans;
size_t decPos = ans.find('.');
if (decPos == std::string::npos) decPos = ans.length();
if ((int)decPos + exp >= (int)ans.length()) {
int i = decPos;
for (; i < (int)ans.length() - 1; ++i) ans[i] = ans[i + 1];
for (; i < (int)ans.length(); ++i) ans[i] = '0';
for (; i < (int)decPos + exp; ++i) ans += '0';
return ans;
} else if ((int)decPos + exp < (int)isNegative) {
std::string dupAns = "0.";
if (ans[0] == '-') dupAns = "-0.";
for (int i = 0; i < isNegative - (int)decPos - exp; ++i) dupAns += '0';
for (size_t i = isNegative; i < ans.length(); ++i)
if (ans[i] != '.') dupAns += ans[i];
return dupAns;
}
if (exp > 0)
for (size_t i = decPos; i < decPos + exp; ++i) ans[i] = ans[i + 1];
else {
if (decPos == ans.length()) ans += ' ';
for (int i = decPos; i > (int)decPos + exp; --i) ans[i] = ans[i - 1];
}
ans[decPos + exp] = '.';
return ans;
}
static inline bool sub_1(uint64_t x[], uint32_t len, uint64_t y) {
for (uint32_t i = 0; i < len; ++i) {
uint64_t __X = x[i];
x[i] -= y;
if (y > __X)
y = 1;
else {
y = 0;
break;
}
}
return (y != 0);
}
static inline bool add_1(uint64_t dest[], uint64_t x[], uint32_t len,
uint64_t y) {
for (uint32_t i = 0; i < len; ++i) {
dest[i] = y + x[i];
if (dest[i] < y)
y = 1;
else {
y = 0;
break;
}
}
return (y != 0);
}
static inline bool add(uint64_t* dest, const uint64_t* x, const uint64_t* y,
uint32_t destlen, uint32_t xlen, uint32_t ylen,
bool xsigned, bool ysigned) {
bool carry = false;
uint32_t len = AESL_std::min(xlen, ylen);
uint32_t i;
for (i = 0; i < len && i < destlen; ++i) {
uint64_t limit =
AESL_std::min(x[i], y[i]);
dest[i] = x[i] + y[i] + carry;
carry = dest[i] < limit || (carry && dest[i] == limit);
}
if (xlen > ylen) {
const uint64_t yext = ysigned && int64_t(y[ylen - 1]) < 0 ? -1 : 0;
for (i = ylen; i < xlen && i < destlen; i++) {
uint64_t limit = AESL_std::min(x[i], yext);
dest[i] = x[i] + yext + carry;
carry = (dest[i] < limit) || (carry && dest[i] == limit);
}
} else if (ylen > xlen) {
const uint64_t xext = xsigned && int64_t(x[xlen - 1]) < 0 ? -1 : 0;
for (i = xlen; i < ylen && i < destlen; i++) {
uint64_t limit = AESL_std::min(xext, y[i]);
dest[i] = xext + y[i] + carry;
carry = (dest[i] < limit) || (carry && dest[i] == limit);
}
}
return carry;
}
static inline bool sub(uint64_t* dest, const uint64_t* x, const uint64_t* y,
uint32_t destlen, uint32_t xlen, uint32_t ylen,
bool xsigned, bool ysigned) {
bool borrow = false;
uint32_t i;
uint32_t len = AESL_std::min(xlen, ylen);
for (i = 0; i < len && i < destlen; ++i) {
uint64_t x_tmp = borrow ? x[i] - 1 : x[i];
borrow = y[i] > x_tmp || (borrow && x[i] == 0);
dest[i] = x_tmp - y[i];
}
if (xlen > ylen) {
const uint64_t yext = ysigned && int64_t(y[ylen - 1]) < 0 ? -1 : 0;
for (i = ylen; i < xlen && i < destlen; i++) {
uint64_t x_tmp = borrow ? x[i] - 1 : x[i];
borrow = yext > x_tmp || (borrow && x[i] == 0);
dest[i] = x_tmp - yext;
}
} else if (ylen > xlen) {
const uint64_t xext = xsigned && int64_t(x[xlen - 1]) < 0 ? -1 : 0;
for (i = xlen; i < ylen && i < destlen; i++) {
uint64_t x_tmp = borrow ? xext - 1 : xext;
borrow = y[i] > x_tmp || (borrow && xext == 0);
dest[i] = x_tmp - y[i];
}
}
return borrow;
}
# 643 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
static inline uint64_t mul_1(uint64_t dest[], const uint64_t x[], uint32_t len,
uint64_t y) {
uint64_t ly = y & 0xffffffffULL, hy = (y) >> 32;
uint64_t carry = 0;
static const uint64_t two_power_32 = 1ULL << 32;
for (uint32_t i = 0; i < len; ++i) {
uint64_t lx = x[i] & 0xffffffffULL;
uint64_t hx = (x[i]) >> 32;
uint8_t hasCarry = 0;
dest[i] = carry + lx * ly;
hasCarry = (dest[i] < carry) ? 1 : 0;
carry = hx * ly + ((dest[i]) >> 32) + (hasCarry ? two_power_32 : 0);
hasCarry = (!carry && hasCarry) ? 1 : (!carry ? 2 : 0);
carry += (lx * hy) & 0xffffffffULL;
dest[i] = ((carry) << 32) | (dest[i] & 0xffffffffULL);
carry = (((!carry && hasCarry != 2) || hasCarry == 1) ? two_power_32 : 0) +
((carry) >> 32) + ((lx * hy) >> 32) + hx * hy;
}
return carry;
}
static inline void mul(uint64_t dest[], const uint64_t x[], uint32_t xlen,
const uint64_t y[], uint32_t ylen, uint32_t destlen) {
# 683 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 683 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
xlen > 0
# 683 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 683 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"xlen > 0"
# 683 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 683, __PRETTY_FUNCTION__))
# 683 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
# 684 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 684 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
ylen > 0
# 684 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 684 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"ylen > 0"
# 684 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 684, __PRETTY_FUNCTION__))
# 684 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
# 685 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 685 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
destlen >= xlen + ylen
# 685 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 685 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"destlen >= xlen + ylen"
# 685 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 685, __PRETTY_FUNCTION__))
# 685 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
if (xlen < destlen) dest[xlen] = mul_1(dest, x, xlen, y[0]);
for (uint32_t i = 1; i < ylen; ++i) {
uint64_t ly = y[i] & 0xffffffffULL, hy = (y[i]) >> 32;
uint64_t carry = 0, lx = 0, hx = 0;
for (uint32_t j = 0; j < xlen; ++j) {
lx = x[j] & 0xffffffffULL;
hx = (x[j]) >> 32;
uint8_t hasCarry = 0;
uint64_t resul = carry + lx * ly;
hasCarry = (resul < carry) ? 1 : 0;
carry = (hasCarry ? (1ULL << 32) : 0) + hx * ly + ((resul) >> 32);
hasCarry = (!carry && hasCarry) ? 1 : (!carry ? 2 : 0);
carry += (lx * hy) & 0xffffffffULL;
resul = ((carry) << 32) | (resul & 0xffffffffULL);
if (i + j < destlen) dest[i + j] += resul;
carry =
(((!carry && hasCarry != 2) || hasCarry == 1) ? (1ULL << 32) : 0) +
((carry) >> 32) + (dest[i + j] < resul ? 1 : 0) + ((lx * hy) >> 32) +
hx * hy;
}
if (i + xlen < destlen) dest[i + xlen] = carry;
}
}
static inline void KnuthDiv(uint32_t* u, uint32_t* v, uint32_t* q, uint32_t* r,
uint32_t m, uint32_t n) {
# 720 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 720 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
u && "Must provide dividend"
# 720 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 720 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"u && \"Must provide dividend\""
# 720 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 720, __PRETTY_FUNCTION__))
# 720 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
# 721 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 721 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
v && "Must provide divisor"
# 721 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 721 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"v && \"Must provide divisor\""
# 721 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 721, __PRETTY_FUNCTION__))
# 721 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
# 722 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 722 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
q && "Must provide quotient"
# 722 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 722 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"q && \"Must provide quotient\""
# 722 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 722, __PRETTY_FUNCTION__))
# 722 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
# 723 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 723 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
u != v && u != q && v != q && "Must us different memory"
# 723 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 723 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"u != v && u != q && v != q && \"Must us different memory\""
# 723 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 723, __PRETTY_FUNCTION__))
# 723 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
# 724 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 724 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
n > 1 && "n must be > 1"
# 724 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 724 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"n > 1 && \"n must be > 1\""
# 724 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 724, __PRETTY_FUNCTION__))
# 724 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
uint64_t b = uint64_t(1) << 32;
# 746 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
uint32_t shift = CountLeadingZeros_32(v[n - 1]);
uint32_t v_carry = 0;
uint32_t u_carry = 0;
if (shift) {
for (uint32_t i = 0; i < m + n; ++i) {
uint32_t u_tmp = (u[i]) >> (32 - shift);
u[i] = ((u[i]) << (shift)) | u_carry;
u_carry = u_tmp;
}
for (uint32_t i = 0; i < n; ++i) {
uint32_t v_tmp = (v[i]) >> (32 - shift);
v[i] = ((v[i]) << (shift)) | v_carry;
v_carry = v_tmp;
}
}
u[m + n] = u_carry;
# 771 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
int j = m;
do {
# 782 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
uint64_t dividend = ((uint64_t(u[j + n]) << 32) + u[j + n - 1]);
uint64_t qp = dividend / v[n - 1];
uint64_t rp = dividend % v[n - 1];
if (qp == b || qp * v[n - 2] > b * rp + u[j + n - 2]) {
qp--;
rp += v[n - 1];
if (rp < b && (qp == b || qp * v[n - 2] > b * rp + u[j + n - 2])) qp--;
}
bool isNeg = false;
for (uint32_t i = 0; i < n; ++i) {
uint64_t u_tmp = uint64_t(u[j + i]) | ((uint64_t(u[j + i + 1])) << 32);
uint64_t subtrahend = uint64_t(qp) * uint64_t(v[i]);
bool borrow = subtrahend > u_tmp;
uint64_t result = u_tmp - subtrahend;
uint32_t k = j + i;
u[k++] = (uint32_t)(result & (b - 1));
u[k++] = (uint32_t)((result) >> 32);
while (borrow && k <= m + n) {
borrow = u[k] == 0;
u[k]--;
k++;
}
isNeg |= borrow;
}
# 827 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
if (isNeg) {
bool carry = true;
for (uint32_t i = 0; i <= m + n; ++i) {
u[i] = ~u[i] + carry;
carry = carry && u[i] == 0;
}
}
q[j] = (uint32_t)qp;
if (isNeg) {
q[j]--;
bool carry = false;
for (uint32_t i = 0; i < n; i++) {
uint32_t limit = AESL_std::min(u[j + i], v[i]);
u[j + i] += v[i] + carry;
carry = u[j + i] < limit || (carry && u[j + i] == limit);
}
u[j + n] += carry;
}
} while (--j >= 0);
# 871 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
if (r) {
if (shift) {
uint32_t carry = 0;
for (int i = n - 1; i >= 0; i--) {
r[i] = ((u[i]) >> (shift)) | carry;
carry = (u[i]) << (32 - shift);
}
} else {
for (int i = n - 1; i >= 0; i--) {
r[i] = u[i];
}
}
}
}
template <int _AP_W, bool _AP_S>
void divide(const ap_private<_AP_W, _AP_S>& LHS, uint32_t lhsWords,
const ap_private<_AP_W, _AP_S>& RHS, uint32_t rhsWords,
ap_private<_AP_W, _AP_S>* Quotient,
ap_private<_AP_W, _AP_S>* Remainder) {
# 899 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 899 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
lhsWords >= rhsWords && "Fractional result"
# 899 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 899 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"lhsWords >= rhsWords && \"Fractional result\""
# 899 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 899, __PRETTY_FUNCTION__))
# 899 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
enum { APINT_BITS_PER_WORD = 64 };
uint64_t mask = ~0ull >> (sizeof(uint32_t) * 8);
uint32_t n = rhsWords * 2;
uint32_t m = (lhsWords * 2) - n;
uint32_t SPACE[128];
uint32_t* __U = 0;
uint32_t* __V = 0;
uint32_t* __Q = 0;
uint32_t* __R = 0;
if ((Remainder ? 4 : 3) * n + 2 * m + 1 <= 128) {
__U = &SPACE[0];
__V = &SPACE[m + n + 1];
__Q = &SPACE[(m + n + 1) + n];
if (Remainder) __R = &SPACE[(m + n + 1) + n + (m + n)];
} else {
__U = new uint32_t[m + n + 1];
__V = new uint32_t[n];
__Q = new uint32_t[m + n];
if (Remainder) __R = new uint32_t[n];
}
memset(__U, 0, (m + n + 1) * sizeof(uint32_t));
for (unsigned i = 0; i < lhsWords; ++i) {
uint64_t tmp = LHS.get_pVal(i);
__U[i * 2] = (uint32_t)(tmp & mask);
__U[i * 2 + 1] = (tmp) >> (sizeof(uint32_t) * 8);
}
__U[m + n] = 0;
memset(__V, 0, (n) * sizeof(uint32_t));
for (unsigned i = 0; i < rhsWords; ++i) {
uint64_t tmp = RHS.get_pVal(i);
__V[i * 2] = (uint32_t)(tmp & mask);
__V[i * 2 + 1] = (tmp) >> (sizeof(uint32_t) * 8);
}
memset(__Q, 0, (m + n) * sizeof(uint32_t));
if (Remainder) memset(__R, 0, n * sizeof(uint32_t));
for (unsigned i = n; i > 0 && __V[i - 1] == 0; i--) {
n--;
m++;
}
for (unsigned i = m + n; i > 0 && __U[i - 1] == 0; i--) m--;
# 968 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 968 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
n != 0 && "Divide by zero?"
# 968 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 968 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"n != 0 && \"Divide by zero?\""
# 968 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 968, __PRETTY_FUNCTION__))
# 968 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
if (n == 1) {
uint32_t divisor = __V[0];
uint32_t remainder = 0;
for (int i = m + n - 1; i >= 0; i--) {
uint64_t partial_dividend = (uint64_t(remainder)) << 32 | __U[i];
if (partial_dividend == 0) {
__Q[i] = 0;
remainder = 0;
} else if (partial_dividend < divisor) {
__Q[i] = 0;
remainder = (uint32_t)partial_dividend;
} else if (partial_dividend == divisor) {
__Q[i] = 1;
remainder = 0;
} else {
__Q[i] = (uint32_t)(partial_dividend / divisor);
remainder = (uint32_t)(partial_dividend - (__Q[i] * divisor));
}
}
if (__R) __R[0] = remainder;
} else {
KnuthDiv(__U, __V, __Q, __R, m, n);
}
if (Quotient) {
if (Quotient->BitWidth != LHS.BitWidth) {
if (Quotient->isSingleWord()) Quotient->set_VAL(0);
} else
Quotient->clear();
if (lhsWords == 1) {
uint64_t tmp =
uint64_t(__Q[0]) | ((uint64_t(__Q[1])) << (APINT_BITS_PER_WORD / 2));
Quotient->set_VAL(tmp);
} else {
# 1010 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 1010 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
!Quotient->isSingleWord() && "Quotient ap_private not large enough"
# 1010 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 1010 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"!Quotient->isSingleWord() && \"Quotient ap_private not large enough\""
# 1010 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
,
"/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
# 1010 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
,
1011
# 1010 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, __PRETTY_FUNCTION__))
# 1011 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
for (unsigned i = 0; i < lhsWords; ++i)
Quotient->set_pVal(
i, uint64_t(__Q[i * 2]) |
((uint64_t(__Q[i * 2 + 1])) << (APINT_BITS_PER_WORD / 2)));
}
Quotient->clearUnusedBits();
}
if (Remainder) {
if (Remainder->BitWidth != RHS.BitWidth) {
if (Remainder->isSingleWord()) Remainder->set_VAL(0);
} else
Remainder->clear();
if (rhsWords == 1) {
uint64_t tmp =
uint64_t(__R[0]) | ((uint64_t(__R[1])) << (APINT_BITS_PER_WORD / 2));
Remainder->set_VAL(tmp);
} else {
# 1035 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 1035 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
!Remainder->isSingleWord() && "Remainder ap_private not large enough"
# 1035 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 1035 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"!Remainder->isSingleWord() && \"Remainder ap_private not large enough\""
# 1035 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
,
"/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
# 1035 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
,
1036
# 1035 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, __PRETTY_FUNCTION__))
# 1036 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
for (unsigned i = 0; i < rhsWords; ++i)
Remainder->set_pVal(
i, uint64_t(__R[i * 2]) |
((uint64_t(__R[i * 2 + 1])) << (APINT_BITS_PER_WORD / 2)));
}
Remainder->clearUnusedBits();
}
if (__U != &SPACE[0]) {
delete[] __U;
delete[] __V;
delete[] __Q;
delete[] __R;
}
}
template <int _AP_W, bool _AP_S>
void divide(const ap_private<_AP_W, _AP_S>& LHS, uint32_t lhsWords,
uint64_t RHS, ap_private<_AP_W, _AP_S>* Quotient,
ap_private<_AP_W, _AP_S>* Remainder) {
uint32_t rhsWords = 1;
# 1059 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 1059 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
lhsWords >= rhsWords && "Fractional result"
# 1059 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 1059 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"lhsWords >= rhsWords && \"Fractional result\""
# 1059 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 1059, __PRETTY_FUNCTION__))
# 1059 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
enum { APINT_BITS_PER_WORD = 64 };
uint64_t mask = ~0ull >> (sizeof(uint32_t) * 8);
uint32_t n = 2;
uint32_t m = (lhsWords * 2) - n;
uint32_t SPACE[128];
uint32_t* __U = 0;
uint32_t* __V = 0;
uint32_t* __Q = 0;
uint32_t* __R = 0;
if ((Remainder ? 4 : 3) * n + 2 * m + 1 <= 128) {
__U = &SPACE[0];
__V = &SPACE[m + n + 1];
__Q = &SPACE[(m + n + 1) + n];
if (Remainder) __R = &SPACE[(m + n + 1) + n + (m + n)];
} else {
__U = new uint32_t[m + n + 1];
__V = new uint32_t[n];
__Q = new uint32_t[m + n];
if (Remainder) __R = new uint32_t[n];
}
memset(__U, 0, (m + n + 1) * sizeof(uint32_t));
for (unsigned i = 0; i < lhsWords; ++i) {
uint64_t tmp = LHS.get_pVal(i);
__U[i * 2] = tmp & mask;
__U[i * 2 + 1] = (tmp) >> (sizeof(uint32_t) * 8);
}
__U[m + n] = 0;
memset(__V, 0, (n) * sizeof(uint32_t));
__V[0] = RHS & mask;
__V[1] = (RHS) >> (sizeof(uint32_t) * 8);
memset(__Q, 0, (m + n) * sizeof(uint32_t));
if (Remainder) memset(__R, 0, n * sizeof(uint32_t));
for (unsigned i = n; i > 0 && __V[i - 1] == 0; i--) {
n--;
m++;
}
for (unsigned i = m + n; i > 0 && __U[i - 1] == 0; i--) m--;
# 1125 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 1125 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
n != 0 && "Divide by zero?"
# 1125 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 1125 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"n != 0 && \"Divide by zero?\""
# 1125 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 1125, __PRETTY_FUNCTION__))
# 1125 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
if (n == 1) {
uint32_t divisor = __V[0];
uint32_t remainder = 0;
for (int i = m + n - 1; i >= 0; i--) {
uint64_t partial_dividend = (uint64_t(remainder)) << 32 | __U[i];
if (partial_dividend == 0) {
__Q[i] = 0;
remainder = 0;
} else if (partial_dividend < divisor) {
__Q[i] = 0;
remainder = partial_dividend;
} else if (partial_dividend == divisor) {
__Q[i] = 1;
remainder = 0;
} else {
__Q[i] = partial_dividend / divisor;
remainder = partial_dividend - (__Q[i] * divisor);
}
}
if (__R) __R[0] = remainder;
} else {
KnuthDiv(__U, __V, __Q, __R, m, n);
}
if (Quotient) {
if (Quotient->BitWidth != LHS.BitWidth) {
if (Quotient->isSingleWord()) Quotient->set_VAL(0);
} else
Quotient->clear();
if (lhsWords == 1) {
uint64_t tmp =
uint64_t(__Q[0]) | ((uint64_t(__Q[1])) << (APINT_BITS_PER_WORD / 2));
Quotient->set_VAL(tmp);
} else {
# 1167 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 1167 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
!Quotient->isSingleWord() && "Quotient ap_private not large enough"
# 1167 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 1167 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"!Quotient->isSingleWord() && \"Quotient ap_private not large enough\""
# 1167 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
,
"/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
# 1167 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
,
1168
# 1167 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, __PRETTY_FUNCTION__))
# 1168 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
for (unsigned i = 0; i < lhsWords; ++i)
Quotient->set_pVal(
i, uint64_t(__Q[i * 2]) |
((uint64_t(__Q[i * 2 + 1])) << (APINT_BITS_PER_WORD / 2)));
}
Quotient->clearUnusedBits();
}
if (Remainder) {
if (Remainder->BitWidth != 64 ) {
if (Remainder->isSingleWord()) Remainder->set_VAL(0);
} else
Remainder->clear();
if (rhsWords == 1) {
uint64_t tmp =
uint64_t(__R[0]) | ((uint64_t(__R[1])) << (APINT_BITS_PER_WORD / 2));
Remainder->set_VAL(tmp);
} else {
# 1192 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 1192 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
!Remainder->isSingleWord() && "Remainder ap_private not large enough"
# 1192 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 1192 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"!Remainder->isSingleWord() && \"Remainder ap_private not large enough\""
# 1192 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
,
"/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
# 1192 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
,
1193
# 1192 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, __PRETTY_FUNCTION__))
# 1193 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
for (unsigned i = 0; i < rhsWords; ++i)
Remainder->set_pVal(
i, uint64_t(__R[i * 2]) |
((uint64_t(__R[i * 2 + 1])) << (APINT_BITS_PER_WORD / 2)));
}
Remainder->clearUnusedBits();
}
if (__U != &SPACE[0]) {
delete[] __U;
delete[] __V;
delete[] __Q;
delete[] __R;
}
}
template <int _AP_W, bool _AP_S, bool _AP_C>
inline ap_private<_AP_W, _AP_S, _AP_C> lshr(
const ap_private<_AP_W, _AP_S, _AP_C>& LHS, uint32_t shiftAmt) {
return LHS.lshr(shiftAmt);
}
template <int _AP_W, bool _AP_S, bool _AP_C>
inline ap_private<_AP_W, _AP_S, _AP_C> shl(
const ap_private<_AP_W, _AP_S, _AP_C>& LHS, uint32_t shiftAmt) {
return LHS.shl(shiftAmt);
}
}
enum {
MIN_INT_BITS = 1,
MAX_INT_BITS = (1 << 23) - 1
};
# 1280 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
typedef unsigned long long ap_ulong;
typedef signed long long ap_slong;
template <int _AP_N8, bool _AP_S>
struct valtype;
template <int _AP_N8>
struct valtype<_AP_N8, false> {
typedef uint64_t Type;
};
template <int _AP_N8>
struct valtype<_AP_N8, true> {
typedef int64_t Type;
};
template <>
struct valtype<1, false> {
typedef unsigned char Type;
};
template <>
struct valtype<2, false> {
typedef unsigned short Type;
};
template <>
struct valtype<3, false> {
typedef unsigned int Type;
};
template <>
struct valtype<4, false> {
typedef unsigned int Type;
};
template <>
struct valtype<1, true> {
typedef signed char Type;
};
template <>
struct valtype<2, true> {
typedef short Type;
};
template <>
struct valtype<3, true> {
typedef int Type;
};
template <>
struct valtype<4, true> {
typedef int Type;
};
template <bool enable>
struct ap_private_enable_if {};
template <>
struct ap_private_enable_if<true> {
static const bool isValid = true;
};
template <int _AP_W, bool _AP_S>
class ap_private<_AP_W, _AP_S, true> {
const static bool valid = ap_private_enable_if<_AP_W <= 64>::isValid;
public:
typedef typename valtype<(_AP_W + 7) / 8, _AP_S>::Type ValType;
typedef ap_private<_AP_W, _AP_S> Type;
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_private<mult_w, mult_s> mult;
typedef ap_private<plus_w, plus_s> plus;
typedef ap_private<minus_w, minus_s> minus;
typedef ap_private<logic_w, logic_s> logic;
typedef ap_private<div_w, div_s> div;
typedef ap_private<mod_w, mod_s> mod;
typedef ap_private<_AP_W, _AP_S> arg1;
typedef bool reduce;
};
enum { APINT_BITS_PER_WORD = sizeof(uint64_t) * 8 };
enum {
excess_bits = (_AP_W % APINT_BITS_PER_WORD)
? APINT_BITS_PER_WORD - (_AP_W % APINT_BITS_PER_WORD)
: 0
};
static const uint64_t mask = ((uint64_t)~0ULL >> (excess_bits));
static const uint64_t not_mask = ~mask;
static const uint64_t sign_bit_mask = 1ULL << (APINT_BITS_PER_WORD - 1);
template <int _AP_W1>
struct sign_ext_mask {
static const uint64_t mask = ~0ULL << _AP_W1;
};
static const int width = _AP_W;
enum {
BitWidth = _AP_W,
_AP_N = 1,
};
ValType VAL;
void check_canary() {}
void set_canary() {}
inline ValType& get_VAL(void) { return VAL; }
inline ValType get_VAL(void) const { return VAL; }
inline ValType get_VAL(void) const volatile { return VAL; }
inline void set_VAL(uint64_t value) { VAL = (ValType)value; }
inline ValType& get_pVal(int i) { return VAL; }
inline ValType get_pVal(int i) const { return VAL; }
inline const uint64_t* get_pVal() const {
# 1411 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 1411 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
0 && "invalid usage"
# 1411 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 1411 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"0 && \"invalid usage\""
# 1411 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 1411, __PRETTY_FUNCTION__))
# 1411 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
return 0;
}
inline ValType get_pVal(int i) const volatile { return VAL; }
inline uint64_t* get_pVal() const volatile {
# 1416 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 1416 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
0 && "invalid usage"
# 1416 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 1416 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"0 && \"invalid usage\""
# 1416 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 1416, __PRETTY_FUNCTION__))
# 1416 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
return 0;
}
inline void set_pVal(int i, uint64_t value) { VAL = (ValType)value; }
inline uint32_t getBitWidth() const { return BitWidth; }
template <int _AP_W1, bool _AP_S1>
ap_private<_AP_W, _AP_S>& operator=(const ap_private<_AP_W1, _AP_S1>& RHS) {
VAL = (ValType)(RHS.get_VAL());
clearUnusedBits();
return *this;
}
template <int _AP_W1, bool _AP_S1>
ap_private<_AP_W, _AP_S>& operator=(
const volatile ap_private<_AP_W1, _AP_S1>& RHS) {
VAL = (ValType)(RHS.get_VAL());
clearUnusedBits();
return *this;
}
void operator=(const ap_private& RHS) volatile {
VAL = RHS.get_VAL();
clearUnusedBits();
}
ap_private& operator=(const ap_private& RHS) {
VAL = RHS.get_VAL();
clearUnusedBits();
return *this;
}
void operator=(const volatile ap_private& RHS) volatile {
VAL = RHS.get_VAL();
clearUnusedBits();
}
ap_private& operator=(const volatile ap_private& RHS) {
VAL = RHS.get_VAL();
clearUnusedBits();
return *this;
}
template <int _AP_W2, bool _AP_S2>
inline ap_private& operator=(const _private_range_ref<_AP_W2, _AP_S2>& op2) {
*this = ap_private<_AP_W2, false>(op2);
return *this;
}
# 1479 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
inline ap_private& operator=(const bool v) { set_canary(); this->VAL = (ValType)v; clearUnusedBits(); check_canary(); return *this; }
inline ap_private& operator=(const char v) { set_canary(); this->VAL = (ValType)v; clearUnusedBits(); check_canary(); return *this; }
inline ap_private& operator=(const signed char v) { set_canary(); this->VAL = (ValType)v; clearUnusedBits(); check_canary(); return *this; }
inline ap_private& operator=(const unsigned char v) { set_canary(); this->VAL = (ValType)v; clearUnusedBits(); check_canary(); return *this; }
inline ap_private& operator=(const short v) { set_canary(); this->VAL = (ValType)v; clearUnusedBits(); check_canary(); return *this; }
inline ap_private& operator=(const unsigned short v) { set_canary(); this->VAL = (ValType)v; clearUnusedBits(); check_canary(); return *this; }
inline ap_private& operator=(const int v) { set_canary(); this->VAL = (ValType)v; clearUnusedBits(); check_canary(); return *this; }
inline ap_private& operator=(const unsigned int v) { set_canary(); this->VAL = (ValType)v; clearUnusedBits(); check_canary(); return *this; }
inline ap_private& operator=(const long v) { set_canary(); this->VAL = (ValType)v; clearUnusedBits(); check_canary(); return *this; }
inline ap_private& operator=(const unsigned long v) { set_canary(); this->VAL = (ValType)v; clearUnusedBits(); check_canary(); return *this; }
inline ap_private& operator=(const ap_slong v) { set_canary(); this->VAL = (ValType)v; clearUnusedBits(); check_canary(); return *this; }
inline ap_private& operator=(const ap_ulong v) { set_canary(); this->VAL = (ValType)v; clearUnusedBits(); check_canary(); return *this; }
inline ap_private& operator=(const half v) { set_canary(); this->VAL = (ValType)v; clearUnusedBits(); check_canary(); return *this; }
inline ap_private& operator=(const float v) { set_canary(); this->VAL = (ValType)v; clearUnusedBits(); check_canary(); return *this; }
inline ap_private& operator=(const double v) { set_canary(); this->VAL = (ValType)v; clearUnusedBits(); check_canary(); return *this; }
inline ap_private& operator=(const char* s) {
ap_private tmp(s);
operator=(tmp);
return *this;
}
private:
explicit inline ap_private(uint64_t* val) : VAL(val[0]) {
set_canary();
clearUnusedBits();
check_canary();
}
inline bool isSingleWord() const { return true; }
public:
inline void fromString(const char* strStart, uint32_t slen, uint8_t radix) {
bool isNeg = strStart[0] == '-';
if (isNeg) {
strStart++;
slen--;
}
if (strStart[0] == '0' && (strStart[1] == 'b' || strStart[1] == 'B')) {
do { if ((radix != 2)) { fprintf(
# 1523 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
stderr
# 1523 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
, "WARNING: " "%s seems to have base %d, but %d given.", strStart, 2, radix); fprintf(
# 1523 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
stderr
# 1523 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
, "\n"); } } while (0);
strStart += 2;
slen -=2;
} else if (strStart[0] == '0' && (strStart[1] == 'o' || strStart[1] == 'O')) {
do { if ((radix != 8)) { fprintf(
# 1528 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
stderr
# 1528 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
, "WARNING: " "%s seems to have base %d, but %d given.", strStart, 8, radix); fprintf(
# 1528 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
stderr
# 1528 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
, "\n"); } } while (0);
strStart += 2;
slen -=2;
} else if (strStart[0] == '0' && (strStart[1] == 'x' || strStart[1] == 'X')) {
do { if ((radix != 16)) { fprintf(
# 1533 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
stderr
# 1533 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
, "WARNING: " "%s seems to have base %d, but %d given.", strStart, 16, radix); fprintf(
# 1533 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
stderr
# 1533 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
, "\n"); } } while (0);
strStart += 2;
slen -=2;
} else if (strStart[0] == '0' && (strStart[1] == 'd' || strStart[1] == 'D')) {
do { if ((radix != 10)) { fprintf(
# 1538 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
stderr
# 1538 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
, "WARNING: " "%s seems to have base %d, but %d given.", strStart, 10, radix); fprintf(
# 1538 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
stderr
# 1538 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
, "\n"); } } while (0);
strStart += 2;
slen -=2;
} else if (radix == 0) {
}
# 1546 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 1546 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
(radix == 10 || radix == 8 || radix == 16 || radix == 2) && "Radix should be 2, 8, 10, or 16!"
# 1546 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 1546 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"(radix == 10 || radix == 8 || radix == 16 || radix == 2) && \"Radix should be 2, 8, 10, or 16!\""
# 1546 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
,
"/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
# 1546 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
,
1547
# 1546 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, __PRETTY_FUNCTION__))
# 1547 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
# 1548 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 1548 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
strStart && "String is null?"
# 1548 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 1548 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"strStart && \"String is null?\""
# 1548 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 1548, __PRETTY_FUNCTION__))
# 1548 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
uint64_t tmpVAL = VAL = 0;
switch (radix) {
case 2:
for (; *strStart; ++strStart) {
# 1558 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 1558 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
(*strStart == '0' || *strStart == '1') && ("Wrong binary number")
# 1558 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 1558 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"(*strStart == '0' || *strStart == '1') && (\"Wrong binary number\")"
# 1558 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
,
"/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
# 1558 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
,
1559
# 1558 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, __PRETTY_FUNCTION__))
# 1559 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
tmpVAL <<= 1;
tmpVAL |= (*strStart - '0');
}
break;
case 8:
sscanf(strStart, "%lo", &tmpVAL);
break;
case 10:
sscanf(strStart, "%lu", &tmpVAL);
break;
case 16:
sscanf(strStart, "%lx", &tmpVAL);
break;
default:
# 1598 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 1598 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
true && "Unknown radix"
# 1598 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 1598 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"true && \"Unknown radix\""
# 1598 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 1598, __PRETTY_FUNCTION__))
# 1598 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
}
VAL = isNeg ? (ValType)(-tmpVAL) : (ValType)(tmpVAL);
clearUnusedBits();
}
private:
inline ap_private(const std::string& val, uint8_t radix = 2) : VAL(0) {
# 1608 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 1608 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
!val.empty() && "String empty?"
# 1608 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 1608 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"!val.empty() && \"String empty?\""
# 1608 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 1608, __PRETTY_FUNCTION__))
# 1608 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
set_canary();
fromString(val.c_str(), val.size(), radix);
check_canary();
}
inline ap_private(const char strStart[], uint32_t slen, uint8_t radix)
: VAL(0) {
set_canary();
fromString(strStart, slen, radix);
check_canary();
}
inline ap_private(uint32_t numWords, const uint64_t bigVal[])
: VAL(bigVal[0]) {
set_canary();
clearUnusedBits();
check_canary();
}
public:
inline ap_private() {
set_canary();
clearUnusedBits();
check_canary();
}
inline ap_private(bool v) : VAL((ValType)v) { set_canary(); clearUnusedBits(); check_canary(); }
inline ap_private(char v) : VAL((ValType)v) { set_canary(); clearUnusedBits(); check_canary(); }
inline ap_private(signed char v) : VAL((ValType)v) { set_canary(); clearUnusedBits(); check_canary(); }
inline ap_private(unsigned char v) : VAL((ValType)v) { set_canary(); clearUnusedBits(); check_canary(); }
inline ap_private(short v) : VAL((ValType)v) { set_canary(); clearUnusedBits(); check_canary(); }
inline ap_private(unsigned short v) : VAL((ValType)v) { set_canary(); clearUnusedBits(); check_canary(); }
inline ap_private(int v) : VAL((ValType)v) { set_canary(); clearUnusedBits(); check_canary(); }
inline ap_private(unsigned int v) : VAL((ValType)v) { set_canary(); clearUnusedBits(); check_canary(); }
inline ap_private(long v) : VAL((ValType)v) { set_canary(); clearUnusedBits(); check_canary(); }
inline ap_private(unsigned long v) : VAL((ValType)v) { set_canary(); clearUnusedBits(); check_canary(); }
inline ap_private(ap_slong v) : VAL((ValType)v) { set_canary(); clearUnusedBits(); check_canary(); }
inline ap_private(ap_ulong v) : VAL((ValType)v) { set_canary(); clearUnusedBits(); check_canary(); }
inline ap_private(half v) : VAL((ValType)v) { set_canary(); clearUnusedBits(); check_canary(); }
inline ap_private(float v) : VAL((ValType)v) { set_canary(); clearUnusedBits(); check_canary(); }
inline ap_private(double v) : VAL((ValType)v) { set_canary(); clearUnusedBits(); check_canary(); }
template <int _AP_W1, bool _AP_S1, bool _AP_OPT>
inline ap_private(const ap_private<_AP_W1, _AP_S1, _AP_OPT>& that)
: VAL((ValType)that.get_VAL()) {
set_canary();
clearUnusedBits();
check_canary();
}
template <int _AP_W1, bool _AP_S1, bool _AP_OPT>
inline ap_private(const volatile ap_private<_AP_W1, _AP_S1, _AP_OPT>& that)
: VAL((ValType)that.get_VAL()) {
set_canary();
clearUnusedBits();
check_canary();
}
explicit inline ap_private(const char* val) {
set_canary();
unsigned char radix = 10;
std::string str = ap_private_ops::parseString(val, radix);
std::string::size_type pos = str.find('.');
if (pos != std::string::npos) str = str.substr(pos);
ap_private<_AP_W, _AP_S> ap_private_val(str, radix);
operator=(ap_private_val);
check_canary();
}
inline ap_private(const char* val, signed char rd) {
set_canary();
unsigned char radix = rd;
std::string str = ap_private_ops::parseString(val, radix);
std::string::size_type pos = str.find('.');
if (pos != std::string::npos) str = str.substr(pos);
ap_private<_AP_W, _AP_S> ap_private_val(str, radix);
operator=(ap_private_val);
check_canary();
}
inline ~ap_private() { check_canary(); }
inline bool isNegative() const {
static const uint64_t sign_mask = 1ULL << (_AP_W - 1);
return _AP_S && (sign_mask & VAL);
}
inline bool isPositive() const { return !isNegative(); }
inline bool isStrictlyPositive() const { return !isNegative() && VAL != 0; }
inline bool isAllOnesValue() const { return (mask & VAL) == mask; }
inline bool operator==(const ap_private<_AP_W, _AP_S>& RHS) const {
return VAL == RHS.get_VAL();
}
inline bool operator==(const ap_private<_AP_W, !_AP_S>& RHS) const {
return (uint64_t)VAL == (uint64_t)RHS.get_VAL();
}
inline bool operator==(uint64_t Val) const { return ((uint64_t)VAL == Val); }
inline bool operator!=(uint64_t Val) const { return ((uint64_t)VAL != Val); }
inline bool operator!=(const ap_private<_AP_W, _AP_S>& RHS) const {
return VAL != RHS.get_VAL();
}
inline bool operator!=(const ap_private<_AP_W, !_AP_S>& RHS) const {
return (uint64_t)VAL != (uint64_t)RHS.get_VAL();
}
const ap_private operator++(int) {
ap_private orig(*this);
VAL++;
clearUnusedBits();
return orig;
}
const ap_private operator++() {
++VAL;
clearUnusedBits();
return *this;
}
const ap_private operator--(int) {
ap_private orig(*this);
--VAL;
clearUnusedBits();
return orig;
}
const ap_private operator--() {
--VAL;
clearUnusedBits();
return *this;
}
inline ap_private<_AP_W + !_AP_S, true> operator~() const {
ap_private<_AP_W + !_AP_S, true> Result(*this);
Result.flip();
return Result;
}
inline typename RType<1, false>::minus operator-() const {
return ap_private<1, false>(0) - (*this);
}
inline bool operator!() const { return !VAL; }
inline std::string toString(uint8_t radix, bool wantSigned) const;
inline std::string toStringUnsigned(uint8_t radix = 10) const {
return toString(radix, false);
}
inline std::string toStringSigned(uint8_t radix = 10) const {
return toString(radix, true);
}
inline void clear() { VAL = 0; }
inline ap_private& clear(uint32_t bitPosition) {
VAL &= ~(1ULL << (bitPosition));
clearUnusedBits();
return *this;
}
inline ap_private ashr(uint32_t shiftAmt) const {
if (_AP_S)
return ap_private((shiftAmt == BitWidth) ? 0
: ((int64_t)VAL) >> (shiftAmt));
else
return ap_private((shiftAmt == BitWidth) ? 0
: ((uint64_t)VAL) >> (shiftAmt));
}
inline ap_private lshr(uint32_t shiftAmt) const {
return ap_private((shiftAmt == BitWidth)
? ap_private(0)
: ap_private((VAL & mask) >> (shiftAmt)));
}
inline ap_private shl(uint32_t shiftAmt) const
{
if (shiftAmt > BitWidth) {
if (!isNegative())
return ap_private(0);
else
return ap_private(-1);
}
if (shiftAmt == BitWidth)
return ap_private(0);
else
return ap_private((VAL) << (shiftAmt));
}
inline int64_t getSExtValue() const { return VAL; }
inline uint64_t getZExtValue() const { return VAL & mask; }
template <int _AP_W2, bool _AP_S2>
inline ap_private(const _private_range_ref<_AP_W2, _AP_S2>& ref) {
set_canary();
*this = ref.get();
check_canary();
}
template <int _AP_W2, bool _AP_S2>
inline ap_private(const _private_bit_ref<_AP_W2, _AP_S2>& ref) {
set_canary();
*this = ((uint64_t)(bool)ref);
check_canary();
}
# 1867 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
inline void write(const ap_private<_AP_W, _AP_S>& op2) volatile {
*this = (op2);
}
inline operator ValType() const { return get_VAL(); }
inline int to_uchar() const { return (unsigned char)get_VAL(); }
inline int to_char() const { return (signed char)get_VAL(); }
inline int to_ushort() const { return (unsigned short)get_VAL(); }
inline int to_short() const { return (short)get_VAL(); }
inline int to_int() const {
return (int)get_VAL();
}
inline unsigned to_uint() const { return (unsigned)get_VAL(); }
inline long to_long() const { return (long)get_VAL(); }
inline unsigned long to_ulong() const { return (unsigned long)get_VAL(); }
inline ap_slong to_int64() const { return (ap_slong)get_VAL(); }
inline ap_ulong to_uint64() const { return (ap_ulong)get_VAL(); }
inline double to_double() const {
if (isNegative())
return roundToDouble(true);
else
return roundToDouble(false);
}
inline unsigned length() const { return _AP_W; }
inline bool isMinValue() const { return VAL == 0; }
template <int _AP_W1, bool _AP_S1>
inline ap_private& operator&=(const ap_private<_AP_W1, _AP_S1>& RHS) {
VAL = (ValType)(((uint64_t)VAL) & RHS.get_VAL());
clearUnusedBits();
return *this;
}
template <int _AP_W1, bool _AP_S1>
inline ap_private& operator|=(const ap_private<_AP_W1, _AP_S1>& RHS) {
VAL = (ValType)(((uint64_t)VAL) | RHS.get_VAL());
clearUnusedBits();
return *this;
}
template <int _AP_W1, bool _AP_S1>
inline ap_private& operator^=(const ap_private<_AP_W1, _AP_S1>& RHS) {
VAL = (ValType)(((uint64_t)VAL) ^ RHS.get_VAL());
clearUnusedBits();
return *this;
}
template <int _AP_W1, bool _AP_S1>
inline ap_private& operator*=(const ap_private<_AP_W1, _AP_S1>& RHS) {
VAL = (ValType)(((uint64_t)VAL) * RHS.get_VAL());
clearUnusedBits();
return *this;
}
template <int _AP_W1, bool _AP_S1>
inline ap_private& operator+=(const ap_private<_AP_W1, _AP_S1>& RHS) {
VAL = (ValType)(((uint64_t)VAL) + RHS.get_VAL());
clearUnusedBits();
return *this;
}
template <int _AP_W1, bool _AP_S1>
inline ap_private& operator-=(const ap_private<_AP_W1, _AP_S1>& RHS) {
VAL = (ValType)(((uint64_t)VAL) - RHS.get_VAL());
clearUnusedBits();
return *this;
}
template <int _AP_W1, bool _AP_S1>
inline typename RType<_AP_W1, _AP_S1>::logic operator&(
const ap_private<_AP_W1, _AP_S1>& RHS) const {
if (RType<_AP_W1, _AP_S1>::logic_w <= 64) {
typename RType<_AP_W1, _AP_S1>::logic Ret(((uint64_t)VAL) &
RHS.get_VAL());
return Ret;
} else {
typename RType<_AP_W1, _AP_S1>::logic Ret = *this;
return Ret & RHS;
}
}
template <int _AP_W1, bool _AP_S1>
inline typename RType<_AP_W1, _AP_S1>::logic operator^(
const ap_private<_AP_W1, _AP_S1>& RHS) const {
if (RType<_AP_W1, _AP_S1>::logic_w <= 64) {
typename RType<_AP_W1, _AP_S1>::logic Ret(((uint64_t)VAL) ^
RHS.get_VAL());
return Ret;
} else {
typename RType<_AP_W1, _AP_S1>::logic Ret = *this;
return Ret ^ RHS;
}
}
template <int _AP_W1, bool _AP_S1>
inline typename RType<_AP_W1, _AP_S1>::logic operator|(
const ap_private<_AP_W1, _AP_S1>& RHS) const {
if (RType<_AP_W1, _AP_S1>::logic_w <= 64) {
typename RType<_AP_W1, _AP_S1>::logic Ret(((uint64_t)VAL) |
RHS.get_VAL());
return Ret;
} else {
typename RType<_AP_W1, _AP_S1>::logic Ret = *this;
return Ret | RHS;
}
}
inline ap_private And(const ap_private& RHS) const {
return ap_private(VAL & RHS.get_VAL());
}
inline ap_private Or(const ap_private& RHS) const {
return ap_private(VAL | RHS.get_VAL());
}
inline ap_private Xor(const ap_private& RHS) const {
return ap_private(VAL ^ RHS.get_VAL());
}
template <int _AP_W1, bool _AP_S1>
inline typename RType<_AP_W1, _AP_S1>::mult operator*(
const ap_private<_AP_W1, _AP_S1>& RHS) const {
if (RType<_AP_W1, _AP_S1>::mult_w <= 64) {
typename RType<_AP_W1, _AP_S1>::mult Result(((uint64_t)VAL) *
RHS.get_VAL());
return Result;
} else {
typename RType<_AP_W1, _AP_S1>::mult Result(*this);
Result *= RHS;
return Result;
}
}
inline ap_private Mul(const ap_private& RHS) const {
return ap_private(VAL * RHS.get_VAL());
}
inline ap_private Add(const ap_private& RHS) const {
return ap_private(VAL + RHS.get_VAL());
}
inline ap_private Sub(const ap_private& RHS) const {
return ap_private(VAL - RHS.get_VAL());
}
inline ap_private& operator&=(uint64_t RHS) {
VAL &= (ValType)RHS;
clearUnusedBits();
return *this;
}
inline ap_private& operator|=(uint64_t RHS) {
VAL |= (ValType)RHS;
clearUnusedBits();
return *this;
}
inline ap_private& operator^=(uint64_t RHS) {
VAL ^= (ValType)RHS;
clearUnusedBits();
return *this;
}
inline ap_private& operator*=(uint64_t RHS) {
VAL *= (ValType)RHS;
clearUnusedBits();
return *this;
}
inline ap_private& operator+=(uint64_t RHS) {
VAL += (ValType)RHS;
clearUnusedBits();
return *this;
}
inline ap_private& operator-=(uint64_t RHS) {
VAL -= (ValType)RHS;
clearUnusedBits();
return *this;
}
inline bool isMinSignedValue() const {
static const uint64_t min_mask = ~(~0ULL << (_AP_W - 1));
return BitWidth == 1 ? VAL == 1
: (ap_private_ops::isNegative<_AP_W>(*this) &&
((min_mask & VAL) == 0));
}
template <int _AP_W1, bool _AP_S1>
inline typename RType<_AP_W1, _AP_S1>::plus operator+(
const ap_private<_AP_W1, _AP_S1>& RHS) const {
if (RType<_AP_W1, _AP_S1>::plus_w <= 64)
return typename RType<_AP_W1, _AP_S1>::plus(
RType<_AP_W1, _AP_S1>::plus_s
? int64_t(((uint64_t)VAL) + RHS.get_VAL())
: uint64_t(((uint64_t)VAL) + RHS.get_VAL()));
typename RType<_AP_W1, _AP_S1>::plus Result = RHS;
Result += VAL;
return Result;
}
template <int _AP_W1, bool _AP_S1>
inline typename RType<_AP_W1, _AP_S1>::minus operator-(
const ap_private<_AP_W1, _AP_S1>& RHS) const {
if (RType<_AP_W1, _AP_S1>::minus_w <= 64)
return typename RType<_AP_W1, _AP_S1>::minus(
int64_t(((uint64_t)VAL) - RHS.get_VAL()));
typename RType<_AP_W1, _AP_S1>::minus Result = *this;
Result -= RHS;
return Result;
}
inline uint32_t countPopulation() const {
return ap_private_ops::CountPopulation_64(VAL);
}
inline uint32_t countLeadingZeros() const {
int remainder = BitWidth % 64;
int excessBits = (64 - remainder) % 64;
uint32_t Count = ap_private_ops::CountLeadingZeros_64(VAL);
if (Count) Count -= excessBits;
return AESL_std::min(Count, (uint32_t)_AP_W);
}
inline ap_private<_AP_W, _AP_S> getHiBits(uint32_t numBits) const {
ap_private<_AP_W, _AP_S> ret(*this);
ret = (ret) >> (BitWidth - numBits);
return ret;
}
inline ap_private<_AP_W, _AP_S> getLoBits(uint32_t numBits) const {
ap_private<_AP_W, _AP_S> ret(((uint64_t)VAL) << (BitWidth - numBits));
ret = (ret) >> (BitWidth - numBits);
return ret;
}
inline ap_private<_AP_W, _AP_S>& set(uint32_t bitPosition) {
VAL |= (1ULL << (bitPosition));
clearUnusedBits();
return *this;
}
inline void set() {
VAL = (ValType)~0ULL;
clearUnusedBits();
}
template <int _AP_W3>
inline void set(const ap_private<_AP_W3, false>& val) {
operator=(ap_private<_AP_W3, _AP_S>(val));
}
inline void set(const ap_private& val) { operator=(val); }
inline void clearUnusedBits(void) volatile
{
enum { excess_bits = (_AP_W % 64) ? 64 - _AP_W % 64 : 0 };
VAL = (ValType)(
_AP_S
? ((((int64_t)VAL) << (excess_bits)) >> (excess_bits))
: (excess_bits ? (((uint64_t)VAL) << (excess_bits)) >> (excess_bits)
: (uint64_t)VAL));
}
inline void clearUnusedBitsToZero(void) {
enum { excess_bits = (_AP_W % 64) ? 64 - _AP_W % 64 : 0 };
static uint64_t mask = ~0ULL >> (excess_bits);
VAL &= mask;
}
inline ap_private udiv(const ap_private& RHS) const {
return ap_private((uint64_t)VAL / RHS.get_VAL());
}
inline ap_private sdiv(const ap_private& RHS) const {
if (isNegative())
if (RHS.isNegative())
return ((uint64_t)(0 - (*this))) / (uint64_t)(0 - RHS);
else
return 0 - ((uint64_t)(0 - (*this)) / (uint64_t)(RHS));
else if (RHS.isNegative())
return 0 - (this->udiv((ap_private)(0 - RHS)));
return this->udiv(RHS);
}
template <bool _AP_S2>
inline ap_private urem(const ap_private<_AP_W, _AP_S2>& RHS) const {
# 2173 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 2173 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
RHS.get_VAL() != 0 && "Divide by 0"
# 2173 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 2173 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"RHS.get_VAL() != 0 && \"Divide by 0\""
# 2173 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 2173, __PRETTY_FUNCTION__))
# 2173 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
return ap_private(((uint64_t)VAL) % ((uint64_t)RHS.get_VAL()));
}
template <bool _AP_S2>
inline ap_private srem(const ap_private<_AP_W, _AP_S2>& RHS) const {
if (isNegative()) {
ap_private lhs = 0 - (*this);
if (RHS.isNegative()) {
ap_private rhs = 0 - RHS;
return 0 - (lhs.urem(rhs));
} else
return 0 - (lhs.urem(RHS));
} else if (RHS.isNegative()) {
ap_private rhs = 0 - RHS;
return this->urem(rhs);
}
return this->urem(RHS);
}
template <int _AP_W1, bool _AP_S1>
inline bool eq(const ap_private<_AP_W1, _AP_S1>& RHS) const {
return (*this) == RHS;
}
template <int _AP_W1, bool _AP_S1>
inline bool ne(const ap_private<_AP_W1, _AP_S1>& RHS) const {
return !((*this) == RHS);
}
template <int _AP_W1, bool _AP_S1>
inline bool ult(const ap_private<_AP_W1, _AP_S1>& RHS) const {
if (_AP_W1 <= 64) {
uint64_t lhsZext = ((uint64_t(VAL)) << (64 - _AP_W)) >> (64 - _AP_W);
uint64_t rhsZext =
((uint64_t(RHS.get_VAL())) << (64 - _AP_W1)) >> (64 - _AP_W1);
return lhsZext < rhsZext;
} else
return RHS.uge(*this);
}
template <int _AP_W1, bool _AP_S1>
inline bool slt(const ap_private<_AP_W1, _AP_S1>& RHS) const
{
if (_AP_W1 <= 64) {
int64_t lhsSext = ((int64_t(VAL)) << (64 - _AP_W)) >> (64 - _AP_W);
int64_t rhsSext =
((int64_t(RHS.get_VAL())) << (64 - _AP_W1)) >> (64 - _AP_W1);
return lhsSext < rhsSext;
} else
return RHS.sge(*this);
}
template <int _AP_W1, bool _AP_S1>
inline bool ule(const ap_private<_AP_W1, _AP_S1>& RHS) const {
return ult(RHS) || eq(RHS);
}
template <int _AP_W1, bool _AP_S1>
inline bool sle(const ap_private<_AP_W1, _AP_S1>& RHS) const {
return slt(RHS) || eq(RHS);
}
template <int _AP_W1, bool _AP_S1>
inline bool ugt(const ap_private<_AP_W1, _AP_S1>& RHS) const {
return !ult(RHS) && !eq(RHS);
}
template <int _AP_W1, bool _AP_S1>
inline bool sgt(const ap_private<_AP_W1, _AP_S1>& RHS) const {
return !slt(RHS) && !eq(RHS);
}
template <int _AP_W1, bool _AP_S1>
inline bool uge(const ap_private<_AP_W1, _AP_S1>& RHS) const {
return !ult(RHS);
}
template <int _AP_W1, bool _AP_S1>
inline bool sge(const ap_private<_AP_W1, _AP_S1>& RHS) const {
return !slt(RHS);
}
inline ap_private abs() const {
if (isNegative()) return -(*this);
return *this;
}
inline ap_private<_AP_W, false> get() const {
ap_private<_AP_W, false> ret(*this);
return ret;
}
inline static uint32_t getBitsNeeded(const char* str, uint32_t slen,
uint8_t radix) {
return _AP_W;
}
inline uint32_t getActiveBits() const {
uint32_t bits = _AP_W - countLeadingZeros();
return bits ? bits : 1;
}
inline double roundToDouble(bool isSigned = false) const {
return isSigned ? double((int64_t)VAL) : double((uint64_t)VAL);
}
inline ap_private& reverse() {
for (int i = 0; i < _AP_W / 2; ++i) {
bool tmp = operator[](i);
if (operator[](_AP_W - 1 - i))
set(i);
else
clear(i);
if (tmp)
set(_AP_W - 1 - i);
else
clear(_AP_W - 1 - i);
}
clearUnusedBits();
return *this;
}
inline bool iszero() const { return isMinValue(); }
inline bool to_bool() const { return !iszero(); }
inline bool sign() const {
if (isNegative()) return true;
return false;
}
inline void invert(int i) {
# 2349 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 2349 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
i >= 0 && "Attempting to read bit with negative index"
# 2349 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 2349 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"i >= 0 && \"Attempting to read bit with negative index\""
# 2349 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 2349, __PRETTY_FUNCTION__))
# 2349 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
# 2350 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 2350 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
i < _AP_W && "Attempting to read bit beyond MSB"
# 2350 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 2350 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"i < _AP_W && \"Attempting to read bit beyond MSB\""
# 2350 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 2350, __PRETTY_FUNCTION__))
# 2350 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
flip(i);
}
inline bool test(int i) const {
# 2356 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 2356 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
i >= 0 && "Attempting to read bit with negative index"
# 2356 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 2356 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"i >= 0 && \"Attempting to read bit with negative index\""
# 2356 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 2356, __PRETTY_FUNCTION__))
# 2356 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
# 2357 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 2357 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
i < _AP_W && "Attempting to read bit beyond MSB"
# 2357 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 2357 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"i < _AP_W && \"Attempting to read bit beyond MSB\""
# 2357 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 2357, __PRETTY_FUNCTION__))
# 2357 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
return operator[](i);
}
inline void lrotate(int n) {
# 2364 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 2364 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
n >= 0 && "Attempting to shift negative index"
# 2364 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 2364 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"n >= 0 && \"Attempting to shift negative index\""
# 2364 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 2364, __PRETTY_FUNCTION__))
# 2364 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
# 2365 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 2365 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
n < _AP_W && "Shift value larger than bit width"
# 2365 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 2365 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"n < _AP_W && \"Shift value larger than bit width\""
# 2365 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 2365, __PRETTY_FUNCTION__))
# 2365 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
operator=(shl(n) | lshr(_AP_W - n));
}
inline void rrotate(int n) {
# 2372 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 2372 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
n >= 0 && "Attempting to shift negative index"
# 2372 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 2372 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"n >= 0 && \"Attempting to shift negative index\""
# 2372 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 2372, __PRETTY_FUNCTION__))
# 2372 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
# 2373 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 2373 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
n < _AP_W && "Shift value larger than bit width"
# 2373 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 2373 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"n < _AP_W && \"Shift value larger than bit width\""
# 2373 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 2373, __PRETTY_FUNCTION__))
# 2373 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
operator=(lshr(n) | shl(_AP_W - n));
}
inline void set(int i, bool v) {
# 2379 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 2379 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
i >= 0 && "Attempting to write bit with negative index"
# 2379 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 2379 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"i >= 0 && \"Attempting to write bit with negative index\""
# 2379 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 2379, __PRETTY_FUNCTION__))
# 2379 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
# 2380 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 2380 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
i < _AP_W && "Attempting to write bit beyond MSB"
# 2380 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 2380 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"i < _AP_W && \"Attempting to write bit beyond MSB\""
# 2380 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 2380, __PRETTY_FUNCTION__))
# 2380 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
v ? set(i) : clear(i);
}
inline void set_bit(int i, bool v) {
# 2386 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 2386 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
i >= 0 && "Attempting to write bit with negative index"
# 2386 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 2386 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"i >= 0 && \"Attempting to write bit with negative index\""
# 2386 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 2386, __PRETTY_FUNCTION__))
# 2386 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
# 2387 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 2387 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
i < _AP_W && "Attempting to write bit beyond MSB"
# 2387 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 2387 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"i < _AP_W && \"Attempting to write bit beyond MSB\""
# 2387 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 2387, __PRETTY_FUNCTION__))
# 2387 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
v ? set(i) : clear(i);
}
inline bool get_bit(int i) const {
# 2393 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 2393 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
i >= 0 && "Attempting to read bit with negative index"
# 2393 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 2393 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"i >= 0 && \"Attempting to read bit with negative index\""
# 2393 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 2393, __PRETTY_FUNCTION__))
# 2393 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
# 2394 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 2394 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
i < _AP_W && "Attempting to read bit beyond MSB"
# 2394 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 2394 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"i < _AP_W && \"Attempting to read bit beyond MSB\""
# 2394 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 2394, __PRETTY_FUNCTION__))
# 2394 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
return (((1ULL << i) & VAL) != 0);
}
inline ap_private& flip() {
VAL = (ValType)((~0ULL ^ VAL) & mask);
clearUnusedBits();
return *this;
}
inline ap_private& flip(uint32_t bitPosition) {
# 2407 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 2407 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
bitPosition < BitWidth && "Out of the bit-width range!"
# 2407 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 2407 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"bitPosition < BitWidth && \"Out of the bit-width range!\""
# 2407 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 2407, __PRETTY_FUNCTION__))
# 2407 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
set_bit(bitPosition, !get_bit(bitPosition));
return *this;
}
inline void b_not() { flip(); }
# 2432 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
template <int _AP_W2, bool _AP_S2>
inline typename RType<_AP_W2, _AP_S2>::div operator/(
const ap_private<_AP_W2, _AP_S2>& op) const {
ap_private<((_AP_W + (_AP_S || _AP_S2)) > (_AP_W2 + (_AP_S || _AP_S2)) ? (_AP_W + (_AP_S || _AP_S2)) : (_AP_W2 + (_AP_S || _AP_S2))),
(_AP_W > _AP_W2 ? _AP_S
: (_AP_W2 > _AP_W ? _AP_S2 : _AP_S || _AP_S2))>
lhs = *this;
ap_private<((_AP_W + (_AP_S || _AP_S2)) > (_AP_W2 + (_AP_S || _AP_S2)) ? (_AP_W + (_AP_S || _AP_S2)) : (_AP_W2 + (_AP_S || _AP_S2))),
(_AP_W > _AP_W2 ? _AP_S
: (_AP_W2 > _AP_W ? _AP_S2 : _AP_S || _AP_S2))>
rhs = op;
return typename RType<_AP_W2, _AP_S2>::div(
(_AP_S || _AP_S2) ? lhs.sdiv(rhs) : lhs.udiv(rhs));
}
template <int _AP_W2, bool _AP_S2>
inline typename RType<_AP_W2, _AP_S2>::mod operator%(
const ap_private<_AP_W2, _AP_S2>& op) const {
ap_private<((_AP_W + (_AP_S || _AP_S2)) > (_AP_W2 + (_AP_S || _AP_S2)) ? (_AP_W + (_AP_S || _AP_S2)) : (_AP_W2 + (_AP_S || _AP_S2))),
(_AP_W > _AP_W2 ? _AP_S
: (_AP_W2 > _AP_W ? _AP_S2 : _AP_S || _AP_S2))>
lhs = *this;
ap_private<((_AP_W + (_AP_S || _AP_S2)) > (_AP_W2 + (_AP_S || _AP_S2)) ? (_AP_W + (_AP_S || _AP_S2)) : (_AP_W2 + (_AP_S || _AP_S2))),
(_AP_W > _AP_W2 ? _AP_S
: (_AP_W2 > _AP_W ? _AP_S2 : _AP_S || _AP_S2))>
rhs = op;
typename RType<_AP_W2, _AP_S2>::mod res =
typename RType<_AP_W2, _AP_S2>::mod(_AP_S ? lhs.srem(rhs)
: lhs.urem(rhs));
return res;
}
# 2472 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
template <int _AP_W2, bool _AP_S2> inline ap_private<_AP_W, _AP_S>& operator /=( const ap_private<_AP_W2, _AP_S2>& op) { *this = operator /(op); return *this; }
template <int _AP_W2, bool _AP_S2> inline ap_private<_AP_W, _AP_S>& operator %=( const ap_private<_AP_W2, _AP_S2>& op) { *this = operator %(op); return *this; }
# 2490 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
inline ap_private operator<<(const char op) const { if (op >= _AP_W) return ap_private(0); if (CHAR_IS_SIGNED && op < 0) return *this >> (0 - op); return shl(op); }
inline ap_private operator<<(const signed char op) const { if (op >= _AP_W) return ap_private(0); if (true && op < 0) return *this >> (0 - op); return shl(op); }
inline ap_private operator<<(const unsigned char op) const { if (op >= _AP_W) return ap_private(0); if (false && op < 0) return *this >> (0 - op); return shl(op); }
inline ap_private operator<<(const short op) const { if (op >= _AP_W) return ap_private(0); if (true && op < 0) return *this >> (0 - op); return shl(op); }
inline ap_private operator<<(const unsigned short op) const { if (op >= _AP_W) return ap_private(0); if (false && op < 0) return *this >> (0 - op); return shl(op); }
inline ap_private operator<<(const int op) const { if (op >= _AP_W) return ap_private(0); if (true && op < 0) return *this >> (0 - op); return shl(op); }
inline ap_private operator<<(const unsigned int op) const { if (op >= _AP_W) return ap_private(0); if (false && op < 0) return *this >> (0 - op); return shl(op); }
inline ap_private operator<<(const long op) const { if (op >= _AP_W) return ap_private(0); if (true && op < 0) return *this >> (0 - op); return shl(op); }
inline ap_private operator<<(const unsigned long op) const { if (op >= _AP_W) return ap_private(0); if (false && op < 0) return *this >> (0 - op); return shl(op); }
inline ap_private operator<<(const long long op) const { if (op >= _AP_W) return ap_private(0); if (true && op < 0) return *this >> (0 - op); return shl(op); }
inline ap_private operator<<(const unsigned long long op) const { if (op >= _AP_W) return ap_private(0); if (false && op < 0) return *this >> (0 - op); return shl(op); }
inline ap_private operator<<(const half op) const { if (op >= _AP_W) return ap_private(0); if (false && op < 0) return *this >> (0 - op); return shl(op); }
inline ap_private operator<<(const float op) const { if (op >= _AP_W) return ap_private(0); if (false && op < 0) return *this >> (0 - op); return shl(op); }
inline ap_private operator<<(const double op) const { if (op >= _AP_W) return ap_private(0); if (false && op < 0) return *this >> (0 - op); return shl(op); }
template <int _AP_W2, bool _AP_S2>
inline ap_private operator<<(const ap_private<_AP_W2, _AP_S2>& op2) const {
if (_AP_S2 == false) {
uint32_t sh = op2.to_uint();
return *this << sh;
} else {
int sh = op2.to_int();
return *this << sh;
}
}
# 2534 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
inline ap_private operator>>(const char op) const { if (op >= _AP_W) { if (isNegative()) return ap_private(-1); else return ap_private(0); } if ((CHAR_IS_SIGNED) && op < 0) return *this << (0 - op); if (_AP_S) return ashr(op); else return lshr(op); }
inline ap_private operator>>(const signed char op) const { if (op >= _AP_W) { if (isNegative()) return ap_private(-1); else return ap_private(0); } if ((true) && op < 0) return *this << (0 - op); if (_AP_S) return ashr(op); else return lshr(op); }
inline ap_private operator>>(const unsigned char op) const { if (op >= _AP_W) { if (isNegative()) return ap_private(-1); else return ap_private(0); } if ((false) && op < 0) return *this << (0 - op); if (_AP_S) return ashr(op); else return lshr(op); }
inline ap_private operator>>(const short op) const { if (op >= _AP_W) { if (isNegative()) return ap_private(-1); else return ap_private(0); } if ((true) && op < 0) return *this << (0 - op); if (_AP_S) return ashr(op); else return lshr(op); }
inline ap_private operator>>(const unsigned short op) const { if (op >= _AP_W) { if (isNegative()) return ap_private(-1); else return ap_private(0); } if ((false) && op < 0) return *this << (0 - op); if (_AP_S) return ashr(op); else return lshr(op); }
inline ap_private operator>>(const int op) const { if (op >= _AP_W) { if (isNegative()) return ap_private(-1); else return ap_private(0); } if ((true) && op < 0) return *this << (0 - op); if (_AP_S) return ashr(op); else return lshr(op); }
inline ap_private operator>>(const unsigned int op) const { if (op >= _AP_W) { if (isNegative()) return ap_private(-1); else return ap_private(0); } if ((false) && op < 0) return *this << (0 - op); if (_AP_S) return ashr(op); else return lshr(op); }
inline ap_private operator>>(const long op) const { if (op >= _AP_W) { if (isNegative()) return ap_private(-1); else return ap_private(0); } if ((true) && op < 0) return *this << (0 - op); if (_AP_S) return ashr(op); else return lshr(op); }
inline ap_private operator>>(const unsigned long op) const { if (op >= _AP_W) { if (isNegative()) return ap_private(-1); else return ap_private(0); } if ((false) && op < 0) return *this << (0 - op); if (_AP_S) return ashr(op); else return lshr(op); }
inline ap_private operator>>(const unsigned long long op) const { if (op >= _AP_W) { if (isNegative()) return ap_private(-1); else return ap_private(0); } if ((false) && op < 0) return *this << (0 - op); if (_AP_S) return ashr(op); else return lshr(op); }
inline ap_private operator>>(const long long op) const { if (op >= _AP_W) { if (isNegative()) return ap_private(-1); else return ap_private(0); } if ((true) && op < 0) return *this << (0 - op); if (_AP_S) return ashr(op); else return lshr(op); }
inline ap_private operator>>(const half op) const { if (op >= _AP_W) { if (isNegative()) return ap_private(-1); else return ap_private(0); } if ((false) && op < 0) return *this << (0 - op); if (_AP_S) return ashr(op); else return lshr(op); }
inline ap_private operator>>(const float op) const { if (op >= _AP_W) { if (isNegative()) return ap_private(-1); else return ap_private(0); } if ((false) && op < 0) return *this << (0 - op); if (_AP_S) return ashr(op); else return lshr(op); }
inline ap_private operator>>(const double op) const { if (op >= _AP_W) { if (isNegative()) return ap_private(-1); else return ap_private(0); } if ((false) && op < 0) return *this << (0 - op); if (_AP_S) return ashr(op); else return lshr(op); }
template <int _AP_W2, bool _AP_S2>
inline ap_private operator>>(const ap_private<_AP_W2, _AP_S2>& op2) const {
if (_AP_S2 == false) {
uint32_t sh = op2.to_uint();
return *this >> sh;
} else {
int sh = op2.to_int();
return *this >> sh;
}
}
# 2590 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
template <int _AP_W2, bool _AP_S2> inline ap_private& operator >>=(int op) { *this = operator >>(op); clearUnusedBits(); return *this; } inline ap_private& operator >>=(unsigned int op) { *this = operator >>(op); clearUnusedBits(); return *this; } template <int _AP_W2, bool _AP_S2> inline ap_private& operator >>=(const ap_private<_AP_W2, _AP_S2>& op) { *this = operator >>(op); clearUnusedBits(); return *this; }
template <int _AP_W2, bool _AP_S2> inline ap_private& operator <<=(int op) { *this = operator <<(op); clearUnusedBits(); return *this; } inline ap_private& operator <<=(unsigned int op) { *this = operator <<(op); clearUnusedBits(); return *this; } template <int _AP_W2, bool _AP_S2> inline ap_private& operator <<=(const ap_private<_AP_W2, _AP_S2>& op) { *this = operator <<(op); clearUnusedBits(); return *this; }
template <int _AP_W1, bool _AP_S1>
inline bool operator==(const ap_private<_AP_W1, _AP_S1>& op) const {
enum { _AP_MAX_W = ((((_AP_W) > (_AP_W1) ? (_AP_W) : (_AP_W1))) > (32) ? (((_AP_W) > (_AP_W1) ? (_AP_W) : (_AP_W1))) : (32)) };
ap_private<_AP_MAX_W, false> lhs(*this);
ap_private<_AP_MAX_W, false> rhs(op);
if (_AP_MAX_W <= 64) {
return (uint64_t)lhs.get_VAL() == (uint64_t)rhs.get_VAL();
} else
return lhs == rhs;
}
template <int _AP_W2, bool _AP_S2>
inline bool operator!=(const ap_private<_AP_W2, _AP_S2>& op) const {
return !(*this == op);
}
template <int _AP_W2, bool _AP_S2>
inline bool operator>(const ap_private<_AP_W2, _AP_S2>& op) const {
enum {
_AP_MAX_W = ((_AP_W + (_AP_S || _AP_S2)) > (_AP_W2 + (_AP_S || _AP_S2)) ? (_AP_W + (_AP_S || _AP_S2)) : (_AP_W2 + (_AP_S || _AP_S2)))
};
ap_private<_AP_MAX_W, _AP_S> lhs(*this);
ap_private<_AP_MAX_W, _AP_S2> rhs(op);
if (_AP_S == _AP_S2)
return _AP_S ? lhs.sgt(rhs) : lhs.ugt(rhs);
else if (_AP_W < 32 && _AP_W2 < 32)
return lhs.sgt(rhs);
else
if (_AP_S)
if (_AP_W2 >= _AP_W)
return lhs.ugt(rhs);
else
return lhs.sgt(rhs);
else if (_AP_W >= _AP_W2)
return lhs.ugt(rhs);
else
return lhs.sgt(rhs);
}
template <int _AP_W2, bool _AP_S2>
inline bool operator<=(const ap_private<_AP_W2, _AP_S2>& op) const {
return !(*this > op);
}
template <int _AP_W2, bool _AP_S2>
inline bool operator<(const ap_private<_AP_W2, _AP_S2>& op) const {
enum {
_AP_MAX_W = ((_AP_W + (_AP_S || _AP_S2)) > (_AP_W2 + (_AP_S || _AP_S2)) ? (_AP_W + (_AP_S || _AP_S2)) : (_AP_W2 + (_AP_S || _AP_S2)))
};
ap_private<_AP_MAX_W, _AP_S> lhs(*this);
ap_private<_AP_MAX_W, _AP_S2> rhs(op);
if (_AP_S == _AP_S2)
return _AP_S ? lhs.slt(rhs) : lhs.ult(rhs);
else if (_AP_W < 32 && _AP_W2 < 32)
return lhs.slt(rhs);
else if (_AP_S)
if (_AP_W2 >= _AP_W)
return lhs.ult(rhs);
else
return lhs.slt(rhs);
else if (_AP_W >= _AP_W2)
return lhs.ult(rhs);
else
return lhs.slt(rhs);
}
template <int _AP_W2, bool _AP_S2>
inline bool operator>=(const ap_private<_AP_W2, _AP_S2>& op) const {
return !(*this < op);
}
inline _private_range_ref<_AP_W, _AP_S> operator()(int Hi, int Lo) {
return _private_range_ref<_AP_W, _AP_S>(this, Hi, Lo);
}
inline _private_range_ref<_AP_W, _AP_S> operator()(int Hi, int Lo) const {
return _private_range_ref<_AP_W, _AP_S>(
const_cast<ap_private<_AP_W, _AP_S>*>(this), Hi, Lo);
}
inline _private_range_ref<_AP_W, _AP_S> range(int Hi, int Lo) const {
return _private_range_ref<_AP_W, _AP_S>(
(const_cast<ap_private<_AP_W, _AP_S>*>(this)), Hi, Lo);
}
inline _private_range_ref<_AP_W, _AP_S> range(int Hi, int Lo) {
return _private_range_ref<_AP_W, _AP_S>(this, Hi, Lo);
}
inline _private_bit_ref<_AP_W, _AP_S> operator[](int index) {
return _private_bit_ref<_AP_W, _AP_S>(*this, index);
}
template <int _AP_W2, bool _AP_S2>
inline _private_bit_ref<_AP_W, _AP_S> operator[](
const ap_private<_AP_W2, _AP_S2>& index) {
return _private_bit_ref<_AP_W, _AP_S>(*this, index.to_int());
}
inline const _private_bit_ref<_AP_W, _AP_S> operator[](int index) const {
return _private_bit_ref<_AP_W, _AP_S>(
const_cast<ap_private<_AP_W, _AP_S>&>(*this), index);
}
template <int _AP_W2, bool _AP_S2>
inline const _private_bit_ref<_AP_W, _AP_S> operator[](
const ap_private<_AP_W2, _AP_S2>& index) const {
return _private_bit_ref<_AP_W, _AP_S>(
const_cast<ap_private<_AP_W, _AP_S>&>(*this), index.to_int());
}
inline _private_bit_ref<_AP_W, _AP_S> bit(int index) {
return _private_bit_ref<_AP_W, _AP_S>(*this, index);
}
template <int _AP_W2, bool _AP_S2>
inline _private_bit_ref<_AP_W, _AP_S> bit(const ap_private<_AP_W2, _AP_S2>& index) {
return _private_bit_ref<_AP_W, _AP_S>(*this, index.to_int());
}
inline const _private_bit_ref<_AP_W, _AP_S> bit(int index) const {
return _private_bit_ref<_AP_W, _AP_S>(
const_cast<ap_private<_AP_W, _AP_S>&>(*this), index);
}
template <int _AP_W2, bool _AP_S2>
inline const _private_bit_ref<_AP_W, _AP_S> bit(
const ap_private<_AP_W2, _AP_S2>& index) const {
return _private_bit_ref<_AP_W, _AP_S>(
const_cast<ap_private<_AP_W, _AP_S>&>(*this), index.to_int());
}
# 2915 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
inline bool and_reduce() const { return (VAL & mask) == mask; }
inline bool nand_reduce() const { return (VAL & mask) != mask; }
inline bool or_reduce() const { return (bool)VAL; }
inline bool nor_reduce() const { return VAL == 0; }
inline bool xor_reduce() const {
unsigned int i = countPopulation();
return (i % 2) ? true : false;
}
inline bool xnor_reduce() const {
unsigned int i = countPopulation();
return (i % 2) ? false : true;
}
inline std::string to_string(uint8_t radix = 2, bool sign = false) const {
return toString(radix, radix == 10 ? _AP_S : sign);
}
};
template <int _AP_W, bool _AP_S>
std::string ap_private<_AP_W, _AP_S, true>::toString(uint8_t radix,
bool wantSigned) const {
# 2941 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 2941 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
(radix == 10 || radix == 8 || radix == 16 || radix == 2) && "Radix should be 2, 8, 10, or 16!"
# 2941 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 2941 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"(radix == 10 || radix == 8 || radix == 16 || radix == 2) && \"Radix should be 2, 8, 10, or 16!\""
# 2941 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
,
"/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
# 2941 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
,
2942
# 2941 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, __PRETTY_FUNCTION__))
# 2942 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
static const char* digits[] = {"0", "1", "2", "3", "4", "5", "6", "7",
"8", "9", "a", "b", "c", "d", "e", "f"};
std::string result;
if (radix != 10) {
if (*this == (uint64_t)(0)) {
switch (radix) {
case 2:
result = "0b0";
break;
case 8:
result = "0o0";
break;
case 16:
result = "0x0";
break;
default:
# 2966 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 2966 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"invalid radix" && 0
# 2966 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 2966 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"\"invalid radix\" && 0"
# 2966 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 2966, __PRETTY_FUNCTION__))
# 2966 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
}
} else {
ap_private<_AP_W, false, true> tmp(*this);
size_t insert_at = 0;
bool leading_zero = true;
if (wantSigned && isNegative()) {
tmp.flip();
tmp++;
result = "-";
insert_at = 1;
leading_zero = false;
}
switch (radix) {
case 2:
result += "0b";
break;
case 8:
result += "0o";
break;
case 16:
result += "0x";
break;
default:
# 2993 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 2993 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"invalid radix" && 0
# 2993 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 2993 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"\"invalid radix\" && 0"
# 2993 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 2993, __PRETTY_FUNCTION__))
# 2993 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
}
insert_at += 2;
uint32_t shift = (radix == 16 ? 4 : (radix == 8 ? 3 : 1));
uint64_t mask = radix - 1;
ap_private<_AP_W, false, true> zero(0);
unsigned bits = 0;
bool msb = false;
while (tmp.ne(zero)) {
unsigned digit = (unsigned)(tmp.get_VAL() & mask);
result.insert(insert_at, digits[digit]);
tmp = tmp.lshr(shift);
bits++;
msb = (digit >> (shift - 1)) == 1;
}
bits *= shift;
if (bits < _AP_W && leading_zero && msb)
result.insert(insert_at, digits[0]);
}
return result;
}
ap_private<_AP_W, false, true> tmp(*this);
ap_private<6, false, true> divisor(radix);
ap_private<_AP_W, _AP_S, true> zero(0);
size_t insert_at = 0;
if (wantSigned && isNegative()) {
tmp.flip();
tmp++;
result = "-";
insert_at = 1;
}
if (tmp == ap_private<_AP_W, false, true>(0ULL))
result = "0";
else
while (tmp.ne(zero)) {
ap_private<_AP_W, false, true> APdigit = tmp % divisor;
ap_private<_AP_W, false, true> tmp2 = tmp / divisor;
uint32_t digit = (uint32_t)(APdigit.getZExtValue());
# 3037 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 3037 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
digit < radix && "divide failed"
# 3037 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 3037 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"digit < radix && \"divide failed\""
# 3037 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 3037, __PRETTY_FUNCTION__))
# 3037 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
result.insert(insert_at, digits[digit]);
tmp = tmp2;
}
return result;
}
template <int _AP_W, bool _AP_S>
class ap_private<_AP_W, _AP_S, false> {
const static bool valid = ap_private_enable_if<(_AP_W > 64)>::isValid;
public:
enum { BitWidth = _AP_W, _AP_N = (_AP_W + 63) / 64 };
static const int width = _AP_W;
private:
# 3069 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
inline ap_private(uint32_t numWords, const uint64_t bigVal[]) {
set_canary();
# 3071 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 3071 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
bigVal && "Null pointer detected!"
# 3071 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 3071 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"bigVal && \"Null pointer detected!\""
# 3071 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 3071, __PRETTY_FUNCTION__))
# 3071 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
{
memset(pVal, 0, _AP_N * sizeof(uint64_t));
uint32_t words = AESL_std::min<uint32_t>(numWords, _AP_N);
memcpy(pVal, bigVal, words * APINT_WORD_SIZE);
if (words >= _AP_W) clearUnusedBits();
}
check_canary();
}
# 3094 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
inline ap_private(const std::string& val, uint8_t radix = 2) {
set_canary();
# 3096 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 3096 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
!val.empty() && "The input string is empty."
# 3096 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 3096 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"!val.empty() && \"The input string is empty.\""
# 3096 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 3096, __PRETTY_FUNCTION__))
# 3096 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
const char* c_str = val.c_str();
fromString(c_str, val.size(), radix);
check_canary();
}
# 3112 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
inline ap_private(const char strStart[], uint32_t slen, uint8_t radix) {
set_canary();
fromString(strStart, slen, radix);
check_canary();
}
inline void report() {
do { if ((_AP_W > ((1024 + 1023) / 1024) * 1024)) { fprintf(
# 3119 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
stderr
# 3119 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
, "ERROR: " "ap_%sint<%d>: Bitwidth exceeds the " "default max value %d. Please use macro " "AP_INT_MAX_W to set a larger max value.", _AP_S ? "" : "u", _AP_W, ((1024 + 1023) / 1024) * 1024); fprintf(
# 3119 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
stderr
# 3119 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
, "\n"); abort(); } } while (0)
;
}
uint64_t pVal[_AP_N];
inline void check_canary() {}
inline void set_canary() {}
public:
typedef typename valtype<8, _AP_S>::Type ValType;
typedef ap_private<_AP_W, _AP_S> Type;
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
friend struct ap_fixed_base;
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_private<mult_w, mult_s> mult;
typedef ap_private<plus_w, plus_s> plus;
typedef ap_private<minus_w, minus_s> minus;
typedef ap_private<logic_w, logic_s> logic;
typedef ap_private<div_w, div_s> div;
typedef ap_private<mod_w, mod_s> mod;
typedef ap_private<_AP_W, _AP_S> arg1;
typedef bool reduce;
};
inline uint64_t& get_VAL(void) { return pVal[0]; }
inline uint64_t get_VAL(void) const { return pVal[0]; }
inline uint64_t get_VAL(void) const volatile { return pVal[0]; }
inline void set_VAL(uint64_t value) { pVal[0] = value; }
inline uint64_t& get_pVal(int index) { return pVal[index]; }
inline uint64_t* get_pVal() { return pVal; }
inline const uint64_t* get_pVal() const { return pVal; }
inline uint64_t get_pVal(int index) const { return pVal[index]; }
inline uint64_t* get_pVal() const volatile { return pVal; }
inline uint64_t get_pVal(int index) const volatile { return pVal[index]; }
inline void set_pVal(int i, uint64_t value) { pVal[i] = value; }
enum {
APINT_BITS_PER_WORD = sizeof(uint64_t) * 8,
APINT_WORD_SIZE = sizeof(uint64_t)
};
enum {
excess_bits = (_AP_W % APINT_BITS_PER_WORD)
? APINT_BITS_PER_WORD - (_AP_W % APINT_BITS_PER_WORD)
: 0
};
static const uint64_t mask = ((uint64_t)~0ULL >> (excess_bits));
public:
explicit inline ap_private(const char* val) {
set_canary();
unsigned char radix = 10;
std::string str = ap_private_ops::parseString(val, radix);
std::string::size_type pos = str.find('.');
if (pos != std::string::npos) str = str.substr(pos);
ap_private ap_private_val(str, radix);
operator=(ap_private_val);
report();
check_canary();
}
inline ap_private(const char* val, unsigned char rd) {
set_canary();
unsigned char radix = rd;
std::string str = ap_private_ops::parseString(val, radix);
std::string::size_type pos = str.find('.');
if (pos != std::string::npos) str = str.substr(pos);
ap_private ap_private_val(str, radix);
operator=(ap_private_val);
report();
report();
check_canary();
}
template <int _AP_W2, bool _AP_S2>
inline ap_private(const _private_range_ref<_AP_W2, _AP_S2>& ref) {
set_canary();
*this = ref.get();
report();
check_canary();
}
template <int _AP_W2, bool _AP_S2>
inline ap_private(const _private_bit_ref<_AP_W2, _AP_S2>& ref) {
set_canary();
*this = ((uint64_t)(bool)ref);
report();
check_canary();
}
# 3276 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
inline ap_private(const ap_private& that) {
set_canary();
memcpy(pVal, that.get_pVal(), _AP_N * APINT_WORD_SIZE);
clearUnusedBits();
check_canary();
}
template <int _AP_W1, bool _AP_S1>
inline ap_private(const ap_private<_AP_W1, _AP_S1, false>& that) {
set_canary();
operator=(that);
check_canary();
}
template <int _AP_W1, bool _AP_S1>
inline ap_private(const volatile ap_private<_AP_W1, _AP_S1, false>& that) {
set_canary();
operator=(const_cast<const ap_private<_AP_W1, _AP_S1, false>&>(that));
check_canary();
}
template <int _AP_W1, bool _AP_S1>
inline ap_private(const ap_private<_AP_W1, _AP_S1, true>& that) {
set_canary();
static const uint64_t that_sign_ext_mask =
(_AP_W1 == APINT_BITS_PER_WORD)
? 0
: ~0ULL >> (_AP_W1 % APINT_BITS_PER_WORD)
<< (_AP_W1 % APINT_BITS_PER_WORD);
if (that.isNegative()) {
pVal[0] = that.get_VAL() | that_sign_ext_mask;
memset(pVal + 1, ~0, sizeof(uint64_t) * (_AP_N - 1));
} else {
pVal[0] = that.get_VAL();
memset(pVal + 1, 0, sizeof(uint64_t) * (_AP_N - 1));
}
clearUnusedBits();
check_canary();
}
template <int _AP_W1, bool _AP_S1>
inline ap_private(const volatile ap_private<_AP_W1, _AP_S1, true>& that) {
set_canary();
operator=(const_cast<const ap_private<_AP_W1, _AP_S1, true>&>(that));
check_canary();
}
inline ~ap_private() { check_canary(); }
inline ap_private() {
set_canary();
clearUnusedBits();
check_canary();
}
inline ap_private(uint64_t* val, uint32_t bits = _AP_W) {
# 3339 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 3339 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
0
# 3339 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 3339 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"0"
# 3339 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 3339, __PRETTY_FUNCTION__))
# 3339 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
; }
inline ap_private(const uint64_t* const val, uint32_t bits) {
# 3340 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 3340 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
0
# 3340 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 3340 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"0"
# 3340 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 3340, __PRETTY_FUNCTION__))
# 3340 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
; }
# 3363 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
inline ap_private(bool val, bool isSigned = false) { set_canary(); pVal[0] = (ValType)val; if (isSigned && int64_t(pVal[0]) < 0) { memset(pVal + 1, ~0, sizeof(uint64_t) * (_AP_N - 1)); } else { memset(pVal + 1, 0, sizeof(uint64_t) * (_AP_N - 1)); } clearUnusedBits(); check_canary(); }
inline ap_private(char val, bool isSigned = CHAR_IS_SIGNED) { set_canary(); pVal[0] = (ValType)val; if (isSigned && int64_t(pVal[0]) < 0) { memset(pVal + 1, ~0, sizeof(uint64_t) * (_AP_N - 1)); } else { memset(pVal + 1, 0, sizeof(uint64_t) * (_AP_N - 1)); } clearUnusedBits(); check_canary(); }
inline ap_private(signed char val, bool isSigned = true) { set_canary(); pVal[0] = (ValType)val; if (isSigned && int64_t(pVal[0]) < 0) { memset(pVal + 1, ~0, sizeof(uint64_t) * (_AP_N - 1)); } else { memset(pVal + 1, 0, sizeof(uint64_t) * (_AP_N - 1)); } clearUnusedBits(); check_canary(); }
inline ap_private(unsigned char val, bool isSigned = false) { set_canary(); pVal[0] = (ValType)val; if (isSigned && int64_t(pVal[0]) < 0) { memset(pVal + 1, ~0, sizeof(uint64_t) * (_AP_N - 1)); } else { memset(pVal + 1, 0, sizeof(uint64_t) * (_AP_N - 1)); } clearUnusedBits(); check_canary(); }
inline ap_private(short val, bool isSigned = true) { set_canary(); pVal[0] = (ValType)val; if (isSigned && int64_t(pVal[0]) < 0) { memset(pVal + 1, ~0, sizeof(uint64_t) * (_AP_N - 1)); } else { memset(pVal + 1, 0, sizeof(uint64_t) * (_AP_N - 1)); } clearUnusedBits(); check_canary(); }
inline ap_private(unsigned short val, bool isSigned = false) { set_canary(); pVal[0] = (ValType)val; if (isSigned && int64_t(pVal[0]) < 0) { memset(pVal + 1, ~0, sizeof(uint64_t) * (_AP_N - 1)); } else { memset(pVal + 1, 0, sizeof(uint64_t) * (_AP_N - 1)); } clearUnusedBits(); check_canary(); }
inline ap_private(int val, bool isSigned = true) { set_canary(); pVal[0] = (ValType)val; if (isSigned && int64_t(pVal[0]) < 0) { memset(pVal + 1, ~0, sizeof(uint64_t) * (_AP_N - 1)); } else { memset(pVal + 1, 0, sizeof(uint64_t) * (_AP_N - 1)); } clearUnusedBits(); check_canary(); }
inline ap_private(unsigned int val, bool isSigned = false) { set_canary(); pVal[0] = (ValType)val; if (isSigned && int64_t(pVal[0]) < 0) { memset(pVal + 1, ~0, sizeof(uint64_t) * (_AP_N - 1)); } else { memset(pVal + 1, 0, sizeof(uint64_t) * (_AP_N - 1)); } clearUnusedBits(); check_canary(); }
inline ap_private(long val, bool isSigned = true) { set_canary(); pVal[0] = (ValType)val; if (isSigned && int64_t(pVal[0]) < 0) { memset(pVal + 1, ~0, sizeof(uint64_t) * (_AP_N - 1)); } else { memset(pVal + 1, 0, sizeof(uint64_t) * (_AP_N - 1)); } clearUnusedBits(); check_canary(); }
inline ap_private(unsigned long val, bool isSigned = false) { set_canary(); pVal[0] = (ValType)val; if (isSigned && int64_t(pVal[0]) < 0) { memset(pVal + 1, ~0, sizeof(uint64_t) * (_AP_N - 1)); } else { memset(pVal + 1, 0, sizeof(uint64_t) * (_AP_N - 1)); } clearUnusedBits(); check_canary(); }
inline ap_private(ap_slong val, bool isSigned = true) { set_canary(); pVal[0] = (ValType)val; if (isSigned && int64_t(pVal[0]) < 0) { memset(pVal + 1, ~0, sizeof(uint64_t) * (_AP_N - 1)); } else { memset(pVal + 1, 0, sizeof(uint64_t) * (_AP_N - 1)); } clearUnusedBits(); check_canary(); }
inline ap_private(ap_ulong val, bool isSigned = false) { set_canary(); pVal[0] = (ValType)val; if (isSigned && int64_t(pVal[0]) < 0) { memset(pVal + 1, ~0, sizeof(uint64_t) * (_AP_N - 1)); } else { memset(pVal + 1, 0, sizeof(uint64_t) * (_AP_N - 1)); } clearUnusedBits(); check_canary(); }
inline ap_private(half val, bool isSigned = false) { set_canary(); pVal[0] = (ValType)val; if (isSigned && int64_t(pVal[0]) < 0) { memset(pVal + 1, ~0, sizeof(uint64_t) * (_AP_N - 1)); } else { memset(pVal + 1, 0, sizeof(uint64_t) * (_AP_N - 1)); } clearUnusedBits(); check_canary(); }
inline ap_private(float val, bool isSigned = false) { set_canary(); pVal[0] = (ValType)val; if (isSigned && int64_t(pVal[0]) < 0) { memset(pVal + 1, ~0, sizeof(uint64_t) * (_AP_N - 1)); } else { memset(pVal + 1, 0, sizeof(uint64_t) * (_AP_N - 1)); } clearUnusedBits(); check_canary(); }
inline ap_private(double val, bool isSigned = false) { set_canary(); pVal[0] = (ValType)val; if (isSigned && int64_t(pVal[0]) < 0) { memset(pVal + 1, ~0, sizeof(uint64_t) * (_AP_N - 1)); } else { memset(pVal + 1, 0, sizeof(uint64_t) * (_AP_N - 1)); } clearUnusedBits(); check_canary(); }
inline bool isSingleWord() const { return false; }
static inline uint32_t whichWord(uint32_t bitPosition) {
return (bitPosition) >> 6;
}
static inline uint32_t whichBit(uint32_t bitPosition) {
return bitPosition & 0x3f;
}
static inline uint64_t maskBit(uint32_t bitPosition) {
return 1ULL << (whichBit(bitPosition));
}
inline uint64_t getWord(uint32_t bitPosition) const {
return pVal[whichWord(bitPosition)];
}
inline void clearUnusedBits(void) volatile
{
pVal[_AP_N - 1] =
_AP_S ? ((((int64_t)pVal[_AP_N - 1]) << (excess_bits)) >> excess_bits)
: (excess_bits
? ((pVal[_AP_N - 1]) << (excess_bits)) >> (excess_bits)
: pVal[_AP_N - 1]);
}
inline void clearUnusedBitsToZero(void) { pVal[_AP_N - 1] &= mask; }
inline void clearUnusedBitsToOne(void) { pVal[_AP_N - 1] |= mask; }
inline void fromString(const char* str, uint32_t slen, uint8_t radix) {
enum { numbits = _AP_W };
bool isNeg = str[0] == '-';
if (isNeg) {
str++;
slen--;
}
if (str[0] == '0' && (str[1] == 'b' || str[1] == 'B')) {
do { if ((radix != 2)) { fprintf(
# 3447 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
stderr
# 3447 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
, "WARNING: " "%s seems to have base %d, but %d given.", str, 2, radix); fprintf(
# 3447 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
stderr
# 3447 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
, "\n"); } } while (0);
str += 2;
slen -=2;
} else if (str[0] == '0' && (str[1] == 'o' || str[1] == 'O')) {
do { if ((radix != 8)) { fprintf(
# 3452 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
stderr
# 3452 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
, "WARNING: " "%s seems to have base %d, but %d given.", str, 8, radix); fprintf(
# 3452 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
stderr
# 3452 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
, "\n"); } } while (0);
str += 2;
slen -=2;
} else if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X')) {
do { if ((radix != 16)) { fprintf(
# 3457 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
stderr
# 3457 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
, "WARNING: " "%s seems to have base %d, but %d given.", str, 16, radix); fprintf(
# 3457 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
stderr
# 3457 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
, "\n"); } } while (0);
str += 2;
slen -=2;
} else if (str[0] == '0' && (str[1] == 'd' || str[1] == 'D')) {
do { if ((radix != 10)) { fprintf(
# 3462 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
stderr
# 3462 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
, "WARNING: " "%s seems to have base %d, but %d given.", str, 10, radix); fprintf(
# 3462 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
stderr
# 3462 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
, "\n"); } } while (0);
str += 2;
slen -=2;
} else if (radix == 0) {
}
# 3470 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 3470 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
(radix == 10 || radix == 8 || radix == 16 || radix == 2) && "Radix should be 2, 8, 10, or 16!"
# 3470 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 3470 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"(radix == 10 || radix == 8 || radix == 16 || radix == 2) && \"Radix should be 2, 8, 10, or 16!\""
# 3470 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
,
"/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
# 3470 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
,
3471
# 3470 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, __PRETTY_FUNCTION__))
# 3471 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
# 3472 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 3472 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
str && "String is null?"
# 3472 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 3472 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"str && \"String is null?\""
# 3472 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 3472, __PRETTY_FUNCTION__))
# 3472 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
while (*str == '0' && *(str + 1) != '\0') {
str++;
slen--;
}
# 3479 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 3479 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
(slen <= numbits || radix != 2) && "Insufficient bit width"
# 3479 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 3479 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"(slen <= numbits || radix != 2) && \"Insufficient bit width\""
# 3479 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 3479, __PRETTY_FUNCTION__))
# 3479 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
# 3480 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 3480 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
((slen - 1) * 3 <= numbits || radix != 8) && "Insufficient bit width"
# 3480 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 3480 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"((slen - 1) * 3 <= numbits || radix != 8) && \"Insufficient bit width\""
# 3480 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
,
"/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
# 3480 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
,
3481
# 3480 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, __PRETTY_FUNCTION__))
# 3481 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
# 3482 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 3482 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
((slen - 1) * 4 <= numbits || radix != 16) && "Insufficient bit width"
# 3482 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 3482 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"((slen - 1) * 4 <= numbits || radix != 16) && \"Insufficient bit width\""
# 3482 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
,
"/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
# 3482 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
,
3483
# 3482 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, __PRETTY_FUNCTION__))
# 3483 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
# 3484 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 3484 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
(((slen - 1) * 64) / 22 <= numbits || radix != 10) && "Insufficient bit width"
# 3484 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 3484 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"(((slen - 1) * 64) / 22 <= numbits || radix != 10) && \"Insufficient bit width\""
# 3484 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
,
"/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
# 3484 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
,
3485
# 3484 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, __PRETTY_FUNCTION__))
# 3485 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
memset(pVal, 0, _AP_N * sizeof(uint64_t));
uint32_t shift = (radix == 16 ? 4 : radix == 8 ? 3 : radix == 2 ? 1 : 0);
uint64_t bigVal[_AP_N];
memset(bigVal, 0, _AP_N * sizeof(uint64_t));
ap_private<_AP_W, _AP_S> apdigit(getBitWidth(), bigVal);
ap_private<_AP_W, _AP_S> apradix(radix);
for (unsigned i = 0; i < slen; i++) {
uint32_t digit = 0;
char cdigit = str[i];
if (radix == 16) {
if (!(((cdigit) >= '0' && (cdigit) <= '9') || ((cdigit) >= 'a' && (cdigit) <= 'f') || ((cdigit) >= 'A' && (cdigit) <= 'F')))
# 3510 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 3510 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
0 && "Invalid hex digit in string"
# 3510 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 3510 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"0 && \"Invalid hex digit in string\""
# 3510 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 3510, __PRETTY_FUNCTION__))
# 3510 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
if (((cdigit) >= '0' && (cdigit) <= '9'))
digit = cdigit - '0';
else if (cdigit >= 'a')
digit = cdigit - 'a' + 10;
else if (cdigit >= 'A')
digit = cdigit - 'A' + 10;
else
# 3518 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 3518 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
0 && "huh? we shouldn't get here"
# 3518 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 3518 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"0 && \"huh? we shouldn't get here\""
# 3518 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 3518, __PRETTY_FUNCTION__))
# 3518 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
} else if (((cdigit) >= '0' && (cdigit) <= '9')) {
digit = cdigit - '0';
} else if (cdigit != '\0') {
# 3522 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 3522 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
0 && "Invalid character in digit string"
# 3522 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 3522 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"0 && \"Invalid character in digit string\""
# 3522 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 3522, __PRETTY_FUNCTION__))
# 3522 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
}
if (shift)
*this <<= shift;
else
*this *= apradix;
apdigit.set_VAL(digit);
*this += apdigit;
}
if (isNeg) {
(*this)--;
this->flip();
}
clearUnusedBits();
}
inline ap_private read() volatile { return *this; }
inline void write(const ap_private& op2) volatile { *this = (op2); }
inline operator ValType() const { return get_VAL(); }
inline int to_uchar() const { return (unsigned char)get_VAL(); }
inline int to_char() const { return (signed char)get_VAL(); }
inline int to_ushort() const { return (unsigned short)get_VAL(); }
inline int to_short() const { return (short)get_VAL(); }
inline int to_int() const { return (int)get_VAL(); }
inline unsigned to_uint() const { return (unsigned)get_VAL(); }
inline long to_long() const { return (long)get_VAL(); }
inline unsigned long to_ulong() const { return (unsigned long)get_VAL(); }
inline ap_slong to_int64() const { return (ap_slong)get_VAL(); }
inline ap_ulong to_uint64() const { return (ap_ulong)get_VAL(); }
inline double to_double() const {
if (isNegative())
return roundToDouble(true);
else
return roundToDouble(false);
}
inline unsigned length() const { return _AP_W; }
inline ap_private& reverse() {
for (int i = 0; i < _AP_W / 2; ++i) {
bool tmp = operator[](i);
if (operator[](_AP_W - 1 - i))
set(i);
else
clear(i);
if (tmp)
set(_AP_W - 1 - i);
else
clear(_AP_W - 1 - i);
}
clearUnusedBits();
return *this;
}
inline bool iszero() const { return isMinValue(); }
inline bool to_bool() const { return !iszero(); }
inline bool sign() const {
if (isNegative()) return true;
return false;
}
inline void invert(int i) {
# 3610 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 3610 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
i >= 0 && "Attempting to read bit with negative index"
# 3610 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 3610 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"i >= 0 && \"Attempting to read bit with negative index\""
# 3610 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 3610, __PRETTY_FUNCTION__))
# 3610 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
# 3611 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 3611 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
i < _AP_W && "Attempting to read bit beyond MSB"
# 3611 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 3611 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"i < _AP_W && \"Attempting to read bit beyond MSB\""
# 3611 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 3611, __PRETTY_FUNCTION__))
# 3611 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
flip(i);
}
inline bool test(int i) const {
# 3617 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 3617 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
i >= 0 && "Attempting to read bit with negative index"
# 3617 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 3617 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"i >= 0 && \"Attempting to read bit with negative index\""
# 3617 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 3617, __PRETTY_FUNCTION__))
# 3617 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
# 3618 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 3618 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
i < _AP_W && "Attempting to read bit beyond MSB"
# 3618 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 3618 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"i < _AP_W && \"Attempting to read bit beyond MSB\""
# 3618 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 3618, __PRETTY_FUNCTION__))
# 3618 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
return operator[](i);
}
inline void set(int i, bool v) {
# 3624 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 3624 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
i >= 0 && "Attempting to write bit with negative index"
# 3624 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 3624 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"i >= 0 && \"Attempting to write bit with negative index\""
# 3624 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 3624, __PRETTY_FUNCTION__))
# 3624 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
# 3625 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 3625 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
i < _AP_W && "Attempting to write bit beyond MSB"
# 3625 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 3625 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"i < _AP_W && \"Attempting to write bit beyond MSB\""
# 3625 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 3625, __PRETTY_FUNCTION__))
# 3625 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
v ? set(i) : clear(i);
}
inline void set_bit(int i, bool v) {
# 3631 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 3631 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
i >= 0 && "Attempting to write bit with negative index"
# 3631 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 3631 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"i >= 0 && \"Attempting to write bit with negative index\""
# 3631 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 3631, __PRETTY_FUNCTION__))
# 3631 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
# 3632 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 3632 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
i < _AP_W && "Attempting to write bit beyond MSB"
# 3632 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 3632 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"i < _AP_W && \"Attempting to write bit beyond MSB\""
# 3632 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 3632, __PRETTY_FUNCTION__))
# 3632 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
v ? set(i) : clear(i);
}
inline ap_private& set(uint32_t bitPosition) {
pVal[whichWord(bitPosition)] |= maskBit(bitPosition);
clearUnusedBits();
return *this;
}
inline void set() {
for (int i = 0; i < _AP_N; ++i) pVal[i] = ~0ULL;
clearUnusedBits();
}
inline bool get(int i) const {
# 3650 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 3650 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
i >= 0 && "Attempting to read bit with negative index"
# 3650 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 3650 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"i >= 0 && \"Attempting to read bit with negative index\""
# 3650 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 3650, __PRETTY_FUNCTION__))
# 3650 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
# 3651 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 3651 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
i < _AP_W && "Attempting to read bit beyond MSB"
# 3651 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 3651 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"i < _AP_W && \"Attempting to read bit beyond MSB\""
# 3651 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 3651, __PRETTY_FUNCTION__))
# 3651 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
return ((maskBit(i) & (pVal[whichWord(i)])) != 0);
}
inline bool get_bit(int i) const {
# 3657 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 3657 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
i >= 0 && "Attempting to read bit with negative index"
# 3657 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 3657 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"i >= 0 && \"Attempting to read bit with negative index\""
# 3657 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 3657, __PRETTY_FUNCTION__))
# 3657 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
# 3658 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 3658 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
i < _AP_W && "Attempting to read bit beyond MSB"
# 3658 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 3658 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"i < _AP_W && \"Attempting to read bit beyond MSB\""
# 3658 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 3658, __PRETTY_FUNCTION__))
# 3658 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
return ((maskBit(i) & (pVal[whichWord(i)])) != 0);
}
inline void lrotate(int n) {
# 3665 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 3665 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
n >= 0 && "Attempting to shift negative index"
# 3665 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 3665 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"n >= 0 && \"Attempting to shift negative index\""
# 3665 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 3665, __PRETTY_FUNCTION__))
# 3665 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
# 3666 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 3666 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
n < _AP_W && "Shift value larger than bit width"
# 3666 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 3666 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"n < _AP_W && \"Shift value larger than bit width\""
# 3666 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 3666, __PRETTY_FUNCTION__))
# 3666 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
operator=(shl(n) | lshr(_AP_W - n));
}
inline void rrotate(int n) {
# 3673 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 3673 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
n >= 0 && "Attempting to shift negative index"
# 3673 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 3673 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"n >= 0 && \"Attempting to shift negative index\""
# 3673 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 3673, __PRETTY_FUNCTION__))
# 3673 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
# 3674 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 3674 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
n < _AP_W && "Shift value larger than bit width"
# 3674 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 3674 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"n < _AP_W && \"Shift value larger than bit width\""
# 3674 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 3674, __PRETTY_FUNCTION__))
# 3674 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
operator=(lshr(n) | shl(_AP_W - n));
}
inline ap_private& clear(uint32_t bitPosition) {
pVal[whichWord(bitPosition)] &= ~maskBit(bitPosition);
clearUnusedBits();
return *this;
}
inline void clear() { memset(pVal, 0, _AP_N * APINT_WORD_SIZE); }
ap_private& flip() {
for (int i = 0; i < _AP_N; ++i) pVal[i] ^= ~0ULL;
clearUnusedBits();
return *this;
}
inline ap_private& flip(uint32_t bitPosition) {
# 3698 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 3698 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
bitPosition < BitWidth && "Out of the bit-width range!"
# 3698 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 3698 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"bitPosition < BitWidth && \"Out of the bit-width range!\""
# 3698 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 3698, __PRETTY_FUNCTION__))
# 3698 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
set_bit(bitPosition, !get_bit(bitPosition));
return *this;
}
inline void b_not() { flip(); }
inline ap_private getLoBits(uint32_t numBits) const {
return ap_private_ops::lshr(ap_private_ops::shl(*this, _AP_W - numBits),
_AP_W - numBits);
}
inline ap_private getHiBits(uint32_t numBits) const {
return ap_private_ops::lshr(*this, _AP_W - numBits);
}
# 3757 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
template <int _AP_W1, bool _AP_S1> inline ap_private& operator &=(const ap_private<_AP_W1, _AP_S1>& RHS) { const int _AP_N1 = ap_private<_AP_W1, _AP_S1>::_AP_N; uint32_t numWords = AESL_std::min((int)_AP_N, _AP_N1); uint32_t i; if (_AP_W != _AP_W1) fprintf(
# 3757 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
stderr
# 3757 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
, "Warning! Bitsize mismach for ap_[u]int " "&=" " ap_[u]int.\n"); for (i = 0; i < numWords; ++i) pVal[i] &= RHS.get_pVal(i); if (_AP_N1 < _AP_N) { uint64_t ext = RHS.isNegative() ? ~0ULL : 0; for (; i < _AP_N; i++) pVal[i] &= ext; } clearUnusedBits(); return *this; };
template <int _AP_W1, bool _AP_S1> inline ap_private& operator |=(const ap_private<_AP_W1, _AP_S1>& RHS) { const int _AP_N1 = ap_private<_AP_W1, _AP_S1>::_AP_N; uint32_t numWords = AESL_std::min((int)_AP_N, _AP_N1); uint32_t i; if (_AP_W != _AP_W1) fprintf(
# 3758 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
stderr
# 3758 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
, "Warning! Bitsize mismach for ap_[u]int " "|=" " ap_[u]int.\n"); for (i = 0; i < numWords; ++i) pVal[i] |= RHS.get_pVal(i); if (_AP_N1 < _AP_N) { uint64_t ext = RHS.isNegative() ? ~0ULL : 0; for (; i < _AP_N; i++) pVal[i] |= ext; } clearUnusedBits(); return *this; };
template <int _AP_W1, bool _AP_S1> inline ap_private& operator ^=(const ap_private<_AP_W1, _AP_S1>& RHS) { const int _AP_N1 = ap_private<_AP_W1, _AP_S1>::_AP_N; uint32_t numWords = AESL_std::min((int)_AP_N, _AP_N1); uint32_t i; if (_AP_W != _AP_W1) fprintf(
# 3759 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
stderr
# 3759 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
, "Warning! Bitsize mismach for ap_[u]int " "^=" " ap_[u]int.\n"); for (i = 0; i < numWords; ++i) pVal[i] ^= RHS.get_pVal(i); if (_AP_N1 < _AP_N) { uint64_t ext = RHS.isNegative() ? ~0ULL : 0; for (; i < _AP_N; i++) pVal[i] ^= ext; } clearUnusedBits(); return *this; };
template <int _AP_W1, bool _AP_S1>
inline ap_private& operator+=(const ap_private<_AP_W1, _AP_S1>& RHS) {
const int _AP_N1 = ap_private<_AP_W1, _AP_S1>::_AP_N;
uint64_t RHSpVal[_AP_N1];
for (int i = 0; i < _AP_N1; ++i) RHSpVal[i] = RHS.get_pVal(i);
ap_private_ops::add(pVal, pVal, RHSpVal, _AP_N, _AP_N, _AP_N1, _AP_S,
_AP_S1);
clearUnusedBits();
return *this;
}
template <int _AP_W1, bool _AP_S1>
inline ap_private& operator-=(const ap_private<_AP_W1, _AP_S1>& RHS) {
const int _AP_N1 = ap_private<_AP_W1, _AP_S1>::_AP_N;
uint64_t RHSpVal[_AP_N1];
for (int i = 0; i < _AP_N1; ++i) RHSpVal[i] = RHS.get_pVal(i);
ap_private_ops::sub(pVal, pVal, RHSpVal, _AP_N, _AP_N, _AP_N1, _AP_S,
_AP_S1);
clearUnusedBits();
return *this;
}
template <int _AP_W1, bool _AP_S1>
inline ap_private& operator*=(const ap_private<_AP_W1, _AP_S1>& RHS) {
uint32_t lhsBits = getActiveBits();
uint32_t lhsWords = !lhsBits ? 0 : whichWord(lhsBits - 1) + 1;
if (!lhsWords) {
return *this;
}
ap_private dupRHS = RHS;
uint32_t rhsBits = dupRHS.getActiveBits();
uint32_t rhsWords = !rhsBits ? 0 : whichWord(rhsBits - 1) + 1;
if (!rhsWords) {
clear();
return *this;
}
uint32_t destWords = rhsWords + lhsWords;
uint64_t* dest = (uint64_t*)malloc(destWords * sizeof(uint64_t));
ap_private_ops::mul(dest, pVal, lhsWords, dupRHS.get_pVal(), rhsWords,
destWords);
clear();
uint32_t wordsToCopy = destWords >= _AP_N ? _AP_N : destWords;
memcpy(pVal, dest, wordsToCopy * APINT_WORD_SIZE);
uint64_t ext = (isNegative() ^ RHS.isNegative()) ? ~0ULL : 0ULL;
for (int i = wordsToCopy; i < _AP_N; i++) pVal[i] = ext;
clearUnusedBits();
free(dest);
return *this;
}
# 3836 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
template <int _AP_W2, bool _AP_S2> inline ap_private& operator /=(const ap_private<_AP_W2, _AP_S2>& op) { *this = operator /(op); return *this; }
template <int _AP_W2, bool _AP_S2> inline ap_private& operator %=(const ap_private<_AP_W2, _AP_S2>& op) { *this = operator %(op); return *this; }
# 3876 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
template <int _AP_W1, bool _AP_S1> inline typename RType<_AP_W1, _AP_S1>::logic operator |( const ap_private<_AP_W1, _AP_S1>& RHS) const { enum { numWords = (RType<_AP_W1, _AP_S1>::logic_w + APINT_BITS_PER_WORD - 1) / APINT_BITS_PER_WORD }; typename RType<_AP_W1, _AP_S1>::logic Result; uint32_t i; const int _AP_N1 = ap_private<_AP_W1, _AP_S1>::_AP_N; uint32_t min_N = std::min((int)_AP_N, _AP_N1); uint32_t max_N = std::max((int)_AP_N, _AP_N1); for (i = 0; i < min_N; ++i) Result.set_pVal(i, pVal[i] | RHS.get_pVal(i)); if (numWords > i) { uint64_t ext = ((_AP_N < _AP_N1 && isNegative()) || (_AP_N1 < _AP_N && RHS.isNegative())) ? ~0ULL : 0; if (_AP_N > _AP_N1) for (; i < max_N; i++) Result.set_pVal(i, pVal[i] | ext); else for (; i < max_N; i++) Result.set_pVal(i, RHS.get_pVal(i) | ext); if (numWords > i) { uint64_t ext2 = ((_AP_N > _AP_N1 && isNegative()) || (_AP_N1 > _AP_N && RHS.isNegative())) ? ~0ULL : 0; Result.set_pVal(i, ext | ext2); } } Result.clearUnusedBits(); return Result; };
template <int _AP_W1, bool _AP_S1> inline typename RType<_AP_W1, _AP_S1>::logic operator &( const ap_private<_AP_W1, _AP_S1>& RHS) const { enum { numWords = (RType<_AP_W1, _AP_S1>::logic_w + APINT_BITS_PER_WORD - 1) / APINT_BITS_PER_WORD }; typename RType<_AP_W1, _AP_S1>::logic Result; uint32_t i; const int _AP_N1 = ap_private<_AP_W1, _AP_S1>::_AP_N; uint32_t min_N = std::min((int)_AP_N, _AP_N1); uint32_t max_N = std::max((int)_AP_N, _AP_N1); for (i = 0; i < min_N; ++i) Result.set_pVal(i, pVal[i] & RHS.get_pVal(i)); if (numWords > i) { uint64_t ext = ((_AP_N < _AP_N1 && isNegative()) || (_AP_N1 < _AP_N && RHS.isNegative())) ? ~0ULL : 0; if (_AP_N > _AP_N1) for (; i < max_N; i++) Result.set_pVal(i, pVal[i] & ext); else for (; i < max_N; i++) Result.set_pVal(i, RHS.get_pVal(i) & ext); if (numWords > i) { uint64_t ext2 = ((_AP_N > _AP_N1 && isNegative()) || (_AP_N1 > _AP_N && RHS.isNegative())) ? ~0ULL : 0; Result.set_pVal(i, ext & ext2); } } Result.clearUnusedBits(); return Result; };
template <int _AP_W1, bool _AP_S1> inline typename RType<_AP_W1, _AP_S1>::logic operator ^( const ap_private<_AP_W1, _AP_S1>& RHS) const { enum { numWords = (RType<_AP_W1, _AP_S1>::logic_w + APINT_BITS_PER_WORD - 1) / APINT_BITS_PER_WORD }; typename RType<_AP_W1, _AP_S1>::logic Result; uint32_t i; const int _AP_N1 = ap_private<_AP_W1, _AP_S1>::_AP_N; uint32_t min_N = std::min((int)_AP_N, _AP_N1); uint32_t max_N = std::max((int)_AP_N, _AP_N1); for (i = 0; i < min_N; ++i) Result.set_pVal(i, pVal[i] ^ RHS.get_pVal(i)); if (numWords > i) { uint64_t ext = ((_AP_N < _AP_N1 && isNegative()) || (_AP_N1 < _AP_N && RHS.isNegative())) ? ~0ULL : 0; if (_AP_N > _AP_N1) for (; i < max_N; i++) Result.set_pVal(i, pVal[i] ^ ext); else for (; i < max_N; i++) Result.set_pVal(i, RHS.get_pVal(i) ^ ext); if (numWords > i) { uint64_t ext2 = ((_AP_N > _AP_N1 && isNegative()) || (_AP_N1 > _AP_N && RHS.isNegative())) ? ~0ULL : 0; Result.set_pVal(i, ext ^ ext2); } } Result.clearUnusedBits(); return Result; };
template <int _AP_W1, bool _AP_S1>
inline typename RType<_AP_W1, _AP_S1>::plus operator+(
const ap_private<_AP_W1, _AP_S1>& RHS) const {
typename RType<_AP_W1, _AP_S1>::plus Result, lhs(*this), rhs(RHS);
const int Result_AP_N = (RType<_AP_W1, _AP_S1>::plus_w + 63) / 64;
ap_private_ops::add(Result.get_pVal(), lhs.get_pVal(), rhs.get_pVal(),
Result_AP_N, Result_AP_N, Result_AP_N, _AP_S, _AP_S1);
Result.clearUnusedBits();
return Result;
}
template <int _AP_W1, bool _AP_S1>
inline typename RType<_AP_W1, _AP_S1>::minus operator-(
const ap_private<_AP_W1, _AP_S1>& RHS) const {
typename RType<_AP_W1, _AP_S1>::minus Result, lhs(*this), rhs(RHS);
const int Result_AP_N = (RType<_AP_W1, _AP_S1>::minus_w + 63) / 64;
ap_private_ops::sub(Result.get_pVal(), lhs.get_pVal(), rhs.get_pVal(),
Result_AP_N, Result_AP_N, Result_AP_N, _AP_S, _AP_S1);
Result.clearUnusedBits();
return Result;
}
template <int _AP_W1, bool _AP_S1>
inline typename RType<_AP_W1, _AP_S1>::mult operator*(
const ap_private<_AP_W1, _AP_S1>& RHS) const {
typename RType<_AP_W1, _AP_S1>::mult temp = *this;
temp *= RHS;
return temp;
}
template <int _AP_W2, bool _AP_S2>
inline typename RType<_AP_W2, _AP_S2>::div operator/(
const ap_private<_AP_W2, _AP_S2>& op) const {
ap_private<((_AP_W + (_AP_S || _AP_S2)) > (_AP_W2 + (_AP_S || _AP_S2)) ? (_AP_W + (_AP_S || _AP_S2)) : (_AP_W2 + (_AP_S || _AP_S2))),
(_AP_W > _AP_W2 ? _AP_S
: (_AP_W2 > _AP_W ? _AP_S2 : _AP_S || _AP_S2))>
lhs = *this;
ap_private<((_AP_W + (_AP_S || _AP_S2)) > (_AP_W2 + (_AP_S || _AP_S2)) ? (_AP_W + (_AP_S || _AP_S2)) : (_AP_W2 + (_AP_S || _AP_S2))),
(_AP_W > _AP_W2 ? _AP_S
: (_AP_W2 > _AP_W ? _AP_S2 : _AP_S || _AP_S2))>
rhs = op;
return typename RType<_AP_W2, _AP_S2>::div(
(_AP_S || _AP_S2) ? lhs.sdiv(rhs) : lhs.udiv(rhs));
}
template <int _AP_W2, bool _AP_S2>
inline typename RType<_AP_W2, _AP_S2>::mod operator%(
const ap_private<_AP_W2, _AP_S2>& op) const {
ap_private<((_AP_W + (_AP_S || _AP_S2)) > (_AP_W2 + (_AP_S || _AP_S2)) ? (_AP_W + (_AP_S || _AP_S2)) : (_AP_W2 + (_AP_S || _AP_S2))),
(_AP_W > _AP_W2 ? _AP_S
: (_AP_W2 > _AP_W ? _AP_S2 : _AP_S || _AP_S2))>
lhs = *this;
ap_private<((_AP_W + (_AP_S || _AP_S2)) > (_AP_W2 + (_AP_S || _AP_S2)) ? (_AP_W + (_AP_S || _AP_S2)) : (_AP_W2 + (_AP_S || _AP_S2))),
(_AP_W > _AP_W2 ? _AP_S
: (_AP_W2 > _AP_W ? _AP_S2 : _AP_S || _AP_S2))>
rhs = op;
typename RType<_AP_W2, _AP_S2>::mod res =
typename RType<_AP_W2, _AP_S2>::mod(_AP_S ? lhs.srem(rhs)
: lhs.urem(rhs));
return res;
}
# 3951 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
inline ap_private operator<<(const int op) const { if (op >= _AP_W) return ap_private(0); if (true && op < 0) return *this >> (0 - op); return shl(op); }
inline ap_private operator<<(const signed char op) const { if (op >= _AP_W) return ap_private(0); if (true && op < 0) return *this >> (0 - op); return shl(op); }
inline ap_private operator<<(const unsigned char op) const { if (op >= _AP_W) return ap_private(0); if (false && op < 0) return *this >> (0 - op); return shl(op); }
inline ap_private operator<<(const short op) const { if (op >= _AP_W) return ap_private(0); if (true && op < 0) return *this >> (0 - op); return shl(op); }
inline ap_private operator<<(const unsigned short op) const { if (op >= _AP_W) return ap_private(0); if (false && op < 0) return *this >> (0 - op); return shl(op); }
inline ap_private operator<<(const unsigned int op) const { if (op >= _AP_W) return ap_private(0); if (false && op < 0) return *this >> (0 - op); return shl(op); }
inline ap_private operator<<(const long op) const { if (op >= _AP_W) return ap_private(0); if (true && op < 0) return *this >> (0 - op); return shl(op); }
inline ap_private operator<<(const unsigned long op) const { if (op >= _AP_W) return ap_private(0); if (false && op < 0) return *this >> (0 - op); return shl(op); }
inline ap_private operator<<(const unsigned long long op) const { if (op >= _AP_W) return ap_private(0); if (false && op < 0) return *this >> (0 - op); return shl(op); }
inline ap_private operator<<(const long long op) const { if (op >= _AP_W) return ap_private(0); if (true && op < 0) return *this >> (0 - op); return shl(op); }
inline ap_private operator<<(const half op) const { if (op >= _AP_W) return ap_private(0); if (false && op < 0) return *this >> (0 - op); return shl(op); }
inline ap_private operator<<(const float op) const { if (op >= _AP_W) return ap_private(0); if (false && op < 0) return *this >> (0 - op); return shl(op); }
inline ap_private operator<<(const double op) const { if (op >= _AP_W) return ap_private(0); if (false && op < 0) return *this >> (0 - op); return shl(op); }
template <int _AP_W2, bool _AP_S2>
inline ap_private operator<<(const ap_private<_AP_W2, _AP_S2>& op2) const {
if (_AP_S2 == false) {
uint32_t sh = op2.to_uint();
return *this << sh;
} else {
int sh = op2.to_int();
return *this << sh;
}
}
# 3994 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
inline ap_private operator>>(const char op) const { if (op >= _AP_W) { if (isNegative()) return ap_private(-1); else return ap_private(0); } if ((CHAR_IS_SIGNED) && op < 0) return *this << (0 - op); if (_AP_S) return ashr(op); else return lshr(op); }
inline ap_private operator>>(const signed char op) const { if (op >= _AP_W) { if (isNegative()) return ap_private(-1); else return ap_private(0); } if ((true) && op < 0) return *this << (0 - op); if (_AP_S) return ashr(op); else return lshr(op); }
inline ap_private operator>>(const unsigned char op) const { if (op >= _AP_W) { if (isNegative()) return ap_private(-1); else return ap_private(0); } if ((false) && op < 0) return *this << (0 - op); if (_AP_S) return ashr(op); else return lshr(op); }
inline ap_private operator>>(const short op) const { if (op >= _AP_W) { if (isNegative()) return ap_private(-1); else return ap_private(0); } if ((true) && op < 0) return *this << (0 - op); if (_AP_S) return ashr(op); else return lshr(op); }
inline ap_private operator>>(const unsigned short op) const { if (op >= _AP_W) { if (isNegative()) return ap_private(-1); else return ap_private(0); } if ((false) && op < 0) return *this << (0 - op); if (_AP_S) return ashr(op); else return lshr(op); }
inline ap_private operator>>(const int op) const { if (op >= _AP_W) { if (isNegative()) return ap_private(-1); else return ap_private(0); } if ((true) && op < 0) return *this << (0 - op); if (_AP_S) return ashr(op); else return lshr(op); }
inline ap_private operator>>(const unsigned int op) const { if (op >= _AP_W) { if (isNegative()) return ap_private(-1); else return ap_private(0); } if ((false) && op < 0) return *this << (0 - op); if (_AP_S) return ashr(op); else return lshr(op); }
inline ap_private operator>>(const long op) const { if (op >= _AP_W) { if (isNegative()) return ap_private(-1); else return ap_private(0); } if ((true) && op < 0) return *this << (0 - op); if (_AP_S) return ashr(op); else return lshr(op); }
inline ap_private operator>>(const unsigned long op) const { if (op >= _AP_W) { if (isNegative()) return ap_private(-1); else return ap_private(0); } if ((false) && op < 0) return *this << (0 - op); if (_AP_S) return ashr(op); else return lshr(op); }
inline ap_private operator>>(const unsigned long long op) const { if (op >= _AP_W) { if (isNegative()) return ap_private(-1); else return ap_private(0); } if ((false) && op < 0) return *this << (0 - op); if (_AP_S) return ashr(op); else return lshr(op); }
inline ap_private operator>>(const long long op) const { if (op >= _AP_W) { if (isNegative()) return ap_private(-1); else return ap_private(0); } if ((true) && op < 0) return *this << (0 - op); if (_AP_S) return ashr(op); else return lshr(op); }
inline ap_private operator>>(const half op) const { if (op >= _AP_W) { if (isNegative()) return ap_private(-1); else return ap_private(0); } if ((false) && op < 0) return *this << (0 - op); if (_AP_S) return ashr(op); else return lshr(op); }
inline ap_private operator>>(const float op) const { if (op >= _AP_W) { if (isNegative()) return ap_private(-1); else return ap_private(0); } if ((false) && op < 0) return *this << (0 - op); if (_AP_S) return ashr(op); else return lshr(op); }
inline ap_private operator>>(const double op) const { if (op >= _AP_W) { if (isNegative()) return ap_private(-1); else return ap_private(0); } if ((false) && op < 0) return *this << (0 - op); if (_AP_S) return ashr(op); else return lshr(op); }
template <int _AP_W2, bool _AP_S2>
inline ap_private operator>>(const ap_private<_AP_W2, _AP_S2>& op2) const {
if (_AP_S2 == false) {
uint32_t sh = op2.to_uint();
return *this >> sh;
} else {
int sh = op2.to_int();
return *this >> sh;
}
}
# 4039 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
template <int _AP_W2, bool _AP_S2> inline ap_private& operator >>=(int op) { *this = operator >>(op); return *this; } inline ap_private& operator >>=(unsigned int op) { *this = operator >>(op); return *this; } template <int _AP_W2, bool _AP_S2> inline ap_private& operator >>=(const ap_private<_AP_W2, _AP_S2>& op) { *this = operator >>(op); return *this; }
template <int _AP_W2, bool _AP_S2> inline ap_private& operator <<=(int op) { *this = operator <<(op); return *this; } inline ap_private& operator <<=(unsigned int op) { *this = operator <<(op); return *this; } template <int _AP_W2, bool _AP_S2> inline ap_private& operator <<=(const ap_private<_AP_W2, _AP_S2>& op) { *this = operator <<(op); return *this; }
inline bool operator==(const ap_private& RHS) const {
uint32_t n1 = getActiveBits();
uint32_t n2 = RHS.getActiveBits();
if (n1 != n2) return false;
if (n1 <= APINT_BITS_PER_WORD) return pVal[0] == RHS.get_pVal(0);
for (int i = whichWord(n1 - 1); i >= 0; --i)
if (pVal[i] != RHS.get_pVal(i)) return false;
return true;
}
template <int _AP_W2, bool _AP_S2>
inline bool operator==(const ap_private<_AP_W2, _AP_S2>& op) const {
enum {
_AP_MAX_W = ((_AP_W) > (_AP_W2) ? (_AP_W) : (_AP_W2)),
};
ap_private<_AP_MAX_W, false> lhs(*this);
ap_private<_AP_MAX_W, false> rhs(op);
return lhs == rhs;
}
inline bool operator==(uint64_t Val) const {
uint32_t n = getActiveBits();
if (n <= APINT_BITS_PER_WORD)
return pVal[0] == Val;
else
return false;
}
template <int _AP_W2, bool _AP_S2>
inline bool operator!=(const ap_private<_AP_W2, _AP_S2>& op) const {
return !(*this == op);
}
template <bool _AP_S1>
inline bool operator!=(const ap_private<_AP_W, _AP_S1>& RHS) const {
return !((*this) == RHS);
}
inline bool operator!=(uint64_t Val) const { return !((*this) == Val); }
template <int _AP_W2, bool _AP_S2>
inline bool operator<=(const ap_private<_AP_W2, _AP_S2>& op) const {
return !(*this > op);
}
inline bool operator<(const ap_private& op) const {
return _AP_S ? slt(op) : ult(op);
}
template <int _AP_W2, bool _AP_S2>
inline bool operator<(const ap_private<_AP_W2, _AP_S2>& op) const {
enum {
_AP_MAX_W = ((_AP_W + (_AP_S || _AP_S2)) > (_AP_W2 + (_AP_S || _AP_S2)) ? (_AP_W + (_AP_S || _AP_S2)) : (_AP_W2 + (_AP_S || _AP_S2)))
};
ap_private<_AP_MAX_W, _AP_S> lhs(*this);
ap_private<_AP_MAX_W, _AP_S2> rhs(op);
if (_AP_S == _AP_S2)
return _AP_S ? lhs.slt(rhs) : lhs.ult(rhs);
else if (_AP_S)
if (_AP_W2 >= _AP_W)
return lhs.ult(rhs);
else
return lhs.slt(rhs);
else if (_AP_W >= _AP_W2)
return lhs.ult(rhs);
else
return lhs.slt(rhs);
}
template <int _AP_W2, bool _AP_S2>
inline bool operator>=(const ap_private<_AP_W2, _AP_S2>& op) const {
return !(*this < op);
}
inline bool operator>(const ap_private& op) const {
return _AP_S ? sgt(op) : ugt(op);
}
template <int _AP_W2, bool _AP_S2>
inline bool operator>(const ap_private<_AP_W2, _AP_S2>& op) const {
enum {
_AP_MAX_W = ((_AP_W + (_AP_S || _AP_S2)) > (_AP_W2 + (_AP_S || _AP_S2)) ? (_AP_W + (_AP_S || _AP_S2)) : (_AP_W2 + (_AP_S || _AP_S2)))
};
ap_private<_AP_MAX_W, _AP_S> lhs(*this);
ap_private<_AP_MAX_W, _AP_S2> rhs(op);
if (_AP_S == _AP_S2)
return _AP_S ? lhs.sgt(rhs) : lhs.ugt(rhs);
else if (_AP_S)
if (_AP_W2 >= _AP_W)
return lhs.ugt(rhs);
else
return lhs.sgt(rhs);
else if (_AP_W >= _AP_W2)
return lhs.ugt(rhs);
else
return lhs.sgt(rhs);
}
inline _private_range_ref<_AP_W, _AP_S> operator()(int Hi, int Lo) {
return _private_range_ref<_AP_W, _AP_S>(this, Hi, Lo);
}
inline _private_range_ref<_AP_W, _AP_S> operator()(int Hi, int Lo) const {
return _private_range_ref<_AP_W, _AP_S>(
const_cast<ap_private<_AP_W, _AP_S>*>(this), Hi, Lo);
}
inline _private_range_ref<_AP_W, _AP_S> range(int Hi, int Lo) const {
return _private_range_ref<_AP_W, _AP_S>(
(const_cast<ap_private<_AP_W, _AP_S>*>(this)), Hi, Lo);
}
inline _private_range_ref<_AP_W, _AP_S> range(int Hi, int Lo) {
return _private_range_ref<_AP_W, _AP_S>(this, Hi, Lo);
}
template <int _AP_W2, bool _AP_S2, int _AP_W3, bool _AP_S3>
inline _private_range_ref<_AP_W, _AP_S> range(
const ap_private<_AP_W2, _AP_S2>& HiIdx,
const ap_private<_AP_W3, _AP_S3>& LoIdx) {
int Hi = HiIdx.to_int();
int Lo = LoIdx.to_int();
return _private_range_ref<_AP_W, _AP_S>(this, Hi, Lo);
}
template <int _AP_W2, bool _AP_S2, int _AP_W3, bool _AP_S3>
inline _private_range_ref<_AP_W, _AP_S> operator()(
const ap_private<_AP_W2, _AP_S2>& HiIdx,
const ap_private<_AP_W3, _AP_S3>& LoIdx) {
int Hi = HiIdx.to_int();
int Lo = LoIdx.to_int();
return _private_range_ref<_AP_W, _AP_S>(this, Hi, Lo);
}
template <int _AP_W2, bool _AP_S2, int _AP_W3, bool _AP_S3>
inline _private_range_ref<_AP_W, _AP_S> range(
const ap_private<_AP_W2, _AP_S2>& HiIdx,
const ap_private<_AP_W3, _AP_S3>& LoIdx) const {
int Hi = HiIdx.to_int();
int Lo = LoIdx.to_int();
return _private_range_ref<_AP_W, _AP_S>(const_cast<ap_private*>(this), Hi, Lo);
}
template <int _AP_W2, bool _AP_S2, int _AP_W3, bool _AP_S3>
inline _private_range_ref<_AP_W, _AP_S> operator()(
const ap_private<_AP_W2, _AP_S2>& HiIdx,
const ap_private<_AP_W3, _AP_S3>& LoIdx) const {
int Hi = HiIdx.to_int();
int Lo = LoIdx.to_int();
return this->range(Hi, Lo);
}
inline _private_bit_ref<_AP_W, _AP_S> operator[](int index) {
return _private_bit_ref<_AP_W, _AP_S>(*this, index);
}
template <int _AP_W2, bool _AP_S2>
inline _private_bit_ref<_AP_W, _AP_S> operator[](
const ap_private<_AP_W2, _AP_S2>& index) {
return _private_bit_ref<_AP_W, _AP_S>(*this, index.to_int());
}
template <int _AP_W2, bool _AP_S2>
inline const _private_bit_ref<_AP_W, _AP_S> operator[](
const ap_private<_AP_W2, _AP_S2>& index) const {
return _private_bit_ref<_AP_W, _AP_S>(
const_cast<ap_private<_AP_W, _AP_S>&>(*this), index.to_int());
}
inline const _private_bit_ref<_AP_W, _AP_S> operator[](int index) const {
return _private_bit_ref<_AP_W, _AP_S>(
const_cast<ap_private<_AP_W, _AP_S>&>(*this), index);
}
inline _private_bit_ref<_AP_W, _AP_S> bit(int index) {
return _private_bit_ref<_AP_W, _AP_S>(*this, index);
}
template <int _AP_W2, bool _AP_S2>
inline _private_bit_ref<_AP_W, _AP_S> bit(const ap_private<_AP_W2, _AP_S2>& index) {
return _private_bit_ref<_AP_W, _AP_S>(*this, index.to_int());
}
inline const _private_bit_ref<_AP_W, _AP_S> bit(int index) const {
return _private_bit_ref<_AP_W, _AP_S>(
const_cast<ap_private<_AP_W, _AP_S>&>(*this), index);
}
template <int _AP_W2, bool _AP_S2>
inline const _private_bit_ref<_AP_W, _AP_S> bit(
const ap_private<_AP_W2, _AP_S2>& index) const {
return _private_bit_ref<_AP_W, _AP_S>(
const_cast<ap_private<_AP_W, _AP_S>&>(*this), index.to_int());
}
# 4409 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
inline ap_private<_AP_W, false> get() const {
ap_private<_AP_W, false> ret(*this);
return ret;
}
template <int _AP_W3>
inline void set(const ap_private<_AP_W3, false>& val) {
operator=(ap_private<_AP_W3, _AP_S>(val));
}
inline bool isNegative() const {
enum { shift = (_AP_W - APINT_BITS_PER_WORD * (_AP_N - 1) - 1) };
static const uint64_t mask = 1ULL << (shift);
return _AP_S && (pVal[_AP_N - 1] & mask);
}
inline bool isPositive() const { return !isNegative(); }
inline bool isStrictlyPositive() const {
return isPositive() && (*this) != 0;
}
inline bool isAllOnesValue() const { return countPopulation() == _AP_W; }
inline bool isMaxValue() const { return countPopulation() == _AP_W; }
inline bool isMaxSignedValue() const {
return !isNegative() && countPopulation() == _AP_W - 1;
}
inline bool isMinValue() const { return countPopulation() == 0; }
inline bool isMinSignedValue() const {
return isNegative() && countPopulation() == 1;
}
inline const uint64_t* getRawData() const { return &pVal[0]; }
# 4484 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
inline ap_private sqrt() const {
uint32_t magnitude = getActiveBits();
if (magnitude <= 5) {
static const uint8_t results[32] = {
0,
1, 1,
2, 2, 2, 2,
3, 3, 3, 3, 3, 3,
4, 4, 4, 4, 4, 4, 4, 4,
5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
6};
return ap_private<_AP_W, _AP_S>( results[get_VAL()]);
}
if (magnitude < 52) {
return ap_private<_AP_W, _AP_S>(
uint64_t(
::round(::sqrt(double(get_VAL())))));
}
uint32_t nbits = BitWidth, i = 4;
ap_private<_AP_W, _AP_S> testy(16);
ap_private<_AP_W, _AP_S> x_old( 1);
ap_private<_AP_W, _AP_S> x_new(0);
ap_private<_AP_W, _AP_S> two( 2);
for (;; i += 2, testy = testy.shl(2))
if (i >= nbits || this->ule(testy)) {
x_old = x_old.shl(i / 2);
break;
}
for (;;) {
x_new = (this->udiv(x_old) + x_old).udiv(two);
if (x_old.ule(x_new)) break;
x_old = x_new;
}
# 4551 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
ap_private<_AP_W, _AP_S> square(x_old * x_old);
ap_private<_AP_W, _AP_S> nextSquare((x_old + 1) * (x_old + 1));
if (this->ult(square))
return x_old;
else if (this->ule(nextSquare)) {
ap_private<_AP_W, _AP_S> midpoint((nextSquare - square).udiv(two));
ap_private<_AP_W, _AP_S> offset(*this - square);
if (offset.ult(midpoint))
return x_old;
else
return x_old + 1;
} else
# 4563 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 4563 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
0 && "Error in ap_private<_AP_W, _AP_S>::sqrt computation"
# 4563 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 4563 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"0 && \"Error in ap_private<_AP_W, _AP_S>::sqrt computation\""
# 4563 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 4563, __PRETTY_FUNCTION__))
# 4563 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
return x_old + 1;
}
inline ap_private& operator=(const ap_private& RHS) {
if (this != &RHS) memcpy(pVal, RHS.get_pVal(), _AP_N * APINT_WORD_SIZE);
clearUnusedBits();
return *this;
}
inline ap_private& operator=(const volatile ap_private& RHS) {
if (this != &RHS)
for (int i = 0; i < _AP_N; ++i) pVal[i] = RHS.get_pVal(i);
clearUnusedBits();
return *this;
}
inline void operator=(const ap_private& RHS) volatile {
if (this != &RHS)
for (int i = 0; i < _AP_N; ++i) pVal[i] = RHS.get_pVal(i);
clearUnusedBits();
}
inline void operator=(const volatile ap_private& RHS) volatile {
if (this != &RHS)
for (int i = 0; i < _AP_N; ++i) pVal[i] = RHS.get_pVal(i);
clearUnusedBits();
}
template <int _AP_W1, bool _AP_S1>
inline ap_private& operator=(const ap_private<_AP_W1, _AP_S1>& RHS) {
if (_AP_S1)
cpSextOrTrunc(RHS);
else
cpZextOrTrunc(RHS);
clearUnusedBits();
return *this;
}
template <int _AP_W1, bool _AP_S1>
inline ap_private& operator=(const volatile ap_private<_AP_W1, _AP_S1>& RHS) {
if (_AP_S1)
cpSextOrTrunc(RHS);
else
cpZextOrTrunc(RHS);
clearUnusedBits();
return *this;
}
template <int _AP_W2, bool _AP_S2>
inline ap_private& operator=(const _private_range_ref<_AP_W2, _AP_S2>& op2) {
*this = ap_private<_AP_W2, false>(op2);
return *this;
}
# 4658 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
inline ap_private& operator=(const bool rhs) { ap_private<(1), (false)> tmp = rhs; operator=(tmp); return *this; }
inline ap_private& operator=(const char rhs) { ap_private<(8), (CHAR_IS_SIGNED)> tmp = rhs; operator=(tmp); return *this; }
inline ap_private& operator=(const signed char rhs) { ap_private<(8), (true)> tmp = rhs; operator=(tmp); return *this; }
inline ap_private& operator=(const unsigned char rhs) { ap_private<(8), (false)> tmp = rhs; operator=(tmp); return *this; }
inline ap_private& operator=(const short rhs) { ap_private<(sizeof(short) * 8), (true)> tmp = rhs; operator=(tmp); return *this; }
inline ap_private& operator=(const unsigned short rhs) { ap_private<(sizeof(unsigned short) * 8), (false)> tmp = rhs; operator=(tmp); return *this; }
inline ap_private& operator=(const int rhs) { ap_private<(sizeof(int) * 8), (true)> tmp = rhs; operator=(tmp); return *this; }
inline ap_private& operator=(const unsigned int rhs) { ap_private<(sizeof(unsigned int) * 8), (false)> tmp = rhs; operator=(tmp); return *this; }
inline ap_private& operator=(const long rhs) { ap_private<(sizeof(long) * 8), (true)> tmp = rhs; operator=(tmp); return *this; }
inline ap_private& operator=(const unsigned long rhs) { ap_private<(sizeof(unsigned long) * 8), (false)> tmp = rhs; operator=(tmp); return *this; }
inline ap_private& operator=(const ap_slong rhs) { ap_private<(sizeof(ap_slong) * 8), (true)> tmp = rhs; operator=(tmp); return *this; }
inline ap_private& operator=(const ap_ulong rhs) { ap_private<(sizeof(ap_ulong) * 8), (false)> tmp = rhs; operator=(tmp); return *this; }
inline ap_private& operator=(const char* s) {
ap_private tmp(s);
operator=(tmp);
return *this;
}
inline const ap_private operator++(int) {
ap_private API(*this);
++(*this);
return API;
}
inline ap_private& operator++() {
ap_private_ops::add_1(pVal, pVal, _AP_N, 1);
clearUnusedBits();
return *this;
}
inline const ap_private operator--(int) {
ap_private API(*this);
--(*this);
return API;
}
inline ap_private& operator--() {
ap_private_ops::sub_1(pVal, _AP_N, 1);
clearUnusedBits();
return *this;
}
inline ap_private<_AP_W + !_AP_S, true> operator~() const {
ap_private<_AP_W + !_AP_S, true> Result(*this);
Result.flip();
return Result;
}
inline typename RType<1, false>::minus operator-() const {
return ap_private<1, false>(0) - (*this);
}
inline bool operator!() const {
for (int i = 0; i < _AP_N; ++i)
if (pVal[i]) return false;
return true;
}
template <bool _AP_S1>
inline ap_private<_AP_W, _AP_S || _AP_S1> And(
const ap_private<_AP_W, _AP_S1>& RHS) const {
return this->operator&(RHS);
}
template <bool _AP_S1>
inline ap_private Or(const ap_private<_AP_W, _AP_S1>& RHS) const {
return this->operator|(RHS);
}
template <bool _AP_S1>
inline ap_private Xor(const ap_private<_AP_W, _AP_S1>& RHS) const {
return this->operator^(RHS);
}
inline ap_private Mul(const ap_private& RHS) const {
ap_private Result(*this);
Result *= RHS;
return Result;
}
inline ap_private Add(const ap_private& RHS) const {
ap_private Result(0);
ap_private_ops::add(Result.get_pVal(), pVal, RHS.get_pVal(), _AP_N, _AP_N,
_AP_N, _AP_S, _AP_S);
Result.clearUnusedBits();
return Result;
}
inline ap_private Sub(const ap_private& RHS) const {
ap_private Result(0);
ap_private_ops::sub(Result.get_pVal(), pVal, RHS.get_pVal(), _AP_N, _AP_N,
_AP_N, _AP_S, _AP_S);
Result.clearUnusedBits();
return Result;
}
inline ap_private ashr(uint32_t shiftAmt) const {
# 4779 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 4779 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
shiftAmt <= BitWidth && "Invalid shift amount, too big"
# 4779 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 4779 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"shiftAmt <= BitWidth && \"Invalid shift amount, too big\""
# 4779 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 4779, __PRETTY_FUNCTION__))
# 4779 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
if (shiftAmt == 0) return ap_private(*this);
if (shiftAmt == BitWidth) {
if (isNegative())
return ap_private(-1);
else
return ap_private(0);
}
ap_private Retval(0);
uint64_t* val = Retval.get_pVal();
uint32_t wordShift =
shiftAmt % APINT_BITS_PER_WORD;
uint32_t offset = shiftAmt / APINT_BITS_PER_WORD;
uint32_t breakWord = _AP_N - 1 - offset;
uint32_t bitsInWord = whichBit(BitWidth);
if (bitsInWord == 0) bitsInWord = APINT_BITS_PER_WORD;
if (wordShift == 0) {
for (uint32_t i = 0; i <= breakWord; ++i)
val[i] = pVal[i + offset];
if (isNegative())
if (bitsInWord < APINT_BITS_PER_WORD)
val[breakWord] |= ~0ULL << (bitsInWord);
} else {
for (uint32_t i = 0; i < breakWord; ++i) {
val[i] = ((pVal[i + offset]) >> (wordShift));
val[i] |= ((pVal[i + offset + 1]) << (APINT_BITS_PER_WORD - wordShift));
}
val[breakWord] = (pVal[breakWord + offset]) >> (wordShift);
if (isNegative()) {
if (wordShift > bitsInWord) {
if (breakWord > 0)
val[breakWord - 1] |=
~0ULL << (APINT_BITS_PER_WORD - (wordShift - bitsInWord));
val[breakWord] |= ~0ULL;
} else
val[breakWord] |= (~0ULL << (bitsInWord - wordShift));
}
}
uint64_t fillValue = (isNegative() ? ~0ULL : 0);
for (int i = breakWord + 1; i < _AP_N; ++i) val[i] = fillValue;
Retval.clearUnusedBits();
return Retval;
}
inline ap_private lshr(uint32_t shiftAmt) const {
if (shiftAmt == BitWidth) return ap_private(0);
if (shiftAmt == 0) return ap_private(*this);
ap_private Retval(0);
uint64_t* val = Retval.get_pVal();
if (shiftAmt < APINT_BITS_PER_WORD) {
uint64_t carry = 0;
for (int i = _AP_N - 1; i >= 0; --i) {
val[i] = ((pVal[i]) >> (shiftAmt)) | carry;
carry = (pVal[i]) << (APINT_BITS_PER_WORD - shiftAmt);
}
Retval.clearUnusedBits();
return Retval;
}
uint32_t wordShift = shiftAmt % APINT_BITS_PER_WORD;
uint32_t offset = shiftAmt / APINT_BITS_PER_WORD;
if (wordShift == 0) {
for (uint32_t i = 0; i < _AP_N - offset; ++i) val[i] = pVal[i + offset];
for (uint32_t i = _AP_N - offset; i < _AP_N; i++) val[i] = 0;
Retval.clearUnusedBits();
return Retval;
}
uint32_t breakWord = _AP_N - offset - 1;
for (uint32_t i = 0; i < breakWord; ++i)
val[i] = ((pVal[i + offset]) >> (wordShift)) |
((pVal[i + offset + 1]) << (APINT_BITS_PER_WORD - wordShift));
val[breakWord] = (pVal[breakWord + offset]) >> (wordShift);
for (int i = breakWord + 1; i < _AP_N; ++i) val[i] = 0;
Retval.clearUnusedBits();
return Retval;
}
inline ap_private shl(uint32_t shiftAmt) const {
# 4908 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 4908 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
shiftAmt <= BitWidth && "Invalid shift amount, too big"
# 4908 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 4908 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"shiftAmt <= BitWidth && \"Invalid shift amount, too big\""
# 4908 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 4908, __PRETTY_FUNCTION__))
# 4908 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
if (shiftAmt == BitWidth) return ap_private(0);
if (shiftAmt == 0) return ap_private(*this);
ap_private Retval(0);
uint64_t* val = Retval.get_pVal();
if (shiftAmt < APINT_BITS_PER_WORD) {
uint64_t carry = 0;
for (int i = 0; i < _AP_N; i++) {
val[i] = ((pVal[i]) << (shiftAmt)) | carry;
carry = (pVal[i]) >> (APINT_BITS_PER_WORD - shiftAmt);
}
Retval.clearUnusedBits();
return Retval;
}
uint32_t wordShift = shiftAmt % APINT_BITS_PER_WORD;
uint32_t offset = shiftAmt / APINT_BITS_PER_WORD;
if (wordShift == 0) {
for (uint32_t i = 0; i < offset; i++) val[i] = 0;
for (int i = offset; i < _AP_N; i++) val[i] = pVal[i - offset];
Retval.clearUnusedBits();
return Retval;
}
uint32_t i = _AP_N - 1;
for (; i > offset; --i)
val[i] = (pVal[i - offset]) << (wordShift) |
(pVal[i - offset - 1]) >> (APINT_BITS_PER_WORD - wordShift);
val[offset] = (pVal[0]) << (wordShift);
for (i = 0; i < offset; ++i) val[i] = 0;
Retval.clearUnusedBits();
return Retval;
}
inline ap_private rotl(uint32_t rotateAmt) const {
if (rotateAmt == 0) return ap_private(*this);
ap_private hi(*this);
ap_private lo(*this);
hi.shl(rotateAmt);
lo.lshr(BitWidth - rotateAmt);
return hi | lo;
}
inline ap_private rotr(uint32_t rotateAmt) const {
if (rotateAmt == 0) return ap_private(*this);
ap_private hi(*this);
ap_private lo(*this);
lo.lshr(rotateAmt);
hi.shl(BitWidth - rotateAmt);
return hi | lo;
}
inline ap_private udiv(const ap_private& RHS) const {
uint32_t rhsBits = RHS.getActiveBits();
uint32_t rhsWords = !rhsBits ? 0 : (whichWord(rhsBits - 1) + 1);
# 4986 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 4986 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
rhsWords && "Divided by zero???"
# 4986 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 4986 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"rhsWords && \"Divided by zero???\""
# 4986 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 4986, __PRETTY_FUNCTION__))
# 4986 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
uint32_t lhsBits = this->getActiveBits();
uint32_t lhsWords = !lhsBits ? 0 : (whichWord(lhsBits - 1) + 1);
if (!lhsWords)
return ap_private(0);
else if (lhsWords < rhsWords || this->ult(RHS)) {
return ap_private(0);
} else if (*this == RHS) {
return ap_private(1);
} else if (lhsWords == 1 && rhsWords == 1) {
return ap_private(this->pVal[0] / RHS.get_pVal(0));
}
ap_private Quotient(0);
ap_private_ops::divide(*this, lhsWords, RHS, rhsWords, &Quotient,
(ap_private*)0);
return Quotient;
}
inline ap_private sdiv(const ap_private& RHS) const {
if (isNegative())
if (RHS.isNegative())
return (-(*this)).udiv(-RHS);
else
return -((-(*this)).udiv(RHS));
else if (RHS.isNegative())
return -(this->udiv((ap_private)(-RHS)));
return this->udiv(RHS);
}
# 5033 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
inline ap_private urem(const ap_private& RHS) const {
uint32_t lhsBits = getActiveBits();
uint32_t lhsWords = !lhsBits ? 0 : (whichWord(lhsBits - 1) + 1);
uint32_t rhsBits = RHS.getActiveBits();
uint32_t rhsWords = !rhsBits ? 0 : (whichWord(rhsBits - 1) + 1);
# 5041 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 5041 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
rhsWords && "Performing remainder operation by zero ???"
# 5041 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 5041 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"rhsWords && \"Performing remainder operation by zero ???\""
# 5041 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 5041, __PRETTY_FUNCTION__))
# 5041 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
if (lhsWords == 0) {
return ap_private(0);
} else if (lhsWords < rhsWords || this->ult(RHS)) {
return *this;
} else if (*this == RHS) {
return ap_private(0);
} else if (lhsWords == 1) {
return ap_private(pVal[0] % RHS.get_pVal(0));
}
ap_private Remainder(0);
ap_private_ops::divide(*this, lhsWords, RHS, rhsWords, (ap_private*)(0),
&Remainder);
return Remainder;
}
inline ap_private urem(uint64_t RHS) const {
uint32_t lhsBits = getActiveBits();
uint32_t lhsWords = !lhsBits ? 0 : (whichWord(lhsBits - 1) + 1);
uint32_t rhsWords = 1;
# 5072 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 5072 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
rhsWords && "Performing remainder operation by zero ???"
# 5072 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 5072 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"rhsWords && \"Performing remainder operation by zero ???\""
# 5072 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 5072, __PRETTY_FUNCTION__))
# 5072 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
if (lhsWords == 0) {
return ap_private(0);
} else if (lhsWords < rhsWords || this->ult(RHS)) {
return *this;
} else if (*this == RHS) {
return ap_private(0);
} else if (lhsWords == 1) {
return ap_private(pVal[0] % RHS);
}
ap_private Remainder(0);
divide(*this, lhsWords, RHS, (ap_private*)(0), &Remainder);
return Remainder;
}
inline ap_private srem(const ap_private& RHS) const {
if (isNegative()) {
ap_private lhs = -(*this);
if (RHS.isNegative()) {
ap_private rhs = -RHS;
return -(lhs.urem(rhs));
} else
return -(lhs.urem(RHS));
} else if (RHS.isNegative()) {
ap_private rhs = -RHS;
return this->urem(rhs);
}
return this->urem(RHS);
}
inline ap_private srem(int64_t RHS) const {
if (isNegative())
if (RHS < 0)
return -((-(*this)).urem(-RHS));
else
return -((-(*this)).urem(RHS));
else if (RHS < 0)
return this->urem(-RHS);
return this->urem(RHS);
}
template <bool _AP_S1>
inline bool eq(const ap_private<_AP_W, _AP_S1>& RHS) const {
return (*this) == RHS;
}
template <bool _AP_S1>
inline bool ne(const ap_private<_AP_W, _AP_S1>& RHS) const {
return !((*this) == RHS);
}
template <bool _AP_S1>
inline bool ult(const ap_private<_AP_W, _AP_S1>& RHS) const {
uint32_t n1 = getActiveBits();
uint32_t n2 = RHS.getActiveBits();
if (n1 < n2) return true;
if (n2 < n1) return false;
if (n1 <= APINT_BITS_PER_WORD && n2 <= APINT_BITS_PER_WORD)
return pVal[0] < RHS.get_pVal(0);
uint32_t topWord = whichWord(AESL_std::max(n1, n2) - 1);
for (int i = topWord; i >= 0; --i) {
if (pVal[i] > RHS.get_pVal(i)) return false;
if (pVal[i] < RHS.get_pVal(i)) return true;
}
return false;
}
inline bool ult(uint64_t RHS) const {
uint32_t n1 = getActiveBits();
uint32_t n2 =
64 - ap_private_ops::CountLeadingZeros_64(RHS);
if (n1 < n2) return true;
if (n2 < n1) return false;
if (n1 <= APINT_BITS_PER_WORD && n2 <= APINT_BITS_PER_WORD)
return pVal[0] < RHS;
# 5186 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 5186 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
0
# 5186 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 5186 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"0"
# 5186 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 5186, __PRETTY_FUNCTION__))
# 5186 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
}
template <bool _AP_S1>
inline bool slt(const ap_private<_AP_W, _AP_S1>& RHS) const {
ap_private lhs(*this);
ap_private<_AP_W, _AP_S1> rhs(RHS);
bool lhsNeg = isNegative();
bool rhsNeg = rhs.isNegative();
if (lhsNeg) {
lhs.flip();
lhs++;
}
if (rhsNeg) {
rhs.flip();
rhs++;
}
if (lhsNeg)
if (rhsNeg)
return lhs.ugt(rhs);
else
return true;
else if (rhsNeg)
return false;
else
return lhs.ult(rhs);
}
template <bool _AP_S1>
inline bool ule(const ap_private<_AP_W, _AP_S1>& RHS) const {
return ult(RHS) || eq(RHS);
}
template <bool _AP_S1>
inline bool sle(const ap_private<_AP_W, _AP_S1>& RHS) const {
return slt(RHS) || eq(RHS);
}
template <bool _AP_S1>
inline bool ugt(const ap_private<_AP_W, _AP_S1>& RHS) const {
return !ult(RHS) && !eq(RHS);
}
template <bool _AP_S1>
inline bool sgt(const ap_private<_AP_W, _AP_S1>& RHS) const {
return !slt(RHS) && !eq(RHS);
}
template <bool _AP_S1>
inline bool uge(const ap_private<_AP_W, _AP_S>& RHS) const {
return !ult(RHS);
}
template <bool _AP_S1>
inline bool sge(const ap_private<_AP_W, _AP_S1>& RHS) const {
return !slt(RHS);
}
template <int _AP_W1, bool _AP_S1>
inline void cpSext(const ap_private<_AP_W1, _AP_S1>& that) {
# 5276 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 5276 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
_AP_W1 < BitWidth && "Invalid ap_private SignExtend request"
# 5276 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 5276 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"_AP_W1 < BitWidth && \"Invalid ap_private SignExtend request\""
# 5276 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 5276, __PRETTY_FUNCTION__))
# 5276 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
# 5277 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 5277 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
_AP_W1 <= MAX_INT_BITS && "Too many bits"
# 5277 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 5277 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"_AP_W1 <= MAX_INT_BITS && \"Too many bits\""
# 5277 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 5277, __PRETTY_FUNCTION__))
# 5277 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
if (!that.isNegative()) {
cpZext(that);
return;
}
enum { wordBits = _AP_W1 % APINT_BITS_PER_WORD };
const int _AP_N1 = ap_private<_AP_W1, _AP_S1>::_AP_N;
if (_AP_N1 == _AP_N) {
enum { newWordBits = _AP_W % APINT_BITS_PER_WORD };
static const uint64_t mask = wordBits ? (~0ULL << (wordBits)) : 0ULL;
for (int i = 0; i < _AP_N; ++i) pVal[i] = that.get_pVal(i);
pVal[_AP_N - 1] |= mask;
return;
}
enum { newWordBits = _AP_W % APINT_BITS_PER_WORD };
static const uint64_t mask = wordBits ? (~0ULL << (wordBits)) : 0ULL;
int i;
for (i = 0; i < _AP_N1; ++i) pVal[i] = that.get_pVal(i);
pVal[i - 1] |= mask;
for (; i < _AP_N - 1; i++) pVal[i] = ~0ULL;
pVal[i] = ~0ULL;
clearUnusedBits();
return;
}
template <int _AP_W1, bool _AP_S1>
inline void cpZext(const ap_private<_AP_W1, _AP_S1>& that) {
# 5312 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 5312 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
_AP_W1 < BitWidth && "Invalid ap_private ZeroExtend request"
# 5312 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 5312 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"_AP_W1 < BitWidth && \"Invalid ap_private ZeroExtend request\""
# 5312 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 5312, __PRETTY_FUNCTION__))
# 5312 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
# 5313 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 5313 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
_AP_W1 <= MAX_INT_BITS && "Too many bits"
# 5313 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 5313 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"_AP_W1 <= MAX_INT_BITS && \"Too many bits\""
# 5313 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 5313, __PRETTY_FUNCTION__))
# 5313 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
const int _AP_N1 = ap_private<_AP_W1, _AP_S1>::_AP_N;
int i = 0;
for (; i < _AP_N1; ++i) pVal[i] = that.get_pVal(i);
for (; i < _AP_N; ++i) pVal[i] = 0;
clearUnusedBits();
}
template <int _AP_W1, bool _AP_S1>
inline void cpZextOrTrunc(const ap_private<_AP_W1, _AP_S1>& that) {
if (BitWidth > _AP_W1)
cpZext(that);
else {
for (int i = 0; i < _AP_N; ++i) pVal[i] = that.get_pVal(i);
clearUnusedBits();
}
}
template <int _AP_W1, bool _AP_S1>
inline void cpSextOrTrunc(const ap_private<_AP_W1, _AP_S1>& that) {
if (BitWidth > _AP_W1)
cpSext(that);
else {
for (int i = 0; i < _AP_N; ++i) pVal[i] = that.get_pVal(i);
clearUnusedBits();
}
}
inline uint32_t getBitWidth() const { return BitWidth; }
inline uint32_t getNumWords() const {
return (BitWidth + APINT_BITS_PER_WORD - 1) / APINT_BITS_PER_WORD;
}
inline uint32_t getActiveBits() const {
uint32_t bits = BitWidth - countLeadingZeros();
return bits ? bits : 1;
}
inline uint64_t getZExtValue() const {
# 5370 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 5370 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
getActiveBits() <= 64 && "Too many bits for uint64_t"
# 5370 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 5370 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"getActiveBits() <= 64 && \"Too many bits for uint64_t\""
# 5370 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 5370, __PRETTY_FUNCTION__))
# 5370 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
return *pVal;
}
inline int64_t getSExtValue() const {
# 5380 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 5380 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
getActiveBits() <= 64 && "Too many bits for int64_t"
# 5380 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 5380 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"getActiveBits() <= 64 && \"Too many bits for int64_t\""
# 5380 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 5380, __PRETTY_FUNCTION__))
# 5380 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
return int64_t(pVal[0]);
}
inline static uint32_t getBitsNeeded(const char* str, uint32_t slen,
uint8_t radix) {
# 5389 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 5389 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
str != 0 && "Invalid value string"
# 5389 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 5389 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"str != 0 && \"Invalid value string\""
# 5389 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 5389, __PRETTY_FUNCTION__))
# 5389 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
# 5390 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 5390 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
slen > 0 && "Invalid string length"
# 5390 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 5390 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"slen > 0 && \"Invalid string length\""
# 5390 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 5390, __PRETTY_FUNCTION__))
# 5390 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
uint32_t isNegative = str[0] == '-';
if (isNegative) {
slen--;
str++;
}
if (radix == 2) return slen + isNegative;
if (radix == 8) return slen * 3 + isNegative;
if (radix == 16) return slen * 4 + isNegative;
# 5405 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 5405 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
radix == 10 && "Invalid radix"
# 5405 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 5405 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"radix == 10 && \"Invalid radix\""
# 5405 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 5405, __PRETTY_FUNCTION__))
# 5405 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
return isNegative + slen * 4;
}
inline uint32_t countLeadingZeros() const {
enum {
msw_bits = (BitWidth % APINT_BITS_PER_WORD)
? (BitWidth % APINT_BITS_PER_WORD)
: APINT_BITS_PER_WORD,
excessBits = APINT_BITS_PER_WORD - msw_bits
};
uint32_t Count = ap_private_ops::CountLeadingZeros_64(pVal[_AP_N - 1]);
if (Count >= excessBits) Count -= excessBits;
if (!pVal[_AP_N - 1]) {
for (int i = _AP_N - 1; i; --i) {
if (!pVal[i - 1])
Count += APINT_BITS_PER_WORD;
else {
Count += ap_private_ops::CountLeadingZeros_64(pVal[i - 1]);
break;
}
}
}
return Count;
}
inline uint32_t countLeadingOnes() const {
if (isSingleWord())
return countLeadingOnes_64(get_VAL(), APINT_BITS_PER_WORD - BitWidth);
uint32_t highWordBits = BitWidth % APINT_BITS_PER_WORD;
uint32_t shift =
(highWordBits == 0 ? 0 : APINT_BITS_PER_WORD - highWordBits);
int i = _AP_N - 1;
uint32_t Count = countLeadingOnes_64(get_pVal(i), shift);
if (Count == highWordBits) {
for (i--; i >= 0; --i) {
if (get_pVal(i) == ~0ULL)
Count += APINT_BITS_PER_WORD;
else {
Count += countLeadingOnes_64(get_pVal(i), 0);
break;
}
}
}
return Count;
}
# 5477 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
inline uint32_t countTrailingZeros() const {
uint32_t Count = 0;
uint32_t i = 0;
for (; i < _AP_N && get_pVal(i) == 0; ++i) Count += APINT_BITS_PER_WORD;
if (i < _AP_N) Count += ap_private_ops::CountTrailingZeros_64(get_pVal(i));
return AESL_std::min(Count, BitWidth);
}
inline uint32_t countPopulation() const {
uint32_t Count = 0;
for (int i = 0; i < _AP_N - 1; ++i)
Count += ap_private_ops::CountPopulation_64(pVal[i]);
Count += ap_private_ops::CountPopulation_64(pVal[_AP_N - 1] & mask);
return Count;
}
inline std::string toString(uint8_t radix, bool wantSigned) const;
inline std::string toStringUnsigned(uint8_t radix = 10) const {
return toString(radix, false);
}
inline std::string toStringSigned(uint8_t radix = 10) const {
return toString(radix, true);
}
inline double roundToDouble(bool isSigned) const {
if (isSingleWord() || getActiveBits() <= APINT_BITS_PER_WORD) {
uint64_t val = pVal[0];
if (isSigned) {
int64_t sext = ((int64_t(val)) << (64 - BitWidth)) >> (64 - BitWidth);
return double(sext);
} else
return double(val);
}
bool isNeg = isSigned ? (*this)[BitWidth - 1] : false;
ap_private<_AP_W, _AP_S> Tmp(isNeg ? -(*this) : (*this));
uint32_t n = Tmp.getActiveBits();
uint64_t exp = n;
if (exp > 1023) {
if (!isSigned || !isNeg)
return std::numeric_limits<double>::infinity();
else
return -std::numeric_limits<double>::infinity();
}
exp += 1023;
uint64_t mantissa;
unsigned hiWord = whichWord(n - 1);
if (hiWord == 0) {
mantissa = Tmp.get_pVal(0);
if (n > 52)
(mantissa) >>= (n - 52);
} else {
# 5568 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 5568 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
hiWord > 0 && "High word is negative?"
# 5568 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 5568 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"hiWord > 0 && \"High word is negative?\""
# 5568 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 5568, __PRETTY_FUNCTION__))
# 5568 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
uint64_t hibits = (Tmp.get_pVal(hiWord))
<< (52 - n % APINT_BITS_PER_WORD);
uint64_t lobits =
(Tmp.get_pVal(hiWord - 1)) >> (11 + n % APINT_BITS_PER_WORD);
mantissa = hibits | lobits;
}
uint64_t sign = isNeg ? (1ULL << (APINT_BITS_PER_WORD - 1)) : 0;
union {
double __D;
uint64_t __I;
} __T;
__T.__I = sign | ((exp) << 52) | mantissa;
return __T.__D;
}
inline double roundToDouble() const { return roundToDouble(false); }
inline double signedRoundToDouble() const { return roundToDouble(true); }
inline double bitsToDouble() const {
union {
uint64_t __I;
double __D;
} __T;
__T.__I = pVal[0];
return __T.__D;
}
inline float bitsToFloat() const {
union {
uint32_t __I;
float __F;
} __T;
__T.__I = uint32_t(pVal[0]);
return __T.__F;
}
inline ap_private& doubleToBits(double __V) {
union {
uint64_t __I;
double __D;
} __T;
__T.__D = __V;
pVal[0] = __T.__I;
return *this;
}
inline ap_private& floatToBits(float __V) {
union {
uint32_t __I;
float __F;
} __T;
__T.__F = __V;
pVal[0] = __T.__I;
}
inline bool and_reduce() const { return isMaxValue(); }
inline bool nand_reduce() const { return isMinValue(); }
inline bool or_reduce() const { return (bool)countPopulation(); }
inline bool nor_reduce() const { return countPopulation() == 0; }
inline bool xor_reduce() const {
unsigned int i = countPopulation();
return (i % 2) ? true : false;
}
inline bool xnor_reduce() const {
unsigned int i = countPopulation();
return (i % 2) ? false : true;
}
inline std::string to_string(uint8_t radix = 16, bool sign = false) const {
return toString(radix, radix == 10 ? _AP_S : sign);
}
};
namespace ap_private_ops {
enum { APINT_BITS_PER_WORD = 64 };
template <int _AP_W, bool _AP_S>
inline bool operator==(uint64_t V1, const ap_private<_AP_W, _AP_S>& V2) {
return V2 == V1;
}
template <int _AP_W, bool _AP_S>
inline bool operator!=(uint64_t V1, const ap_private<_AP_W, _AP_S>& V2) {
return V2 != V1;
}
template <int _AP_W, bool _AP_S, int index>
inline bool get(const ap_private<_AP_W, _AP_S>& a) {
static const uint64_t mask = 1ULL << (index & 0x3f);
return ((mask & a.get_pVal((index) >> 6)) != 0);
}
template <int _AP_W, bool _AP_S, int msb_index, int lsb_index>
inline void set(ap_private<_AP_W, _AP_S>& a,
const ap_private<((msb_index) > (1) ? (msb_index) : (1)), true>& mark1 = 0,
const ap_private<((lsb_index) > (1) ? (lsb_index) : (1)), true>& mark2 = 0) {
enum {
APINT_BITS_PER_WORD = 64,
lsb_word = lsb_index / APINT_BITS_PER_WORD,
msb_word = msb_index / APINT_BITS_PER_WORD,
msb = msb_index % APINT_BITS_PER_WORD,
lsb = lsb_index % APINT_BITS_PER_WORD
};
if (msb_word == lsb_word) {
const uint64_t mask = ~0ULL >>
(lsb) << (APINT_BITS_PER_WORD - msb + lsb - 1) >>
(APINT_BITS_PER_WORD - msb - 1);
a.get_pVal(msb_word) |= mask;
} else {
const uint64_t lsb_mask = ~0ULL >> (lsb) << (lsb);
const uint64_t msb_mask = ~0ULL << (APINT_BITS_PER_WORD - msb - 1) >>
(APINT_BITS_PER_WORD - msb - 1);
a.get_pVal(lsb_word) |= lsb_mask;
for (int i = lsb_word + 1; i < msb_word; i++) {
a.set_pVal(i, ~0ULL);
}
a.get_pVal(msb_word) |= msb_mask;
}
a.clearUnusedBits();
}
template <int _AP_W, bool _AP_S, int msb_index, int lsb_index>
inline void clear(ap_private<_AP_W, _AP_S>& a,
const ap_private<((msb_index) > (1) ? (msb_index) : (1)), true>& mark1 = 0,
const ap_private<((lsb_index) > (1) ? (lsb_index) : (1)), true>& mark2 = 0) {
enum {
APINT_BITS_PER_WORD = 64,
lsb_word = lsb_index / APINT_BITS_PER_WORD,
msb_word = msb_index / APINT_BITS_PER_WORD,
msb = msb_index % APINT_BITS_PER_WORD,
lsb = lsb_index % APINT_BITS_PER_WORD
};
if (msb_word == lsb_word) {
const uint64_t mask =
~(~0ULL >> (lsb) << (APINT_BITS_PER_WORD - msb + lsb - 1) >>
(APINT_BITS_PER_WORD - msb - 1));
a.get_pVal(msb_word) &= mask;
} else {
const uint64_t lsb_mask = ~(~0ULL >> (lsb) << (lsb));
const uint64_t msb_mask = ~(~0ULL << (APINT_BITS_PER_WORD - msb - 1) >>
(APINT_BITS_PER_WORD - msb - 1));
a.get_pVal(lsb_word) &= lsb_mask;
for (int i = lsb_word + 1; i < msb_word; i++) {
a.get_pVal(i) = 0;
}
a.get_pVal(msb_word) &= msb_mask;
}
a.clearUnusedBits();
}
template <int _AP_W, bool _AP_S, int index>
inline void set(ap_private<_AP_W, _AP_S>& a,
const ap_private<((index) > (1) ? (index) : (1)), true>& mark = 0) {
enum { APINT_BITS_PER_WORD = 64, word = index / APINT_BITS_PER_WORD };
static const uint64_t mask = 1ULL << (index % APINT_BITS_PER_WORD);
a.get_pVal(word) |= mask;
a.clearUnusedBits();
}
template <int _AP_W, bool _AP_S, int index>
inline void clear(ap_private<_AP_W, _AP_S>& a,
const ap_private<((index) > (1) ? (index) : (1)), true>& mark = 0) {
enum { APINT_BITS_PER_WORD = 64, word = index / APINT_BITS_PER_WORD };
static const uint64_t mask = ~(1ULL << (index % APINT_BITS_PER_WORD));
a.get_pVal(word) &= mask;
a.clearUnusedBits();
}
}
template <int _AP_W, bool _AP_S>
inline std::string ap_private<_AP_W, _AP_S, false>::toString(
uint8_t radix, bool wantSigned) const {
# 5780 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 5780 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
(radix == 10 || radix == 8 || radix == 16 || radix == 2) && "Radix should be 2, 8, 10, or 16!"
# 5780 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 5780 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"(radix == 10 || radix == 8 || radix == 16 || radix == 2) && \"Radix should be 2, 8, 10, or 16!\""
# 5780 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
,
"/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
# 5780 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
,
5781
# 5780 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, __PRETTY_FUNCTION__))
# 5781 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
static const char* digits[] = {"0", "1", "2", "3", "4", "5", "6", "7",
"8", "9", "A", "B", "C", "D", "E", "F"};
std::string result;
if (radix != 10) {
if (*this == (uint64_t)(0))
result = "0";
else {
ap_private<_AP_W, false> tmp(*this);
size_t insert_at = 0;
bool leading_zero = true;
if (wantSigned && isNegative()) {
tmp.flip();
tmp++;
tmp.clearUnusedBitsToZero();
result = "-";
insert_at = 1;
leading_zero = false;
}
switch (radix) {
case 2:
result += "0b";
break;
case 8:
result += "0o";
break;
case 16:
result += "0x";
break;
default:
# 5820 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 5820 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"invalid radix" && 0
# 5820 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 5820 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"\"invalid radix\" && 0"
# 5820 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 5820, __PRETTY_FUNCTION__))
# 5820 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
}
insert_at += 2;
uint32_t shift = (radix == 16 ? 4 : (radix == 8 ? 3 : 1));
uint64_t mask = radix - 1;
ap_private<_AP_W, false> zero(0);
unsigned bits = 0;
while (tmp.ne(zero)) {
uint64_t digit = tmp.get_VAL() & mask;
result.insert(insert_at, digits[digit]);
tmp = tmp.lshr(shift);
++bits;
}
bits *= shift;
if (bits < _AP_W && leading_zero) result.insert(insert_at, digits[0]);
}
return result;
}
ap_private<_AP_W, false> tmp(*this);
ap_private<_AP_W, false> divisor(radix);
ap_private<_AP_W, false> zero(0);
size_t insert_at = 0;
if (wantSigned && isNegative()) {
tmp.flip();
tmp++;
tmp.clearUnusedBitsToZero();
result = "-";
insert_at = 1;
}
if (tmp == ap_private<_AP_W, false>(0))
result = "0";
else
while (tmp.ne(zero)) {
ap_private<_AP_W, false> APdigit(0);
ap_private<_AP_W, false> tmp2(0);
ap_private_ops::divide(tmp, tmp.getNumWords(), divisor,
divisor.getNumWords(), &tmp2, &APdigit);
uint64_t digit = APdigit.getZExtValue();
# 5863 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
((
# 5863 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
digit < radix && "divide failed"
# 5863 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 5863 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
"digit < radix && \"divide failed\""
# 5863 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h", 5863, __PRETTY_FUNCTION__))
# 5863 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
;
result.insert(insert_at, digits[digit]);
tmp = tmp2;
}
return result;
}
template <int _AP_W, bool _AP_S>
std::ostream &operator<<(std::ostream &os, const ap_private<_AP_W, _AP_S> &x) {
std::ios_base::fmtflags ff = std::cout.flags();
if (ff & std::cout.hex) {
os << x.toString(16, false);
} else if (ff & std::cout.oct) {
os << x.toString(8, false);
} else {
os << x.toString(10, _AP_S);
}
return os;
}
# 6128 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
template <int _AP_W, bool _AP_S>
struct _private_range_ref {
ap_private<_AP_W, _AP_S>& d_bv;
int l_index;
int h_index;
public:
inline _private_range_ref(const _private_range_ref<_AP_W, _AP_S>& ref)
: d_bv(ref.d_bv), l_index(ref.l_index), h_index(ref.h_index) {}
inline _private_range_ref(ap_private<_AP_W, _AP_S>* bv, int h, int l)
: d_bv(*bv), l_index(l), h_index(h) {
do { if ((h < 0 || l < 0)) { fprintf(
# 6145 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
stderr
# 6145 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
, "WARNING: " "Higher bound (%d) and lower bound (%d) cannot be " "negative.", h, l); fprintf(
# 6145 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
stderr
# 6145 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
, "\n"); } } while (0)
;
do { if ((h >= _AP_W || l >= _AP_W)) { fprintf(
# 6149 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
stderr
# 6149 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
, "WARNING: " "Higher bound (%d) or lower bound (%d) out of range (%d).", h, l, _AP_W); fprintf(
# 6149 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
stderr
# 6149 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
, "\n"); } } while (0)
;
}
template <int _AP_W2, bool _AP_S2>
inline _private_range_ref<_AP_W, _AP_S>& operator|=(
const _private_range_ref<_AP_W2, _AP_S2>& ref) {
do { if (((h_index - l_index) != (ref.h_index - ref.l_index))) { fprintf(
# 6158 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
stderr
# 6158 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
, "WARNING: " "Bitsize mismach for ap_private<>.range() &= " "ap_private<>.range()."); fprintf(
# 6158 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
stderr
# 6158 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
, "\n"); } } while (0)
;
this->d_bv |= ref.d_bv;
return *this;
}
template <int _AP_W2, bool _AP_S2>
inline _private_range_ref<_AP_W, _AP_S>& operator|=(
const ssdm_int_sim<_AP_W2, _AP_S2>& ref) {
do { if (((h_index - l_index + 1) != _AP_W2)) { fprintf(
# 6169 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
stderr
# 6169 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
, "WARNING: " "Bitsize mismach for ap_private<>.range() |= _AP_ROOT_TYPE<>."); fprintf(
# 6169 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
stderr
# 6169 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
, "\n"); } } while (0)
;
this->d_bv |= ref.V;
return *this;
}
template <int _AP_W2, bool _AP_S2>
inline _private_range_ref<_AP_W, _AP_S>& operator&=(
const _private_range_ref<_AP_W2, _AP_S2>& ref) {
do { if (((h_index - l_index) != (ref.h_index - ref.l_index))) { fprintf(
# 6179 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
stderr
# 6179 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
, "WARNING: " "Bitsize mismach for ap_private<>.range() &= " "ap_private<>.range()."); fprintf(
# 6179 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
stderr
# 6179 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
, "\n"); } } while (0)
;
this->d_bv &= ref.d_bv;
return *this;
};
template <int _AP_W2, bool _AP_S2>
inline _private_range_ref<_AP_W, _AP_S>& operator&=(
const ssdm_int_sim<_AP_W2, _AP_S2>& ref) {
do { if (((h_index - l_index + 1) != _AP_W2)) { fprintf(
# 6190 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
stderr
# 6190 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
, "WARNING: " "Bitsize mismach for ap_private<>.range() &= _AP_ROOT_TYPE<>."); fprintf(
# 6190 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
stderr
# 6190 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
, "\n"); } } while (0)
;
this->d_bv &= ref.V;
return *this;
}
template <int _AP_W2, bool _AP_S2>
inline _private_range_ref<_AP_W, _AP_S>& operator^=(
const _private_range_ref<_AP_W2, _AP_S2>& ref) {
do { if (((h_index - l_index) != (ref.h_index - ref.l_index))) { fprintf(
# 6200 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
stderr
# 6200 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
, "WARNING: " "Bitsize mismach for ap_private<>.range() ^= " "ap_private<>.range()."); fprintf(
# 6200 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
stderr
# 6200 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
, "\n"); } } while (0)
;
this->d_bv ^= ref.d_bv;
return *this;
};
template <int _AP_W2, bool _AP_S2>
inline _private_range_ref<_AP_W, _AP_S>& operator^=(
const ssdm_int_sim<_AP_W2, _AP_S2>& ref) {
do { if (((h_index - l_index + 1) != _AP_W2)) { fprintf(
# 6211 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
stderr
# 6211 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
, "WARNING: " "Bitsize mismach for ap_private<>.range() ^= _AP_ROOT_TYPE<>."); fprintf(
# 6211 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
stderr
# 6211 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
, "\n"); } } while (0)
;
this->d_bv ^= ref.V;
return *this;
}
inline operator ap_private<_AP_W, false>() const {
ap_private<_AP_W, false> val(0);
if (h_index >= l_index) {
if (_AP_W > 64) {
val = d_bv;
ap_private<_AP_W, false> mask(-1);
mask >>= _AP_W - (h_index - l_index + 1);
val >>= l_index;
val &= mask;
} else {
const static uint64_t mask = (~0ULL >> (64 > _AP_W ? (64 - _AP_W) : 0));
val = (d_bv >> l_index) & (mask >> (_AP_W - (h_index - l_index + 1)));
}
} else {
for (int i = 0, j = l_index; j >= 0 && j >= h_index; j--, i++)
if ((d_bv)[j]) val.set(i);
}
return val;
}
inline operator unsigned long long() const { return to_uint64(); }
template <int _AP_W2, bool _AP_S2>
inline _private_range_ref& operator=(const ap_private<_AP_W2, _AP_S2>& val) {
ap_private<_AP_W, false> vval = ap_private<_AP_W, false>(val);
if (l_index > h_index) {
for (int i = 0, j = l_index; j >= 0 && j >= h_index; j--, i++)
(vval)[i] ? d_bv.set(j) : d_bv.clear(j);
} else {
if (_AP_W > 64) {
ap_private<_AP_W, false> mask(-1);
if (l_index > 0) {
mask <<= l_index;
vval <<= l_index;
}
if (h_index < _AP_W - 1) {
ap_private<_AP_W, false> mask2(-1);
mask2 >>= _AP_W - h_index - 1;
mask &= mask2;
vval &= mask2;
}
mask.flip();
d_bv &= mask;
d_bv |= vval;
} else {
unsigned shift = 64 - _AP_W;
uint64_t mask = ~0ULL >> (shift);
if (l_index > 0) {
vval = mask & vval << l_index;
mask = mask & mask << l_index;
}
if (h_index < _AP_W - 1) {
uint64_t mask2 = mask;
mask2 >>= (_AP_W - h_index - 1);
mask &= mask2;
vval &= mask2;
}
mask = ~mask;
d_bv &= mask;
d_bv |= vval;
}
}
return *this;
}
inline _private_range_ref& operator=(unsigned long long val) {
const ap_private<_AP_W, _AP_S> vval = val;
return operator=(vval);
}
template <int _AP_W2, bool _AP_S2>
inline _private_range_ref& operator=(
const _private_bit_ref<_AP_W2, _AP_S2>& val) {
return operator=((unsigned long long)(bool)val);
}
template <int _AP_W2, bool _AP_S2>
inline _private_range_ref& operator=(
const _private_range_ref<_AP_W2, _AP_S2>& val) {
const ap_private<_AP_W, false> tmpVal(val);
return operator=(tmpVal);
}
# 6312 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.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 _private_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().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 _private_range_ref& operator=(
const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& val) {
return operator=(val.operator ap_int_base<_AP_W2, false>().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 _private_range_ref& operator=(
const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& val) {
return operator=((unsigned long long)(bool)val);
}
# 6405 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
template <int _AP_W2, bool _AP_S2>
inline bool operator==(const _private_range_ref<_AP_W2, _AP_S2>& op2) {
ap_private<_AP_W, false> lhs = get();
ap_private<_AP_W2, false> rhs = op2.get();
return lhs == rhs;
}
template <int _AP_W2, bool _AP_S2>
inline bool operator!=(const _private_range_ref<_AP_W2, _AP_S2>& op2) {
ap_private<_AP_W, false> lhs = get();
ap_private<_AP_W2, false> rhs = op2.get();
return lhs != rhs;
}
template <int _AP_W2, bool _AP_S2>
inline bool operator>(const _private_range_ref<_AP_W2, _AP_S2>& op2) {
ap_private<_AP_W, false> lhs = get();
ap_private<_AP_W2, false> rhs = op2.get();
return lhs > rhs;
}
template <int _AP_W2, bool _AP_S2>
inline bool operator>=(const _private_range_ref<_AP_W2, _AP_S2>& op2) {
ap_private<_AP_W, false> lhs = get();
ap_private<_AP_W2, false> rhs = op2.get();
return lhs >= rhs;
}
template <int _AP_W2, bool _AP_S2>
inline bool operator<(const _private_range_ref<_AP_W2, _AP_S2>& op2) {
ap_private<_AP_W, false> lhs = get();
ap_private<_AP_W2, false> rhs = op2.get();
return lhs < rhs;
}
template <int _AP_W2, bool _AP_S2>
inline bool operator<=(const _private_range_ref<_AP_W2, _AP_S2>& op2) {
ap_private<_AP_W, false> lhs = get();
ap_private<_AP_W2, false> rhs = op2.get();
return lhs <= rhs;
}
template <int _AP_W2>
inline void set(const ap_private<_AP_W2, false>& val) {
ap_private<_AP_W, _AP_S> vval = val;
if (l_index > h_index) {
for (int i = 0, j = l_index; j >= 0 && j >= h_index; j--, i++)
(vval)[i] ? d_bv.set(j) : d_bv.clear(j);
} else {
if (_AP_W > 64) {
ap_private<_AP_W, _AP_S> mask(-1);
if (l_index > 0) {
ap_private<_AP_W, false> mask1(-1);
mask1 >>= _AP_W - l_index;
mask1.flip();
mask = mask1;
vval <<= l_index;
}
if (h_index < _AP_W - 1) {
ap_private<_AP_W, false> mask2(-1);
mask2 <<= h_index + 1;
mask2.flip();
mask &= mask2;
vval &= mask2;
}
mask.flip();
d_bv &= mask;
d_bv |= vval;
} else {
uint64_t mask = ~0ULL >> (64 - _AP_W);
if (l_index > 0) {
uint64_t mask1 = mask;
mask1 = mask & (mask1 >> (_AP_W - l_index));
vval = mask & (vval << l_index);
mask = ~mask1 & mask;
}
if (h_index < _AP_W - 1) {
uint64_t mask2 = ~0ULL >> (64 - _AP_W);
mask2 = mask & (mask2 << (h_index + 1));
mask &= ~mask2;
vval &= ~mask2;
}
d_bv &= (~mask & (~0ULL >> (64 - _AP_W)));
d_bv |= vval;
}
}
}
inline ap_private<_AP_W, false> get() const {
ap_private<_AP_W, false> val(0);
if (h_index < l_index) {
for (int i = 0, j = l_index; j >= 0 && j >= h_index; j--, i++)
if ((d_bv)[j]) val.set(i);
} else {
val = d_bv;
val >>= l_index;
if (h_index < _AP_W - 1) {
if (_AP_W <= 64) {
const static uint64_t mask =
(~0ULL >> (64 > _AP_W ? (64 - _AP_W) : 0));
val &= (mask >> (_AP_W - (h_index - l_index + 1)));
} else {
ap_private<_AP_W, false> mask(-1);
mask >>= _AP_W - (h_index - l_index + 1);
val &= mask;
}
}
}
return val;
}
inline ap_private<_AP_W, false> get() {
ap_private<_AP_W, false> val(0);
if (h_index < l_index) {
for (int i = 0, j = l_index; j >= 0 && j >= h_index; j--, i++)
if ((d_bv)[j]) val.set(i);
} else {
val = d_bv;
val >>= l_index;
if (h_index < _AP_W - 1) {
if (_AP_W <= 64) {
static const uint64_t mask = ~0ULL >> (64 > _AP_W ? (64 - _AP_W) : 0);
return val &= ((mask) >> (_AP_W - (h_index - l_index + 1)));
} else {
ap_private<_AP_W, false> mask(-1);
mask >>= _AP_W - (h_index - l_index + 1);
val &= mask;
}
}
}
return val;
}
inline int length() const {
return h_index >= l_index ? h_index - l_index + 1 : l_index - h_index + 1;
}
inline int to_int() const {
ap_private<_AP_W, false> val = get();
return val.to_int();
}
inline unsigned int to_uint() const {
ap_private<_AP_W, false> val = get();
return val.to_uint();
}
inline long to_long() const {
ap_private<_AP_W, false> val = get();
return val.to_long();
}
inline unsigned long to_ulong() const {
ap_private<_AP_W, false> val = get();
return val.to_ulong();
}
inline ap_slong to_int64() const {
ap_private<_AP_W, false> val = get();
return val.to_int64();
}
inline ap_ulong to_uint64() const {
ap_private<_AP_W, false> val = get();
return val.to_uint64();
}
inline std::string to_string(uint8_t radix = 2) const {
return get().to_string(radix);
}
inline bool and_reduce() {
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) ret &= d_bv[i];
return ret;
}
inline bool or_reduce() {
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) ret |= d_bv[i];
return ret;
}
inline bool xor_reduce() {
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) ret ^= d_bv[i];
return ret;
}
};
template <int _AP_W, bool _AP_S>
struct _private_bit_ref {
ap_private<_AP_W, _AP_S>& d_bv;
int d_index;
public:
inline _private_bit_ref(const _private_bit_ref<_AP_W, _AP_S>& ref)
: d_bv(ref.d_bv), d_index(ref.d_index) {}
inline _private_bit_ref(ap_private<_AP_W, _AP_S>& bv, int index = 0)
: d_bv(bv), d_index(index) {
do { if ((d_index < 0)) { fprintf(
# 6626 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
stderr
# 6626 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
, "WARNING: " "Index of bit vector (%d) cannot be negative.\n", d_index); fprintf(
# 6626 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
stderr
# 6626 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
, "\n"); } } while (0)
;
do { if ((d_index >= _AP_W)) { fprintf(
# 6628 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
stderr
# 6628 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
, "WARNING: " "Index of bit vector (%d) out of range (%d).\n", d_index, _AP_W); fprintf(
# 6628 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h" 3 4
stderr
# 6628 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
, "\n"); } } while (0)
;
}
inline operator bool() const { return d_bv.get_bit(d_index); }
inline bool to_bool() const { return operator bool(); }
template <typename T>
inline _private_bit_ref& operator=(const T& val) {
if (!!val)
d_bv.set(d_index);
else
d_bv.clear(d_index);
return *this;
}
# 6730 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
template <int _AP_W2, bool _AP_S2>
inline bool operator==(const _private_bit_ref<_AP_W2, _AP_S2>& op) const {
return get() == op.get();
}
template <int _AP_W2, bool _AP_S2>
inline bool operator!=(const _private_bit_ref<_AP_W2, _AP_S2>& op) const {
return get() != op.get();
}
inline bool get() const { return operator bool(); }
# 6752 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
inline int length() const { return 1; }
};
# 6780 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
template <typename PTR_TYPE, int _AP_W, bool _AP_S> inline PTR_TYPE* operator +(PTR_TYPE* i_op, const ap_private<_AP_W, _AP_S>& op) { typename ap_private<_AP_W, _AP_S>::ValType op2 = op; return i_op + op2; } template <typename PTR_TYPE, int _AP_W, bool _AP_S> inline PTR_TYPE* operator +(const ap_private<_AP_W, _AP_S>& op, PTR_TYPE* i_op) { typename ap_private<_AP_W, _AP_S>::ValType op2 = op; return op2 + i_op; }
template <typename PTR_TYPE, int _AP_W, bool _AP_S> inline PTR_TYPE* operator -(PTR_TYPE* i_op, const ap_private<_AP_W, _AP_S>& op) { typename ap_private<_AP_W, _AP_S>::ValType op2 = op; return i_op - op2; } template <typename PTR_TYPE, int _AP_W, bool _AP_S> inline PTR_TYPE* operator -(const ap_private<_AP_W, _AP_S>& op, PTR_TYPE* i_op) { typename ap_private<_AP_W, _AP_S>::ValType op2 = op; return op2 - i_op; }
# 6806 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
template <int _AP_W, bool _AP_S> inline float operator *(float i_op, const ap_private<_AP_W, _AP_S>& op) { typename ap_private<_AP_W, _AP_S>::ValType op2 = op; return i_op * op2; } template <int _AP_W, bool _AP_S> inline float operator *(const ap_private<_AP_W, _AP_S>& op, float i_op) { typename ap_private<_AP_W, _AP_S>::ValType op2 = op; return op2 * i_op; } template <int _AP_W, bool _AP_S> inline float operator /(float i_op, const ap_private<_AP_W, _AP_S>& op) { typename ap_private<_AP_W, _AP_S>::ValType op2 = op; return i_op / op2; } template <int _AP_W, bool _AP_S> inline float operator /(const ap_private<_AP_W, _AP_S>& op, float i_op) { typename ap_private<_AP_W, _AP_S>::ValType op2 = op; return op2 / i_op; } template <int _AP_W, bool _AP_S> inline float operator +(float i_op, const ap_private<_AP_W, _AP_S>& op) { typename ap_private<_AP_W, _AP_S>::ValType op2 = op; return i_op + op2; } template <int _AP_W, bool _AP_S> inline float operator +(const ap_private<_AP_W, _AP_S>& op, float i_op) { typename ap_private<_AP_W, _AP_S>::ValType op2 = op; return op2 + i_op; } template <int _AP_W, bool _AP_S> inline float operator -(float i_op, const ap_private<_AP_W, _AP_S>& op) { typename ap_private<_AP_W, _AP_S>::ValType op2 = op; return i_op - op2; } template <int _AP_W, bool _AP_S> inline float operator -(const ap_private<_AP_W, _AP_S>& op, float i_op) { typename ap_private<_AP_W, _AP_S>::ValType op2 = op; return op2 - i_op; }
template <int _AP_W, bool _AP_S> inline double operator *(double i_op, const ap_private<_AP_W, _AP_S>& op) { typename ap_private<_AP_W, _AP_S>::ValType op2 = op; return i_op * op2; } template <int _AP_W, bool _AP_S> inline double operator *(const ap_private<_AP_W, _AP_S>& op, double i_op) { typename ap_private<_AP_W, _AP_S>::ValType op2 = op; return op2 * i_op; } template <int _AP_W, bool _AP_S> inline double operator /(double i_op, const ap_private<_AP_W, _AP_S>& op) { typename ap_private<_AP_W, _AP_S>::ValType op2 = op; return i_op / op2; } template <int _AP_W, bool _AP_S> inline double operator /(const ap_private<_AP_W, _AP_S>& op, double i_op) { typename ap_private<_AP_W, _AP_S>::ValType op2 = op; return op2 / i_op; } template <int _AP_W, bool _AP_S> inline double operator +(double i_op, const ap_private<_AP_W, _AP_S>& op) { typename ap_private<_AP_W, _AP_S>::ValType op2 = op; return i_op + op2; } template <int _AP_W, bool _AP_S> inline double operator +(const ap_private<_AP_W, _AP_S>& op, double i_op) { typename ap_private<_AP_W, _AP_S>::ValType op2 = op; return op2 + i_op; } template <int _AP_W, bool _AP_S> inline double operator -(double i_op, const ap_private<_AP_W, _AP_S>& op) { typename ap_private<_AP_W, _AP_S>::ValType op2 = op; return i_op - op2; } template <int _AP_W, bool _AP_S> inline double operator -(const ap_private<_AP_W, _AP_S>& op, double i_op) { typename ap_private<_AP_W, _AP_S>::ValType op2 = op; return op2 - i_op; }
# 6911 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
template <int _AP_W, bool _AP_S> inline typename ap_private<(1), (false)>::template RType<_AP_W, _AP_S>::mult operator *(bool i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(1), (false)>(i_op).operator *(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(1), (false)>::mult operator *(const ap_private<_AP_W, _AP_S>& op, bool i_op) { return op.operator *(ap_private<(1), (false)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(1), (false)>::template RType<_AP_W, _AP_S>::plus operator +(bool i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(1), (false)>(i_op).operator +(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(1), (false)>::plus operator +(const ap_private<_AP_W, _AP_S>& op, bool i_op) { return op.operator +(ap_private<(1), (false)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(1), (false)>::template RType<_AP_W, _AP_S>::minus operator -(bool i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(1), (false)>(i_op).operator -(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(1), (false)>::minus operator -(const ap_private<_AP_W, _AP_S>& op, bool i_op) { return op.operator -(ap_private<(1), (false)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(1), (false)>::template RType<_AP_W, _AP_S>::div operator /(bool i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(1), (false)>(i_op).operator /(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(1), (false)>::div operator /(const ap_private<_AP_W, _AP_S>& op, bool i_op) { return op.operator /(ap_private<(1), (false)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(1), (false)>::template RType<_AP_W, _AP_S>::mod operator %(bool i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(1), (false)>(i_op).operator %(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(1), (false)>::mod operator %(const ap_private<_AP_W, _AP_S>& op, bool i_op) { return op.operator %(ap_private<(1), (false)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(1), (false)>::template RType<_AP_W, _AP_S>::logic operator &(bool i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(1), (false)>(i_op).operator &(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(1), (false)>::logic operator &(const ap_private<_AP_W, _AP_S>& op, bool i_op) { return op.operator &(ap_private<(1), (false)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(1), (false)>::template RType<_AP_W, _AP_S>::logic operator |(bool i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(1), (false)>(i_op).operator |(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(1), (false)>::logic operator |(const ap_private<_AP_W, _AP_S>& op, bool i_op) { return op.operator |(ap_private<(1), (false)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(1), (false)>::template RType<_AP_W, _AP_S>::logic operator ^(bool i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(1), (false)>(i_op).operator ^(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(1), (false)>::logic operator ^(const ap_private<_AP_W, _AP_S>& op, bool i_op) { return op.operator ^(ap_private<(1), (false)>(i_op)); } template <int _AP_W, bool _AP_S> bool operator >>(bool i_op, const ap_private<_AP_W, _AP_S, false>& op) { return i_op >>(op.get_VAL()); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(1), (false)>::arg1 operator >>(const ap_private<_AP_W, _AP_S>& op, bool i_op) { return op.operator >>(i_op); } template <int _AP_W, bool _AP_S> bool operator <<(bool i_op, const ap_private<_AP_W, _AP_S, false>& op) { return i_op <<(op.get_VAL()); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(1), (false)>::arg1 operator <<(const ap_private<_AP_W, _AP_S>& op, bool i_op) { return op.operator <<(i_op); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator +=( ap_private<_AP_W, _AP_S>& op, bool op2) { return op.operator +=(ap_private<(1), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator -=( ap_private<_AP_W, _AP_S>& op, bool op2) { return op.operator -=(ap_private<(1), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator *=( ap_private<_AP_W, _AP_S>& op, bool op2) { return op.operator *=(ap_private<(1), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator /=( ap_private<_AP_W, _AP_S>& op, bool op2) { return op.operator /=(ap_private<(1), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator %=( ap_private<_AP_W, _AP_S>& op, bool op2) { return op.operator %=(ap_private<(1), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator &=( ap_private<_AP_W, _AP_S>& op, bool op2) { return op.operator &=(ap_private<(1), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator |=( ap_private<_AP_W, _AP_S>& op, bool op2) { return op.operator |=(ap_private<(1), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator ^=( ap_private<_AP_W, _AP_S>& op, bool op2) { return op.operator ^=(ap_private<(1), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator >>=( ap_private<_AP_W, _AP_S>& op, bool op2) { op = op.operator>>(op2); return op; } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator <<=( ap_private<_AP_W, _AP_S>& op, bool op2) { op = op.operator<<(op2); return op; } template <int _AP_W, bool _AP_S> inline bool operator >(const ap_private<_AP_W, _AP_S>& op, bool op2) { return op.operator >(ap_private<(1), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >(bool op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(1), (false)>(op2).operator >(op); } template <int _AP_W, bool _AP_S> inline bool operator <(const ap_private<_AP_W, _AP_S>& op, bool op2) { return op.operator <(ap_private<(1), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <(bool op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(1), (false)>(op2).operator <(op); } template <int _AP_W, bool _AP_S> inline bool operator >=(const ap_private<_AP_W, _AP_S>& op, bool op2) { return op.operator >=(ap_private<(1), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >=(bool op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(1), (false)>(op2).operator >=(op); } template <int _AP_W, bool _AP_S> inline bool operator <=(const ap_private<_AP_W, _AP_S>& op, bool op2) { return op.operator <=(ap_private<(1), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <=(bool op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(1), (false)>(op2).operator <=(op); } template <int _AP_W, bool _AP_S> inline bool operator ==(const ap_private<_AP_W, _AP_S>& op, bool op2) { return op.operator ==(ap_private<(1), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator ==(bool op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(1), (false)>(op2).operator ==(op); } template <int _AP_W, bool _AP_S> inline bool operator !=(const ap_private<_AP_W, _AP_S>& op, bool op2) { return op.operator !=(ap_private<(1), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator !=(bool op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(1), (false)>(op2).operator !=(op); }
template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (CHAR_IS_SIGNED)>::template RType<_AP_W, _AP_S>::mult operator *(char i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(8), (CHAR_IS_SIGNED)>(i_op).operator *(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(8), (CHAR_IS_SIGNED)>::mult operator *(const ap_private<_AP_W, _AP_S>& op, char i_op) { return op.operator *(ap_private<(8), (CHAR_IS_SIGNED)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (CHAR_IS_SIGNED)>::template RType<_AP_W, _AP_S>::plus operator +(char i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(8), (CHAR_IS_SIGNED)>(i_op).operator +(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(8), (CHAR_IS_SIGNED)>::plus operator +(const ap_private<_AP_W, _AP_S>& op, char i_op) { return op.operator +(ap_private<(8), (CHAR_IS_SIGNED)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (CHAR_IS_SIGNED)>::template RType<_AP_W, _AP_S>::minus operator -(char i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(8), (CHAR_IS_SIGNED)>(i_op).operator -(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(8), (CHAR_IS_SIGNED)>::minus operator -(const ap_private<_AP_W, _AP_S>& op, char i_op) { return op.operator -(ap_private<(8), (CHAR_IS_SIGNED)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (CHAR_IS_SIGNED)>::template RType<_AP_W, _AP_S>::div operator /(char i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(8), (CHAR_IS_SIGNED)>(i_op).operator /(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(8), (CHAR_IS_SIGNED)>::div operator /(const ap_private<_AP_W, _AP_S>& op, char i_op) { return op.operator /(ap_private<(8), (CHAR_IS_SIGNED)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (CHAR_IS_SIGNED)>::template RType<_AP_W, _AP_S>::mod operator %(char i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(8), (CHAR_IS_SIGNED)>(i_op).operator %(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(8), (CHAR_IS_SIGNED)>::mod operator %(const ap_private<_AP_W, _AP_S>& op, char i_op) { return op.operator %(ap_private<(8), (CHAR_IS_SIGNED)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (CHAR_IS_SIGNED)>::template RType<_AP_W, _AP_S>::logic operator &(char i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(8), (CHAR_IS_SIGNED)>(i_op).operator &(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(8), (CHAR_IS_SIGNED)>::logic operator &(const ap_private<_AP_W, _AP_S>& op, char i_op) { return op.operator &(ap_private<(8), (CHAR_IS_SIGNED)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (CHAR_IS_SIGNED)>::template RType<_AP_W, _AP_S>::logic operator |(char i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(8), (CHAR_IS_SIGNED)>(i_op).operator |(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(8), (CHAR_IS_SIGNED)>::logic operator |(const ap_private<_AP_W, _AP_S>& op, char i_op) { return op.operator |(ap_private<(8), (CHAR_IS_SIGNED)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (CHAR_IS_SIGNED)>::template RType<_AP_W, _AP_S>::logic operator ^(char i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(8), (CHAR_IS_SIGNED)>(i_op).operator ^(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(8), (CHAR_IS_SIGNED)>::logic operator ^(const ap_private<_AP_W, _AP_S>& op, char i_op) { return op.operator ^(ap_private<(8), (CHAR_IS_SIGNED)>(i_op)); } template <int _AP_W, bool _AP_S> char operator >>(char i_op, const ap_private<_AP_W, _AP_S, false>& op) { return i_op >>(op.get_VAL()); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(8), (CHAR_IS_SIGNED)>::arg1 operator >>(const ap_private<_AP_W, _AP_S>& op, char i_op) { return op.operator >>(i_op); } template <int _AP_W, bool _AP_S> char operator <<(char i_op, const ap_private<_AP_W, _AP_S, false>& op) { return i_op <<(op.get_VAL()); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(8), (CHAR_IS_SIGNED)>::arg1 operator <<(const ap_private<_AP_W, _AP_S>& op, char i_op) { return op.operator <<(i_op); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator +=( ap_private<_AP_W, _AP_S>& op, char op2) { return op.operator +=(ap_private<(8), (CHAR_IS_SIGNED)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator -=( ap_private<_AP_W, _AP_S>& op, char op2) { return op.operator -=(ap_private<(8), (CHAR_IS_SIGNED)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator *=( ap_private<_AP_W, _AP_S>& op, char op2) { return op.operator *=(ap_private<(8), (CHAR_IS_SIGNED)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator /=( ap_private<_AP_W, _AP_S>& op, char op2) { return op.operator /=(ap_private<(8), (CHAR_IS_SIGNED)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator %=( ap_private<_AP_W, _AP_S>& op, char op2) { return op.operator %=(ap_private<(8), (CHAR_IS_SIGNED)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator &=( ap_private<_AP_W, _AP_S>& op, char op2) { return op.operator &=(ap_private<(8), (CHAR_IS_SIGNED)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator |=( ap_private<_AP_W, _AP_S>& op, char op2) { return op.operator |=(ap_private<(8), (CHAR_IS_SIGNED)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator ^=( ap_private<_AP_W, _AP_S>& op, char op2) { return op.operator ^=(ap_private<(8), (CHAR_IS_SIGNED)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator >>=( ap_private<_AP_W, _AP_S>& op, char op2) { op = op.operator>>(op2); return op; } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator <<=( ap_private<_AP_W, _AP_S>& op, char op2) { op = op.operator<<(op2); return op; } template <int _AP_W, bool _AP_S> inline bool operator >(const ap_private<_AP_W, _AP_S>& op, char op2) { return op.operator >(ap_private<(8), (CHAR_IS_SIGNED)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >(char op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(8), (CHAR_IS_SIGNED)>(op2).operator >(op); } template <int _AP_W, bool _AP_S> inline bool operator <(const ap_private<_AP_W, _AP_S>& op, char op2) { return op.operator <(ap_private<(8), (CHAR_IS_SIGNED)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <(char op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(8), (CHAR_IS_SIGNED)>(op2).operator <(op); } template <int _AP_W, bool _AP_S> inline bool operator >=(const ap_private<_AP_W, _AP_S>& op, char op2) { return op.operator >=(ap_private<(8), (CHAR_IS_SIGNED)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >=(char op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(8), (CHAR_IS_SIGNED)>(op2).operator >=(op); } template <int _AP_W, bool _AP_S> inline bool operator <=(const ap_private<_AP_W, _AP_S>& op, char op2) { return op.operator <=(ap_private<(8), (CHAR_IS_SIGNED)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <=(char op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(8), (CHAR_IS_SIGNED)>(op2).operator <=(op); } template <int _AP_W, bool _AP_S> inline bool operator ==(const ap_private<_AP_W, _AP_S>& op, char op2) { return op.operator ==(ap_private<(8), (CHAR_IS_SIGNED)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator ==(char op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(8), (CHAR_IS_SIGNED)>(op2).operator ==(op); } template <int _AP_W, bool _AP_S> inline bool operator !=(const ap_private<_AP_W, _AP_S>& op, char op2) { return op.operator !=(ap_private<(8), (CHAR_IS_SIGNED)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator !=(char op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(8), (CHAR_IS_SIGNED)>(op2).operator !=(op); }
template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (true)>::template RType<_AP_W, _AP_S>::mult operator *(signed char i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(8), (true)>(i_op).operator *(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(8), (true)>::mult operator *(const ap_private<_AP_W, _AP_S>& op, signed char i_op) { return op.operator *(ap_private<(8), (true)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (true)>::template RType<_AP_W, _AP_S>::plus operator +(signed char i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(8), (true)>(i_op).operator +(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(8), (true)>::plus operator +(const ap_private<_AP_W, _AP_S>& op, signed char i_op) { return op.operator +(ap_private<(8), (true)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (true)>::template RType<_AP_W, _AP_S>::minus operator -(signed char i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(8), (true)>(i_op).operator -(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(8), (true)>::minus operator -(const ap_private<_AP_W, _AP_S>& op, signed char i_op) { return op.operator -(ap_private<(8), (true)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (true)>::template RType<_AP_W, _AP_S>::div operator /(signed char i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(8), (true)>(i_op).operator /(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(8), (true)>::div operator /(const ap_private<_AP_W, _AP_S>& op, signed char i_op) { return op.operator /(ap_private<(8), (true)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (true)>::template RType<_AP_W, _AP_S>::mod operator %(signed char i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(8), (true)>(i_op).operator %(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(8), (true)>::mod operator %(const ap_private<_AP_W, _AP_S>& op, signed char i_op) { return op.operator %(ap_private<(8), (true)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (true)>::template RType<_AP_W, _AP_S>::logic operator &(signed char i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(8), (true)>(i_op).operator &(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(8), (true)>::logic operator &(const ap_private<_AP_W, _AP_S>& op, signed char i_op) { return op.operator &(ap_private<(8), (true)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (true)>::template RType<_AP_W, _AP_S>::logic operator |(signed char i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(8), (true)>(i_op).operator |(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(8), (true)>::logic operator |(const ap_private<_AP_W, _AP_S>& op, signed char i_op) { return op.operator |(ap_private<(8), (true)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (true)>::template RType<_AP_W, _AP_S>::logic operator ^(signed char i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(8), (true)>(i_op).operator ^(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(8), (true)>::logic operator ^(const ap_private<_AP_W, _AP_S>& op, signed char i_op) { return op.operator ^(ap_private<(8), (true)>(i_op)); } template <int _AP_W, bool _AP_S> signed char operator >>(signed char i_op, const ap_private<_AP_W, _AP_S, false>& op) { return i_op >>(op.get_VAL()); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(8), (true)>::arg1 operator >>(const ap_private<_AP_W, _AP_S>& op, signed char i_op) { return op.operator >>(i_op); } template <int _AP_W, bool _AP_S> signed char operator <<(signed char i_op, const ap_private<_AP_W, _AP_S, false>& op) { return i_op <<(op.get_VAL()); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(8), (true)>::arg1 operator <<(const ap_private<_AP_W, _AP_S>& op, signed char i_op) { return op.operator <<(i_op); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator +=( ap_private<_AP_W, _AP_S>& op, signed char op2) { return op.operator +=(ap_private<(8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator -=( ap_private<_AP_W, _AP_S>& op, signed char op2) { return op.operator -=(ap_private<(8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator *=( ap_private<_AP_W, _AP_S>& op, signed char op2) { return op.operator *=(ap_private<(8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator /=( ap_private<_AP_W, _AP_S>& op, signed char op2) { return op.operator /=(ap_private<(8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator %=( ap_private<_AP_W, _AP_S>& op, signed char op2) { return op.operator %=(ap_private<(8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator &=( ap_private<_AP_W, _AP_S>& op, signed char op2) { return op.operator &=(ap_private<(8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator |=( ap_private<_AP_W, _AP_S>& op, signed char op2) { return op.operator |=(ap_private<(8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator ^=( ap_private<_AP_W, _AP_S>& op, signed char op2) { return op.operator ^=(ap_private<(8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator >>=( ap_private<_AP_W, _AP_S>& op, signed char op2) { op = op.operator>>(op2); return op; } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator <<=( ap_private<_AP_W, _AP_S>& op, signed char op2) { op = op.operator<<(op2); return op; } template <int _AP_W, bool _AP_S> inline bool operator >(const ap_private<_AP_W, _AP_S>& op, signed char op2) { return op.operator >(ap_private<(8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >(signed char op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(8), (true)>(op2).operator >(op); } template <int _AP_W, bool _AP_S> inline bool operator <(const ap_private<_AP_W, _AP_S>& op, signed char op2) { return op.operator <(ap_private<(8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <(signed char op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(8), (true)>(op2).operator <(op); } template <int _AP_W, bool _AP_S> inline bool operator >=(const ap_private<_AP_W, _AP_S>& op, signed char op2) { return op.operator >=(ap_private<(8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >=(signed char op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(8), (true)>(op2).operator >=(op); } template <int _AP_W, bool _AP_S> inline bool operator <=(const ap_private<_AP_W, _AP_S>& op, signed char op2) { return op.operator <=(ap_private<(8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <=(signed char op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(8), (true)>(op2).operator <=(op); } template <int _AP_W, bool _AP_S> inline bool operator ==(const ap_private<_AP_W, _AP_S>& op, signed char op2) { return op.operator ==(ap_private<(8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator ==(signed char op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(8), (true)>(op2).operator ==(op); } template <int _AP_W, bool _AP_S> inline bool operator !=(const ap_private<_AP_W, _AP_S>& op, signed char op2) { return op.operator !=(ap_private<(8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator !=(signed char op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(8), (true)>(op2).operator !=(op); }
template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (false)>::template RType<_AP_W, _AP_S>::mult operator *(unsigned char i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(8), (false)>(i_op).operator *(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(8), (false)>::mult operator *(const ap_private<_AP_W, _AP_S>& op, unsigned char i_op) { return op.operator *(ap_private<(8), (false)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (false)>::template RType<_AP_W, _AP_S>::plus operator +(unsigned char i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(8), (false)>(i_op).operator +(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(8), (false)>::plus operator +(const ap_private<_AP_W, _AP_S>& op, unsigned char i_op) { return op.operator +(ap_private<(8), (false)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (false)>::template RType<_AP_W, _AP_S>::minus operator -(unsigned char i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(8), (false)>(i_op).operator -(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(8), (false)>::minus operator -(const ap_private<_AP_W, _AP_S>& op, unsigned char i_op) { return op.operator -(ap_private<(8), (false)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (false)>::template RType<_AP_W, _AP_S>::div operator /(unsigned char i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(8), (false)>(i_op).operator /(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(8), (false)>::div operator /(const ap_private<_AP_W, _AP_S>& op, unsigned char i_op) { return op.operator /(ap_private<(8), (false)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (false)>::template RType<_AP_W, _AP_S>::mod operator %(unsigned char i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(8), (false)>(i_op).operator %(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(8), (false)>::mod operator %(const ap_private<_AP_W, _AP_S>& op, unsigned char i_op) { return op.operator %(ap_private<(8), (false)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (false)>::template RType<_AP_W, _AP_S>::logic operator &(unsigned char i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(8), (false)>(i_op).operator &(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(8), (false)>::logic operator &(const ap_private<_AP_W, _AP_S>& op, unsigned char i_op) { return op.operator &(ap_private<(8), (false)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (false)>::template RType<_AP_W, _AP_S>::logic operator |(unsigned char i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(8), (false)>(i_op).operator |(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(8), (false)>::logic operator |(const ap_private<_AP_W, _AP_S>& op, unsigned char i_op) { return op.operator |(ap_private<(8), (false)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (false)>::template RType<_AP_W, _AP_S>::logic operator ^(unsigned char i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(8), (false)>(i_op).operator ^(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(8), (false)>::logic operator ^(const ap_private<_AP_W, _AP_S>& op, unsigned char i_op) { return op.operator ^(ap_private<(8), (false)>(i_op)); } template <int _AP_W, bool _AP_S> unsigned char operator >>(unsigned char i_op, const ap_private<_AP_W, _AP_S, false>& op) { return i_op >>(op.get_VAL()); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(8), (false)>::arg1 operator >>(const ap_private<_AP_W, _AP_S>& op, unsigned char i_op) { return op.operator >>(i_op); } template <int _AP_W, bool _AP_S> unsigned char operator <<(unsigned char i_op, const ap_private<_AP_W, _AP_S, false>& op) { return i_op <<(op.get_VAL()); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(8), (false)>::arg1 operator <<(const ap_private<_AP_W, _AP_S>& op, unsigned char i_op) { return op.operator <<(i_op); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator +=( ap_private<_AP_W, _AP_S>& op, unsigned char op2) { return op.operator +=(ap_private<(8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator -=( ap_private<_AP_W, _AP_S>& op, unsigned char op2) { return op.operator -=(ap_private<(8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator *=( ap_private<_AP_W, _AP_S>& op, unsigned char op2) { return op.operator *=(ap_private<(8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator /=( ap_private<_AP_W, _AP_S>& op, unsigned char op2) { return op.operator /=(ap_private<(8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator %=( ap_private<_AP_W, _AP_S>& op, unsigned char op2) { return op.operator %=(ap_private<(8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator &=( ap_private<_AP_W, _AP_S>& op, unsigned char op2) { return op.operator &=(ap_private<(8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator |=( ap_private<_AP_W, _AP_S>& op, unsigned char op2) { return op.operator |=(ap_private<(8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator ^=( ap_private<_AP_W, _AP_S>& op, unsigned char op2) { return op.operator ^=(ap_private<(8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator >>=( ap_private<_AP_W, _AP_S>& op, unsigned char op2) { op = op.operator>>(op2); return op; } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator <<=( ap_private<_AP_W, _AP_S>& op, unsigned char op2) { op = op.operator<<(op2); return op; } template <int _AP_W, bool _AP_S> inline bool operator >(const ap_private<_AP_W, _AP_S>& op, unsigned char op2) { return op.operator >(ap_private<(8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >(unsigned char op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(8), (false)>(op2).operator >(op); } template <int _AP_W, bool _AP_S> inline bool operator <(const ap_private<_AP_W, _AP_S>& op, unsigned char op2) { return op.operator <(ap_private<(8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <(unsigned char op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(8), (false)>(op2).operator <(op); } template <int _AP_W, bool _AP_S> inline bool operator >=(const ap_private<_AP_W, _AP_S>& op, unsigned char op2) { return op.operator >=(ap_private<(8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >=(unsigned char op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(8), (false)>(op2).operator >=(op); } template <int _AP_W, bool _AP_S> inline bool operator <=(const ap_private<_AP_W, _AP_S>& op, unsigned char op2) { return op.operator <=(ap_private<(8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <=(unsigned char op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(8), (false)>(op2).operator <=(op); } template <int _AP_W, bool _AP_S> inline bool operator ==(const ap_private<_AP_W, _AP_S>& op, unsigned char op2) { return op.operator ==(ap_private<(8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator ==(unsigned char op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(8), (false)>(op2).operator ==(op); } template <int _AP_W, bool _AP_S> inline bool operator !=(const ap_private<_AP_W, _AP_S>& op, unsigned char op2) { return op.operator !=(ap_private<(8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator !=(unsigned char op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(8), (false)>(op2).operator !=(op); }
template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(short) * 8), (true)>::template RType<_AP_W, _AP_S>::mult operator *(short i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(short) * 8), (true)>(i_op).operator *(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(short) * 8), (true)>::mult operator *(const ap_private<_AP_W, _AP_S>& op, short i_op) { return op.operator *(ap_private<(sizeof(short) * 8), (true)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(short) * 8), (true)>::template RType<_AP_W, _AP_S>::plus operator +(short i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(short) * 8), (true)>(i_op).operator +(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(short) * 8), (true)>::plus operator +(const ap_private<_AP_W, _AP_S>& op, short i_op) { return op.operator +(ap_private<(sizeof(short) * 8), (true)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(short) * 8), (true)>::template RType<_AP_W, _AP_S>::minus operator -(short i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(short) * 8), (true)>(i_op).operator -(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(short) * 8), (true)>::minus operator -(const ap_private<_AP_W, _AP_S>& op, short i_op) { return op.operator -(ap_private<(sizeof(short) * 8), (true)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(short) * 8), (true)>::template RType<_AP_W, _AP_S>::div operator /(short i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(short) * 8), (true)>(i_op).operator /(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(short) * 8), (true)>::div operator /(const ap_private<_AP_W, _AP_S>& op, short i_op) { return op.operator /(ap_private<(sizeof(short) * 8), (true)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(short) * 8), (true)>::template RType<_AP_W, _AP_S>::mod operator %(short i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(short) * 8), (true)>(i_op).operator %(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(short) * 8), (true)>::mod operator %(const ap_private<_AP_W, _AP_S>& op, short i_op) { return op.operator %(ap_private<(sizeof(short) * 8), (true)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(short) * 8), (true)>::template RType<_AP_W, _AP_S>::logic operator &(short i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(short) * 8), (true)>(i_op).operator &(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(short) * 8), (true)>::logic operator &(const ap_private<_AP_W, _AP_S>& op, short i_op) { return op.operator &(ap_private<(sizeof(short) * 8), (true)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(short) * 8), (true)>::template RType<_AP_W, _AP_S>::logic operator |(short i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(short) * 8), (true)>(i_op).operator |(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(short) * 8), (true)>::logic operator |(const ap_private<_AP_W, _AP_S>& op, short i_op) { return op.operator |(ap_private<(sizeof(short) * 8), (true)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(short) * 8), (true)>::template RType<_AP_W, _AP_S>::logic operator ^(short i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(short) * 8), (true)>(i_op).operator ^(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(short) * 8), (true)>::logic operator ^(const ap_private<_AP_W, _AP_S>& op, short i_op) { return op.operator ^(ap_private<(sizeof(short) * 8), (true)>(i_op)); } template <int _AP_W, bool _AP_S> short operator >>(short i_op, const ap_private<_AP_W, _AP_S, false>& op) { return i_op >>(op.get_VAL()); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(short) * 8), (true)>::arg1 operator >>(const ap_private<_AP_W, _AP_S>& op, short i_op) { return op.operator >>(i_op); } template <int _AP_W, bool _AP_S> short operator <<(short i_op, const ap_private<_AP_W, _AP_S, false>& op) { return i_op <<(op.get_VAL()); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(short) * 8), (true)>::arg1 operator <<(const ap_private<_AP_W, _AP_S>& op, short i_op) { return op.operator <<(i_op); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator +=( ap_private<_AP_W, _AP_S>& op, short op2) { return op.operator +=(ap_private<(sizeof(short) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator -=( ap_private<_AP_W, _AP_S>& op, short op2) { return op.operator -=(ap_private<(sizeof(short) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator *=( ap_private<_AP_W, _AP_S>& op, short op2) { return op.operator *=(ap_private<(sizeof(short) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator /=( ap_private<_AP_W, _AP_S>& op, short op2) { return op.operator /=(ap_private<(sizeof(short) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator %=( ap_private<_AP_W, _AP_S>& op, short op2) { return op.operator %=(ap_private<(sizeof(short) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator &=( ap_private<_AP_W, _AP_S>& op, short op2) { return op.operator &=(ap_private<(sizeof(short) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator |=( ap_private<_AP_W, _AP_S>& op, short op2) { return op.operator |=(ap_private<(sizeof(short) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator ^=( ap_private<_AP_W, _AP_S>& op, short op2) { return op.operator ^=(ap_private<(sizeof(short) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator >>=( ap_private<_AP_W, _AP_S>& op, short op2) { op = op.operator>>(op2); return op; } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator <<=( ap_private<_AP_W, _AP_S>& op, short op2) { op = op.operator<<(op2); return op; } template <int _AP_W, bool _AP_S> inline bool operator >(const ap_private<_AP_W, _AP_S>& op, short op2) { return op.operator >(ap_private<(sizeof(short) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >(short op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(short) * 8), (true)>(op2).operator >(op); } template <int _AP_W, bool _AP_S> inline bool operator <(const ap_private<_AP_W, _AP_S>& op, short op2) { return op.operator <(ap_private<(sizeof(short) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <(short op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(short) * 8), (true)>(op2).operator <(op); } template <int _AP_W, bool _AP_S> inline bool operator >=(const ap_private<_AP_W, _AP_S>& op, short op2) { return op.operator >=(ap_private<(sizeof(short) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >=(short op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(short) * 8), (true)>(op2).operator >=(op); } template <int _AP_W, bool _AP_S> inline bool operator <=(const ap_private<_AP_W, _AP_S>& op, short op2) { return op.operator <=(ap_private<(sizeof(short) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <=(short op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(short) * 8), (true)>(op2).operator <=(op); } template <int _AP_W, bool _AP_S> inline bool operator ==(const ap_private<_AP_W, _AP_S>& op, short op2) { return op.operator ==(ap_private<(sizeof(short) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator ==(short op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(short) * 8), (true)>(op2).operator ==(op); } template <int _AP_W, bool _AP_S> inline bool operator !=(const ap_private<_AP_W, _AP_S>& op, short op2) { return op.operator !=(ap_private<(sizeof(short) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator !=(short op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(short) * 8), (true)>(op2).operator !=(op); }
template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned short) * 8), (false)>::template RType<_AP_W, _AP_S>::mult operator *(unsigned short i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned short) * 8), (false)>(i_op).operator *(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(unsigned short) * 8), (false)>::mult operator *(const ap_private<_AP_W, _AP_S>& op, unsigned short i_op) { return op.operator *(ap_private<(sizeof(unsigned short) * 8), (false)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned short) * 8), (false)>::template RType<_AP_W, _AP_S>::plus operator +(unsigned short i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned short) * 8), (false)>(i_op).operator +(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(unsigned short) * 8), (false)>::plus operator +(const ap_private<_AP_W, _AP_S>& op, unsigned short i_op) { return op.operator +(ap_private<(sizeof(unsigned short) * 8), (false)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned short) * 8), (false)>::template RType<_AP_W, _AP_S>::minus operator -(unsigned short i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned short) * 8), (false)>(i_op).operator -(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(unsigned short) * 8), (false)>::minus operator -(const ap_private<_AP_W, _AP_S>& op, unsigned short i_op) { return op.operator -(ap_private<(sizeof(unsigned short) * 8), (false)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned short) * 8), (false)>::template RType<_AP_W, _AP_S>::div operator /(unsigned short i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned short) * 8), (false)>(i_op).operator /(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(unsigned short) * 8), (false)>::div operator /(const ap_private<_AP_W, _AP_S>& op, unsigned short i_op) { return op.operator /(ap_private<(sizeof(unsigned short) * 8), (false)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned short) * 8), (false)>::template RType<_AP_W, _AP_S>::mod operator %(unsigned short i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned short) * 8), (false)>(i_op).operator %(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(unsigned short) * 8), (false)>::mod operator %(const ap_private<_AP_W, _AP_S>& op, unsigned short i_op) { return op.operator %(ap_private<(sizeof(unsigned short) * 8), (false)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned short) * 8), (false)>::template RType<_AP_W, _AP_S>::logic operator &(unsigned short i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned short) * 8), (false)>(i_op).operator &(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(unsigned short) * 8), (false)>::logic operator &(const ap_private<_AP_W, _AP_S>& op, unsigned short i_op) { return op.operator &(ap_private<(sizeof(unsigned short) * 8), (false)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned short) * 8), (false)>::template RType<_AP_W, _AP_S>::logic operator |(unsigned short i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned short) * 8), (false)>(i_op).operator |(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(unsigned short) * 8), (false)>::logic operator |(const ap_private<_AP_W, _AP_S>& op, unsigned short i_op) { return op.operator |(ap_private<(sizeof(unsigned short) * 8), (false)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned short) * 8), (false)>::template RType<_AP_W, _AP_S>::logic operator ^(unsigned short i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned short) * 8), (false)>(i_op).operator ^(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(unsigned short) * 8), (false)>::logic operator ^(const ap_private<_AP_W, _AP_S>& op, unsigned short i_op) { return op.operator ^(ap_private<(sizeof(unsigned short) * 8), (false)>(i_op)); } template <int _AP_W, bool _AP_S> unsigned short operator >>(unsigned short i_op, const ap_private<_AP_W, _AP_S, false>& op) { return i_op >>(op.get_VAL()); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(unsigned short) * 8), (false)>::arg1 operator >>(const ap_private<_AP_W, _AP_S>& op, unsigned short i_op) { return op.operator >>(i_op); } template <int _AP_W, bool _AP_S> unsigned short operator <<(unsigned short i_op, const ap_private<_AP_W, _AP_S, false>& op) { return i_op <<(op.get_VAL()); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(unsigned short) * 8), (false)>::arg1 operator <<(const ap_private<_AP_W, _AP_S>& op, unsigned short i_op) { return op.operator <<(i_op); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator +=( ap_private<_AP_W, _AP_S>& op, unsigned short op2) { return op.operator +=(ap_private<(sizeof(unsigned short) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator -=( ap_private<_AP_W, _AP_S>& op, unsigned short op2) { return op.operator -=(ap_private<(sizeof(unsigned short) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator *=( ap_private<_AP_W, _AP_S>& op, unsigned short op2) { return op.operator *=(ap_private<(sizeof(unsigned short) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator /=( ap_private<_AP_W, _AP_S>& op, unsigned short op2) { return op.operator /=(ap_private<(sizeof(unsigned short) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator %=( ap_private<_AP_W, _AP_S>& op, unsigned short op2) { return op.operator %=(ap_private<(sizeof(unsigned short) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator &=( ap_private<_AP_W, _AP_S>& op, unsigned short op2) { return op.operator &=(ap_private<(sizeof(unsigned short) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator |=( ap_private<_AP_W, _AP_S>& op, unsigned short op2) { return op.operator |=(ap_private<(sizeof(unsigned short) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator ^=( ap_private<_AP_W, _AP_S>& op, unsigned short op2) { return op.operator ^=(ap_private<(sizeof(unsigned short) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator >>=( ap_private<_AP_W, _AP_S>& op, unsigned short op2) { op = op.operator>>(op2); return op; } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator <<=( ap_private<_AP_W, _AP_S>& op, unsigned short op2) { op = op.operator<<(op2); return op; } template <int _AP_W, bool _AP_S> inline bool operator >(const ap_private<_AP_W, _AP_S>& op, unsigned short op2) { return op.operator >(ap_private<(sizeof(unsigned short) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >(unsigned short op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(unsigned short) * 8), (false)>(op2).operator >(op); } template <int _AP_W, bool _AP_S> inline bool operator <(const ap_private<_AP_W, _AP_S>& op, unsigned short op2) { return op.operator <(ap_private<(sizeof(unsigned short) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <(unsigned short op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(unsigned short) * 8), (false)>(op2).operator <(op); } template <int _AP_W, bool _AP_S> inline bool operator >=(const ap_private<_AP_W, _AP_S>& op, unsigned short op2) { return op.operator >=(ap_private<(sizeof(unsigned short) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >=(unsigned short op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(unsigned short) * 8), (false)>(op2).operator >=(op); } template <int _AP_W, bool _AP_S> inline bool operator <=(const ap_private<_AP_W, _AP_S>& op, unsigned short op2) { return op.operator <=(ap_private<(sizeof(unsigned short) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <=(unsigned short op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(unsigned short) * 8), (false)>(op2).operator <=(op); } template <int _AP_W, bool _AP_S> inline bool operator ==(const ap_private<_AP_W, _AP_S>& op, unsigned short op2) { return op.operator ==(ap_private<(sizeof(unsigned short) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator ==(unsigned short op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(unsigned short) * 8), (false)>(op2).operator ==(op); } template <int _AP_W, bool _AP_S> inline bool operator !=(const ap_private<_AP_W, _AP_S>& op, unsigned short op2) { return op.operator !=(ap_private<(sizeof(unsigned short) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator !=(unsigned short op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(unsigned short) * 8), (false)>(op2).operator !=(op); }
template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(int) * 8), (true)>::template RType<_AP_W, _AP_S>::mult operator *(int i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(int) * 8), (true)>(i_op).operator *(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(int) * 8), (true)>::mult operator *(const ap_private<_AP_W, _AP_S>& op, int i_op) { return op.operator *(ap_private<(sizeof(int) * 8), (true)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(int) * 8), (true)>::template RType<_AP_W, _AP_S>::plus operator +(int i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(int) * 8), (true)>(i_op).operator +(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(int) * 8), (true)>::plus operator +(const ap_private<_AP_W, _AP_S>& op, int i_op) { return op.operator +(ap_private<(sizeof(int) * 8), (true)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(int) * 8), (true)>::template RType<_AP_W, _AP_S>::minus operator -(int i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(int) * 8), (true)>(i_op).operator -(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(int) * 8), (true)>::minus operator -(const ap_private<_AP_W, _AP_S>& op, int i_op) { return op.operator -(ap_private<(sizeof(int) * 8), (true)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(int) * 8), (true)>::template RType<_AP_W, _AP_S>::div operator /(int i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(int) * 8), (true)>(i_op).operator /(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(int) * 8), (true)>::div operator /(const ap_private<_AP_W, _AP_S>& op, int i_op) { return op.operator /(ap_private<(sizeof(int) * 8), (true)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(int) * 8), (true)>::template RType<_AP_W, _AP_S>::mod operator %(int i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(int) * 8), (true)>(i_op).operator %(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(int) * 8), (true)>::mod operator %(const ap_private<_AP_W, _AP_S>& op, int i_op) { return op.operator %(ap_private<(sizeof(int) * 8), (true)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(int) * 8), (true)>::template RType<_AP_W, _AP_S>::logic operator &(int i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(int) * 8), (true)>(i_op).operator &(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(int) * 8), (true)>::logic operator &(const ap_private<_AP_W, _AP_S>& op, int i_op) { return op.operator &(ap_private<(sizeof(int) * 8), (true)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(int) * 8), (true)>::template RType<_AP_W, _AP_S>::logic operator |(int i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(int) * 8), (true)>(i_op).operator |(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(int) * 8), (true)>::logic operator |(const ap_private<_AP_W, _AP_S>& op, int i_op) { return op.operator |(ap_private<(sizeof(int) * 8), (true)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(int) * 8), (true)>::template RType<_AP_W, _AP_S>::logic operator ^(int i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(int) * 8), (true)>(i_op).operator ^(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(int) * 8), (true)>::logic operator ^(const ap_private<_AP_W, _AP_S>& op, int i_op) { return op.operator ^(ap_private<(sizeof(int) * 8), (true)>(i_op)); } template <int _AP_W, bool _AP_S> int operator >>(int i_op, const ap_private<_AP_W, _AP_S, false>& op) { return i_op >>(op.get_VAL()); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(int) * 8), (true)>::arg1 operator >>(const ap_private<_AP_W, _AP_S>& op, int i_op) { return op.operator >>(i_op); } template <int _AP_W, bool _AP_S> int operator <<(int i_op, const ap_private<_AP_W, _AP_S, false>& op) { return i_op <<(op.get_VAL()); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(int) * 8), (true)>::arg1 operator <<(const ap_private<_AP_W, _AP_S>& op, int i_op) { return op.operator <<(i_op); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator +=( ap_private<_AP_W, _AP_S>& op, int op2) { return op.operator +=(ap_private<(sizeof(int) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator -=( ap_private<_AP_W, _AP_S>& op, int op2) { return op.operator -=(ap_private<(sizeof(int) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator *=( ap_private<_AP_W, _AP_S>& op, int op2) { return op.operator *=(ap_private<(sizeof(int) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator /=( ap_private<_AP_W, _AP_S>& op, int op2) { return op.operator /=(ap_private<(sizeof(int) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator %=( ap_private<_AP_W, _AP_S>& op, int op2) { return op.operator %=(ap_private<(sizeof(int) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator &=( ap_private<_AP_W, _AP_S>& op, int op2) { return op.operator &=(ap_private<(sizeof(int) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator |=( ap_private<_AP_W, _AP_S>& op, int op2) { return op.operator |=(ap_private<(sizeof(int) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator ^=( ap_private<_AP_W, _AP_S>& op, int op2) { return op.operator ^=(ap_private<(sizeof(int) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator >>=( ap_private<_AP_W, _AP_S>& op, int op2) { op = op.operator>>(op2); return op; } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator <<=( ap_private<_AP_W, _AP_S>& op, int op2) { op = op.operator<<(op2); return op; } template <int _AP_W, bool _AP_S> inline bool operator >(const ap_private<_AP_W, _AP_S>& op, int op2) { return op.operator >(ap_private<(sizeof(int) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >(int op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(int) * 8), (true)>(op2).operator >(op); } template <int _AP_W, bool _AP_S> inline bool operator <(const ap_private<_AP_W, _AP_S>& op, int op2) { return op.operator <(ap_private<(sizeof(int) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <(int op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(int) * 8), (true)>(op2).operator <(op); } template <int _AP_W, bool _AP_S> inline bool operator >=(const ap_private<_AP_W, _AP_S>& op, int op2) { return op.operator >=(ap_private<(sizeof(int) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >=(int op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(int) * 8), (true)>(op2).operator >=(op); } template <int _AP_W, bool _AP_S> inline bool operator <=(const ap_private<_AP_W, _AP_S>& op, int op2) { return op.operator <=(ap_private<(sizeof(int) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <=(int op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(int) * 8), (true)>(op2).operator <=(op); } template <int _AP_W, bool _AP_S> inline bool operator ==(const ap_private<_AP_W, _AP_S>& op, int op2) { return op.operator ==(ap_private<(sizeof(int) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator ==(int op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(int) * 8), (true)>(op2).operator ==(op); } template <int _AP_W, bool _AP_S> inline bool operator !=(const ap_private<_AP_W, _AP_S>& op, int op2) { return op.operator !=(ap_private<(sizeof(int) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator !=(int op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(int) * 8), (true)>(op2).operator !=(op); }
template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned int) * 8), (false)>::template RType<_AP_W, _AP_S>::mult operator *(unsigned int i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned int) * 8), (false)>(i_op).operator *(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(unsigned int) * 8), (false)>::mult operator *(const ap_private<_AP_W, _AP_S>& op, unsigned int i_op) { return op.operator *(ap_private<(sizeof(unsigned int) * 8), (false)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned int) * 8), (false)>::template RType<_AP_W, _AP_S>::plus operator +(unsigned int i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned int) * 8), (false)>(i_op).operator +(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(unsigned int) * 8), (false)>::plus operator +(const ap_private<_AP_W, _AP_S>& op, unsigned int i_op) { return op.operator +(ap_private<(sizeof(unsigned int) * 8), (false)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned int) * 8), (false)>::template RType<_AP_W, _AP_S>::minus operator -(unsigned int i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned int) * 8), (false)>(i_op).operator -(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(unsigned int) * 8), (false)>::minus operator -(const ap_private<_AP_W, _AP_S>& op, unsigned int i_op) { return op.operator -(ap_private<(sizeof(unsigned int) * 8), (false)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned int) * 8), (false)>::template RType<_AP_W, _AP_S>::div operator /(unsigned int i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned int) * 8), (false)>(i_op).operator /(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(unsigned int) * 8), (false)>::div operator /(const ap_private<_AP_W, _AP_S>& op, unsigned int i_op) { return op.operator /(ap_private<(sizeof(unsigned int) * 8), (false)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned int) * 8), (false)>::template RType<_AP_W, _AP_S>::mod operator %(unsigned int i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned int) * 8), (false)>(i_op).operator %(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(unsigned int) * 8), (false)>::mod operator %(const ap_private<_AP_W, _AP_S>& op, unsigned int i_op) { return op.operator %(ap_private<(sizeof(unsigned int) * 8), (false)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned int) * 8), (false)>::template RType<_AP_W, _AP_S>::logic operator &(unsigned int i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned int) * 8), (false)>(i_op).operator &(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(unsigned int) * 8), (false)>::logic operator &(const ap_private<_AP_W, _AP_S>& op, unsigned int i_op) { return op.operator &(ap_private<(sizeof(unsigned int) * 8), (false)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned int) * 8), (false)>::template RType<_AP_W, _AP_S>::logic operator |(unsigned int i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned int) * 8), (false)>(i_op).operator |(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(unsigned int) * 8), (false)>::logic operator |(const ap_private<_AP_W, _AP_S>& op, unsigned int i_op) { return op.operator |(ap_private<(sizeof(unsigned int) * 8), (false)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned int) * 8), (false)>::template RType<_AP_W, _AP_S>::logic operator ^(unsigned int i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned int) * 8), (false)>(i_op).operator ^(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(unsigned int) * 8), (false)>::logic operator ^(const ap_private<_AP_W, _AP_S>& op, unsigned int i_op) { return op.operator ^(ap_private<(sizeof(unsigned int) * 8), (false)>(i_op)); } template <int _AP_W, bool _AP_S> unsigned int operator >>(unsigned int i_op, const ap_private<_AP_W, _AP_S, false>& op) { return i_op >>(op.get_VAL()); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(unsigned int) * 8), (false)>::arg1 operator >>(const ap_private<_AP_W, _AP_S>& op, unsigned int i_op) { return op.operator >>(i_op); } template <int _AP_W, bool _AP_S> unsigned int operator <<(unsigned int i_op, const ap_private<_AP_W, _AP_S, false>& op) { return i_op <<(op.get_VAL()); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(unsigned int) * 8), (false)>::arg1 operator <<(const ap_private<_AP_W, _AP_S>& op, unsigned int i_op) { return op.operator <<(i_op); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator +=( ap_private<_AP_W, _AP_S>& op, unsigned int op2) { return op.operator +=(ap_private<(sizeof(unsigned int) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator -=( ap_private<_AP_W, _AP_S>& op, unsigned int op2) { return op.operator -=(ap_private<(sizeof(unsigned int) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator *=( ap_private<_AP_W, _AP_S>& op, unsigned int op2) { return op.operator *=(ap_private<(sizeof(unsigned int) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator /=( ap_private<_AP_W, _AP_S>& op, unsigned int op2) { return op.operator /=(ap_private<(sizeof(unsigned int) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator %=( ap_private<_AP_W, _AP_S>& op, unsigned int op2) { return op.operator %=(ap_private<(sizeof(unsigned int) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator &=( ap_private<_AP_W, _AP_S>& op, unsigned int op2) { return op.operator &=(ap_private<(sizeof(unsigned int) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator |=( ap_private<_AP_W, _AP_S>& op, unsigned int op2) { return op.operator |=(ap_private<(sizeof(unsigned int) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator ^=( ap_private<_AP_W, _AP_S>& op, unsigned int op2) { return op.operator ^=(ap_private<(sizeof(unsigned int) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator >>=( ap_private<_AP_W, _AP_S>& op, unsigned int op2) { op = op.operator>>(op2); return op; } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator <<=( ap_private<_AP_W, _AP_S>& op, unsigned int op2) { op = op.operator<<(op2); return op; } template <int _AP_W, bool _AP_S> inline bool operator >(const ap_private<_AP_W, _AP_S>& op, unsigned int op2) { return op.operator >(ap_private<(sizeof(unsigned int) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >(unsigned int op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(unsigned int) * 8), (false)>(op2).operator >(op); } template <int _AP_W, bool _AP_S> inline bool operator <(const ap_private<_AP_W, _AP_S>& op, unsigned int op2) { return op.operator <(ap_private<(sizeof(unsigned int) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <(unsigned int op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(unsigned int) * 8), (false)>(op2).operator <(op); } template <int _AP_W, bool _AP_S> inline bool operator >=(const ap_private<_AP_W, _AP_S>& op, unsigned int op2) { return op.operator >=(ap_private<(sizeof(unsigned int) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >=(unsigned int op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(unsigned int) * 8), (false)>(op2).operator >=(op); } template <int _AP_W, bool _AP_S> inline bool operator <=(const ap_private<_AP_W, _AP_S>& op, unsigned int op2) { return op.operator <=(ap_private<(sizeof(unsigned int) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <=(unsigned int op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(unsigned int) * 8), (false)>(op2).operator <=(op); } template <int _AP_W, bool _AP_S> inline bool operator ==(const ap_private<_AP_W, _AP_S>& op, unsigned int op2) { return op.operator ==(ap_private<(sizeof(unsigned int) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator ==(unsigned int op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(unsigned int) * 8), (false)>(op2).operator ==(op); } template <int _AP_W, bool _AP_S> inline bool operator !=(const ap_private<_AP_W, _AP_S>& op, unsigned int op2) { return op.operator !=(ap_private<(sizeof(unsigned int) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator !=(unsigned int op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(unsigned int) * 8), (false)>(op2).operator !=(op); }
template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(long) * 8), (true)>::template RType<_AP_W, _AP_S>::mult operator *(long i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(long) * 8), (true)>(i_op).operator *(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(long) * 8), (true)>::mult operator *(const ap_private<_AP_W, _AP_S>& op, long i_op) { return op.operator *(ap_private<(sizeof(long) * 8), (true)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(long) * 8), (true)>::template RType<_AP_W, _AP_S>::plus operator +(long i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(long) * 8), (true)>(i_op).operator +(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(long) * 8), (true)>::plus operator +(const ap_private<_AP_W, _AP_S>& op, long i_op) { return op.operator +(ap_private<(sizeof(long) * 8), (true)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(long) * 8), (true)>::template RType<_AP_W, _AP_S>::minus operator -(long i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(long) * 8), (true)>(i_op).operator -(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(long) * 8), (true)>::minus operator -(const ap_private<_AP_W, _AP_S>& op, long i_op) { return op.operator -(ap_private<(sizeof(long) * 8), (true)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(long) * 8), (true)>::template RType<_AP_W, _AP_S>::div operator /(long i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(long) * 8), (true)>(i_op).operator /(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(long) * 8), (true)>::div operator /(const ap_private<_AP_W, _AP_S>& op, long i_op) { return op.operator /(ap_private<(sizeof(long) * 8), (true)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(long) * 8), (true)>::template RType<_AP_W, _AP_S>::mod operator %(long i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(long) * 8), (true)>(i_op).operator %(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(long) * 8), (true)>::mod operator %(const ap_private<_AP_W, _AP_S>& op, long i_op) { return op.operator %(ap_private<(sizeof(long) * 8), (true)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(long) * 8), (true)>::template RType<_AP_W, _AP_S>::logic operator &(long i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(long) * 8), (true)>(i_op).operator &(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(long) * 8), (true)>::logic operator &(const ap_private<_AP_W, _AP_S>& op, long i_op) { return op.operator &(ap_private<(sizeof(long) * 8), (true)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(long) * 8), (true)>::template RType<_AP_W, _AP_S>::logic operator |(long i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(long) * 8), (true)>(i_op).operator |(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(long) * 8), (true)>::logic operator |(const ap_private<_AP_W, _AP_S>& op, long i_op) { return op.operator |(ap_private<(sizeof(long) * 8), (true)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(long) * 8), (true)>::template RType<_AP_W, _AP_S>::logic operator ^(long i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(long) * 8), (true)>(i_op).operator ^(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(long) * 8), (true)>::logic operator ^(const ap_private<_AP_W, _AP_S>& op, long i_op) { return op.operator ^(ap_private<(sizeof(long) * 8), (true)>(i_op)); } template <int _AP_W, bool _AP_S> long operator >>(long i_op, const ap_private<_AP_W, _AP_S, false>& op) { return i_op >>(op.get_VAL()); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(long) * 8), (true)>::arg1 operator >>(const ap_private<_AP_W, _AP_S>& op, long i_op) { return op.operator >>(i_op); } template <int _AP_W, bool _AP_S> long operator <<(long i_op, const ap_private<_AP_W, _AP_S, false>& op) { return i_op <<(op.get_VAL()); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(long) * 8), (true)>::arg1 operator <<(const ap_private<_AP_W, _AP_S>& op, long i_op) { return op.operator <<(i_op); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator +=( ap_private<_AP_W, _AP_S>& op, long op2) { return op.operator +=(ap_private<(sizeof(long) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator -=( ap_private<_AP_W, _AP_S>& op, long op2) { return op.operator -=(ap_private<(sizeof(long) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator *=( ap_private<_AP_W, _AP_S>& op, long op2) { return op.operator *=(ap_private<(sizeof(long) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator /=( ap_private<_AP_W, _AP_S>& op, long op2) { return op.operator /=(ap_private<(sizeof(long) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator %=( ap_private<_AP_W, _AP_S>& op, long op2) { return op.operator %=(ap_private<(sizeof(long) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator &=( ap_private<_AP_W, _AP_S>& op, long op2) { return op.operator &=(ap_private<(sizeof(long) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator |=( ap_private<_AP_W, _AP_S>& op, long op2) { return op.operator |=(ap_private<(sizeof(long) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator ^=( ap_private<_AP_W, _AP_S>& op, long op2) { return op.operator ^=(ap_private<(sizeof(long) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator >>=( ap_private<_AP_W, _AP_S>& op, long op2) { op = op.operator>>(op2); return op; } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator <<=( ap_private<_AP_W, _AP_S>& op, long op2) { op = op.operator<<(op2); return op; } template <int _AP_W, bool _AP_S> inline bool operator >(const ap_private<_AP_W, _AP_S>& op, long op2) { return op.operator >(ap_private<(sizeof(long) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >(long op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(long) * 8), (true)>(op2).operator >(op); } template <int _AP_W, bool _AP_S> inline bool operator <(const ap_private<_AP_W, _AP_S>& op, long op2) { return op.operator <(ap_private<(sizeof(long) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <(long op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(long) * 8), (true)>(op2).operator <(op); } template <int _AP_W, bool _AP_S> inline bool operator >=(const ap_private<_AP_W, _AP_S>& op, long op2) { return op.operator >=(ap_private<(sizeof(long) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >=(long op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(long) * 8), (true)>(op2).operator >=(op); } template <int _AP_W, bool _AP_S> inline bool operator <=(const ap_private<_AP_W, _AP_S>& op, long op2) { return op.operator <=(ap_private<(sizeof(long) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <=(long op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(long) * 8), (true)>(op2).operator <=(op); } template <int _AP_W, bool _AP_S> inline bool operator ==(const ap_private<_AP_W, _AP_S>& op, long op2) { return op.operator ==(ap_private<(sizeof(long) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator ==(long op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(long) * 8), (true)>(op2).operator ==(op); } template <int _AP_W, bool _AP_S> inline bool operator !=(const ap_private<_AP_W, _AP_S>& op, long op2) { return op.operator !=(ap_private<(sizeof(long) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator !=(long op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(long) * 8), (true)>(op2).operator !=(op); }
template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned long) * 8), (false)>::template RType<_AP_W, _AP_S>::mult operator *(unsigned long i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned long) * 8), (false)>(i_op).operator *(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(unsigned long) * 8), (false)>::mult operator *(const ap_private<_AP_W, _AP_S>& op, unsigned long i_op) { return op.operator *(ap_private<(sizeof(unsigned long) * 8), (false)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned long) * 8), (false)>::template RType<_AP_W, _AP_S>::plus operator +(unsigned long i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned long) * 8), (false)>(i_op).operator +(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(unsigned long) * 8), (false)>::plus operator +(const ap_private<_AP_W, _AP_S>& op, unsigned long i_op) { return op.operator +(ap_private<(sizeof(unsigned long) * 8), (false)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned long) * 8), (false)>::template RType<_AP_W, _AP_S>::minus operator -(unsigned long i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned long) * 8), (false)>(i_op).operator -(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(unsigned long) * 8), (false)>::minus operator -(const ap_private<_AP_W, _AP_S>& op, unsigned long i_op) { return op.operator -(ap_private<(sizeof(unsigned long) * 8), (false)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned long) * 8), (false)>::template RType<_AP_W, _AP_S>::div operator /(unsigned long i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned long) * 8), (false)>(i_op).operator /(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(unsigned long) * 8), (false)>::div operator /(const ap_private<_AP_W, _AP_S>& op, unsigned long i_op) { return op.operator /(ap_private<(sizeof(unsigned long) * 8), (false)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned long) * 8), (false)>::template RType<_AP_W, _AP_S>::mod operator %(unsigned long i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned long) * 8), (false)>(i_op).operator %(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(unsigned long) * 8), (false)>::mod operator %(const ap_private<_AP_W, _AP_S>& op, unsigned long i_op) { return op.operator %(ap_private<(sizeof(unsigned long) * 8), (false)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned long) * 8), (false)>::template RType<_AP_W, _AP_S>::logic operator &(unsigned long i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned long) * 8), (false)>(i_op).operator &(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(unsigned long) * 8), (false)>::logic operator &(const ap_private<_AP_W, _AP_S>& op, unsigned long i_op) { return op.operator &(ap_private<(sizeof(unsigned long) * 8), (false)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned long) * 8), (false)>::template RType<_AP_W, _AP_S>::logic operator |(unsigned long i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned long) * 8), (false)>(i_op).operator |(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(unsigned long) * 8), (false)>::logic operator |(const ap_private<_AP_W, _AP_S>& op, unsigned long i_op) { return op.operator |(ap_private<(sizeof(unsigned long) * 8), (false)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned long) * 8), (false)>::template RType<_AP_W, _AP_S>::logic operator ^(unsigned long i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned long) * 8), (false)>(i_op).operator ^(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(unsigned long) * 8), (false)>::logic operator ^(const ap_private<_AP_W, _AP_S>& op, unsigned long i_op) { return op.operator ^(ap_private<(sizeof(unsigned long) * 8), (false)>(i_op)); } template <int _AP_W, bool _AP_S> unsigned long operator >>(unsigned long i_op, const ap_private<_AP_W, _AP_S, false>& op) { return i_op >>(op.get_VAL()); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(unsigned long) * 8), (false)>::arg1 operator >>(const ap_private<_AP_W, _AP_S>& op, unsigned long i_op) { return op.operator >>(i_op); } template <int _AP_W, bool _AP_S> unsigned long operator <<(unsigned long i_op, const ap_private<_AP_W, _AP_S, false>& op) { return i_op <<(op.get_VAL()); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(unsigned long) * 8), (false)>::arg1 operator <<(const ap_private<_AP_W, _AP_S>& op, unsigned long i_op) { return op.operator <<(i_op); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator +=( ap_private<_AP_W, _AP_S>& op, unsigned long op2) { return op.operator +=(ap_private<(sizeof(unsigned long) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator -=( ap_private<_AP_W, _AP_S>& op, unsigned long op2) { return op.operator -=(ap_private<(sizeof(unsigned long) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator *=( ap_private<_AP_W, _AP_S>& op, unsigned long op2) { return op.operator *=(ap_private<(sizeof(unsigned long) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator /=( ap_private<_AP_W, _AP_S>& op, unsigned long op2) { return op.operator /=(ap_private<(sizeof(unsigned long) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator %=( ap_private<_AP_W, _AP_S>& op, unsigned long op2) { return op.operator %=(ap_private<(sizeof(unsigned long) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator &=( ap_private<_AP_W, _AP_S>& op, unsigned long op2) { return op.operator &=(ap_private<(sizeof(unsigned long) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator |=( ap_private<_AP_W, _AP_S>& op, unsigned long op2) { return op.operator |=(ap_private<(sizeof(unsigned long) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator ^=( ap_private<_AP_W, _AP_S>& op, unsigned long op2) { return op.operator ^=(ap_private<(sizeof(unsigned long) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator >>=( ap_private<_AP_W, _AP_S>& op, unsigned long op2) { op = op.operator>>(op2); return op; } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator <<=( ap_private<_AP_W, _AP_S>& op, unsigned long op2) { op = op.operator<<(op2); return op; } template <int _AP_W, bool _AP_S> inline bool operator >(const ap_private<_AP_W, _AP_S>& op, unsigned long op2) { return op.operator >(ap_private<(sizeof(unsigned long) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >(unsigned long op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(unsigned long) * 8), (false)>(op2).operator >(op); } template <int _AP_W, bool _AP_S> inline bool operator <(const ap_private<_AP_W, _AP_S>& op, unsigned long op2) { return op.operator <(ap_private<(sizeof(unsigned long) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <(unsigned long op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(unsigned long) * 8), (false)>(op2).operator <(op); } template <int _AP_W, bool _AP_S> inline bool operator >=(const ap_private<_AP_W, _AP_S>& op, unsigned long op2) { return op.operator >=(ap_private<(sizeof(unsigned long) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >=(unsigned long op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(unsigned long) * 8), (false)>(op2).operator >=(op); } template <int _AP_W, bool _AP_S> inline bool operator <=(const ap_private<_AP_W, _AP_S>& op, unsigned long op2) { return op.operator <=(ap_private<(sizeof(unsigned long) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <=(unsigned long op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(unsigned long) * 8), (false)>(op2).operator <=(op); } template <int _AP_W, bool _AP_S> inline bool operator ==(const ap_private<_AP_W, _AP_S>& op, unsigned long op2) { return op.operator ==(ap_private<(sizeof(unsigned long) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator ==(unsigned long op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(unsigned long) * 8), (false)>(op2).operator ==(op); } template <int _AP_W, bool _AP_S> inline bool operator !=(const ap_private<_AP_W, _AP_S>& op, unsigned long op2) { return op.operator !=(ap_private<(sizeof(unsigned long) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator !=(unsigned long op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(unsigned long) * 8), (false)>(op2).operator !=(op); }
template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(ap_slong) * 8), (true)>::template RType<_AP_W, _AP_S>::mult operator *(ap_slong i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_slong) * 8), (true)>(i_op).operator *(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(ap_slong) * 8), (true)>::mult operator *(const ap_private<_AP_W, _AP_S>& op, ap_slong i_op) { return op.operator *(ap_private<(sizeof(ap_slong) * 8), (true)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(ap_slong) * 8), (true)>::template RType<_AP_W, _AP_S>::plus operator +(ap_slong i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_slong) * 8), (true)>(i_op).operator +(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(ap_slong) * 8), (true)>::plus operator +(const ap_private<_AP_W, _AP_S>& op, ap_slong i_op) { return op.operator +(ap_private<(sizeof(ap_slong) * 8), (true)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(ap_slong) * 8), (true)>::template RType<_AP_W, _AP_S>::minus operator -(ap_slong i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_slong) * 8), (true)>(i_op).operator -(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(ap_slong) * 8), (true)>::minus operator -(const ap_private<_AP_W, _AP_S>& op, ap_slong i_op) { return op.operator -(ap_private<(sizeof(ap_slong) * 8), (true)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(ap_slong) * 8), (true)>::template RType<_AP_W, _AP_S>::div operator /(ap_slong i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_slong) * 8), (true)>(i_op).operator /(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(ap_slong) * 8), (true)>::div operator /(const ap_private<_AP_W, _AP_S>& op, ap_slong i_op) { return op.operator /(ap_private<(sizeof(ap_slong) * 8), (true)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(ap_slong) * 8), (true)>::template RType<_AP_W, _AP_S>::mod operator %(ap_slong i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_slong) * 8), (true)>(i_op).operator %(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(ap_slong) * 8), (true)>::mod operator %(const ap_private<_AP_W, _AP_S>& op, ap_slong i_op) { return op.operator %(ap_private<(sizeof(ap_slong) * 8), (true)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(ap_slong) * 8), (true)>::template RType<_AP_W, _AP_S>::logic operator &(ap_slong i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_slong) * 8), (true)>(i_op).operator &(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(ap_slong) * 8), (true)>::logic operator &(const ap_private<_AP_W, _AP_S>& op, ap_slong i_op) { return op.operator &(ap_private<(sizeof(ap_slong) * 8), (true)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(ap_slong) * 8), (true)>::template RType<_AP_W, _AP_S>::logic operator |(ap_slong i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_slong) * 8), (true)>(i_op).operator |(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(ap_slong) * 8), (true)>::logic operator |(const ap_private<_AP_W, _AP_S>& op, ap_slong i_op) { return op.operator |(ap_private<(sizeof(ap_slong) * 8), (true)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(ap_slong) * 8), (true)>::template RType<_AP_W, _AP_S>::logic operator ^(ap_slong i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_slong) * 8), (true)>(i_op).operator ^(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(ap_slong) * 8), (true)>::logic operator ^(const ap_private<_AP_W, _AP_S>& op, ap_slong i_op) { return op.operator ^(ap_private<(sizeof(ap_slong) * 8), (true)>(i_op)); } template <int _AP_W, bool _AP_S> ap_slong operator >>(ap_slong i_op, const ap_private<_AP_W, _AP_S, false>& op) { return i_op >>(op.get_VAL()); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(ap_slong) * 8), (true)>::arg1 operator >>(const ap_private<_AP_W, _AP_S>& op, ap_slong i_op) { return op.operator >>(i_op); } template <int _AP_W, bool _AP_S> ap_slong operator <<(ap_slong i_op, const ap_private<_AP_W, _AP_S, false>& op) { return i_op <<(op.get_VAL()); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(ap_slong) * 8), (true)>::arg1 operator <<(const ap_private<_AP_W, _AP_S>& op, ap_slong i_op) { return op.operator <<(i_op); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator +=( ap_private<_AP_W, _AP_S>& op, ap_slong op2) { return op.operator +=(ap_private<(sizeof(ap_slong) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator -=( ap_private<_AP_W, _AP_S>& op, ap_slong op2) { return op.operator -=(ap_private<(sizeof(ap_slong) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator *=( ap_private<_AP_W, _AP_S>& op, ap_slong op2) { return op.operator *=(ap_private<(sizeof(ap_slong) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator /=( ap_private<_AP_W, _AP_S>& op, ap_slong op2) { return op.operator /=(ap_private<(sizeof(ap_slong) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator %=( ap_private<_AP_W, _AP_S>& op, ap_slong op2) { return op.operator %=(ap_private<(sizeof(ap_slong) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator &=( ap_private<_AP_W, _AP_S>& op, ap_slong op2) { return op.operator &=(ap_private<(sizeof(ap_slong) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator |=( ap_private<_AP_W, _AP_S>& op, ap_slong op2) { return op.operator |=(ap_private<(sizeof(ap_slong) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator ^=( ap_private<_AP_W, _AP_S>& op, ap_slong op2) { return op.operator ^=(ap_private<(sizeof(ap_slong) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator >>=( ap_private<_AP_W, _AP_S>& op, ap_slong op2) { op = op.operator>>(op2); return op; } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator <<=( ap_private<_AP_W, _AP_S>& op, ap_slong op2) { op = op.operator<<(op2); return op; } template <int _AP_W, bool _AP_S> inline bool operator >(const ap_private<_AP_W, _AP_S>& op, ap_slong op2) { return op.operator >(ap_private<(sizeof(ap_slong) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >(ap_slong op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(ap_slong) * 8), (true)>(op2).operator >(op); } template <int _AP_W, bool _AP_S> inline bool operator <(const ap_private<_AP_W, _AP_S>& op, ap_slong op2) { return op.operator <(ap_private<(sizeof(ap_slong) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <(ap_slong op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(ap_slong) * 8), (true)>(op2).operator <(op); } template <int _AP_W, bool _AP_S> inline bool operator >=(const ap_private<_AP_W, _AP_S>& op, ap_slong op2) { return op.operator >=(ap_private<(sizeof(ap_slong) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >=(ap_slong op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(ap_slong) * 8), (true)>(op2).operator >=(op); } template <int _AP_W, bool _AP_S> inline bool operator <=(const ap_private<_AP_W, _AP_S>& op, ap_slong op2) { return op.operator <=(ap_private<(sizeof(ap_slong) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <=(ap_slong op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(ap_slong) * 8), (true)>(op2).operator <=(op); } template <int _AP_W, bool _AP_S> inline bool operator ==(const ap_private<_AP_W, _AP_S>& op, ap_slong op2) { return op.operator ==(ap_private<(sizeof(ap_slong) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator ==(ap_slong op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(ap_slong) * 8), (true)>(op2).operator ==(op); } template <int _AP_W, bool _AP_S> inline bool operator !=(const ap_private<_AP_W, _AP_S>& op, ap_slong op2) { return op.operator !=(ap_private<(sizeof(ap_slong) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator !=(ap_slong op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(ap_slong) * 8), (true)>(op2).operator !=(op); }
template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(ap_ulong) * 8), (false)>::template RType<_AP_W, _AP_S>::mult operator *(ap_ulong i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_ulong) * 8), (false)>(i_op).operator *(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(ap_ulong) * 8), (false)>::mult operator *(const ap_private<_AP_W, _AP_S>& op, ap_ulong i_op) { return op.operator *(ap_private<(sizeof(ap_ulong) * 8), (false)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(ap_ulong) * 8), (false)>::template RType<_AP_W, _AP_S>::plus operator +(ap_ulong i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_ulong) * 8), (false)>(i_op).operator +(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(ap_ulong) * 8), (false)>::plus operator +(const ap_private<_AP_W, _AP_S>& op, ap_ulong i_op) { return op.operator +(ap_private<(sizeof(ap_ulong) * 8), (false)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(ap_ulong) * 8), (false)>::template RType<_AP_W, _AP_S>::minus operator -(ap_ulong i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_ulong) * 8), (false)>(i_op).operator -(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(ap_ulong) * 8), (false)>::minus operator -(const ap_private<_AP_W, _AP_S>& op, ap_ulong i_op) { return op.operator -(ap_private<(sizeof(ap_ulong) * 8), (false)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(ap_ulong) * 8), (false)>::template RType<_AP_W, _AP_S>::div operator /(ap_ulong i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_ulong) * 8), (false)>(i_op).operator /(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(ap_ulong) * 8), (false)>::div operator /(const ap_private<_AP_W, _AP_S>& op, ap_ulong i_op) { return op.operator /(ap_private<(sizeof(ap_ulong) * 8), (false)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(ap_ulong) * 8), (false)>::template RType<_AP_W, _AP_S>::mod operator %(ap_ulong i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_ulong) * 8), (false)>(i_op).operator %(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(ap_ulong) * 8), (false)>::mod operator %(const ap_private<_AP_W, _AP_S>& op, ap_ulong i_op) { return op.operator %(ap_private<(sizeof(ap_ulong) * 8), (false)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(ap_ulong) * 8), (false)>::template RType<_AP_W, _AP_S>::logic operator &(ap_ulong i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_ulong) * 8), (false)>(i_op).operator &(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(ap_ulong) * 8), (false)>::logic operator &(const ap_private<_AP_W, _AP_S>& op, ap_ulong i_op) { return op.operator &(ap_private<(sizeof(ap_ulong) * 8), (false)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(ap_ulong) * 8), (false)>::template RType<_AP_W, _AP_S>::logic operator |(ap_ulong i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_ulong) * 8), (false)>(i_op).operator |(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(ap_ulong) * 8), (false)>::logic operator |(const ap_private<_AP_W, _AP_S>& op, ap_ulong i_op) { return op.operator |(ap_private<(sizeof(ap_ulong) * 8), (false)>(i_op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(ap_ulong) * 8), (false)>::template RType<_AP_W, _AP_S>::logic operator ^(ap_ulong i_op, const ap_private<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_ulong) * 8), (false)>(i_op).operator ^(op); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(ap_ulong) * 8), (false)>::logic operator ^(const ap_private<_AP_W, _AP_S>& op, ap_ulong i_op) { return op.operator ^(ap_private<(sizeof(ap_ulong) * 8), (false)>(i_op)); } template <int _AP_W, bool _AP_S> ap_ulong operator >>(ap_ulong i_op, const ap_private<_AP_W, _AP_S, false>& op) { return i_op >>(op.get_VAL()); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(ap_ulong) * 8), (false)>::arg1 operator >>(const ap_private<_AP_W, _AP_S>& op, ap_ulong i_op) { return op.operator >>(i_op); } template <int _AP_W, bool _AP_S> ap_ulong operator <<(ap_ulong i_op, const ap_private<_AP_W, _AP_S, false>& op) { return i_op <<(op.get_VAL()); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, _AP_S>::template RType<(sizeof(ap_ulong) * 8), (false)>::arg1 operator <<(const ap_private<_AP_W, _AP_S>& op, ap_ulong i_op) { return op.operator <<(i_op); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator +=( ap_private<_AP_W, _AP_S>& op, ap_ulong op2) { return op.operator +=(ap_private<(sizeof(ap_ulong) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator -=( ap_private<_AP_W, _AP_S>& op, ap_ulong op2) { return op.operator -=(ap_private<(sizeof(ap_ulong) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator *=( ap_private<_AP_W, _AP_S>& op, ap_ulong op2) { return op.operator *=(ap_private<(sizeof(ap_ulong) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator /=( ap_private<_AP_W, _AP_S>& op, ap_ulong op2) { return op.operator /=(ap_private<(sizeof(ap_ulong) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator %=( ap_private<_AP_W, _AP_S>& op, ap_ulong op2) { return op.operator %=(ap_private<(sizeof(ap_ulong) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator &=( ap_private<_AP_W, _AP_S>& op, ap_ulong op2) { return op.operator &=(ap_private<(sizeof(ap_ulong) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator |=( ap_private<_AP_W, _AP_S>& op, ap_ulong op2) { return op.operator |=(ap_private<(sizeof(ap_ulong) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator ^=( ap_private<_AP_W, _AP_S>& op, ap_ulong op2) { return op.operator ^=(ap_private<(sizeof(ap_ulong) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator >>=( ap_private<_AP_W, _AP_S>& op, ap_ulong op2) { op = op.operator>>(op2); return op; } template <int _AP_W, bool _AP_S> inline ap_private<_AP_W, _AP_S>& operator <<=( ap_private<_AP_W, _AP_S>& op, ap_ulong op2) { op = op.operator<<(op2); return op; } template <int _AP_W, bool _AP_S> inline bool operator >(const ap_private<_AP_W, _AP_S>& op, ap_ulong op2) { return op.operator >(ap_private<(sizeof(ap_ulong) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >(ap_ulong op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(ap_ulong) * 8), (false)>(op2).operator >(op); } template <int _AP_W, bool _AP_S> inline bool operator <(const ap_private<_AP_W, _AP_S>& op, ap_ulong op2) { return op.operator <(ap_private<(sizeof(ap_ulong) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <(ap_ulong op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(ap_ulong) * 8), (false)>(op2).operator <(op); } template <int _AP_W, bool _AP_S> inline bool operator >=(const ap_private<_AP_W, _AP_S>& op, ap_ulong op2) { return op.operator >=(ap_private<(sizeof(ap_ulong) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >=(ap_ulong op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(ap_ulong) * 8), (false)>(op2).operator >=(op); } template <int _AP_W, bool _AP_S> inline bool operator <=(const ap_private<_AP_W, _AP_S>& op, ap_ulong op2) { return op.operator <=(ap_private<(sizeof(ap_ulong) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <=(ap_ulong op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(ap_ulong) * 8), (false)>(op2).operator <=(op); } template <int _AP_W, bool _AP_S> inline bool operator ==(const ap_private<_AP_W, _AP_S>& op, ap_ulong op2) { return op.operator ==(ap_private<(sizeof(ap_ulong) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator ==(ap_ulong op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(ap_ulong) * 8), (false)>(op2).operator ==(op); } template <int _AP_W, bool _AP_S> inline bool operator !=(const ap_private<_AP_W, _AP_S>& op, ap_ulong op2) { return op.operator !=(ap_private<(sizeof(ap_ulong) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator !=(ap_ulong op2, const ap_private<_AP_W, _AP_S, false>& op) { return ap_private<(sizeof(ap_ulong) * 8), (false)>(op2).operator !=(op); }
# 6977 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline typename ap_private<_AP_W1, _AP_S1>::template RType<_AP_W2, _AP_S2>::plus operator +(const _private_range_ref<_AP_W1, _AP_S1>& op1, const ap_private<_AP_W2, _AP_S2>& op2) { return ap_private<_AP_W1, false>(op1).operator +(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline typename ap_private<_AP_W1, _AP_S1>::template RType<_AP_W2, _AP_S2>::plus operator +(const ap_private<_AP_W1, _AP_S1>& op1, const _private_range_ref<_AP_W2, _AP_S2>& op2) { return op1.operator +(ap_private<_AP_W2, false>(op2)); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline typename ap_private<_AP_W1, _AP_S1>::template RType<_AP_W2, _AP_S2>::minus operator -(const _private_range_ref<_AP_W1, _AP_S1>& op1, const ap_private<_AP_W2, _AP_S2>& op2) { return ap_private<_AP_W1, false>(op1).operator -(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline typename ap_private<_AP_W1, _AP_S1>::template RType<_AP_W2, _AP_S2>::minus operator -(const ap_private<_AP_W1, _AP_S1>& op1, const _private_range_ref<_AP_W2, _AP_S2>& op2) { return op1.operator -(ap_private<_AP_W2, false>(op2)); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline typename ap_private<_AP_W1, _AP_S1>::template RType<_AP_W2, _AP_S2>::mult operator *(const _private_range_ref<_AP_W1, _AP_S1>& op1, const ap_private<_AP_W2, _AP_S2>& op2) { return ap_private<_AP_W1, false>(op1).operator *(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline typename ap_private<_AP_W1, _AP_S1>::template RType<_AP_W2, _AP_S2>::mult operator *(const ap_private<_AP_W1, _AP_S1>& op1, const _private_range_ref<_AP_W2, _AP_S2>& op2) { return op1.operator *(ap_private<_AP_W2, false>(op2)); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline typename ap_private<_AP_W1, _AP_S1>::template RType<_AP_W2, _AP_S2>::div operator /(const _private_range_ref<_AP_W1, _AP_S1>& op1, const ap_private<_AP_W2, _AP_S2>& op2) { return ap_private<_AP_W1, false>(op1).operator /(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline typename ap_private<_AP_W1, _AP_S1>::template RType<_AP_W2, _AP_S2>::div operator /(const ap_private<_AP_W1, _AP_S1>& op1, const _private_range_ref<_AP_W2, _AP_S2>& op2) { return op1.operator /(ap_private<_AP_W2, false>(op2)); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline typename ap_private<_AP_W1, _AP_S1>::template RType<_AP_W2, _AP_S2>::mod operator %(const _private_range_ref<_AP_W1, _AP_S1>& op1, const ap_private<_AP_W2, _AP_S2>& op2) { return ap_private<_AP_W1, false>(op1).operator %(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline typename ap_private<_AP_W1, _AP_S1>::template RType<_AP_W2, _AP_S2>::mod operator %(const ap_private<_AP_W1, _AP_S1>& op1, const _private_range_ref<_AP_W2, _AP_S2>& op2) { return op1.operator %(ap_private<_AP_W2, false>(op2)); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline typename ap_private<_AP_W1, _AP_S1>::template RType<_AP_W2, _AP_S2>::logic operator &(const _private_range_ref<_AP_W1, _AP_S1>& op1, const ap_private<_AP_W2, _AP_S2>& op2) { return ap_private<_AP_W1, false>(op1).operator &(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline typename ap_private<_AP_W1, _AP_S1>::template RType<_AP_W2, _AP_S2>::logic operator &(const ap_private<_AP_W1, _AP_S1>& op1, const _private_range_ref<_AP_W2, _AP_S2>& op2) { return op1.operator &(ap_private<_AP_W2, false>(op2)); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline typename ap_private<_AP_W1, _AP_S1>::template RType<_AP_W2, _AP_S2>::logic operator |(const _private_range_ref<_AP_W1, _AP_S1>& op1, const ap_private<_AP_W2, _AP_S2>& op2) { return ap_private<_AP_W1, false>(op1).operator |(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline typename ap_private<_AP_W1, _AP_S1>::template RType<_AP_W2, _AP_S2>::logic operator |(const ap_private<_AP_W1, _AP_S1>& op1, const _private_range_ref<_AP_W2, _AP_S2>& op2) { return op1.operator |(ap_private<_AP_W2, false>(op2)); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline typename ap_private<_AP_W1, _AP_S1>::template RType<_AP_W2, _AP_S2>::logic operator ^(const _private_range_ref<_AP_W1, _AP_S1>& op1, const ap_private<_AP_W2, _AP_S2>& op2) { return ap_private<_AP_W1, false>(op1).operator ^(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline typename ap_private<_AP_W1, _AP_S1>::template RType<_AP_W2, _AP_S2>::logic operator ^(const ap_private<_AP_W1, _AP_S1>& op1, const _private_range_ref<_AP_W2, _AP_S2>& op2) { return op1.operator ^(ap_private<_AP_W2, false>(op2)); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline typename ap_private<_AP_W1, _AP_S1>::template RType<_AP_W2, _AP_S2>::arg1 operator >>(const _private_range_ref<_AP_W1, _AP_S1>& op1, const ap_private<_AP_W2, _AP_S2>& op2) { return ap_private<_AP_W1, false>(op1).operator >>(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline typename ap_private<_AP_W1, _AP_S1>::template RType<_AP_W2, _AP_S2>::arg1 operator >>(const ap_private<_AP_W1, _AP_S1>& op1, const _private_range_ref<_AP_W2, _AP_S2>& op2) { return op1.operator >>(ap_private<_AP_W2, false>(op2)); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline typename ap_private<_AP_W1, _AP_S1>::template RType<_AP_W2, _AP_S2>::arg1 operator <<(const _private_range_ref<_AP_W1, _AP_S1>& op1, const ap_private<_AP_W2, _AP_S2>& op2) { return ap_private<_AP_W1, false>(op1).operator <<(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline typename ap_private<_AP_W1, _AP_S1>::template RType<_AP_W2, _AP_S2>::arg1 operator <<(const ap_private<_AP_W1, _AP_S1>& op1, const _private_range_ref<_AP_W2, _AP_S2>& op2) { return op1.operator <<(ap_private<_AP_W2, false>(op2)); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline ap_private<_AP_W1, _AP_S1>& operator +=( ap_private<_AP_W1, _AP_S1>& op1, const _private_range_ref<_AP_W2, _AP_S2>& op2) { return op1.operator +=(ap_private<_AP_W2, false>(op2)); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline _private_range_ref<_AP_W1, _AP_S1>& operator +=( _private_range_ref<_AP_W1, _AP_S1>& op1, ap_private<_AP_W2, _AP_S2>& op2) { ap_private<_AP_W1, false> tmp(op1); tmp.operator +=(op2); op1 = tmp; return op1; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline ap_private<_AP_W1, _AP_S1>& operator -=( ap_private<_AP_W1, _AP_S1>& op1, const _private_range_ref<_AP_W2, _AP_S2>& op2) { return op1.operator -=(ap_private<_AP_W2, false>(op2)); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline _private_range_ref<_AP_W1, _AP_S1>& operator -=( _private_range_ref<_AP_W1, _AP_S1>& op1, ap_private<_AP_W2, _AP_S2>& op2) { ap_private<_AP_W1, false> tmp(op1); tmp.operator -=(op2); op1 = tmp; return op1; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline ap_private<_AP_W1, _AP_S1>& operator *=( ap_private<_AP_W1, _AP_S1>& op1, const _private_range_ref<_AP_W2, _AP_S2>& op2) { return op1.operator *=(ap_private<_AP_W2, false>(op2)); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline _private_range_ref<_AP_W1, _AP_S1>& operator *=( _private_range_ref<_AP_W1, _AP_S1>& op1, ap_private<_AP_W2, _AP_S2>& op2) { ap_private<_AP_W1, false> tmp(op1); tmp.operator *=(op2); op1 = tmp; return op1; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline ap_private<_AP_W1, _AP_S1>& operator /=( ap_private<_AP_W1, _AP_S1>& op1, const _private_range_ref<_AP_W2, _AP_S2>& op2) { return op1.operator /=(ap_private<_AP_W2, false>(op2)); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline _private_range_ref<_AP_W1, _AP_S1>& operator /=( _private_range_ref<_AP_W1, _AP_S1>& op1, ap_private<_AP_W2, _AP_S2>& op2) { ap_private<_AP_W1, false> tmp(op1); tmp.operator /=(op2); op1 = tmp; return op1; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline ap_private<_AP_W1, _AP_S1>& operator %=( ap_private<_AP_W1, _AP_S1>& op1, const _private_range_ref<_AP_W2, _AP_S2>& op2) { return op1.operator %=(ap_private<_AP_W2, false>(op2)); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline _private_range_ref<_AP_W1, _AP_S1>& operator %=( _private_range_ref<_AP_W1, _AP_S1>& op1, ap_private<_AP_W2, _AP_S2>& op2) { ap_private<_AP_W1, false> tmp(op1); tmp.operator %=(op2); op1 = tmp; return op1; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline ap_private<_AP_W1, _AP_S1>& operator &=( ap_private<_AP_W1, _AP_S1>& op1, const _private_range_ref<_AP_W2, _AP_S2>& op2) { return op1.operator &=(ap_private<_AP_W2, false>(op2)); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline _private_range_ref<_AP_W1, _AP_S1>& operator &=( _private_range_ref<_AP_W1, _AP_S1>& op1, ap_private<_AP_W2, _AP_S2>& op2) { ap_private<_AP_W1, false> tmp(op1); tmp.operator &=(op2); op1 = tmp; return op1; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline ap_private<_AP_W1, _AP_S1>& operator |=( ap_private<_AP_W1, _AP_S1>& op1, const _private_range_ref<_AP_W2, _AP_S2>& op2) { return op1.operator |=(ap_private<_AP_W2, false>(op2)); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline _private_range_ref<_AP_W1, _AP_S1>& operator |=( _private_range_ref<_AP_W1, _AP_S1>& op1, ap_private<_AP_W2, _AP_S2>& op2) { ap_private<_AP_W1, false> tmp(op1); tmp.operator |=(op2); op1 = tmp; return op1; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline ap_private<_AP_W1, _AP_S1>& operator ^=( ap_private<_AP_W1, _AP_S1>& op1, const _private_range_ref<_AP_W2, _AP_S2>& op2) { return op1.operator ^=(ap_private<_AP_W2, false>(op2)); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline _private_range_ref<_AP_W1, _AP_S1>& operator ^=( _private_range_ref<_AP_W1, _AP_S1>& op1, ap_private<_AP_W2, _AP_S2>& op2) { ap_private<_AP_W1, false> tmp(op1); tmp.operator ^=(op2); op1 = tmp; return op1; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline ap_private<_AP_W1, _AP_S1>& operator >>=( ap_private<_AP_W1, _AP_S1>& op1, const _private_range_ref<_AP_W2, _AP_S2>& op2) { return op1.operator >>=(ap_private<_AP_W2, false>(op2)); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline _private_range_ref<_AP_W1, _AP_S1>& operator >>=( _private_range_ref<_AP_W1, _AP_S1>& op1, ap_private<_AP_W2, _AP_S2>& op2) { ap_private<_AP_W1, false> tmp(op1); tmp.operator >>=(op2); op1 = tmp; return op1; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline ap_private<_AP_W1, _AP_S1>& operator <<=( ap_private<_AP_W1, _AP_S1>& op1, const _private_range_ref<_AP_W2, _AP_S2>& op2) { return op1.operator <<=(ap_private<_AP_W2, false>(op2)); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline _private_range_ref<_AP_W1, _AP_S1>& operator <<=( _private_range_ref<_AP_W1, _AP_S1>& op1, ap_private<_AP_W2, _AP_S2>& op2) { ap_private<_AP_W1, false> tmp(op1); tmp.operator <<=(op2); op1 = tmp; return op1; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline bool operator >(const _private_range_ref<_AP_W1, _AP_S1>& op1, const ap_private<_AP_W2, _AP_S2>& op2) { return ap_private<_AP_W1, false>(op1).operator >(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline bool operator >(const ap_private<_AP_W1, _AP_S1>& op1, const _private_range_ref<_AP_W2, _AP_S2>& op2) { return op1.operator >(op2.operator ap_private<_AP_W2, false>()); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline bool operator <(const _private_range_ref<_AP_W1, _AP_S1>& op1, const ap_private<_AP_W2, _AP_S2>& op2) { return ap_private<_AP_W1, false>(op1).operator <(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline bool operator <(const ap_private<_AP_W1, _AP_S1>& op1, const _private_range_ref<_AP_W2, _AP_S2>& op2) { return op1.operator <(op2.operator ap_private<_AP_W2, false>()); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline bool operator >=(const _private_range_ref<_AP_W1, _AP_S1>& op1, const ap_private<_AP_W2, _AP_S2>& op2) { return ap_private<_AP_W1, false>(op1).operator >=(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline bool operator >=(const ap_private<_AP_W1, _AP_S1>& op1, const _private_range_ref<_AP_W2, _AP_S2>& op2) { return op1.operator >=(op2.operator ap_private<_AP_W2, false>()); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline bool operator <=(const _private_range_ref<_AP_W1, _AP_S1>& op1, const ap_private<_AP_W2, _AP_S2>& op2) { return ap_private<_AP_W1, false>(op1).operator <=(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline bool operator <=(const ap_private<_AP_W1, _AP_S1>& op1, const _private_range_ref<_AP_W2, _AP_S2>& op2) { return op1.operator <=(op2.operator ap_private<_AP_W2, false>()); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline bool operator ==(const _private_range_ref<_AP_W1, _AP_S1>& op1, const ap_private<_AP_W2, _AP_S2>& op2) { return ap_private<_AP_W1, false>(op1).operator ==(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline bool operator ==(const ap_private<_AP_W1, _AP_S1>& op1, const _private_range_ref<_AP_W2, _AP_S2>& op2) { return op1.operator ==(op2.operator ap_private<_AP_W2, false>()); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline bool operator !=(const _private_range_ref<_AP_W1, _AP_S1>& op1, const ap_private<_AP_W2, _AP_S2>& op2) { return ap_private<_AP_W1, false>(op1).operator !=(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline bool operator !=(const ap_private<_AP_W1, _AP_S1>& op1, const _private_range_ref<_AP_W2, _AP_S2>& op2) { return op1.operator !=(op2.operator ap_private<_AP_W2, false>()); }
# 7052 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline ap_private<_AP_W1, _AP_S1>& operator +=( ap_private<_AP_W1, _AP_S1>& op1, _private_bit_ref<_AP_W2, _AP_S2>& op2) { return op1.operator +=(ap_private<1, false>(op2)); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline _private_bit_ref<_AP_W1, _AP_S1>& operator +=( _private_bit_ref<_AP_W1, _AP_S1>& op1, ap_private<_AP_W2, _AP_S2>& op2) { ap_private<1, false> tmp(op1); tmp.operator +=(op2); op1 = tmp; return op1; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline ap_private<_AP_W1, _AP_S1>& operator -=( ap_private<_AP_W1, _AP_S1>& op1, _private_bit_ref<_AP_W2, _AP_S2>& op2) { return op1.operator -=(ap_private<1, false>(op2)); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline _private_bit_ref<_AP_W1, _AP_S1>& operator -=( _private_bit_ref<_AP_W1, _AP_S1>& op1, ap_private<_AP_W2, _AP_S2>& op2) { ap_private<1, false> tmp(op1); tmp.operator -=(op2); op1 = tmp; return op1; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline ap_private<_AP_W1, _AP_S1>& operator *=( ap_private<_AP_W1, _AP_S1>& op1, _private_bit_ref<_AP_W2, _AP_S2>& op2) { return op1.operator *=(ap_private<1, false>(op2)); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline _private_bit_ref<_AP_W1, _AP_S1>& operator *=( _private_bit_ref<_AP_W1, _AP_S1>& op1, ap_private<_AP_W2, _AP_S2>& op2) { ap_private<1, false> tmp(op1); tmp.operator *=(op2); op1 = tmp; return op1; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline ap_private<_AP_W1, _AP_S1>& operator /=( ap_private<_AP_W1, _AP_S1>& op1, _private_bit_ref<_AP_W2, _AP_S2>& op2) { return op1.operator /=(ap_private<1, false>(op2)); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline _private_bit_ref<_AP_W1, _AP_S1>& operator /=( _private_bit_ref<_AP_W1, _AP_S1>& op1, ap_private<_AP_W2, _AP_S2>& op2) { ap_private<1, false> tmp(op1); tmp.operator /=(op2); op1 = tmp; return op1; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline ap_private<_AP_W1, _AP_S1>& operator %=( ap_private<_AP_W1, _AP_S1>& op1, _private_bit_ref<_AP_W2, _AP_S2>& op2) { return op1.operator %=(ap_private<1, false>(op2)); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline _private_bit_ref<_AP_W1, _AP_S1>& operator %=( _private_bit_ref<_AP_W1, _AP_S1>& op1, ap_private<_AP_W2, _AP_S2>& op2) { ap_private<1, false> tmp(op1); tmp.operator %=(op2); op1 = tmp; return op1; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline ap_private<_AP_W1, _AP_S1>& operator &=( ap_private<_AP_W1, _AP_S1>& op1, _private_bit_ref<_AP_W2, _AP_S2>& op2) { return op1.operator &=(ap_private<1, false>(op2)); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline _private_bit_ref<_AP_W1, _AP_S1>& operator &=( _private_bit_ref<_AP_W1, _AP_S1>& op1, ap_private<_AP_W2, _AP_S2>& op2) { ap_private<1, false> tmp(op1); tmp.operator &=(op2); op1 = tmp; return op1; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline ap_private<_AP_W1, _AP_S1>& operator |=( ap_private<_AP_W1, _AP_S1>& op1, _private_bit_ref<_AP_W2, _AP_S2>& op2) { return op1.operator |=(ap_private<1, false>(op2)); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline _private_bit_ref<_AP_W1, _AP_S1>& operator |=( _private_bit_ref<_AP_W1, _AP_S1>& op1, ap_private<_AP_W2, _AP_S2>& op2) { ap_private<1, false> tmp(op1); tmp.operator |=(op2); op1 = tmp; return op1; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline ap_private<_AP_W1, _AP_S1>& operator ^=( ap_private<_AP_W1, _AP_S1>& op1, _private_bit_ref<_AP_W2, _AP_S2>& op2) { return op1.operator ^=(ap_private<1, false>(op2)); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline _private_bit_ref<_AP_W1, _AP_S1>& operator ^=( _private_bit_ref<_AP_W1, _AP_S1>& op1, ap_private<_AP_W2, _AP_S2>& op2) { ap_private<1, false> tmp(op1); tmp.operator ^=(op2); op1 = tmp; return op1; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline ap_private<_AP_W1, _AP_S1>& operator >>=( ap_private<_AP_W1, _AP_S1>& op1, _private_bit_ref<_AP_W2, _AP_S2>& op2) { return op1.operator >>=(ap_private<1, false>(op2)); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline _private_bit_ref<_AP_W1, _AP_S1>& operator >>=( _private_bit_ref<_AP_W1, _AP_S1>& op1, ap_private<_AP_W2, _AP_S2>& op2) { ap_private<1, false> tmp(op1); tmp.operator >>=(op2); op1 = tmp; return op1; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline ap_private<_AP_W1, _AP_S1>& operator <<=( ap_private<_AP_W1, _AP_S1>& op1, _private_bit_ref<_AP_W2, _AP_S2>& op2) { return op1.operator <<=(ap_private<1, false>(op2)); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline _private_bit_ref<_AP_W1, _AP_S1>& operator <<=( _private_bit_ref<_AP_W1, _AP_S1>& op1, ap_private<_AP_W2, _AP_S2>& op2) { ap_private<1, false> tmp(op1); tmp.operator <<=(op2); op1 = tmp; return op1; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline typename ap_private<1, false>::template RType<_AP_W2, _AP_S2>::plus operator +(const _private_bit_ref<_AP_W1, _AP_S1>& op1, const ap_private<_AP_W2, _AP_S2>& op2) { return ap_private<1, false>(op1).operator +(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline typename ap_private<_AP_W1, _AP_S1>::template RType<1, false>::plus operator +(const ap_private<_AP_W1, _AP_S1>& op1, const _private_bit_ref<_AP_W2, _AP_S2>& op2) { return op1.operator +(ap_private<1, false>(op2)); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline typename ap_private<1, false>::template RType<_AP_W2, _AP_S2>::minus operator -(const _private_bit_ref<_AP_W1, _AP_S1>& op1, const ap_private<_AP_W2, _AP_S2>& op2) { return ap_private<1, false>(op1).operator -(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline typename ap_private<_AP_W1, _AP_S1>::template RType<1, false>::minus operator -(const ap_private<_AP_W1, _AP_S1>& op1, const _private_bit_ref<_AP_W2, _AP_S2>& op2) { return op1.operator -(ap_private<1, false>(op2)); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline typename ap_private<1, false>::template RType<_AP_W2, _AP_S2>::mult operator *(const _private_bit_ref<_AP_W1, _AP_S1>& op1, const ap_private<_AP_W2, _AP_S2>& op2) { return ap_private<1, false>(op1).operator *(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline typename ap_private<_AP_W1, _AP_S1>::template RType<1, false>::mult operator *(const ap_private<_AP_W1, _AP_S1>& op1, const _private_bit_ref<_AP_W2, _AP_S2>& op2) { return op1.operator *(ap_private<1, false>(op2)); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline typename ap_private<1, false>::template RType<_AP_W2, _AP_S2>::div operator /(const _private_bit_ref<_AP_W1, _AP_S1>& op1, const ap_private<_AP_W2, _AP_S2>& op2) { return ap_private<1, false>(op1).operator /(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline typename ap_private<_AP_W1, _AP_S1>::template RType<1, false>::div operator /(const ap_private<_AP_W1, _AP_S1>& op1, const _private_bit_ref<_AP_W2, _AP_S2>& op2) { return op1.operator /(ap_private<1, false>(op2)); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline typename ap_private<1, false>::template RType<_AP_W2, _AP_S2>::mod operator %(const _private_bit_ref<_AP_W1, _AP_S1>& op1, const ap_private<_AP_W2, _AP_S2>& op2) { return ap_private<1, false>(op1).operator %(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline typename ap_private<_AP_W1, _AP_S1>::template RType<1, false>::mod operator %(const ap_private<_AP_W1, _AP_S1>& op1, const _private_bit_ref<_AP_W2, _AP_S2>& op2) { return op1.operator %(ap_private<1, false>(op2)); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline typename ap_private<1, false>::template RType<_AP_W2, _AP_S2>::logic operator &(const _private_bit_ref<_AP_W1, _AP_S1>& op1, const ap_private<_AP_W2, _AP_S2>& op2) { return ap_private<1, false>(op1).operator &(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline typename ap_private<_AP_W1, _AP_S1>::template RType<1, false>::logic operator &(const ap_private<_AP_W1, _AP_S1>& op1, const _private_bit_ref<_AP_W2, _AP_S2>& op2) { return op1.operator &(ap_private<1, false>(op2)); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline typename ap_private<1, false>::template RType<_AP_W2, _AP_S2>::logic operator |(const _private_bit_ref<_AP_W1, _AP_S1>& op1, const ap_private<_AP_W2, _AP_S2>& op2) { return ap_private<1, false>(op1).operator |(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline typename ap_private<_AP_W1, _AP_S1>::template RType<1, false>::logic operator |(const ap_private<_AP_W1, _AP_S1>& op1, const _private_bit_ref<_AP_W2, _AP_S2>& op2) { return op1.operator |(ap_private<1, false>(op2)); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline typename ap_private<1, false>::template RType<_AP_W2, _AP_S2>::logic operator ^(const _private_bit_ref<_AP_W1, _AP_S1>& op1, const ap_private<_AP_W2, _AP_S2>& op2) { return ap_private<1, false>(op1).operator ^(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline typename ap_private<_AP_W1, _AP_S1>::template RType<1, false>::logic operator ^(const ap_private<_AP_W1, _AP_S1>& op1, const _private_bit_ref<_AP_W2, _AP_S2>& op2) { return op1.operator ^(ap_private<1, false>(op2)); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline typename ap_private<1, false>::template RType<_AP_W2, _AP_S2>::arg1 operator >>(const _private_bit_ref<_AP_W1, _AP_S1>& op1, const ap_private<_AP_W2, _AP_S2>& op2) { return ap_private<1, false>(op1).operator >>(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline typename ap_private<_AP_W1, _AP_S1>::template RType<1, false>::arg1 operator >>(const ap_private<_AP_W1, _AP_S1>& op1, const _private_bit_ref<_AP_W2, _AP_S2>& op2) { return op1.operator >>(ap_private<1, false>(op2)); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline typename ap_private<1, false>::template RType<_AP_W2, _AP_S2>::arg1 operator <<(const _private_bit_ref<_AP_W1, _AP_S1>& op1, const ap_private<_AP_W2, _AP_S2>& op2) { return ap_private<1, false>(op1).operator <<(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline typename ap_private<_AP_W1, _AP_S1>::template RType<1, false>::arg1 operator <<(const ap_private<_AP_W1, _AP_S1>& op1, const _private_bit_ref<_AP_W2, _AP_S2>& op2) { return op1.operator <<(ap_private<1, false>(op2)); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline bool operator >(const _private_bit_ref<_AP_W1, _AP_S1>& op1, const ap_private<_AP_W2, _AP_S2>& op2) { return ap_private<_AP_W1, false>(op1).operator >(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline bool operator >(const ap_private<_AP_W1, _AP_S1>& op1, const _private_bit_ref<_AP_W2, _AP_S2>& op2) { return op1.operator >(ap_private<1, false>(op2)); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline bool operator <(const _private_bit_ref<_AP_W1, _AP_S1>& op1, const ap_private<_AP_W2, _AP_S2>& op2) { return ap_private<_AP_W1, false>(op1).operator <(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline bool operator <(const ap_private<_AP_W1, _AP_S1>& op1, const _private_bit_ref<_AP_W2, _AP_S2>& op2) { return op1.operator <(ap_private<1, false>(op2)); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline bool operator <=(const _private_bit_ref<_AP_W1, _AP_S1>& op1, const ap_private<_AP_W2, _AP_S2>& op2) { return ap_private<_AP_W1, false>(op1).operator <=(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline bool operator <=(const ap_private<_AP_W1, _AP_S1>& op1, const _private_bit_ref<_AP_W2, _AP_S2>& op2) { return op1.operator <=(ap_private<1, false>(op2)); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline bool operator >=(const _private_bit_ref<_AP_W1, _AP_S1>& op1, const ap_private<_AP_W2, _AP_S2>& op2) { return ap_private<_AP_W1, false>(op1).operator >=(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline bool operator >=(const ap_private<_AP_W1, _AP_S1>& op1, const _private_bit_ref<_AP_W2, _AP_S2>& op2) { return op1.operator >=(ap_private<1, false>(op2)); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline bool operator ==(const _private_bit_ref<_AP_W1, _AP_S1>& op1, const ap_private<_AP_W2, _AP_S2>& op2) { return ap_private<_AP_W1, false>(op1).operator ==(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline bool operator ==(const ap_private<_AP_W1, _AP_S1>& op1, const _private_bit_ref<_AP_W2, _AP_S2>& op2) { return op1.operator ==(ap_private<1, false>(op2)); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline bool operator !=(const _private_bit_ref<_AP_W1, _AP_S1>& op1, const ap_private<_AP_W2, _AP_S2>& op2) { return ap_private<_AP_W1, false>(op1).operator !=(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline bool operator !=(const ap_private<_AP_W1, _AP_S1>& op1, const _private_bit_ref<_AP_W2, _AP_S2>& op2) { return op1.operator !=(ap_private<1, false>(op2)); }
# 7117 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
template <int _AP_W, bool _AP_S> inline bool operator >(const _private_range_ref<_AP_W, _AP_S>& op, bool op2) { return (ap_private<_AP_W, false>(op)) . operator >(ap_private<(1), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >(bool op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(1), (false)>(op2).operator >( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator >(const _private_bit_ref<_AP_W, _AP_S>& op, bool op2) { return (bool(op))> op2; } template <int _AP_W, bool _AP_S> inline bool operator >(bool op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 >(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator <(const _private_range_ref<_AP_W, _AP_S>& op, bool op2) { return (ap_private<_AP_W, false>(op)) . operator <(ap_private<(1), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <(bool op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(1), (false)>(op2).operator <( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator <(const _private_bit_ref<_AP_W, _AP_S>& op, bool op2) { return (bool(op))< op2; } template <int _AP_W, bool _AP_S> inline bool operator <(bool op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 <(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator >=(const _private_range_ref<_AP_W, _AP_S>& op, bool op2) { return (ap_private<_AP_W, false>(op)) . operator >=(ap_private<(1), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >=(bool op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(1), (false)>(op2).operator >=( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator >=(const _private_bit_ref<_AP_W, _AP_S>& op, bool op2) { return (bool(op))>= op2; } template <int _AP_W, bool _AP_S> inline bool operator >=(bool op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 >=(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator <=(const _private_range_ref<_AP_W, _AP_S>& op, bool op2) { return (ap_private<_AP_W, false>(op)) . operator <=(ap_private<(1), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <=(bool op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(1), (false)>(op2).operator <=( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator <=(const _private_bit_ref<_AP_W, _AP_S>& op, bool op2) { return (bool(op))<= op2; } template <int _AP_W, bool _AP_S> inline bool operator <=(bool op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 <=(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator ==(const _private_range_ref<_AP_W, _AP_S>& op, bool op2) { return (ap_private<_AP_W, false>(op)) . operator ==(ap_private<(1), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator ==(bool op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(1), (false)>(op2).operator ==( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator ==(const _private_bit_ref<_AP_W, _AP_S>& op, bool op2) { return (bool(op))== op2; } template <int _AP_W, bool _AP_S> inline bool operator ==(bool op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 ==(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator !=(const _private_range_ref<_AP_W, _AP_S>& op, bool op2) { return (ap_private<_AP_W, false>(op)) . operator !=(ap_private<(1), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator !=(bool op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(1), (false)>(op2).operator !=( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator !=(const _private_bit_ref<_AP_W, _AP_S>& op, bool op2) { return (bool(op))!= op2; } template <int _AP_W, bool _AP_S> inline bool operator !=(bool op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 !=(bool(op)); }
template <int _AP_W, bool _AP_S> inline bool operator >(const _private_range_ref<_AP_W, _AP_S>& op, char op2) { return (ap_private<_AP_W, false>(op)) . operator >(ap_private<(8), (CHAR_IS_SIGNED)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >(char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (CHAR_IS_SIGNED)>(op2).operator >( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator >(const _private_bit_ref<_AP_W, _AP_S>& op, char op2) { return (bool(op))> op2; } template <int _AP_W, bool _AP_S> inline bool operator >(char op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 >(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator <(const _private_range_ref<_AP_W, _AP_S>& op, char op2) { return (ap_private<_AP_W, false>(op)) . operator <(ap_private<(8), (CHAR_IS_SIGNED)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <(char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (CHAR_IS_SIGNED)>(op2).operator <( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator <(const _private_bit_ref<_AP_W, _AP_S>& op, char op2) { return (bool(op))< op2; } template <int _AP_W, bool _AP_S> inline bool operator <(char op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 <(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator >=(const _private_range_ref<_AP_W, _AP_S>& op, char op2) { return (ap_private<_AP_W, false>(op)) . operator >=(ap_private<(8), (CHAR_IS_SIGNED)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >=(char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (CHAR_IS_SIGNED)>(op2).operator >=( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator >=(const _private_bit_ref<_AP_W, _AP_S>& op, char op2) { return (bool(op))>= op2; } template <int _AP_W, bool _AP_S> inline bool operator >=(char op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 >=(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator <=(const _private_range_ref<_AP_W, _AP_S>& op, char op2) { return (ap_private<_AP_W, false>(op)) . operator <=(ap_private<(8), (CHAR_IS_SIGNED)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <=(char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (CHAR_IS_SIGNED)>(op2).operator <=( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator <=(const _private_bit_ref<_AP_W, _AP_S>& op, char op2) { return (bool(op))<= op2; } template <int _AP_W, bool _AP_S> inline bool operator <=(char op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 <=(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator ==(const _private_range_ref<_AP_W, _AP_S>& op, char op2) { return (ap_private<_AP_W, false>(op)) . operator ==(ap_private<(8), (CHAR_IS_SIGNED)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator ==(char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (CHAR_IS_SIGNED)>(op2).operator ==( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator ==(const _private_bit_ref<_AP_W, _AP_S>& op, char op2) { return (bool(op))== op2; } template <int _AP_W, bool _AP_S> inline bool operator ==(char op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 ==(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator !=(const _private_range_ref<_AP_W, _AP_S>& op, char op2) { return (ap_private<_AP_W, false>(op)) . operator !=(ap_private<(8), (CHAR_IS_SIGNED)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator !=(char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (CHAR_IS_SIGNED)>(op2).operator !=( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator !=(const _private_bit_ref<_AP_W, _AP_S>& op, char op2) { return (bool(op))!= op2; } template <int _AP_W, bool _AP_S> inline bool operator !=(char op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 !=(bool(op)); }
template <int _AP_W, bool _AP_S> inline bool operator >(const _private_range_ref<_AP_W, _AP_S>& op, signed char op2) { return (ap_private<_AP_W, false>(op)) . operator >(ap_private<(8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >(signed char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (true)>(op2).operator >( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator >(const _private_bit_ref<_AP_W, _AP_S>& op, signed char op2) { return (bool(op))> op2; } template <int _AP_W, bool _AP_S> inline bool operator >(signed char op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 >(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator <(const _private_range_ref<_AP_W, _AP_S>& op, signed char op2) { return (ap_private<_AP_W, false>(op)) . operator <(ap_private<(8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <(signed char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (true)>(op2).operator <( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator <(const _private_bit_ref<_AP_W, _AP_S>& op, signed char op2) { return (bool(op))< op2; } template <int _AP_W, bool _AP_S> inline bool operator <(signed char op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 <(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator >=(const _private_range_ref<_AP_W, _AP_S>& op, signed char op2) { return (ap_private<_AP_W, false>(op)) . operator >=(ap_private<(8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >=(signed char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (true)>(op2).operator >=( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator >=(const _private_bit_ref<_AP_W, _AP_S>& op, signed char op2) { return (bool(op))>= op2; } template <int _AP_W, bool _AP_S> inline bool operator >=(signed char op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 >=(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator <=(const _private_range_ref<_AP_W, _AP_S>& op, signed char op2) { return (ap_private<_AP_W, false>(op)) . operator <=(ap_private<(8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <=(signed char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (true)>(op2).operator <=( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator <=(const _private_bit_ref<_AP_W, _AP_S>& op, signed char op2) { return (bool(op))<= op2; } template <int _AP_W, bool _AP_S> inline bool operator <=(signed char op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 <=(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator ==(const _private_range_ref<_AP_W, _AP_S>& op, signed char op2) { return (ap_private<_AP_W, false>(op)) . operator ==(ap_private<(8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator ==(signed char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (true)>(op2).operator ==( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator ==(const _private_bit_ref<_AP_W, _AP_S>& op, signed char op2) { return (bool(op))== op2; } template <int _AP_W, bool _AP_S> inline bool operator ==(signed char op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 ==(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator !=(const _private_range_ref<_AP_W, _AP_S>& op, signed char op2) { return (ap_private<_AP_W, false>(op)) . operator !=(ap_private<(8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator !=(signed char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (true)>(op2).operator !=( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator !=(const _private_bit_ref<_AP_W, _AP_S>& op, signed char op2) { return (bool(op))!= op2; } template <int _AP_W, bool _AP_S> inline bool operator !=(signed char op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 !=(bool(op)); }
template <int _AP_W, bool _AP_S> inline bool operator >(const _private_range_ref<_AP_W, _AP_S>& op, unsigned char op2) { return (ap_private<_AP_W, false>(op)) . operator >(ap_private<(8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >(unsigned char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (false)>(op2).operator >( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator >(const _private_bit_ref<_AP_W, _AP_S>& op, unsigned char op2) { return (bool(op))> op2; } template <int _AP_W, bool _AP_S> inline bool operator >(unsigned char op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 >(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator <(const _private_range_ref<_AP_W, _AP_S>& op, unsigned char op2) { return (ap_private<_AP_W, false>(op)) . operator <(ap_private<(8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <(unsigned char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (false)>(op2).operator <( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator <(const _private_bit_ref<_AP_W, _AP_S>& op, unsigned char op2) { return (bool(op))< op2; } template <int _AP_W, bool _AP_S> inline bool operator <(unsigned char op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 <(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator >=(const _private_range_ref<_AP_W, _AP_S>& op, unsigned char op2) { return (ap_private<_AP_W, false>(op)) . operator >=(ap_private<(8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >=(unsigned char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (false)>(op2).operator >=( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator >=(const _private_bit_ref<_AP_W, _AP_S>& op, unsigned char op2) { return (bool(op))>= op2; } template <int _AP_W, bool _AP_S> inline bool operator >=(unsigned char op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 >=(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator <=(const _private_range_ref<_AP_W, _AP_S>& op, unsigned char op2) { return (ap_private<_AP_W, false>(op)) . operator <=(ap_private<(8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <=(unsigned char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (false)>(op2).operator <=( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator <=(const _private_bit_ref<_AP_W, _AP_S>& op, unsigned char op2) { return (bool(op))<= op2; } template <int _AP_W, bool _AP_S> inline bool operator <=(unsigned char op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 <=(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator ==(const _private_range_ref<_AP_W, _AP_S>& op, unsigned char op2) { return (ap_private<_AP_W, false>(op)) . operator ==(ap_private<(8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator ==(unsigned char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (false)>(op2).operator ==( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator ==(const _private_bit_ref<_AP_W, _AP_S>& op, unsigned char op2) { return (bool(op))== op2; } template <int _AP_W, bool _AP_S> inline bool operator ==(unsigned char op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 ==(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator !=(const _private_range_ref<_AP_W, _AP_S>& op, unsigned char op2) { return (ap_private<_AP_W, false>(op)) . operator !=(ap_private<(8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator !=(unsigned char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (false)>(op2).operator !=( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator !=(const _private_bit_ref<_AP_W, _AP_S>& op, unsigned char op2) { return (bool(op))!= op2; } template <int _AP_W, bool _AP_S> inline bool operator !=(unsigned char op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 !=(bool(op)); }
template <int _AP_W, bool _AP_S> inline bool operator >(const _private_range_ref<_AP_W, _AP_S>& op, short op2) { return (ap_private<_AP_W, false>(op)) . operator >(ap_private<(sizeof(short) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >(short op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(short) * 8), (true)>(op2).operator >( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator >(const _private_bit_ref<_AP_W, _AP_S>& op, short op2) { return (bool(op))> op2; } template <int _AP_W, bool _AP_S> inline bool operator >(short op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 >(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator <(const _private_range_ref<_AP_W, _AP_S>& op, short op2) { return (ap_private<_AP_W, false>(op)) . operator <(ap_private<(sizeof(short) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <(short op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(short) * 8), (true)>(op2).operator <( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator <(const _private_bit_ref<_AP_W, _AP_S>& op, short op2) { return (bool(op))< op2; } template <int _AP_W, bool _AP_S> inline bool operator <(short op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 <(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator >=(const _private_range_ref<_AP_W, _AP_S>& op, short op2) { return (ap_private<_AP_W, false>(op)) . operator >=(ap_private<(sizeof(short) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >=(short op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(short) * 8), (true)>(op2).operator >=( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator >=(const _private_bit_ref<_AP_W, _AP_S>& op, short op2) { return (bool(op))>= op2; } template <int _AP_W, bool _AP_S> inline bool operator >=(short op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 >=(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator <=(const _private_range_ref<_AP_W, _AP_S>& op, short op2) { return (ap_private<_AP_W, false>(op)) . operator <=(ap_private<(sizeof(short) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <=(short op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(short) * 8), (true)>(op2).operator <=( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator <=(const _private_bit_ref<_AP_W, _AP_S>& op, short op2) { return (bool(op))<= op2; } template <int _AP_W, bool _AP_S> inline bool operator <=(short op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 <=(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator ==(const _private_range_ref<_AP_W, _AP_S>& op, short op2) { return (ap_private<_AP_W, false>(op)) . operator ==(ap_private<(sizeof(short) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator ==(short op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(short) * 8), (true)>(op2).operator ==( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator ==(const _private_bit_ref<_AP_W, _AP_S>& op, short op2) { return (bool(op))== op2; } template <int _AP_W, bool _AP_S> inline bool operator ==(short op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 ==(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator !=(const _private_range_ref<_AP_W, _AP_S>& op, short op2) { return (ap_private<_AP_W, false>(op)) . operator !=(ap_private<(sizeof(short) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator !=(short op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(short) * 8), (true)>(op2).operator !=( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator !=(const _private_bit_ref<_AP_W, _AP_S>& op, short op2) { return (bool(op))!= op2; } template <int _AP_W, bool _AP_S> inline bool operator !=(short op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 !=(bool(op)); }
template <int _AP_W, bool _AP_S> inline bool operator >(const _private_range_ref<_AP_W, _AP_S>& op, unsigned short op2) { return (ap_private<_AP_W, false>(op)) . operator >(ap_private<(sizeof(unsigned short) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >(unsigned short op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned short) * 8), (false)>(op2).operator >( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator >(const _private_bit_ref<_AP_W, _AP_S>& op, unsigned short op2) { return (bool(op))> op2; } template <int _AP_W, bool _AP_S> inline bool operator >(unsigned short op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 >(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator <(const _private_range_ref<_AP_W, _AP_S>& op, unsigned short op2) { return (ap_private<_AP_W, false>(op)) . operator <(ap_private<(sizeof(unsigned short) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <(unsigned short op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned short) * 8), (false)>(op2).operator <( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator <(const _private_bit_ref<_AP_W, _AP_S>& op, unsigned short op2) { return (bool(op))< op2; } template <int _AP_W, bool _AP_S> inline bool operator <(unsigned short op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 <(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator >=(const _private_range_ref<_AP_W, _AP_S>& op, unsigned short op2) { return (ap_private<_AP_W, false>(op)) . operator >=(ap_private<(sizeof(unsigned short) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >=(unsigned short op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned short) * 8), (false)>(op2).operator >=( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator >=(const _private_bit_ref<_AP_W, _AP_S>& op, unsigned short op2) { return (bool(op))>= op2; } template <int _AP_W, bool _AP_S> inline bool operator >=(unsigned short op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 >=(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator <=(const _private_range_ref<_AP_W, _AP_S>& op, unsigned short op2) { return (ap_private<_AP_W, false>(op)) . operator <=(ap_private<(sizeof(unsigned short) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <=(unsigned short op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned short) * 8), (false)>(op2).operator <=( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator <=(const _private_bit_ref<_AP_W, _AP_S>& op, unsigned short op2) { return (bool(op))<= op2; } template <int _AP_W, bool _AP_S> inline bool operator <=(unsigned short op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 <=(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator ==(const _private_range_ref<_AP_W, _AP_S>& op, unsigned short op2) { return (ap_private<_AP_W, false>(op)) . operator ==(ap_private<(sizeof(unsigned short) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator ==(unsigned short op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned short) * 8), (false)>(op2).operator ==( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator ==(const _private_bit_ref<_AP_W, _AP_S>& op, unsigned short op2) { return (bool(op))== op2; } template <int _AP_W, bool _AP_S> inline bool operator ==(unsigned short op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 ==(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator !=(const _private_range_ref<_AP_W, _AP_S>& op, unsigned short op2) { return (ap_private<_AP_W, false>(op)) . operator !=(ap_private<(sizeof(unsigned short) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator !=(unsigned short op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned short) * 8), (false)>(op2).operator !=( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator !=(const _private_bit_ref<_AP_W, _AP_S>& op, unsigned short op2) { return (bool(op))!= op2; } template <int _AP_W, bool _AP_S> inline bool operator !=(unsigned short op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 !=(bool(op)); }
template <int _AP_W, bool _AP_S> inline bool operator >(const _private_range_ref<_AP_W, _AP_S>& op, int op2) { return (ap_private<_AP_W, false>(op)) . operator >(ap_private<(sizeof(int) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >(int op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(int) * 8), (true)>(op2).operator >( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator >(const _private_bit_ref<_AP_W, _AP_S>& op, int op2) { return (bool(op))> op2; } template <int _AP_W, bool _AP_S> inline bool operator >(int op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 >(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator <(const _private_range_ref<_AP_W, _AP_S>& op, int op2) { return (ap_private<_AP_W, false>(op)) . operator <(ap_private<(sizeof(int) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <(int op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(int) * 8), (true)>(op2).operator <( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator <(const _private_bit_ref<_AP_W, _AP_S>& op, int op2) { return (bool(op))< op2; } template <int _AP_W, bool _AP_S> inline bool operator <(int op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 <(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator >=(const _private_range_ref<_AP_W, _AP_S>& op, int op2) { return (ap_private<_AP_W, false>(op)) . operator >=(ap_private<(sizeof(int) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >=(int op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(int) * 8), (true)>(op2).operator >=( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator >=(const _private_bit_ref<_AP_W, _AP_S>& op, int op2) { return (bool(op))>= op2; } template <int _AP_W, bool _AP_S> inline bool operator >=(int op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 >=(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator <=(const _private_range_ref<_AP_W, _AP_S>& op, int op2) { return (ap_private<_AP_W, false>(op)) . operator <=(ap_private<(sizeof(int) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <=(int op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(int) * 8), (true)>(op2).operator <=( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator <=(const _private_bit_ref<_AP_W, _AP_S>& op, int op2) { return (bool(op))<= op2; } template <int _AP_W, bool _AP_S> inline bool operator <=(int op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 <=(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator ==(const _private_range_ref<_AP_W, _AP_S>& op, int op2) { return (ap_private<_AP_W, false>(op)) . operator ==(ap_private<(sizeof(int) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator ==(int op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(int) * 8), (true)>(op2).operator ==( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator ==(const _private_bit_ref<_AP_W, _AP_S>& op, int op2) { return (bool(op))== op2; } template <int _AP_W, bool _AP_S> inline bool operator ==(int op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 ==(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator !=(const _private_range_ref<_AP_W, _AP_S>& op, int op2) { return (ap_private<_AP_W, false>(op)) . operator !=(ap_private<(sizeof(int) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator !=(int op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(int) * 8), (true)>(op2).operator !=( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator !=(const _private_bit_ref<_AP_W, _AP_S>& op, int op2) { return (bool(op))!= op2; } template <int _AP_W, bool _AP_S> inline bool operator !=(int op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 !=(bool(op)); }
template <int _AP_W, bool _AP_S> inline bool operator >(const _private_range_ref<_AP_W, _AP_S>& op, unsigned int op2) { return (ap_private<_AP_W, false>(op)) . operator >(ap_private<(sizeof(unsigned int) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >(unsigned int op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned int) * 8), (false)>(op2).operator >( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator >(const _private_bit_ref<_AP_W, _AP_S>& op, unsigned int op2) { return (bool(op))> op2; } template <int _AP_W, bool _AP_S> inline bool operator >(unsigned int op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 >(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator <(const _private_range_ref<_AP_W, _AP_S>& op, unsigned int op2) { return (ap_private<_AP_W, false>(op)) . operator <(ap_private<(sizeof(unsigned int) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <(unsigned int op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned int) * 8), (false)>(op2).operator <( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator <(const _private_bit_ref<_AP_W, _AP_S>& op, unsigned int op2) { return (bool(op))< op2; } template <int _AP_W, bool _AP_S> inline bool operator <(unsigned int op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 <(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator >=(const _private_range_ref<_AP_W, _AP_S>& op, unsigned int op2) { return (ap_private<_AP_W, false>(op)) . operator >=(ap_private<(sizeof(unsigned int) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >=(unsigned int op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned int) * 8), (false)>(op2).operator >=( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator >=(const _private_bit_ref<_AP_W, _AP_S>& op, unsigned int op2) { return (bool(op))>= op2; } template <int _AP_W, bool _AP_S> inline bool operator >=(unsigned int op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 >=(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator <=(const _private_range_ref<_AP_W, _AP_S>& op, unsigned int op2) { return (ap_private<_AP_W, false>(op)) . operator <=(ap_private<(sizeof(unsigned int) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <=(unsigned int op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned int) * 8), (false)>(op2).operator <=( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator <=(const _private_bit_ref<_AP_W, _AP_S>& op, unsigned int op2) { return (bool(op))<= op2; } template <int _AP_W, bool _AP_S> inline bool operator <=(unsigned int op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 <=(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator ==(const _private_range_ref<_AP_W, _AP_S>& op, unsigned int op2) { return (ap_private<_AP_W, false>(op)) . operator ==(ap_private<(sizeof(unsigned int) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator ==(unsigned int op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned int) * 8), (false)>(op2).operator ==( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator ==(const _private_bit_ref<_AP_W, _AP_S>& op, unsigned int op2) { return (bool(op))== op2; } template <int _AP_W, bool _AP_S> inline bool operator ==(unsigned int op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 ==(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator !=(const _private_range_ref<_AP_W, _AP_S>& op, unsigned int op2) { return (ap_private<_AP_W, false>(op)) . operator !=(ap_private<(sizeof(unsigned int) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator !=(unsigned int op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned int) * 8), (false)>(op2).operator !=( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator !=(const _private_bit_ref<_AP_W, _AP_S>& op, unsigned int op2) { return (bool(op))!= op2; } template <int _AP_W, bool _AP_S> inline bool operator !=(unsigned int op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 !=(bool(op)); }
template <int _AP_W, bool _AP_S> inline bool operator >(const _private_range_ref<_AP_W, _AP_S>& op, long op2) { return (ap_private<_AP_W, false>(op)) . operator >(ap_private<(sizeof(long) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >(long op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(long) * 8), (true)>(op2).operator >( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator >(const _private_bit_ref<_AP_W, _AP_S>& op, long op2) { return (bool(op))> op2; } template <int _AP_W, bool _AP_S> inline bool operator >(long op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 >(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator <(const _private_range_ref<_AP_W, _AP_S>& op, long op2) { return (ap_private<_AP_W, false>(op)) . operator <(ap_private<(sizeof(long) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <(long op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(long) * 8), (true)>(op2).operator <( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator <(const _private_bit_ref<_AP_W, _AP_S>& op, long op2) { return (bool(op))< op2; } template <int _AP_W, bool _AP_S> inline bool operator <(long op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 <(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator >=(const _private_range_ref<_AP_W, _AP_S>& op, long op2) { return (ap_private<_AP_W, false>(op)) . operator >=(ap_private<(sizeof(long) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >=(long op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(long) * 8), (true)>(op2).operator >=( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator >=(const _private_bit_ref<_AP_W, _AP_S>& op, long op2) { return (bool(op))>= op2; } template <int _AP_W, bool _AP_S> inline bool operator >=(long op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 >=(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator <=(const _private_range_ref<_AP_W, _AP_S>& op, long op2) { return (ap_private<_AP_W, false>(op)) . operator <=(ap_private<(sizeof(long) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <=(long op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(long) * 8), (true)>(op2).operator <=( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator <=(const _private_bit_ref<_AP_W, _AP_S>& op, long op2) { return (bool(op))<= op2; } template <int _AP_W, bool _AP_S> inline bool operator <=(long op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 <=(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator ==(const _private_range_ref<_AP_W, _AP_S>& op, long op2) { return (ap_private<_AP_W, false>(op)) . operator ==(ap_private<(sizeof(long) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator ==(long op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(long) * 8), (true)>(op2).operator ==( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator ==(const _private_bit_ref<_AP_W, _AP_S>& op, long op2) { return (bool(op))== op2; } template <int _AP_W, bool _AP_S> inline bool operator ==(long op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 ==(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator !=(const _private_range_ref<_AP_W, _AP_S>& op, long op2) { return (ap_private<_AP_W, false>(op)) . operator !=(ap_private<(sizeof(long) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator !=(long op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(long) * 8), (true)>(op2).operator !=( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator !=(const _private_bit_ref<_AP_W, _AP_S>& op, long op2) { return (bool(op))!= op2; } template <int _AP_W, bool _AP_S> inline bool operator !=(long op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 !=(bool(op)); }
template <int _AP_W, bool _AP_S> inline bool operator >(const _private_range_ref<_AP_W, _AP_S>& op, unsigned long op2) { return (ap_private<_AP_W, false>(op)) . operator >(ap_private<(sizeof(unsigned long) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >(unsigned long op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned long) * 8), (false)>(op2).operator >( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator >(const _private_bit_ref<_AP_W, _AP_S>& op, unsigned long op2) { return (bool(op))> op2; } template <int _AP_W, bool _AP_S> inline bool operator >(unsigned long op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 >(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator <(const _private_range_ref<_AP_W, _AP_S>& op, unsigned long op2) { return (ap_private<_AP_W, false>(op)) . operator <(ap_private<(sizeof(unsigned long) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <(unsigned long op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned long) * 8), (false)>(op2).operator <( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator <(const _private_bit_ref<_AP_W, _AP_S>& op, unsigned long op2) { return (bool(op))< op2; } template <int _AP_W, bool _AP_S> inline bool operator <(unsigned long op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 <(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator >=(const _private_range_ref<_AP_W, _AP_S>& op, unsigned long op2) { return (ap_private<_AP_W, false>(op)) . operator >=(ap_private<(sizeof(unsigned long) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >=(unsigned long op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned long) * 8), (false)>(op2).operator >=( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator >=(const _private_bit_ref<_AP_W, _AP_S>& op, unsigned long op2) { return (bool(op))>= op2; } template <int _AP_W, bool _AP_S> inline bool operator >=(unsigned long op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 >=(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator <=(const _private_range_ref<_AP_W, _AP_S>& op, unsigned long op2) { return (ap_private<_AP_W, false>(op)) . operator <=(ap_private<(sizeof(unsigned long) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <=(unsigned long op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned long) * 8), (false)>(op2).operator <=( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator <=(const _private_bit_ref<_AP_W, _AP_S>& op, unsigned long op2) { return (bool(op))<= op2; } template <int _AP_W, bool _AP_S> inline bool operator <=(unsigned long op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 <=(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator ==(const _private_range_ref<_AP_W, _AP_S>& op, unsigned long op2) { return (ap_private<_AP_W, false>(op)) . operator ==(ap_private<(sizeof(unsigned long) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator ==(unsigned long op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned long) * 8), (false)>(op2).operator ==( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator ==(const _private_bit_ref<_AP_W, _AP_S>& op, unsigned long op2) { return (bool(op))== op2; } template <int _AP_W, bool _AP_S> inline bool operator ==(unsigned long op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 ==(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator !=(const _private_range_ref<_AP_W, _AP_S>& op, unsigned long op2) { return (ap_private<_AP_W, false>(op)) . operator !=(ap_private<(sizeof(unsigned long) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator !=(unsigned long op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned long) * 8), (false)>(op2).operator !=( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator !=(const _private_bit_ref<_AP_W, _AP_S>& op, unsigned long op2) { return (bool(op))!= op2; } template <int _AP_W, bool _AP_S> inline bool operator !=(unsigned long op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 !=(bool(op)); }
template <int _AP_W, bool _AP_S> inline bool operator >(const _private_range_ref<_AP_W, _AP_S>& op, ap_slong op2) { return (ap_private<_AP_W, false>(op)) . operator >(ap_private<(sizeof(ap_slong) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >(ap_slong op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_slong) * 8), (true)>(op2).operator >( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator >(const _private_bit_ref<_AP_W, _AP_S>& op, ap_slong op2) { return (bool(op))> op2; } template <int _AP_W, bool _AP_S> inline bool operator >(ap_slong op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 >(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator <(const _private_range_ref<_AP_W, _AP_S>& op, ap_slong op2) { return (ap_private<_AP_W, false>(op)) . operator <(ap_private<(sizeof(ap_slong) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <(ap_slong op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_slong) * 8), (true)>(op2).operator <( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator <(const _private_bit_ref<_AP_W, _AP_S>& op, ap_slong op2) { return (bool(op))< op2; } template <int _AP_W, bool _AP_S> inline bool operator <(ap_slong op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 <(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator >=(const _private_range_ref<_AP_W, _AP_S>& op, ap_slong op2) { return (ap_private<_AP_W, false>(op)) . operator >=(ap_private<(sizeof(ap_slong) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >=(ap_slong op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_slong) * 8), (true)>(op2).operator >=( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator >=(const _private_bit_ref<_AP_W, _AP_S>& op, ap_slong op2) { return (bool(op))>= op2; } template <int _AP_W, bool _AP_S> inline bool operator >=(ap_slong op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 >=(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator <=(const _private_range_ref<_AP_W, _AP_S>& op, ap_slong op2) { return (ap_private<_AP_W, false>(op)) . operator <=(ap_private<(sizeof(ap_slong) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <=(ap_slong op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_slong) * 8), (true)>(op2).operator <=( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator <=(const _private_bit_ref<_AP_W, _AP_S>& op, ap_slong op2) { return (bool(op))<= op2; } template <int _AP_W, bool _AP_S> inline bool operator <=(ap_slong op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 <=(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator ==(const _private_range_ref<_AP_W, _AP_S>& op, ap_slong op2) { return (ap_private<_AP_W, false>(op)) . operator ==(ap_private<(sizeof(ap_slong) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator ==(ap_slong op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_slong) * 8), (true)>(op2).operator ==( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator ==(const _private_bit_ref<_AP_W, _AP_S>& op, ap_slong op2) { return (bool(op))== op2; } template <int _AP_W, bool _AP_S> inline bool operator ==(ap_slong op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 ==(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator !=(const _private_range_ref<_AP_W, _AP_S>& op, ap_slong op2) { return (ap_private<_AP_W, false>(op)) . operator !=(ap_private<(sizeof(ap_slong) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator !=(ap_slong op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_slong) * 8), (true)>(op2).operator !=( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator !=(const _private_bit_ref<_AP_W, _AP_S>& op, ap_slong op2) { return (bool(op))!= op2; } template <int _AP_W, bool _AP_S> inline bool operator !=(ap_slong op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 !=(bool(op)); }
template <int _AP_W, bool _AP_S> inline bool operator >(const _private_range_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return (ap_private<_AP_W, false>(op)) . operator >(ap_private<(sizeof(ap_ulong) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >(ap_ulong op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_ulong) * 8), (false)>(op2).operator >( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator >(const _private_bit_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return (bool(op))> op2; } template <int _AP_W, bool _AP_S> inline bool operator >(ap_ulong op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 >(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator <(const _private_range_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return (ap_private<_AP_W, false>(op)) . operator <(ap_private<(sizeof(ap_ulong) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <(ap_ulong op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_ulong) * 8), (false)>(op2).operator <( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator <(const _private_bit_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return (bool(op))< op2; } template <int _AP_W, bool _AP_S> inline bool operator <(ap_ulong op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 <(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator >=(const _private_range_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return (ap_private<_AP_W, false>(op)) . operator >=(ap_private<(sizeof(ap_ulong) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator >=(ap_ulong op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_ulong) * 8), (false)>(op2).operator >=( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator >=(const _private_bit_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return (bool(op))>= op2; } template <int _AP_W, bool _AP_S> inline bool operator >=(ap_ulong op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 >=(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator <=(const _private_range_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return (ap_private<_AP_W, false>(op)) . operator <=(ap_private<(sizeof(ap_ulong) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator <=(ap_ulong op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_ulong) * 8), (false)>(op2).operator <=( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator <=(const _private_bit_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return (bool(op))<= op2; } template <int _AP_W, bool _AP_S> inline bool operator <=(ap_ulong op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 <=(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator ==(const _private_range_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return (ap_private<_AP_W, false>(op)) . operator ==(ap_private<(sizeof(ap_ulong) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator ==(ap_ulong op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_ulong) * 8), (false)>(op2).operator ==( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator ==(const _private_bit_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return (bool(op))== op2; } template <int _AP_W, bool _AP_S> inline bool operator ==(ap_ulong op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 ==(bool(op)); } template <int _AP_W, bool _AP_S> inline bool operator !=(const _private_range_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return (ap_private<_AP_W, false>(op)) . operator !=(ap_private<(sizeof(ap_ulong) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline bool operator !=(ap_ulong op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_ulong) * 8), (false)>(op2).operator !=( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline bool operator !=(const _private_bit_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return (bool(op))!= op2; } template <int _AP_W, bool _AP_S> inline bool operator !=(ap_ulong op2, const _private_bit_ref<_AP_W, _AP_S>& op) { return op2 !=(bool(op)); }
# 7163 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(1), (false)>::plus operator +(const _private_range_ref<_AP_W, _AP_S>& op, bool op2) { return (ap_private<_AP_W, false>(op)) . operator +(ap_private<(1), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(1), (false)>::template RType<_AP_W, false>::plus operator +(bool op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(1), (false)>(op2).operator +( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(1), (false)>::minus operator -(const _private_range_ref<_AP_W, _AP_S>& op, bool op2) { return (ap_private<_AP_W, false>(op)) . operator -(ap_private<(1), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(1), (false)>::template RType<_AP_W, false>::minus operator -(bool op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(1), (false)>(op2).operator -( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(1), (false)>::mult operator *(const _private_range_ref<_AP_W, _AP_S>& op, bool op2) { return (ap_private<_AP_W, false>(op)) . operator *(ap_private<(1), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(1), (false)>::template RType<_AP_W, false>::mult operator *(bool op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(1), (false)>(op2).operator *( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(1), (false)>::div operator /(const _private_range_ref<_AP_W, _AP_S>& op, bool op2) { return (ap_private<_AP_W, false>(op)) . operator /(ap_private<(1), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(1), (false)>::template RType<_AP_W, false>::div operator /(bool op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(1), (false)>(op2).operator /( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(1), (false)>::mod operator %(const _private_range_ref<_AP_W, _AP_S>& op, bool op2) { return (ap_private<_AP_W, false>(op)) . operator %(ap_private<(1), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(1), (false)>::template RType<_AP_W, false>::mod operator %(bool op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(1), (false)>(op2).operator %( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(1), (false)>::logic operator &(const _private_range_ref<_AP_W, _AP_S>& op, bool op2) { return (ap_private<_AP_W, false>(op)) . operator &(ap_private<(1), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(1), (false)>::template RType<_AP_W, false>::logic operator &(bool op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(1), (false)>(op2).operator &( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(1), (false)>::logic operator |(const _private_range_ref<_AP_W, _AP_S>& op, bool op2) { return (ap_private<_AP_W, false>(op)) . operator |(ap_private<(1), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(1), (false)>::template RType<_AP_W, false>::logic operator |(bool op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(1), (false)>(op2).operator |( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(1), (false)>::logic operator ^(const _private_range_ref<_AP_W, _AP_S>& op, bool op2) { return (ap_private<_AP_W, false>(op)) . operator ^(ap_private<(1), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(1), (false)>::template RType<_AP_W, false>::logic operator ^(bool op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(1), (false)>(op2).operator ^( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(1), (false)>::arg1 operator >>(const _private_range_ref<_AP_W, _AP_S>& op, bool op2) { return (ap_private<_AP_W, false>(op)) . operator >>(ap_private<(1), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(1), (false)>::template RType<_AP_W, false>::arg1 operator >>(bool op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(1), (false)>(op2).operator >>( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(1), (false)>::arg1 operator <<(const _private_range_ref<_AP_W, _AP_S>& op, bool op2) { return (ap_private<_AP_W, false>(op)) . operator <<(ap_private<(1), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(1), (false)>::template RType<_AP_W, false>::arg1 operator <<(bool op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(1), (false)>(op2).operator <<( ap_private<_AP_W, false>(op)); }
template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(8), (CHAR_IS_SIGNED)>::plus operator +(const _private_range_ref<_AP_W, _AP_S>& op, char op2) { return (ap_private<_AP_W, false>(op)) . operator +(ap_private<(8), (CHAR_IS_SIGNED)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (CHAR_IS_SIGNED)>::template RType<_AP_W, false>::plus operator +(char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (CHAR_IS_SIGNED)>(op2).operator +( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(8), (CHAR_IS_SIGNED)>::minus operator -(const _private_range_ref<_AP_W, _AP_S>& op, char op2) { return (ap_private<_AP_W, false>(op)) . operator -(ap_private<(8), (CHAR_IS_SIGNED)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (CHAR_IS_SIGNED)>::template RType<_AP_W, false>::minus operator -(char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (CHAR_IS_SIGNED)>(op2).operator -( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(8), (CHAR_IS_SIGNED)>::mult operator *(const _private_range_ref<_AP_W, _AP_S>& op, char op2) { return (ap_private<_AP_W, false>(op)) . operator *(ap_private<(8), (CHAR_IS_SIGNED)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (CHAR_IS_SIGNED)>::template RType<_AP_W, false>::mult operator *(char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (CHAR_IS_SIGNED)>(op2).operator *( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(8), (CHAR_IS_SIGNED)>::div operator /(const _private_range_ref<_AP_W, _AP_S>& op, char op2) { return (ap_private<_AP_W, false>(op)) . operator /(ap_private<(8), (CHAR_IS_SIGNED)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (CHAR_IS_SIGNED)>::template RType<_AP_W, false>::div operator /(char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (CHAR_IS_SIGNED)>(op2).operator /( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(8), (CHAR_IS_SIGNED)>::mod operator %(const _private_range_ref<_AP_W, _AP_S>& op, char op2) { return (ap_private<_AP_W, false>(op)) . operator %(ap_private<(8), (CHAR_IS_SIGNED)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (CHAR_IS_SIGNED)>::template RType<_AP_W, false>::mod operator %(char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (CHAR_IS_SIGNED)>(op2).operator %( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(8), (CHAR_IS_SIGNED)>::logic operator &(const _private_range_ref<_AP_W, _AP_S>& op, char op2) { return (ap_private<_AP_W, false>(op)) . operator &(ap_private<(8), (CHAR_IS_SIGNED)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (CHAR_IS_SIGNED)>::template RType<_AP_W, false>::logic operator &(char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (CHAR_IS_SIGNED)>(op2).operator &( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(8), (CHAR_IS_SIGNED)>::logic operator |(const _private_range_ref<_AP_W, _AP_S>& op, char op2) { return (ap_private<_AP_W, false>(op)) . operator |(ap_private<(8), (CHAR_IS_SIGNED)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (CHAR_IS_SIGNED)>::template RType<_AP_W, false>::logic operator |(char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (CHAR_IS_SIGNED)>(op2).operator |( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(8), (CHAR_IS_SIGNED)>::logic operator ^(const _private_range_ref<_AP_W, _AP_S>& op, char op2) { return (ap_private<_AP_W, false>(op)) . operator ^(ap_private<(8), (CHAR_IS_SIGNED)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (CHAR_IS_SIGNED)>::template RType<_AP_W, false>::logic operator ^(char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (CHAR_IS_SIGNED)>(op2).operator ^( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(8), (CHAR_IS_SIGNED)>::arg1 operator >>(const _private_range_ref<_AP_W, _AP_S>& op, char op2) { return (ap_private<_AP_W, false>(op)) . operator >>(ap_private<(8), (CHAR_IS_SIGNED)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (CHAR_IS_SIGNED)>::template RType<_AP_W, false>::arg1 operator >>(char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (CHAR_IS_SIGNED)>(op2).operator >>( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(8), (CHAR_IS_SIGNED)>::arg1 operator <<(const _private_range_ref<_AP_W, _AP_S>& op, char op2) { return (ap_private<_AP_W, false>(op)) . operator <<(ap_private<(8), (CHAR_IS_SIGNED)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (CHAR_IS_SIGNED)>::template RType<_AP_W, false>::arg1 operator <<(char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (CHAR_IS_SIGNED)>(op2).operator <<( ap_private<_AP_W, false>(op)); }
template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(8), (true)>::plus operator +(const _private_range_ref<_AP_W, _AP_S>& op, signed char op2) { return (ap_private<_AP_W, false>(op)) . operator +(ap_private<(8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (true)>::template RType<_AP_W, false>::plus operator +(signed char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (true)>(op2).operator +( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(8), (true)>::minus operator -(const _private_range_ref<_AP_W, _AP_S>& op, signed char op2) { return (ap_private<_AP_W, false>(op)) . operator -(ap_private<(8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (true)>::template RType<_AP_W, false>::minus operator -(signed char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (true)>(op2).operator -( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(8), (true)>::mult operator *(const _private_range_ref<_AP_W, _AP_S>& op, signed char op2) { return (ap_private<_AP_W, false>(op)) . operator *(ap_private<(8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (true)>::template RType<_AP_W, false>::mult operator *(signed char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (true)>(op2).operator *( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(8), (true)>::div operator /(const _private_range_ref<_AP_W, _AP_S>& op, signed char op2) { return (ap_private<_AP_W, false>(op)) . operator /(ap_private<(8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (true)>::template RType<_AP_W, false>::div operator /(signed char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (true)>(op2).operator /( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(8), (true)>::mod operator %(const _private_range_ref<_AP_W, _AP_S>& op, signed char op2) { return (ap_private<_AP_W, false>(op)) . operator %(ap_private<(8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (true)>::template RType<_AP_W, false>::mod operator %(signed char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (true)>(op2).operator %( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(8), (true)>::logic operator &(const _private_range_ref<_AP_W, _AP_S>& op, signed char op2) { return (ap_private<_AP_W, false>(op)) . operator &(ap_private<(8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (true)>::template RType<_AP_W, false>::logic operator &(signed char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (true)>(op2).operator &( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(8), (true)>::logic operator |(const _private_range_ref<_AP_W, _AP_S>& op, signed char op2) { return (ap_private<_AP_W, false>(op)) . operator |(ap_private<(8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (true)>::template RType<_AP_W, false>::logic operator |(signed char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (true)>(op2).operator |( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(8), (true)>::logic operator ^(const _private_range_ref<_AP_W, _AP_S>& op, signed char op2) { return (ap_private<_AP_W, false>(op)) . operator ^(ap_private<(8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (true)>::template RType<_AP_W, false>::logic operator ^(signed char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (true)>(op2).operator ^( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(8), (true)>::arg1 operator >>(const _private_range_ref<_AP_W, _AP_S>& op, signed char op2) { return (ap_private<_AP_W, false>(op)) . operator >>(ap_private<(8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (true)>::template RType<_AP_W, false>::arg1 operator >>(signed char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (true)>(op2).operator >>( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(8), (true)>::arg1 operator <<(const _private_range_ref<_AP_W, _AP_S>& op, signed char op2) { return (ap_private<_AP_W, false>(op)) . operator <<(ap_private<(8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (true)>::template RType<_AP_W, false>::arg1 operator <<(signed char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (true)>(op2).operator <<( ap_private<_AP_W, false>(op)); }
template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(8), (false)>::plus operator +(const _private_range_ref<_AP_W, _AP_S>& op, unsigned char op2) { return (ap_private<_AP_W, false>(op)) . operator +(ap_private<(8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (false)>::template RType<_AP_W, false>::plus operator +(unsigned char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (false)>(op2).operator +( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(8), (false)>::minus operator -(const _private_range_ref<_AP_W, _AP_S>& op, unsigned char op2) { return (ap_private<_AP_W, false>(op)) . operator -(ap_private<(8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (false)>::template RType<_AP_W, false>::minus operator -(unsigned char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (false)>(op2).operator -( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(8), (false)>::mult operator *(const _private_range_ref<_AP_W, _AP_S>& op, unsigned char op2) { return (ap_private<_AP_W, false>(op)) . operator *(ap_private<(8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (false)>::template RType<_AP_W, false>::mult operator *(unsigned char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (false)>(op2).operator *( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(8), (false)>::div operator /(const _private_range_ref<_AP_W, _AP_S>& op, unsigned char op2) { return (ap_private<_AP_W, false>(op)) . operator /(ap_private<(8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (false)>::template RType<_AP_W, false>::div operator /(unsigned char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (false)>(op2).operator /( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(8), (false)>::mod operator %(const _private_range_ref<_AP_W, _AP_S>& op, unsigned char op2) { return (ap_private<_AP_W, false>(op)) . operator %(ap_private<(8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (false)>::template RType<_AP_W, false>::mod operator %(unsigned char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (false)>(op2).operator %( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(8), (false)>::logic operator &(const _private_range_ref<_AP_W, _AP_S>& op, unsigned char op2) { return (ap_private<_AP_W, false>(op)) . operator &(ap_private<(8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (false)>::template RType<_AP_W, false>::logic operator &(unsigned char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (false)>(op2).operator &( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(8), (false)>::logic operator |(const _private_range_ref<_AP_W, _AP_S>& op, unsigned char op2) { return (ap_private<_AP_W, false>(op)) . operator |(ap_private<(8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (false)>::template RType<_AP_W, false>::logic operator |(unsigned char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (false)>(op2).operator |( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(8), (false)>::logic operator ^(const _private_range_ref<_AP_W, _AP_S>& op, unsigned char op2) { return (ap_private<_AP_W, false>(op)) . operator ^(ap_private<(8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (false)>::template RType<_AP_W, false>::logic operator ^(unsigned char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (false)>(op2).operator ^( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(8), (false)>::arg1 operator >>(const _private_range_ref<_AP_W, _AP_S>& op, unsigned char op2) { return (ap_private<_AP_W, false>(op)) . operator >>(ap_private<(8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (false)>::template RType<_AP_W, false>::arg1 operator >>(unsigned char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (false)>(op2).operator >>( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(8), (false)>::arg1 operator <<(const _private_range_ref<_AP_W, _AP_S>& op, unsigned char op2) { return (ap_private<_AP_W, false>(op)) . operator <<(ap_private<(8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(8), (false)>::template RType<_AP_W, false>::arg1 operator <<(unsigned char op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(8), (false)>(op2).operator <<( ap_private<_AP_W, false>(op)); }
template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(short) * 8), (true)>::plus operator +(const _private_range_ref<_AP_W, _AP_S>& op, short op2) { return (ap_private<_AP_W, false>(op)) . operator +(ap_private<(sizeof(short) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(short) * 8), (true)>::template RType<_AP_W, false>::plus operator +(short op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(short) * 8), (true)>(op2).operator +( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(short) * 8), (true)>::minus operator -(const _private_range_ref<_AP_W, _AP_S>& op, short op2) { return (ap_private<_AP_W, false>(op)) . operator -(ap_private<(sizeof(short) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(short) * 8), (true)>::template RType<_AP_W, false>::minus operator -(short op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(short) * 8), (true)>(op2).operator -( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(short) * 8), (true)>::mult operator *(const _private_range_ref<_AP_W, _AP_S>& op, short op2) { return (ap_private<_AP_W, false>(op)) . operator *(ap_private<(sizeof(short) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(short) * 8), (true)>::template RType<_AP_W, false>::mult operator *(short op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(short) * 8), (true)>(op2).operator *( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(short) * 8), (true)>::div operator /(const _private_range_ref<_AP_W, _AP_S>& op, short op2) { return (ap_private<_AP_W, false>(op)) . operator /(ap_private<(sizeof(short) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(short) * 8), (true)>::template RType<_AP_W, false>::div operator /(short op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(short) * 8), (true)>(op2).operator /( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(short) * 8), (true)>::mod operator %(const _private_range_ref<_AP_W, _AP_S>& op, short op2) { return (ap_private<_AP_W, false>(op)) . operator %(ap_private<(sizeof(short) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(short) * 8), (true)>::template RType<_AP_W, false>::mod operator %(short op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(short) * 8), (true)>(op2).operator %( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(short) * 8), (true)>::logic operator &(const _private_range_ref<_AP_W, _AP_S>& op, short op2) { return (ap_private<_AP_W, false>(op)) . operator &(ap_private<(sizeof(short) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(short) * 8), (true)>::template RType<_AP_W, false>::logic operator &(short op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(short) * 8), (true)>(op2).operator &( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(short) * 8), (true)>::logic operator |(const _private_range_ref<_AP_W, _AP_S>& op, short op2) { return (ap_private<_AP_W, false>(op)) . operator |(ap_private<(sizeof(short) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(short) * 8), (true)>::template RType<_AP_W, false>::logic operator |(short op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(short) * 8), (true)>(op2).operator |( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(short) * 8), (true)>::logic operator ^(const _private_range_ref<_AP_W, _AP_S>& op, short op2) { return (ap_private<_AP_W, false>(op)) . operator ^(ap_private<(sizeof(short) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(short) * 8), (true)>::template RType<_AP_W, false>::logic operator ^(short op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(short) * 8), (true)>(op2).operator ^( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(short) * 8), (true)>::arg1 operator >>(const _private_range_ref<_AP_W, _AP_S>& op, short op2) { return (ap_private<_AP_W, false>(op)) . operator >>(ap_private<(sizeof(short) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(short) * 8), (true)>::template RType<_AP_W, false>::arg1 operator >>(short op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(short) * 8), (true)>(op2).operator >>( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(short) * 8), (true)>::arg1 operator <<(const _private_range_ref<_AP_W, _AP_S>& op, short op2) { return (ap_private<_AP_W, false>(op)) . operator <<(ap_private<(sizeof(short) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(short) * 8), (true)>::template RType<_AP_W, false>::arg1 operator <<(short op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(short) * 8), (true)>(op2).operator <<( ap_private<_AP_W, false>(op)); }
template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(unsigned short) * 8), (false)>::plus operator +(const _private_range_ref<_AP_W, _AP_S>& op, unsigned short op2) { return (ap_private<_AP_W, false>(op)) . operator +(ap_private<(sizeof(unsigned short) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned short) * 8), (false)>::template RType<_AP_W, false>::plus operator +(unsigned short op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned short) * 8), (false)>(op2).operator +( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(unsigned short) * 8), (false)>::minus operator -(const _private_range_ref<_AP_W, _AP_S>& op, unsigned short op2) { return (ap_private<_AP_W, false>(op)) . operator -(ap_private<(sizeof(unsigned short) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned short) * 8), (false)>::template RType<_AP_W, false>::minus operator -(unsigned short op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned short) * 8), (false)>(op2).operator -( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(unsigned short) * 8), (false)>::mult operator *(const _private_range_ref<_AP_W, _AP_S>& op, unsigned short op2) { return (ap_private<_AP_W, false>(op)) . operator *(ap_private<(sizeof(unsigned short) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned short) * 8), (false)>::template RType<_AP_W, false>::mult operator *(unsigned short op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned short) * 8), (false)>(op2).operator *( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(unsigned short) * 8), (false)>::div operator /(const _private_range_ref<_AP_W, _AP_S>& op, unsigned short op2) { return (ap_private<_AP_W, false>(op)) . operator /(ap_private<(sizeof(unsigned short) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned short) * 8), (false)>::template RType<_AP_W, false>::div operator /(unsigned short op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned short) * 8), (false)>(op2).operator /( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(unsigned short) * 8), (false)>::mod operator %(const _private_range_ref<_AP_W, _AP_S>& op, unsigned short op2) { return (ap_private<_AP_W, false>(op)) . operator %(ap_private<(sizeof(unsigned short) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned short) * 8), (false)>::template RType<_AP_W, false>::mod operator %(unsigned short op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned short) * 8), (false)>(op2).operator %( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(unsigned short) * 8), (false)>::logic operator &(const _private_range_ref<_AP_W, _AP_S>& op, unsigned short op2) { return (ap_private<_AP_W, false>(op)) . operator &(ap_private<(sizeof(unsigned short) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned short) * 8), (false)>::template RType<_AP_W, false>::logic operator &(unsigned short op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned short) * 8), (false)>(op2).operator &( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(unsigned short) * 8), (false)>::logic operator |(const _private_range_ref<_AP_W, _AP_S>& op, unsigned short op2) { return (ap_private<_AP_W, false>(op)) . operator |(ap_private<(sizeof(unsigned short) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned short) * 8), (false)>::template RType<_AP_W, false>::logic operator |(unsigned short op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned short) * 8), (false)>(op2).operator |( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(unsigned short) * 8), (false)>::logic operator ^(const _private_range_ref<_AP_W, _AP_S>& op, unsigned short op2) { return (ap_private<_AP_W, false>(op)) . operator ^(ap_private<(sizeof(unsigned short) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned short) * 8), (false)>::template RType<_AP_W, false>::logic operator ^(unsigned short op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned short) * 8), (false)>(op2).operator ^( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(unsigned short) * 8), (false)>::arg1 operator >>(const _private_range_ref<_AP_W, _AP_S>& op, unsigned short op2) { return (ap_private<_AP_W, false>(op)) . operator >>(ap_private<(sizeof(unsigned short) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned short) * 8), (false)>::template RType<_AP_W, false>::arg1 operator >>(unsigned short op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned short) * 8), (false)>(op2).operator >>( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(unsigned short) * 8), (false)>::arg1 operator <<(const _private_range_ref<_AP_W, _AP_S>& op, unsigned short op2) { return (ap_private<_AP_W, false>(op)) . operator <<(ap_private<(sizeof(unsigned short) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned short) * 8), (false)>::template RType<_AP_W, false>::arg1 operator <<(unsigned short op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned short) * 8), (false)>(op2).operator <<( ap_private<_AP_W, false>(op)); }
template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(int) * 8), (true)>::plus operator +(const _private_range_ref<_AP_W, _AP_S>& op, int op2) { return (ap_private<_AP_W, false>(op)) . operator +(ap_private<(sizeof(int) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(int) * 8), (true)>::template RType<_AP_W, false>::plus operator +(int op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(int) * 8), (true)>(op2).operator +( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(int) * 8), (true)>::minus operator -(const _private_range_ref<_AP_W, _AP_S>& op, int op2) { return (ap_private<_AP_W, false>(op)) . operator -(ap_private<(sizeof(int) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(int) * 8), (true)>::template RType<_AP_W, false>::minus operator -(int op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(int) * 8), (true)>(op2).operator -( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(int) * 8), (true)>::mult operator *(const _private_range_ref<_AP_W, _AP_S>& op, int op2) { return (ap_private<_AP_W, false>(op)) . operator *(ap_private<(sizeof(int) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(int) * 8), (true)>::template RType<_AP_W, false>::mult operator *(int op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(int) * 8), (true)>(op2).operator *( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(int) * 8), (true)>::div operator /(const _private_range_ref<_AP_W, _AP_S>& op, int op2) { return (ap_private<_AP_W, false>(op)) . operator /(ap_private<(sizeof(int) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(int) * 8), (true)>::template RType<_AP_W, false>::div operator /(int op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(int) * 8), (true)>(op2).operator /( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(int) * 8), (true)>::mod operator %(const _private_range_ref<_AP_W, _AP_S>& op, int op2) { return (ap_private<_AP_W, false>(op)) . operator %(ap_private<(sizeof(int) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(int) * 8), (true)>::template RType<_AP_W, false>::mod operator %(int op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(int) * 8), (true)>(op2).operator %( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(int) * 8), (true)>::logic operator &(const _private_range_ref<_AP_W, _AP_S>& op, int op2) { return (ap_private<_AP_W, false>(op)) . operator &(ap_private<(sizeof(int) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(int) * 8), (true)>::template RType<_AP_W, false>::logic operator &(int op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(int) * 8), (true)>(op2).operator &( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(int) * 8), (true)>::logic operator |(const _private_range_ref<_AP_W, _AP_S>& op, int op2) { return (ap_private<_AP_W, false>(op)) . operator |(ap_private<(sizeof(int) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(int) * 8), (true)>::template RType<_AP_W, false>::logic operator |(int op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(int) * 8), (true)>(op2).operator |( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(int) * 8), (true)>::logic operator ^(const _private_range_ref<_AP_W, _AP_S>& op, int op2) { return (ap_private<_AP_W, false>(op)) . operator ^(ap_private<(sizeof(int) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(int) * 8), (true)>::template RType<_AP_W, false>::logic operator ^(int op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(int) * 8), (true)>(op2).operator ^( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(int) * 8), (true)>::arg1 operator >>(const _private_range_ref<_AP_W, _AP_S>& op, int op2) { return (ap_private<_AP_W, false>(op)) . operator >>(ap_private<(sizeof(int) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(int) * 8), (true)>::template RType<_AP_W, false>::arg1 operator >>(int op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(int) * 8), (true)>(op2).operator >>( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(int) * 8), (true)>::arg1 operator <<(const _private_range_ref<_AP_W, _AP_S>& op, int op2) { return (ap_private<_AP_W, false>(op)) . operator <<(ap_private<(sizeof(int) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(int) * 8), (true)>::template RType<_AP_W, false>::arg1 operator <<(int op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(int) * 8), (true)>(op2).operator <<( ap_private<_AP_W, false>(op)); }
template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(unsigned int) * 8), (false)>::plus operator +(const _private_range_ref<_AP_W, _AP_S>& op, unsigned int op2) { return (ap_private<_AP_W, false>(op)) . operator +(ap_private<(sizeof(unsigned int) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned int) * 8), (false)>::template RType<_AP_W, false>::plus operator +(unsigned int op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned int) * 8), (false)>(op2).operator +( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(unsigned int) * 8), (false)>::minus operator -(const _private_range_ref<_AP_W, _AP_S>& op, unsigned int op2) { return (ap_private<_AP_W, false>(op)) . operator -(ap_private<(sizeof(unsigned int) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned int) * 8), (false)>::template RType<_AP_W, false>::minus operator -(unsigned int op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned int) * 8), (false)>(op2).operator -( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(unsigned int) * 8), (false)>::mult operator *(const _private_range_ref<_AP_W, _AP_S>& op, unsigned int op2) { return (ap_private<_AP_W, false>(op)) . operator *(ap_private<(sizeof(unsigned int) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned int) * 8), (false)>::template RType<_AP_W, false>::mult operator *(unsigned int op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned int) * 8), (false)>(op2).operator *( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(unsigned int) * 8), (false)>::div operator /(const _private_range_ref<_AP_W, _AP_S>& op, unsigned int op2) { return (ap_private<_AP_W, false>(op)) . operator /(ap_private<(sizeof(unsigned int) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned int) * 8), (false)>::template RType<_AP_W, false>::div operator /(unsigned int op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned int) * 8), (false)>(op2).operator /( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(unsigned int) * 8), (false)>::mod operator %(const _private_range_ref<_AP_W, _AP_S>& op, unsigned int op2) { return (ap_private<_AP_W, false>(op)) . operator %(ap_private<(sizeof(unsigned int) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned int) * 8), (false)>::template RType<_AP_W, false>::mod operator %(unsigned int op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned int) * 8), (false)>(op2).operator %( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(unsigned int) * 8), (false)>::logic operator &(const _private_range_ref<_AP_W, _AP_S>& op, unsigned int op2) { return (ap_private<_AP_W, false>(op)) . operator &(ap_private<(sizeof(unsigned int) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned int) * 8), (false)>::template RType<_AP_W, false>::logic operator &(unsigned int op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned int) * 8), (false)>(op2).operator &( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(unsigned int) * 8), (false)>::logic operator |(const _private_range_ref<_AP_W, _AP_S>& op, unsigned int op2) { return (ap_private<_AP_W, false>(op)) . operator |(ap_private<(sizeof(unsigned int) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned int) * 8), (false)>::template RType<_AP_W, false>::logic operator |(unsigned int op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned int) * 8), (false)>(op2).operator |( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(unsigned int) * 8), (false)>::logic operator ^(const _private_range_ref<_AP_W, _AP_S>& op, unsigned int op2) { return (ap_private<_AP_W, false>(op)) . operator ^(ap_private<(sizeof(unsigned int) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned int) * 8), (false)>::template RType<_AP_W, false>::logic operator ^(unsigned int op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned int) * 8), (false)>(op2).operator ^( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(unsigned int) * 8), (false)>::arg1 operator >>(const _private_range_ref<_AP_W, _AP_S>& op, unsigned int op2) { return (ap_private<_AP_W, false>(op)) . operator >>(ap_private<(sizeof(unsigned int) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned int) * 8), (false)>::template RType<_AP_W, false>::arg1 operator >>(unsigned int op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned int) * 8), (false)>(op2).operator >>( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(unsigned int) * 8), (false)>::arg1 operator <<(const _private_range_ref<_AP_W, _AP_S>& op, unsigned int op2) { return (ap_private<_AP_W, false>(op)) . operator <<(ap_private<(sizeof(unsigned int) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned int) * 8), (false)>::template RType<_AP_W, false>::arg1 operator <<(unsigned int op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned int) * 8), (false)>(op2).operator <<( ap_private<_AP_W, false>(op)); }
template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(long) * 8), (true)>::plus operator +(const _private_range_ref<_AP_W, _AP_S>& op, long op2) { return (ap_private<_AP_W, false>(op)) . operator +(ap_private<(sizeof(long) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(long) * 8), (true)>::template RType<_AP_W, false>::plus operator +(long op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(long) * 8), (true)>(op2).operator +( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(long) * 8), (true)>::minus operator -(const _private_range_ref<_AP_W, _AP_S>& op, long op2) { return (ap_private<_AP_W, false>(op)) . operator -(ap_private<(sizeof(long) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(long) * 8), (true)>::template RType<_AP_W, false>::minus operator -(long op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(long) * 8), (true)>(op2).operator -( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(long) * 8), (true)>::mult operator *(const _private_range_ref<_AP_W, _AP_S>& op, long op2) { return (ap_private<_AP_W, false>(op)) . operator *(ap_private<(sizeof(long) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(long) * 8), (true)>::template RType<_AP_W, false>::mult operator *(long op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(long) * 8), (true)>(op2).operator *( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(long) * 8), (true)>::div operator /(const _private_range_ref<_AP_W, _AP_S>& op, long op2) { return (ap_private<_AP_W, false>(op)) . operator /(ap_private<(sizeof(long) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(long) * 8), (true)>::template RType<_AP_W, false>::div operator /(long op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(long) * 8), (true)>(op2).operator /( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(long) * 8), (true)>::mod operator %(const _private_range_ref<_AP_W, _AP_S>& op, long op2) { return (ap_private<_AP_W, false>(op)) . operator %(ap_private<(sizeof(long) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(long) * 8), (true)>::template RType<_AP_W, false>::mod operator %(long op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(long) * 8), (true)>(op2).operator %( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(long) * 8), (true)>::logic operator &(const _private_range_ref<_AP_W, _AP_S>& op, long op2) { return (ap_private<_AP_W, false>(op)) . operator &(ap_private<(sizeof(long) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(long) * 8), (true)>::template RType<_AP_W, false>::logic operator &(long op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(long) * 8), (true)>(op2).operator &( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(long) * 8), (true)>::logic operator |(const _private_range_ref<_AP_W, _AP_S>& op, long op2) { return (ap_private<_AP_W, false>(op)) . operator |(ap_private<(sizeof(long) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(long) * 8), (true)>::template RType<_AP_W, false>::logic operator |(long op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(long) * 8), (true)>(op2).operator |( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(long) * 8), (true)>::logic operator ^(const _private_range_ref<_AP_W, _AP_S>& op, long op2) { return (ap_private<_AP_W, false>(op)) . operator ^(ap_private<(sizeof(long) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(long) * 8), (true)>::template RType<_AP_W, false>::logic operator ^(long op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(long) * 8), (true)>(op2).operator ^( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(long) * 8), (true)>::arg1 operator >>(const _private_range_ref<_AP_W, _AP_S>& op, long op2) { return (ap_private<_AP_W, false>(op)) . operator >>(ap_private<(sizeof(long) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(long) * 8), (true)>::template RType<_AP_W, false>::arg1 operator >>(long op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(long) * 8), (true)>(op2).operator >>( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(long) * 8), (true)>::arg1 operator <<(const _private_range_ref<_AP_W, _AP_S>& op, long op2) { return (ap_private<_AP_W, false>(op)) . operator <<(ap_private<(sizeof(long) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(long) * 8), (true)>::template RType<_AP_W, false>::arg1 operator <<(long op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(long) * 8), (true)>(op2).operator <<( ap_private<_AP_W, false>(op)); }
template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(unsigned long) * 8), (false)>::plus operator +(const _private_range_ref<_AP_W, _AP_S>& op, unsigned long op2) { return (ap_private<_AP_W, false>(op)) . operator +(ap_private<(sizeof(unsigned long) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned long) * 8), (false)>::template RType<_AP_W, false>::plus operator +(unsigned long op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned long) * 8), (false)>(op2).operator +( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(unsigned long) * 8), (false)>::minus operator -(const _private_range_ref<_AP_W, _AP_S>& op, unsigned long op2) { return (ap_private<_AP_W, false>(op)) . operator -(ap_private<(sizeof(unsigned long) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned long) * 8), (false)>::template RType<_AP_W, false>::minus operator -(unsigned long op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned long) * 8), (false)>(op2).operator -( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(unsigned long) * 8), (false)>::mult operator *(const _private_range_ref<_AP_W, _AP_S>& op, unsigned long op2) { return (ap_private<_AP_W, false>(op)) . operator *(ap_private<(sizeof(unsigned long) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned long) * 8), (false)>::template RType<_AP_W, false>::mult operator *(unsigned long op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned long) * 8), (false)>(op2).operator *( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(unsigned long) * 8), (false)>::div operator /(const _private_range_ref<_AP_W, _AP_S>& op, unsigned long op2) { return (ap_private<_AP_W, false>(op)) . operator /(ap_private<(sizeof(unsigned long) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned long) * 8), (false)>::template RType<_AP_W, false>::div operator /(unsigned long op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned long) * 8), (false)>(op2).operator /( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(unsigned long) * 8), (false)>::mod operator %(const _private_range_ref<_AP_W, _AP_S>& op, unsigned long op2) { return (ap_private<_AP_W, false>(op)) . operator %(ap_private<(sizeof(unsigned long) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned long) * 8), (false)>::template RType<_AP_W, false>::mod operator %(unsigned long op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned long) * 8), (false)>(op2).operator %( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(unsigned long) * 8), (false)>::logic operator &(const _private_range_ref<_AP_W, _AP_S>& op, unsigned long op2) { return (ap_private<_AP_W, false>(op)) . operator &(ap_private<(sizeof(unsigned long) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned long) * 8), (false)>::template RType<_AP_W, false>::logic operator &(unsigned long op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned long) * 8), (false)>(op2).operator &( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(unsigned long) * 8), (false)>::logic operator |(const _private_range_ref<_AP_W, _AP_S>& op, unsigned long op2) { return (ap_private<_AP_W, false>(op)) . operator |(ap_private<(sizeof(unsigned long) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned long) * 8), (false)>::template RType<_AP_W, false>::logic operator |(unsigned long op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned long) * 8), (false)>(op2).operator |( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(unsigned long) * 8), (false)>::logic operator ^(const _private_range_ref<_AP_W, _AP_S>& op, unsigned long op2) { return (ap_private<_AP_W, false>(op)) . operator ^(ap_private<(sizeof(unsigned long) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned long) * 8), (false)>::template RType<_AP_W, false>::logic operator ^(unsigned long op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned long) * 8), (false)>(op2).operator ^( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(unsigned long) * 8), (false)>::arg1 operator >>(const _private_range_ref<_AP_W, _AP_S>& op, unsigned long op2) { return (ap_private<_AP_W, false>(op)) . operator >>(ap_private<(sizeof(unsigned long) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned long) * 8), (false)>::template RType<_AP_W, false>::arg1 operator >>(unsigned long op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned long) * 8), (false)>(op2).operator >>( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(unsigned long) * 8), (false)>::arg1 operator <<(const _private_range_ref<_AP_W, _AP_S>& op, unsigned long op2) { return (ap_private<_AP_W, false>(op)) . operator <<(ap_private<(sizeof(unsigned long) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(unsigned long) * 8), (false)>::template RType<_AP_W, false>::arg1 operator <<(unsigned long op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(unsigned long) * 8), (false)>(op2).operator <<( ap_private<_AP_W, false>(op)); }
template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(ap_slong) * 8), (true)>::plus operator +(const _private_range_ref<_AP_W, _AP_S>& op, ap_slong op2) { return (ap_private<_AP_W, false>(op)) . operator +(ap_private<(sizeof(ap_slong) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(ap_slong) * 8), (true)>::template RType<_AP_W, false>::plus operator +(ap_slong op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_slong) * 8), (true)>(op2).operator +( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(ap_slong) * 8), (true)>::minus operator -(const _private_range_ref<_AP_W, _AP_S>& op, ap_slong op2) { return (ap_private<_AP_W, false>(op)) . operator -(ap_private<(sizeof(ap_slong) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(ap_slong) * 8), (true)>::template RType<_AP_W, false>::minus operator -(ap_slong op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_slong) * 8), (true)>(op2).operator -( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(ap_slong) * 8), (true)>::mult operator *(const _private_range_ref<_AP_W, _AP_S>& op, ap_slong op2) { return (ap_private<_AP_W, false>(op)) . operator *(ap_private<(sizeof(ap_slong) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(ap_slong) * 8), (true)>::template RType<_AP_W, false>::mult operator *(ap_slong op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_slong) * 8), (true)>(op2).operator *( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(ap_slong) * 8), (true)>::div operator /(const _private_range_ref<_AP_W, _AP_S>& op, ap_slong op2) { return (ap_private<_AP_W, false>(op)) . operator /(ap_private<(sizeof(ap_slong) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(ap_slong) * 8), (true)>::template RType<_AP_W, false>::div operator /(ap_slong op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_slong) * 8), (true)>(op2).operator /( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(ap_slong) * 8), (true)>::mod operator %(const _private_range_ref<_AP_W, _AP_S>& op, ap_slong op2) { return (ap_private<_AP_W, false>(op)) . operator %(ap_private<(sizeof(ap_slong) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(ap_slong) * 8), (true)>::template RType<_AP_W, false>::mod operator %(ap_slong op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_slong) * 8), (true)>(op2).operator %( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(ap_slong) * 8), (true)>::logic operator &(const _private_range_ref<_AP_W, _AP_S>& op, ap_slong op2) { return (ap_private<_AP_W, false>(op)) . operator &(ap_private<(sizeof(ap_slong) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(ap_slong) * 8), (true)>::template RType<_AP_W, false>::logic operator &(ap_slong op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_slong) * 8), (true)>(op2).operator &( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(ap_slong) * 8), (true)>::logic operator |(const _private_range_ref<_AP_W, _AP_S>& op, ap_slong op2) { return (ap_private<_AP_W, false>(op)) . operator |(ap_private<(sizeof(ap_slong) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(ap_slong) * 8), (true)>::template RType<_AP_W, false>::logic operator |(ap_slong op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_slong) * 8), (true)>(op2).operator |( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(ap_slong) * 8), (true)>::logic operator ^(const _private_range_ref<_AP_W, _AP_S>& op, ap_slong op2) { return (ap_private<_AP_W, false>(op)) . operator ^(ap_private<(sizeof(ap_slong) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(ap_slong) * 8), (true)>::template RType<_AP_W, false>::logic operator ^(ap_slong op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_slong) * 8), (true)>(op2).operator ^( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(ap_slong) * 8), (true)>::arg1 operator >>(const _private_range_ref<_AP_W, _AP_S>& op, ap_slong op2) { return (ap_private<_AP_W, false>(op)) . operator >>(ap_private<(sizeof(ap_slong) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(ap_slong) * 8), (true)>::template RType<_AP_W, false>::arg1 operator >>(ap_slong op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_slong) * 8), (true)>(op2).operator >>( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(ap_slong) * 8), (true)>::arg1 operator <<(const _private_range_ref<_AP_W, _AP_S>& op, ap_slong op2) { return (ap_private<_AP_W, false>(op)) . operator <<(ap_private<(sizeof(ap_slong) * 8), (true)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(ap_slong) * 8), (true)>::template RType<_AP_W, false>::arg1 operator <<(ap_slong op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_slong) * 8), (true)>(op2).operator <<( ap_private<_AP_W, false>(op)); }
template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(ap_ulong) * 8), (false)>::plus operator +(const _private_range_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return (ap_private<_AP_W, false>(op)) . operator +(ap_private<(sizeof(ap_ulong) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(ap_ulong) * 8), (false)>::template RType<_AP_W, false>::plus operator +(ap_ulong op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_ulong) * 8), (false)>(op2).operator +( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(ap_ulong) * 8), (false)>::minus operator -(const _private_range_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return (ap_private<_AP_W, false>(op)) . operator -(ap_private<(sizeof(ap_ulong) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(ap_ulong) * 8), (false)>::template RType<_AP_W, false>::minus operator -(ap_ulong op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_ulong) * 8), (false)>(op2).operator -( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(ap_ulong) * 8), (false)>::mult operator *(const _private_range_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return (ap_private<_AP_W, false>(op)) . operator *(ap_private<(sizeof(ap_ulong) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(ap_ulong) * 8), (false)>::template RType<_AP_W, false>::mult operator *(ap_ulong op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_ulong) * 8), (false)>(op2).operator *( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(ap_ulong) * 8), (false)>::div operator /(const _private_range_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return (ap_private<_AP_W, false>(op)) . operator /(ap_private<(sizeof(ap_ulong) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(ap_ulong) * 8), (false)>::template RType<_AP_W, false>::div operator /(ap_ulong op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_ulong) * 8), (false)>(op2).operator /( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(ap_ulong) * 8), (false)>::mod operator %(const _private_range_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return (ap_private<_AP_W, false>(op)) . operator %(ap_private<(sizeof(ap_ulong) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(ap_ulong) * 8), (false)>::template RType<_AP_W, false>::mod operator %(ap_ulong op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_ulong) * 8), (false)>(op2).operator %( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(ap_ulong) * 8), (false)>::logic operator &(const _private_range_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return (ap_private<_AP_W, false>(op)) . operator &(ap_private<(sizeof(ap_ulong) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(ap_ulong) * 8), (false)>::template RType<_AP_W, false>::logic operator &(ap_ulong op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_ulong) * 8), (false)>(op2).operator &( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(ap_ulong) * 8), (false)>::logic operator |(const _private_range_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return (ap_private<_AP_W, false>(op)) . operator |(ap_private<(sizeof(ap_ulong) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(ap_ulong) * 8), (false)>::template RType<_AP_W, false>::logic operator |(ap_ulong op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_ulong) * 8), (false)>(op2).operator |( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(ap_ulong) * 8), (false)>::logic operator ^(const _private_range_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return (ap_private<_AP_W, false>(op)) . operator ^(ap_private<(sizeof(ap_ulong) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(ap_ulong) * 8), (false)>::template RType<_AP_W, false>::logic operator ^(ap_ulong op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_ulong) * 8), (false)>(op2).operator ^( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(ap_ulong) * 8), (false)>::arg1 operator >>(const _private_range_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return (ap_private<_AP_W, false>(op)) . operator >>(ap_private<(sizeof(ap_ulong) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(ap_ulong) * 8), (false)>::template RType<_AP_W, false>::arg1 operator >>(ap_ulong op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_ulong) * 8), (false)>(op2).operator >>( ap_private<_AP_W, false>(op)); } template <int _AP_W, bool _AP_S> inline typename ap_private<_AP_W, false>::template RType<(sizeof(ap_ulong) * 8), (false)>::arg1 operator <<(const _private_range_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return (ap_private<_AP_W, false>(op)) . operator <<(ap_private<(sizeof(ap_ulong) * 8), (false)>(op2)); } template <int _AP_W, bool _AP_S> inline typename ap_private<(sizeof(ap_ulong) * 8), (false)>::template RType<_AP_W, false>::arg1 operator <<(ap_ulong op2, const _private_range_ref<_AP_W, _AP_S>& op) { return ap_private<(sizeof(ap_ulong) * 8), (false)>(op2).operator <<( ap_private<_AP_W, false>(op)); }
# 7188 "/data/tools/Xilinx/Vivado/2019.1/include/etc/ap_private.h"
template <int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline typename ap_private<_AP_W, false>::template RType<_AP_W2, false>::plus operator +(const _private_range_ref<_AP_W, _AP_S>& lhs, const _private_range_ref<_AP_W2, _AP_S2>& rhs) { return ap_private<_AP_W, false>(lhs).operator +( ap_private<_AP_W2, false>(rhs)); }
template <int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline typename ap_private<_AP_W, false>::template RType<_AP_W2, false>::minus operator -(const _private_range_ref<_AP_W, _AP_S>& lhs, const _private_range_ref<_AP_W2, _AP_S2>& rhs) { return ap_private<_AP_W, false>(lhs).operator -( ap_private<_AP_W2, false>(rhs)); }
template <int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline typename ap_private<_AP_W, false>::template RType<_AP_W2, false>::mult operator *(const _private_range_ref<_AP_W, _AP_S>& lhs, const _private_range_ref<_AP_W2, _AP_S2>& rhs) { return ap_private<_AP_W, false>(lhs).operator *( ap_private<_AP_W2, false>(rhs)); }
template <int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline typename ap_private<_AP_W, false>::template RType<_AP_W2, false>::div operator /(const _private_range_ref<_AP_W, _AP_S>& lhs, const _private_range_ref<_AP_W2, _AP_S2>& rhs) { return ap_private<_AP_W, false>(lhs).operator /( ap_private<_AP_W2, false>(rhs)); }
template <int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline typename ap_private<_AP_W, false>::template RType<_AP_W2, false>::mod operator %(const _private_range_ref<_AP_W, _AP_S>& lhs, const _private_range_ref<_AP_W2, _AP_S2>& rhs) { return ap_private<_AP_W, false>(lhs).operator %( ap_private<_AP_W2, false>(rhs)); }
template <int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline typename ap_private<_AP_W, false>::template RType<_AP_W2, false>::logic operator &(const _private_range_ref<_AP_W, _AP_S>& lhs, const _private_range_ref<_AP_W2, _AP_S2>& rhs) { return ap_private<_AP_W, false>(lhs).operator &( ap_private<_AP_W2, false>(rhs)); }
template <int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline typename ap_private<_AP_W, false>::template RType<_AP_W2, false>::logic operator |(const _private_range_ref<_AP_W, _AP_S>& lhs, const _private_range_ref<_AP_W2, _AP_S2>& rhs) { return ap_private<_AP_W, false>(lhs).operator |( ap_private<_AP_W2, false>(rhs)); }
template <int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline typename ap_private<_AP_W, false>::template RType<_AP_W2, false>::logic operator ^(const _private_range_ref<_AP_W, _AP_S>& lhs, const _private_range_ref<_AP_W2, _AP_S2>& rhs) { return ap_private<_AP_W, false>(lhs).operator ^( ap_private<_AP_W2, false>(rhs)); }
template <int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline typename ap_private<_AP_W, false>::template RType<_AP_W2, false>::arg1 operator >>(const _private_range_ref<_AP_W, _AP_S>& lhs, const _private_range_ref<_AP_W2, _AP_S2>& rhs) { return ap_private<_AP_W, false>(lhs).operator >>( ap_private<_AP_W2, false>(rhs)); }
template <int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline typename ap_private<_AP_W, false>::template RType<_AP_W2, false>::arg1 operator <<(const _private_range_ref<_AP_W, _AP_S>& lhs, const _private_range_ref<_AP_W2, _AP_S2>& rhs) { return ap_private<_AP_W, false>(lhs).operator <<( ap_private<_AP_W2, false>(rhs)); }
# 642 "/data/tools/Xilinx/Vivado/2019.1/include/ap_common.h" 2
template <typename _Tp1, typename _Tp2, typename _Tp3>
inline _Tp1 _AP_ROOT_op_concat(const _Tp1& Ret, const _Tp2& X, const _Tp3& Y) {
_Tp1 r = (X).operator,(Y);
return r;
}
template <typename _Tp1, typename _Tp2, typename _Tp3>
inline _Tp1& _AP_ROOT_op_set_bit(_Tp1& Val, const _Tp2& Bit, const _Tp3& Repl) {
(Val).set_bit((Bit), (Repl));
return Val;
}
template <typename _Tp1, typename _Tp2, typename _Tp3, typename _Tp4>
inline _Tp1& _AP_ROOT_op_set_range(_Tp1& Val, const _Tp2& Lo, const _Tp3& Hi,
const _Tp4& Repl) {
(Val).range((Hi), (Lo)) = Repl;
return (Val);
}
# 691 "/data/tools/Xilinx/Vivado/2019.1/include/ap_common.h"
inline ap_ulong doubleToRawBits(double pf) {
union {
ap_ulong __L;
double __D;
} LD;
LD.__D = pf;
return LD.__L;
}
inline unsigned int floatToRawBits(float pf) {
union {
unsigned int __L;
float __D;
} LD;
LD.__D = pf;
return LD.__L;
}
inline unsigned short halfToRawBits(half pf) {
# 718 "/data/tools/Xilinx/Vivado/2019.1/include/ap_common.h"
return pf.get_bits();
}
inline double rawBitsToDouble(ap_ulong pi) {
union {
ap_ulong __L;
double __D;
} LD;
LD.__L = pi;
return LD.__D;
}
inline float rawBitsToFloat(unsigned long pi) {
union {
unsigned int __L;
float __D;
} LD;
LD.__L = pi;
return LD.__D;
}
inline half rawBitsToHalf(unsigned short pi) {
# 753 "/data/tools/Xilinx/Vivado/2019.1/include/ap_common.h"
half __D;
__D.set_bits(pi);
return __D;
}
# 55 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int.h" 2
# 1 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 1
# 80 "/data/tools/Xilinx/Vivado/2019.1/include/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_sim<_AP_W, _AP_S> {
public:
typedef ssdm_int_sim<_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 ap_int_base() {
}
template <int _AP_W2, bool _AP_S2>
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 ap_int_base(const volatile ap_int_base<_AP_W2, _AP_S2>& op) {
Base::V = op.V;
}
# 237 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
inline ap_int_base(const bool op) { Base::V = op; }
inline ap_int_base(const char op) { Base::V = op; }
inline ap_int_base(const signed char op) { Base::V = op; }
inline ap_int_base(const unsigned char op) { Base::V = op; }
inline ap_int_base(const short op) { Base::V = op; }
inline ap_int_base(const unsigned short op) { Base::V = op; }
inline ap_int_base(const int op) { Base::V = op; }
inline ap_int_base(const unsigned int op) { Base::V = op; }
inline ap_int_base(const long op) { Base::V = op; }
inline ap_int_base(const unsigned long op) { Base::V = op; }
inline ap_int_base(const ap_slong op) { Base::V = op; }
inline ap_int_base(const ap_ulong op) { Base::V = op; }
inline ap_int_base(half op) {
ap_int_base<_AP_W, _AP_S> t((float)op);
Base::V = t.V;
}
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 = (reg.V).get_bit((BITS - 1));
ap_int_base<8 + 1, true> exp = 0;
exp.V = (reg.V).range((BITS - 2), (23));
exp = exp - ((1L << (8 - 1L)) - 1L);
ap_int_base<23 + 2, true> man;
man.V = (reg.V).range((23 - 1), (0));
do { if ((exp == ((unsigned char)(((1L << (8 - 1L)) - 1L) + 1)) && man.V != 0)) { fprintf(
# 272 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
stderr
# 272 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
, "WARNING: " "assign NaN to ap integer value"); fprintf(
# 272 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
stderr
# 272 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
, "\n"); } } while (0)
;
man.V = _AP_ROOT_op_set_bit(man.V, 23, 1);
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 ap_int_base(double op) {
const int BITS = 52 + 11 + 1;
ap_int_base<BITS, false> reg;
reg.V = doubleToRawBits(op);
bool is_neg = (reg.V).get_bit((BITS - 1));
ap_int_base<11 + 1, true> exp = 0;
exp.V = (reg.V).range((BITS - 2), (52));
exp = exp - ((1L << (11 - 1L)) - 1L);
ap_int_base<52 + 2, true> man;
man.V = (reg.V).range((52 - 1), (0));
do { if ((exp == ((unsigned char)(((1L << (11 - 1L)) - 1L) + 1)) && man.V != 0)) { fprintf(
# 320 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
stderr
# 320 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
, "WARNING: " "assign NaN to ap integer value"); fprintf(
# 320 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
stderr
# 320 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
, "\n"); } } while (0)
;
man.V = _AP_ROOT_op_set_bit(man.V, 52, 1);
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 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 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 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 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;
}
inline ap_int_base(const char* s, signed char rd = 0) {
if (rd == 0)
rd = guess_radix(s);
unsigned int length = strlen(s);
Base::V.fromString(s, length, rd);
}
# 405 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_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 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 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 ap_int_base read() volatile {
ap_int_base ret;
ret.V = Base::V;
return ret;
}
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 void operator=(
const volatile ap_int_base<_AP_W2, _AP_S2>& op2) volatile {
Base::V = op2.V;
}
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 void operator=(const ap_int_base<_AP_W2, _AP_S2>& op2) volatile {
Base::V = op2.V;
}
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 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 ap_int_base& operator=(const ap_int_base<_AP_W2, _AP_S2>& op2) {
Base::V = op2.V;
return *this;
}
inline ap_int_base& operator=(const volatile ap_int_base<_AP_W, _AP_S>& op2) {
Base::V = op2.V;
return *this;
}
inline ap_int_base& operator=(const ap_int_base<_AP_W, _AP_S>& op2) {
Base::V = op2.V;
return *this;
}
# 482 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
inline ap_int_base& operator=(bool op) { Base::V = op; return *this; }
inline ap_int_base& operator=(char op) { Base::V = op; return *this; }
inline ap_int_base& operator=(signed char op) { Base::V = op; return *this; }
inline ap_int_base& operator=(unsigned char op) { Base::V = op; return *this; }
inline ap_int_base& operator=(short op) { Base::V = op; return *this; }
inline ap_int_base& operator=(unsigned short op) { Base::V = op; return *this; }
inline ap_int_base& operator=(int op) { Base::V = op; return *this; }
inline ap_int_base& operator=(unsigned int op) { Base::V = op; return *this; }
inline ap_int_base& operator=(long op) { Base::V = op; return *this; }
inline ap_int_base& operator=(unsigned long op) { Base::V = op; return *this; }
inline ap_int_base& operator=(ap_slong op) { Base::V = op; return *this; }
inline ap_int_base& operator=(ap_ulong op) { Base::V = op; return *this; }
template <int _AP_W2, bool _AP_S2>
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 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 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 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 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 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 operator RetType() const { return (RetType)(Base::V); }
inline bool to_bool() const { return (bool)(Base::V); }
inline char to_char() const { return (char)(Base::V); }
inline signed char to_schar() const { return (signed char)(Base::V); }
inline unsigned char to_uchar() const { return (unsigned char)(Base::V); }
inline short to_short() const { return (short)(Base::V); }
inline unsigned short to_ushort() const { return (unsigned short)(Base::V); }
inline int to_int() const { return (int)(Base::V); }
inline unsigned to_uint() const { return (unsigned)(Base::V); }
inline long to_long() const { return (long)(Base::V); }
inline unsigned long to_ulong() const { return (unsigned long)(Base::V); }
inline ap_slong to_int64() const { return (ap_slong)(Base::V); }
inline ap_ulong to_uint64() const { return (ap_ulong)(Base::V); }
inline float to_float() const { return (float)(Base::V); }
inline double to_double() const { return (double)(Base::V); }
# 586 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
inline int length() const volatile { return _AP_W; }
inline bool iszero() const { return Base::V == 0; }
inline bool is_zero() const { return Base::V == 0; }
inline bool sign() const {
if (_AP_S &&
(Base::V).get_bit((_AP_W - 1)))
return true;
else
return false;
}
inline void clear(int i) {
# 605 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
((
# 605 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
(i >= 0 && i < _AP_W) && ("position out of range")
# 605 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 605 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
"(i >= 0 && i < _AP_W) && (\"position out of range\")"
# 605 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h", 605, __PRETTY_FUNCTION__))
# 605 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
;
Base::V = _AP_ROOT_op_set_bit(Base::V, i, 0);
}
inline void invert(int i) {
# 611 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
((
# 611 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
(i >= 0 && i < _AP_W) && ("position out of range")
# 611 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 611 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
"(i >= 0 && i < _AP_W) && (\"position out of range\")"
# 611 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h", 611, __PRETTY_FUNCTION__))
# 611 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
;
bool val = (Base::V).get_bit((i));
if (val)
Base::V = _AP_ROOT_op_set_bit(Base::V, i, 0);
else
Base::V = _AP_ROOT_op_set_bit(Base::V, i, 1);
}
inline bool test(int i) const {
# 620 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
((
# 620 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
(i >= 0 && i < _AP_W) && ("position out of range")
# 620 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 620 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
"(i >= 0 && i < _AP_W) && (\"position out of range\")"
# 620 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h", 620, __PRETTY_FUNCTION__))
# 620 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
;
return (Base::V).get_bit((i));
}
inline ap_int_base& get() { return *this; }
inline void set(int i) {
# 629 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
((
# 629 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
(i >= 0 && i < _AP_W) && ("position out of range")
# 629 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 629 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
"(i >= 0 && i < _AP_W) && (\"position out of range\")"
# 629 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h", 629, __PRETTY_FUNCTION__))
# 629 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
;
Base::V = _AP_ROOT_op_set_bit(Base::V, i, 1);
}
inline void set(int i, bool v) {
# 635 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
((
# 635 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
(i >= 0 && i < _AP_W) && ("position out of range")
# 635 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 635 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
"(i >= 0 && i < _AP_W) && (\"position out of range\")"
# 635 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h", 635, __PRETTY_FUNCTION__))
# 635 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
;
Base::V = _AP_ROOT_op_set_bit(Base::V, i, v);
}
inline ap_int_base& lrotate(int n) {
# 642 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
((
# 642 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
(n >= 0 && n < _AP_W) && ("shift value out of range")
# 642 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 642 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
"(n >= 0 && n < _AP_W) && (\"shift value out of range\")"
# 642 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h", 642, __PRETTY_FUNCTION__))
# 642 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
;
Base::V.lrotate(n);
return *this;
}
inline ap_int_base& rrotate(int n) {
# 657 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
((
# 657 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
(n >= 0 && n < _AP_W) && ("shift value out of range")
# 657 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 657 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
"(n >= 0 && n < _AP_W) && (\"shift value out of range\")"
# 657 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h", 657, __PRETTY_FUNCTION__))
# 657 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
;
Base::V.rrotate(n);
return *this;
}
inline ap_int_base& reverse() {
Base::V = (Base::V).range((0), (_AP_W - 1));
return *this;
}
inline void set_bit(int i, bool v) {
Base::V = _AP_ROOT_op_set_bit(Base::V, i, v);
}
inline bool get_bit(int i) const {
return (bool)(Base::V).get_bit((i));
}
inline void b_not() { Base::V = ~Base::V; }
# 699 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
template <int _AP_W2, bool _AP_S2> 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 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 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 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 ap_int_base& operator %=(const ap_int_base<_AP_W2, _AP_S2>& op2) { Base::V %= op2.V; return *this; }
# 717 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
template <int _AP_W2, bool _AP_S2> inline ap_int_base& operator &=(const ap_int_base<_AP_W2, _AP_S2>& op2) { do { if (((_AP_W != _AP_W2))) { fprintf(
# 717 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
stderr
# 717 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
, "WARNING: " "Bitsize mismatch for ap_[u]int" "&=" "ap_[u]int."); fprintf(
# 717 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
stderr
# 717 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
, "\n"); } } while (0); Base::V &= op2.V; return *this; }
template <int _AP_W2, bool _AP_S2> inline ap_int_base& operator |=(const ap_int_base<_AP_W2, _AP_S2>& op2) { do { if (((_AP_W != _AP_W2))) { fprintf(
# 718 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
stderr
# 718 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
, "WARNING: " "Bitsize mismatch for ap_[u]int" "|=" "ap_[u]int."); fprintf(
# 718 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
stderr
# 718 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
, "\n"); } } while (0); Base::V |= op2.V; return *this; }
template <int _AP_W2, bool _AP_S2> inline ap_int_base& operator ^=(const ap_int_base<_AP_W2, _AP_S2>& op2) { do { if (((_AP_W != _AP_W2))) { fprintf(
# 719 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
stderr
# 719 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
, "WARNING: " "Bitsize mismatch for ap_[u]int" "^=" "ap_[u]int."); fprintf(
# 719 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
stderr
# 719 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
, "\n"); } } while (0); Base::V ^= op2.V; return *this; }
inline ap_int_base& operator++() {
operator+=((ap_int_base<1, false>)1);
return *this;
}
inline ap_int_base& operator--() {
operator-=((ap_int_base<1, false>)1);
return *this;
}
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 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 typename RType<_AP_W,_AP_S>::arg1 operator+() const { return *this; }
inline typename RType<1, false>::minus operator-() const {
return ap_int_base<1, false>(0) - *this;
}
inline bool operator!() const { return Base::V == 0; }
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 typename RType<_AP_W,_AP_S>::arg1 operator<<(const ap_int_base<_AP_W2, true>& op2) const {
bool isNeg = (op2.V).get_bit((_AP_W2 - 1));
ap_int_base<_AP_W2, false> sh = op2;
if (isNeg) {
sh = -op2;
return operator>>(sh);
} else
return operator<<(sh);
}
template <int _AP_W2>
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 typename RType<_AP_W,_AP_S>::arg1 operator>>(const ap_int_base<_AP_W2, true>& op2) const {
bool isNeg = (op2.V).get_bit((_AP_W2 - 1));
ap_int_base<_AP_W2, false> sh = op2;
if (isNeg) {
sh = -op2;
return operator<<(sh);
}
return operator>>(sh);
}
template <int _AP_W2>
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;
}
# 828 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
template <int _AP_W2>
inline ap_int_base& operator<<=(const ap_int_base<_AP_W2, true>& op2) {
bool isNeg = (op2.V).get_bit((_AP_W2 - 1));
ap_int_base<_AP_W2, false> sh = op2;
if (isNeg) {
sh = -op2;
return operator>>=(sh);
} else
return operator<<=(sh);
}
template <int _AP_W2>
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 ap_int_base& operator>>=(const ap_int_base<_AP_W2, true>& op2) {
bool isNeg = (op2.V).get_bit((_AP_W2 - 1));
ap_int_base<_AP_W2, false> sh = op2;
if (isNeg) {
sh = -op2;
return operator<<=(sh);
}
return operator>>=(sh);
}
template <int _AP_W2>
inline ap_int_base& operator>>=(const ap_int_base<_AP_W2, false>& op2) {
Base::V >>= op2.to_uint();
return *this;
}
# 877 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
template <int _AP_W2, bool _AP_S2>
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 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 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 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 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 bool operator<=(const ap_int_base<_AP_W2, _AP_S2>& op2) const {
return Base::V <= op2.V;
}
inline ap_range_ref<_AP_W, _AP_S> range(int Hi, int Lo) {
do { if ((Hi >= _AP_W)) { fprintf(
# 906 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
stderr
# 906 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
, "ERROR: " "Hi(%d)out of bound(%d) in range()", Hi, _AP_W); fprintf(
# 906 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
stderr
# 906 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
, "\n"); abort(); } } while (0);
do { if ((Lo >= _AP_W)) { fprintf(
# 907 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
stderr
# 907 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
, "ERROR: " "Lo(%d)out of bound(%d) in range()", Lo, _AP_W); fprintf(
# 907 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
stderr
# 907 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
, "\n"); abort(); } } while (0);
return ap_range_ref<_AP_W, _AP_S>(this, Hi, Lo);
}
inline ap_range_ref<_AP_W, _AP_S> range(int Hi, int Lo) const {
do { if ((Hi >= _AP_W)) { fprintf(
# 913 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
stderr
# 913 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
, "ERROR: " "Hi(%d)out of bound(%d) in range()", Hi, _AP_W); fprintf(
# 913 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
stderr
# 913 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
, "\n"); abort(); } } while (0);
do { if ((Lo >= _AP_W)) { fprintf(
# 914 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
stderr
# 914 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
, "ERROR: " "Lo(%d)out of bound(%d) in range()", Lo, _AP_W); fprintf(
# 914 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
stderr
# 914 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
, "\n"); abort(); } } while (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 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 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 ap_range_ref<_AP_W, _AP_S> range() {
return this->range(_AP_W - 1, 0);
}
inline ap_range_ref<_AP_W, _AP_S> range() const {
return this->range(_AP_W - 1, 0);
}
inline ap_range_ref<_AP_W, _AP_S> operator()(int Hi, int Lo) {
return this->range(Hi, Lo);
}
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 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 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);
}
# 986 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
inline ap_bit_ref<_AP_W, _AP_S> operator[](int index) {
# 987 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
((
# 987 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
(index >= 0) && ("Attempting to read bit with negative index")
# 987 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 987 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
"(index >= 0) && (\"Attempting to read bit with negative index\")"
# 987 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h", 987, __PRETTY_FUNCTION__))
# 987 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
;
# 988 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
((
# 988 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
(index < _AP_W) && ("Attempting to read bit beyond MSB")
# 988 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 988 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
"(index < _AP_W) && (\"Attempting to read bit beyond MSB\")"
# 988 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h", 988, __PRETTY_FUNCTION__))
# 988 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
;
ap_bit_ref<_AP_W, _AP_S> bvh(this, index);
return bvh;
}
template <int _AP_W2, bool _AP_S2>
inline ap_bit_ref<_AP_W, _AP_S> operator[](
const ap_int_base<_AP_W2, _AP_S2>& index) {
# 996 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
((
# 996 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
(index >= 0) && ("Attempting to read bit with negative index")
# 996 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 996 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
"(index >= 0) && (\"Attempting to read bit with negative index\")"
# 996 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h", 996, __PRETTY_FUNCTION__))
# 996 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
;
# 997 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
((
# 997 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
(index < _AP_W) && ("Attempting to read bit beyond MSB")
# 997 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 997 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
"(index < _AP_W) && (\"Attempting to read bit beyond MSB\")"
# 997 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h", 997, __PRETTY_FUNCTION__))
# 997 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
;
ap_bit_ref<_AP_W, _AP_S> bvh(this, index.to_int());
return bvh;
}
inline bool operator[](int index) const {
# 1003 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
((
# 1003 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
(index >= 0) && ("Attempting to read bit with negative index")
# 1003 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 1003 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
"(index >= 0) && (\"Attempting to read bit with negative index\")"
# 1003 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h", 1003, __PRETTY_FUNCTION__))
# 1003 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
;
# 1004 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
((
# 1004 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
(index < _AP_W) && ("Attempting to read bit beyond MSB")
# 1004 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 1004 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
"(index < _AP_W) && (\"Attempting to read bit beyond MSB\")"
# 1004 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h", 1004, __PRETTY_FUNCTION__))
# 1004 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
;
ap_bit_ref<_AP_W, _AP_S> br(this, index);
return br.to_bool();
}
template <int _AP_W2, bool _AP_S2>
inline bool operator[](const ap_int_base<_AP_W2, _AP_S2>& index) const {
# 1010 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
((
# 1010 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
(index < _AP_W) && ("Attempting to read bit beyond MSB")
# 1010 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 1010 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
"(index < _AP_W) && (\"Attempting to read bit beyond MSB\")"
# 1010 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h", 1010, __PRETTY_FUNCTION__))
# 1010 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
;
ap_bit_ref<_AP_W, _AP_S> br(this, index.to_int());
return br.to_bool();
}
inline ap_bit_ref<_AP_W, _AP_S> bit(int index) {
# 1016 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
((
# 1016 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
(index >= 0) && ("Attempting to read bit with negative index")
# 1016 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 1016 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
"(index >= 0) && (\"Attempting to read bit with negative index\")"
# 1016 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h", 1016, __PRETTY_FUNCTION__))
# 1016 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
;
# 1017 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
((
# 1017 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
(index < _AP_W) && ("Attempting to read bit beyond MSB")
# 1017 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 1017 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
"(index < _AP_W) && (\"Attempting to read bit beyond MSB\")"
# 1017 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h", 1017, __PRETTY_FUNCTION__))
# 1017 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
;
ap_bit_ref<_AP_W, _AP_S> bvh(this, index);
return bvh;
}
template <int _AP_W2, bool _AP_S2>
inline ap_bit_ref<_AP_W, _AP_S> bit(
const ap_int_base<_AP_W2, _AP_S2>& index) {
# 1024 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
((
# 1024 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
(index >= 0) && ("Attempting to read bit with negative index")
# 1024 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 1024 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
"(index >= 0) && (\"Attempting to read bit with negative index\")"
# 1024 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h", 1024, __PRETTY_FUNCTION__))
# 1024 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
;
# 1025 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
((
# 1025 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
(index < _AP_W) && ("Attempting to read bit beyond MSB")
# 1025 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 1025 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
"(index < _AP_W) && (\"Attempting to read bit beyond MSB\")"
# 1025 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h", 1025, __PRETTY_FUNCTION__))
# 1025 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
;
ap_bit_ref<_AP_W, _AP_S> bvh(this, index.to_int());
return bvh;
}
inline bool bit(int index) const {
# 1031 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
((
# 1031 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
(index >= 0) && ("Attempting to read bit with negative index")
# 1031 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 1031 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
"(index >= 0) && (\"Attempting to read bit with negative index\")"
# 1031 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h", 1031, __PRETTY_FUNCTION__))
# 1031 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
;
# 1032 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
((
# 1032 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
(index < _AP_W) && ("Attempting to read bit beyond MSB")
# 1032 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
) ? static_cast<void> (0) : __assert_fail (
# 1032 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
"(index < _AP_W) && (\"Attempting to read bit beyond MSB\")"
# 1032 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h" 3 4
, "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h", 1032, __PRETTY_FUNCTION__))
# 1032 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
;
ap_bit_ref<_AP_W, _AP_S> br(this, index);
return br.to_bool();
}
template <int _AP_W2, bool _AP_S2>
inline bool bit(const ap_int_base<_AP_W2, _AP_S2>& index) const {
return bit(index.to_int());
}
# 1053 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
inline int countLeadingZeros() {
# 1088 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
return (Base::V).countLeadingZeros();
}
template <int _AP_W2, bool _AP_S2>
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 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
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
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 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 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 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 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 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 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 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 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 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 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
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
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 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 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 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 void set(const ap_int_base<_AP_W3, false>& val) {
Base::V = val.V;
}
inline bool and_reduce() const { return (Base::V).and_reduce(); }
inline bool nand_reduce() const { return (Base::V).nand_reduce(); }
inline bool or_reduce() const { return (Base::V).or_reduce(); }
inline bool nor_reduce() const { return !((Base::V).or_reduce()); }
inline bool xor_reduce() const { return (Base::V).xor_reduce(); }
inline bool xnor_reduce() const {
return !((Base::V).xor_reduce());
}
std::string to_string(signed char rd = 2, bool sign = _AP_S) const {
if (rd == 2) sign = false;
return (Base::V).to_string(rd, sign);
}
};
template <int _AP_W, bool _AP_S>
inline std::ostream& operator<<(std::ostream& os,
const ap_int_base<_AP_W, _AP_S>& x) {
std::ios_base::fmtflags ff = std::cout.flags();
if (ff & std::cout.hex) {
os << x.to_string(16);
} else if (ff & std::cout.oct) {
os << x.to_string(8);
} else {
os << x.to_string(10);
}
return os;
}
template <int _AP_W, bool _AP_S>
inline std::istream& operator>>(std::istream& in,
ap_int_base<_AP_W, _AP_S>& op) {
std::string str;
in >> str;
const std::ios_base::fmtflags basefield = in.flags() & std::ios_base::basefield;
unsigned radix = (basefield == std::ios_base::dec) ? 0 : (
(basefield == std::ios_base::oct) ? 8 : (
(basefield == std::ios_base::hex) ? 16 : 0));
op = ap_int_base<_AP_W, _AP_S>(str.c_str(), radix);
return in;
}
# 1352 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
template <int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> 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 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 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 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 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 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; }
# 1371 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
template <int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> 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 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; }
# 1399 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
template <typename PTR_TYPE, int _AP_W, bool _AP_S> inline PTR_TYPE* operator +(PTR_TYPE* i_op, const ap_int_base<_AP_W, _AP_S>& op) { ap_slong op2 = op.to_int64(); return i_op + op2; } template <typename PTR_TYPE, int _AP_W, bool _AP_S> inline PTR_TYPE* operator +(const ap_int_base<_AP_W, _AP_S>& op, PTR_TYPE* i_op) { ap_slong op2 = op.to_int64(); return op2 + i_op; }
template <typename PTR_TYPE, int _AP_W, bool _AP_S> inline PTR_TYPE* operator -(PTR_TYPE* i_op, const ap_int_base<_AP_W, _AP_S>& op) { ap_slong op2 = op.to_int64(); return i_op - op2; } template <typename PTR_TYPE, int _AP_W, bool _AP_S> inline PTR_TYPE* operator -(const ap_int_base<_AP_W, _AP_S>& op, PTR_TYPE* i_op) { ap_slong op2 = op.to_int64(); return op2 - i_op; }
# 1427 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
template <int _AP_W, bool _AP_S> 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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; }
# 1461 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
template <int _AP_W, bool _AP_S> 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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); }
# 1500 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
template <int _AP_W, bool _AP_S> 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 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 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 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 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 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 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 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 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 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 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 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; }
# 1524 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
template <int _AP_W, bool _AP_S> 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 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 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 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 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 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 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 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 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 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 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 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; }
# 1555 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
template <int _AP_W, bool _AP_S> 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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); }
# 1592 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
template <int _AP_W, bool _AP_S> 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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); }
# 1629 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
template <int _AP_W, bool _AP_S> 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 bool operator !=(float op1, const ap_int_base<_AP_W, _AP_S>& op2) { return op1 != op2.to_double() ; }
# 1659 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline ap_int_base<_AP_W1, _AP_S1>& operator +=( 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 ap_range_ref<_AP_W1, _AP_S1>& operator +=( ap_range_ref<_AP_W1, _AP_S1>& op1, const 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 ap_int_base<_AP_W1, _AP_S1>& operator -=( 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 ap_range_ref<_AP_W1, _AP_S1>& operator -=( ap_range_ref<_AP_W1, _AP_S1>& op1, const 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 ap_int_base<_AP_W1, _AP_S1>& operator *=( 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 ap_range_ref<_AP_W1, _AP_S1>& operator *=( ap_range_ref<_AP_W1, _AP_S1>& op1, const 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 ap_int_base<_AP_W1, _AP_S1>& operator /=( 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 ap_range_ref<_AP_W1, _AP_S1>& operator /=( ap_range_ref<_AP_W1, _AP_S1>& op1, const 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 ap_int_base<_AP_W1, _AP_S1>& operator %=( 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 ap_range_ref<_AP_W1, _AP_S1>& operator %=( ap_range_ref<_AP_W1, _AP_S1>& op1, const 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 ap_int_base<_AP_W1, _AP_S1>& operator >>=( 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 ap_range_ref<_AP_W1, _AP_S1>& operator >>=( ap_range_ref<_AP_W1, _AP_S1>& op1, const 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 ap_int_base<_AP_W1, _AP_S1>& operator <<=( 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 ap_range_ref<_AP_W1, _AP_S1>& operator <<=( ap_range_ref<_AP_W1, _AP_S1>& op1, const ap_int_base<_AP_W2, _AP_S2>& op2) { ap_int_base<_AP_W1, false> tmp(op1); tmp <<= op2; op1 = tmp; return op1; }
# 1722 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline ap_int_base<_AP_W1, _AP_S1>& operator &=( ap_int_base<_AP_W1, _AP_S1>& op1, const ap_range_ref<_AP_W2, _AP_S2>& op2) { ap_int_base<_AP_W2, false> tmp(op2); op1.V &= tmp.V; return op1; } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline ap_range_ref<_AP_W1, _AP_S1>& operator &=( ap_range_ref<_AP_W1, _AP_S1>& op1, const ap_int_base<_AP_W2, _AP_S2>& op2) { ap_int_base<_AP_W1, false> tmp(op1); tmp.V &= op2.V; op1 = tmp; return op1; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline ap_int_base<_AP_W1, _AP_S1>& operator |=( ap_int_base<_AP_W1, _AP_S1>& op1, const ap_range_ref<_AP_W2, _AP_S2>& op2) { ap_int_base<_AP_W2, false> tmp(op2); op1.V |= tmp.V; return op1; } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline ap_range_ref<_AP_W1, _AP_S1>& operator |=( ap_range_ref<_AP_W1, _AP_S1>& op1, const ap_int_base<_AP_W2, _AP_S2>& op2) { ap_int_base<_AP_W1, false> tmp(op1); tmp.V |= op2.V; op1 = tmp; return op1; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline ap_int_base<_AP_W1, _AP_S1>& operator ^=( ap_int_base<_AP_W1, _AP_S1>& op1, const ap_range_ref<_AP_W2, _AP_S2>& op2) { ap_int_base<_AP_W2, false> tmp(op2); op1.V ^= tmp.V; return op1; } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline ap_range_ref<_AP_W1, _AP_S1>& operator ^=( ap_range_ref<_AP_W1, _AP_S1>& op1, const ap_int_base<_AP_W2, _AP_S2>& op2) { ap_int_base<_AP_W1, false> tmp(op1); tmp.V ^= op2.V; op1 = tmp; return op1; }
# 1741 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> 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 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 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 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 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 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 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 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 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 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 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 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>()); }
# 1768 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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; }
# 1799 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline ap_int_base<_AP_W1, _AP_S1>& operator +=( 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 ap_bit_ref<_AP_W1, _AP_S1>& operator +=( ap_bit_ref<_AP_W1, _AP_S1>& op1, const 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 ap_int_base<_AP_W1, _AP_S1>& operator -=( 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 ap_bit_ref<_AP_W1, _AP_S1>& operator -=( ap_bit_ref<_AP_W1, _AP_S1>& op1, const 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 ap_int_base<_AP_W1, _AP_S1>& operator *=( 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 ap_bit_ref<_AP_W1, _AP_S1>& operator *=( ap_bit_ref<_AP_W1, _AP_S1>& op1, const 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 ap_int_base<_AP_W1, _AP_S1>& operator /=( 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 ap_bit_ref<_AP_W1, _AP_S1>& operator /=( ap_bit_ref<_AP_W1, _AP_S1>& op1, const 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 ap_int_base<_AP_W1, _AP_S1>& operator %=( 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 ap_bit_ref<_AP_W1, _AP_S1>& operator %=( ap_bit_ref<_AP_W1, _AP_S1>& op1, const 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 ap_int_base<_AP_W1, _AP_S1>& operator >>=( 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 ap_bit_ref<_AP_W1, _AP_S1>& operator >>=( ap_bit_ref<_AP_W1, _AP_S1>& op1, const 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 ap_int_base<_AP_W1, _AP_S1>& operator <<=( 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 ap_bit_ref<_AP_W1, _AP_S1>& operator <<=( ap_bit_ref<_AP_W1, _AP_S1>& op1, const ap_int_base<_AP_W2, _AP_S2>& op2) { ap_int_base<1, false> tmp(op1); tmp <<= op2; op1 = tmp; return op1; }
# 1831 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline ap_int_base<_AP_W1, _AP_S1>& operator &=( ap_int_base<_AP_W1, _AP_S1>& op1, const ap_bit_ref<_AP_W2, _AP_S2>& op2) { ap_int_base<1, false> tmp(op2); op1.V &= tmp.V; return op1; } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline ap_bit_ref<_AP_W1, _AP_S1>& operator &=( ap_bit_ref<_AP_W1, _AP_S1>& op1, const ap_int_base<_AP_W2, _AP_S2>& op2) { ap_int_base<1, false> tmp(op1); tmp.V &= op2.V; op1 = tmp; return op1; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline ap_int_base<_AP_W1, _AP_S1>& operator |=( ap_int_base<_AP_W1, _AP_S1>& op1, const ap_bit_ref<_AP_W2, _AP_S2>& op2) { ap_int_base<1, false> tmp(op2); op1.V |= tmp.V; return op1; } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline ap_bit_ref<_AP_W1, _AP_S1>& operator |=( ap_bit_ref<_AP_W1, _AP_S1>& op1, const ap_int_base<_AP_W2, _AP_S2>& op2) { ap_int_base<1, false> tmp(op1); tmp.V |= op2.V; op1 = tmp; return op1; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline ap_int_base<_AP_W1, _AP_S1>& operator ^=( ap_int_base<_AP_W1, _AP_S1>& op1, const ap_bit_ref<_AP_W2, _AP_S2>& op2) { ap_int_base<1, false> tmp(op2); op1.V ^= tmp.V; return op1; } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline ap_bit_ref<_AP_W1, _AP_S1>& operator ^=( ap_bit_ref<_AP_W1, _AP_S1>& op1, const ap_int_base<_AP_W2, _AP_S2>& op2) { ap_int_base<1, false> tmp(op1); tmp.V ^= op2.V; op1 = tmp; return op1; }
# 1850 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> 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 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 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 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 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 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 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 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 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 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 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 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; }
# 1958 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_base.h"
template <int _AP_W1, typename _AP_T1, int _AP_W2, typename _AP_T2, int _AP_W3, bool _AP_S3> 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 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 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 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 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 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 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 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 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 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 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 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 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int.h" 2
# 1 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_ref.h" 1
# 73 "/data/tools/Xilinx/Vivado/2019.1/include/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 ap_concat_ref(const ap_concat_ref<_AP_W1, _AP_T1, _AP_W2, _AP_T2>& ref)
: mbv1(ref.mbv1), mbv2(ref.mbv2) {}
inline ap_concat_ref(_AP_T1& bv1, _AP_T2& bv2) : mbv1(bv1), mbv2(bv2) {}
template <int _AP_W3, bool _AP_S3>
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 = (vval.V).range((W_ref1 + W_ref2 - 1), (W_ref2));
mbv1.set(Part1);
ap_int_base<_AP_W2, false> Part2;
Part2.V = (vval.V).range((W_ref2 - 1), (0));
mbv2.set(Part2);
return *this;
}
# 116 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_ref.h"
inline ap_concat_ref& operator=(bool val) { ap_int_base<_AP_W1 + _AP_W2, false> tmpVal(val); return operator=(tmpVal); }
inline ap_concat_ref& operator=(char val) { ap_int_base<_AP_W1 + _AP_W2, false> tmpVal(val); return operator=(tmpVal); }
inline ap_concat_ref& operator=(signed char val) { ap_int_base<_AP_W1 + _AP_W2, false> tmpVal(val); return operator=(tmpVal); }
inline ap_concat_ref& operator=(unsigned char val) { ap_int_base<_AP_W1 + _AP_W2, false> tmpVal(val); return operator=(tmpVal); }
inline ap_concat_ref& operator=(short val) { ap_int_base<_AP_W1 + _AP_W2, false> tmpVal(val); return operator=(tmpVal); }
inline ap_concat_ref& operator=(unsigned short val) { ap_int_base<_AP_W1 + _AP_W2, false> tmpVal(val); return operator=(tmpVal); }
inline ap_concat_ref& operator=(int val) { ap_int_base<_AP_W1 + _AP_W2, false> tmpVal(val); return operator=(tmpVal); }
inline ap_concat_ref& operator=(unsigned int val) { ap_int_base<_AP_W1 + _AP_W2, false> tmpVal(val); return operator=(tmpVal); }
inline ap_concat_ref& operator=(long val) { ap_int_base<_AP_W1 + _AP_W2, false> tmpVal(val); return operator=(tmpVal); }
inline ap_concat_ref& operator=(unsigned long val) { ap_int_base<_AP_W1 + _AP_W2, false> tmpVal(val); return operator=(tmpVal); }
inline ap_concat_ref& operator=(ap_slong val) { ap_int_base<_AP_W1 + _AP_W2, false> tmpVal(val); return operator=(tmpVal); }
inline ap_concat_ref& operator=(ap_ulong val) { ap_int_base<_AP_W1 + _AP_W2, false> tmpVal(val); return operator=(tmpVal); }
inline ap_concat_ref& operator=(half val) { ap_int_base<_AP_W1 + _AP_W2, false> tmpVal(val); return operator=(tmpVal); }
inline ap_concat_ref& operator=(float val) { ap_int_base<_AP_W1 + _AP_W2, false> tmpVal(val); return operator=(tmpVal); }
inline ap_concat_ref& operator=(double val) { ap_int_base<_AP_W1 + _AP_W2, false> tmpVal(val); return operator=(tmpVal); }
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 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 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 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 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 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 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 operator ap_int_base<_AP_WR, false>() const { return get(); }
inline operator ap_ulong() const { return get().to_uint64(); }
template <int _AP_W3, bool _AP_S3>
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
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
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
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
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 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 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 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
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 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 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 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;
}
# 304 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_ref.h"
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 = _AP_ROOT_op_set_range(tmpVal.V, 0, W_ref2 - 1, v2.V);
tmpVal.V =
_AP_ROOT_op_set_range(tmpVal.V, W_ref2, W_ref1 + W_ref2 - 1, v1.V);
return tmpVal;
}
template <int _AP_W3>
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 = (vval.V).range((W_ref1 + W_ref2 - 1), (W_ref2));
mbv1.set(tmpVal1);
ap_int_base<_AP_W2, false> tmpVal2;
tmpVal2.V = (vval.V).range((W_ref2 - 1), (0));
mbv2.set(tmpVal2);
}
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 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 ap_range_ref(ref_type* bv, int h, int l)
: d_bv(*bv), l_index(l), h_index(h) {}
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 operator ap_int_base<_AP_W, false>() const {
ap_int_base<_AP_W, false> ret;
ret.V = (d_bv.V).range((h_index), (l_index));
return ret;
}
inline operator ap_ulong() const { return to_uint64(); }
# 385 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_ref.h"
inline ap_range_ref& operator=(bool val) { ap_int_base<_AP_W, false> tmp(val); d_bv.V = _AP_ROOT_op_set_range(d_bv.V, l_index, h_index, tmp.V); return *this; }
inline ap_range_ref& operator=(char val) { ap_int_base<_AP_W, false> tmp(val); d_bv.V = _AP_ROOT_op_set_range(d_bv.V, l_index, h_index, tmp.V); return *this; }
inline ap_range_ref& operator=(signed char val) { ap_int_base<_AP_W, false> tmp(val); d_bv.V = _AP_ROOT_op_set_range(d_bv.V, l_index, h_index, tmp.V); return *this; }
inline ap_range_ref& operator=(unsigned char val) { ap_int_base<_AP_W, false> tmp(val); d_bv.V = _AP_ROOT_op_set_range(d_bv.V, l_index, h_index, tmp.V); return *this; }
inline ap_range_ref& operator=(short val) { ap_int_base<_AP_W, false> tmp(val); d_bv.V = _AP_ROOT_op_set_range(d_bv.V, l_index, h_index, tmp.V); return *this; }
inline ap_range_ref& operator=(unsigned short val) { ap_int_base<_AP_W, false> tmp(val); d_bv.V = _AP_ROOT_op_set_range(d_bv.V, l_index, h_index, tmp.V); return *this; }
inline ap_range_ref& operator=(int val) { ap_int_base<_AP_W, false> tmp(val); d_bv.V = _AP_ROOT_op_set_range(d_bv.V, l_index, h_index, tmp.V); return *this; }
inline ap_range_ref& operator=(unsigned int val) { ap_int_base<_AP_W, false> tmp(val); d_bv.V = _AP_ROOT_op_set_range(d_bv.V, l_index, h_index, tmp.V); return *this; }
inline ap_range_ref& operator=(long val) { ap_int_base<_AP_W, false> tmp(val); d_bv.V = _AP_ROOT_op_set_range(d_bv.V, l_index, h_index, tmp.V); return *this; }
inline ap_range_ref& operator=(unsigned long val) { ap_int_base<_AP_W, false> tmp(val); d_bv.V = _AP_ROOT_op_set_range(d_bv.V, l_index, h_index, tmp.V); return *this; }
inline ap_range_ref& operator=(ap_slong val) { ap_int_base<_AP_W, false> tmp(val); d_bv.V = _AP_ROOT_op_set_range(d_bv.V, l_index, h_index, tmp.V); return *this; }
inline ap_range_ref& operator=(ap_ulong val) { ap_int_base<_AP_W, false> tmp(val); d_bv.V = _AP_ROOT_op_set_range(d_bv.V, l_index, h_index, tmp.V); return *this; }
inline ap_range_ref& operator=(half val) { ap_int_base<_AP_W, false> tmp(val); d_bv.V = _AP_ROOT_op_set_range(d_bv.V, l_index, h_index, tmp.V); return *this; }
inline ap_range_ref& operator=(float val) { ap_int_base<_AP_W, false> tmp(val); d_bv.V = _AP_ROOT_op_set_range(d_bv.V, l_index, h_index, tmp.V); return *this; }
inline ap_range_ref& operator=(double val) { ap_int_base<_AP_W, false> tmp(val); d_bv.V = _AP_ROOT_op_set_range(d_bv.V, l_index, h_index, tmp.V); return *this; }
inline ap_range_ref& operator=(const char* val) {
const ap_int_base<_AP_W, false> tmp(val);
d_bv.V = _AP_ROOT_op_set_range(d_bv.V, l_index, h_index, tmp.V);
return *this;
}
template <int _AP_W2, bool _AP_S2>
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 = _AP_ROOT_op_set_range(d_bv.V, l_index, h_index, tmp.V);
return *this;
}
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 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 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 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 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 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 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
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
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
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
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
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
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 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 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 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
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 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 bool operator!=(const ap_range_ref<_AP_W2, _AP_S2>& op2) {
return !(operator==(op2));
}
template <int _AP_W2, bool _AP_S2>
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 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 bool operator>(const ap_range_ref<_AP_W2, _AP_S2>& op2) {
return !(operator<=(op2));
}
template <int _AP_W2, bool _AP_S2>
inline bool operator>=(const ap_range_ref<_AP_W2, _AP_S2>& op2) {
return !(operator<(op2));
}
template <int _AP_W2, bool _AP_S2>
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 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 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 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 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 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 ap_int_base<_AP_W, false> get() const {
ap_int_base<_AP_W, false> ret;
ret.V = (d_bv.V).range((h_index), (l_index));
return ret;
}
template <int _AP_W2>
inline void set(const ap_int_base<_AP_W2, false>& val) {
d_bv.V = _AP_ROOT_op_set_range(d_bv.V, l_index, h_index, val.V);
}
inline int length() const {
return h_index >= l_index ? h_index - l_index + 1 : l_index - h_index + 1;
}
inline int to_int() const {
return (int)((d_bv.V).range((h_index), (l_index)));
}
inline unsigned to_uint() const {
return (unsigned)((d_bv.V).range((h_index), (l_index)));
}
inline long to_long() const {
return (long)((d_bv.V).range((h_index), (l_index)));
}
inline unsigned long to_ulong() const {
return (unsigned long)((d_bv.V).range((h_index), (l_index)));
}
inline ap_slong to_int64() const {
return (ap_slong)((d_bv.V).range((h_index), (l_index)));
}
inline ap_ulong to_uint64() const {
return (ap_ulong)((d_bv.V).range((h_index), (l_index)));
}
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) {
ret &= (d_bv.V).get_bit((i));
}
return ret;
}
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) {
ret |= (d_bv.V).get_bit((i));
}
return ret;
}
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) {
ret ^= (d_bv.V).get_bit((i));
}
return ret;
}
std::string to_string(signed char radix = 2) const {
ap_int_base<_AP_W, false> ret;
ret.V = (d_bv.V).range((h_index), (l_index));
return ret.to_string(radix);
}
};
template <int _AP_W, bool _AP_S>
inline std::ostream& operator<<(std::ostream& os,
const ap_range_ref<_AP_W, _AP_S>& x) {
std::ios_base::fmtflags ff = std::cout.flags();
if (ff & std::cout.hex) {
os << x.to_string(16);
} else if (ff & std::cout.oct) {
os << x.to_string(8);
} else {
os << x.to_string(10);
}
return os;
}
template <int _AP_W, bool _AP_S>
inline std::istream& operator>>(std::istream& in,
ap_range_ref<_AP_W, _AP_S>& op) {
std::string str;
in >> str;
op = ap_int_base<_AP_W, _AP_S>(str.c_str());
return in;
}
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 ap_bit_ref(const ap_bit_ref<_AP_W, _AP_S>& ref)
: d_bv(ref.d_bv), d_index(ref.d_index) {}
inline ap_bit_ref(ref_type* bv, int index = 0) : d_bv(*bv), d_index(index) {}
inline ap_bit_ref(const ref_type* bv, int index = 0)
: d_bv(*const_cast<ref_type*>(bv)), d_index(index) {}
inline operator bool() const { return (d_bv.V).get_bit((d_index)); }
inline bool to_bool() const { return (d_bv.V).get_bit((d_index)); }
# 810 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_ref.h"
inline ap_bit_ref& operator=(bool val) { d_bv.V = _AP_ROOT_op_set_bit(d_bv.V, d_index, val); return *this; }
inline ap_bit_ref& operator=(char val) { d_bv.V = _AP_ROOT_op_set_bit(d_bv.V, d_index, val); return *this; }
inline ap_bit_ref& operator=(signed char val) { d_bv.V = _AP_ROOT_op_set_bit(d_bv.V, d_index, val); return *this; }
inline ap_bit_ref& operator=(unsigned char val) { d_bv.V = _AP_ROOT_op_set_bit(d_bv.V, d_index, val); return *this; }
inline ap_bit_ref& operator=(short val) { d_bv.V = _AP_ROOT_op_set_bit(d_bv.V, d_index, val); return *this; }
inline ap_bit_ref& operator=(unsigned short val) { d_bv.V = _AP_ROOT_op_set_bit(d_bv.V, d_index, val); return *this; }
inline ap_bit_ref& operator=(int val) { d_bv.V = _AP_ROOT_op_set_bit(d_bv.V, d_index, val); return *this; }
inline ap_bit_ref& operator=(unsigned int val) { d_bv.V = _AP_ROOT_op_set_bit(d_bv.V, d_index, val); return *this; }
inline ap_bit_ref& operator=(long val) { d_bv.V = _AP_ROOT_op_set_bit(d_bv.V, d_index, val); return *this; }
inline ap_bit_ref& operator=(unsigned long val) { d_bv.V = _AP_ROOT_op_set_bit(d_bv.V, d_index, val); return *this; }
inline ap_bit_ref& operator=(ap_slong val) { d_bv.V = _AP_ROOT_op_set_bit(d_bv.V, d_index, val); return *this; }
inline ap_bit_ref& operator=(ap_ulong val) { d_bv.V = _AP_ROOT_op_set_bit(d_bv.V, d_index, val); return *this; }
# 832 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_ref.h"
inline ap_bit_ref& operator=(half val) { bool tmp_val = val; d_bv.V = _AP_ROOT_op_set_bit(d_bv.V, d_index,tmp_val); return *this; }
inline ap_bit_ref& operator=(float val) { bool tmp_val = val; d_bv.V = _AP_ROOT_op_set_bit(d_bv.V, d_index,tmp_val); return *this; }
inline ap_bit_ref& operator=(double val) { bool tmp_val = val; d_bv.V = _AP_ROOT_op_set_bit(d_bv.V, d_index,tmp_val); return *this; }
template <int _AP_W2, bool _AP_S2>
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 ap_bit_ref& operator=(const ap_range_ref<_AP_W2, _AP_S2>& val) {
return operator=((ap_int_base<_AP_W2, false>)val);
}
inline ap_bit_ref& operator=(const ap_bit_ref& val) {
return operator=((ap_ulong)(bool)val);
}
template <int _AP_W2, bool _AP_S2>
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 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 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 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 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 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 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 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 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 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 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 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 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 bool operator==(const ap_bit_ref<_AP_W2, _AP_S2>& op) {
return get() == op.get();
}
template <int _AP_W2, bool _AP_S2>
inline bool operator!=(const ap_bit_ref<_AP_W2, _AP_S2>& op) {
return get() != op.get();
}
inline bool get() const { return (d_bv.V).get_bit((d_index)); }
inline bool get() { return (d_bv.V).get_bit((d_index)); }
template <int _AP_W3>
inline void set(const ap_int_base<_AP_W3, false>& val) {
operator=(val);
}
inline bool operator~() const {
bool bit = (d_bv.V).get_bit((d_index));
return bit ? false : true;
}
inline int length() const { return 1; }
std::string to_string() const { return get() ? "1" : "0"; }
};
# 1030 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_ref.h"
template <int _AP_W, bool _AP_S> 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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); }
# 1089 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_ref.h"
template <int _AP_W, bool _AP_S> 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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); }
# 1112 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_ref.h"
template <int _AP_W, bool _AP_S> 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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); }
# 1140 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_ref.h"
template <int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> 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 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 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 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 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 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 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 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 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 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>()); }
# 1189 "/data/tools/Xilinx/Vivado/2019.1/include/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 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 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 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 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 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 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 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 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 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 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(); }
# 1336 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_ref.h"
template <int _AP_W, bool _AP_S> 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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; }
# 1360 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_ref.h"
template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> 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 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 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 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 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 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 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 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 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 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 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 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 "/data/tools/Xilinx/Vivado/2019.1/include/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 ap_int() : Base() {}
template <int _AP_W2>
inline ap_int(const ap_int<_AP_W2>& op) {
Base::V = op.V;
}
template <int _AP_W2>
inline ap_int(const volatile ap_int<_AP_W2>& op) {
Base::V = op.V;
}
template <int _AP_W2>
inline ap_int(const ap_uint<_AP_W2>& op) {
Base::V = op.V;
}
template <int _AP_W2>
inline ap_int(const volatile ap_uint<_AP_W2>& op) {
Base::V = op.V;
}
# 95 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int.h"
template <int _AP_W2, bool _AP_S2>
inline ap_int(const ap_range_ref<_AP_W2, _AP_S2>& ref) : Base(ref) {}
template <int _AP_W2, bool _AP_S2>
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 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 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 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 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 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 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 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 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 ap_int(
const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op)
: Base(op) {}
inline ap_int(bool val) { Base::V = val; }
inline ap_int(char val) { Base::V = val; }
inline ap_int(signed char val) { Base::V = val; }
inline ap_int(unsigned char val) { Base::V = val; }
inline ap_int(short val) { Base::V = val; }
inline ap_int(unsigned short val) { Base::V = val; }
inline ap_int(int val) { Base::V = val; }
inline ap_int(unsigned int val) { Base::V = val; }
inline ap_int(long val) { Base::V = val; }
inline ap_int(unsigned long val) { Base::V = val; }
inline ap_int(ap_slong val) { Base::V = val; }
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 ap_int(const char* s) : Base(s) {}
inline ap_int(const char* s, signed char rd) : Base(s, rd) {}
inline ap_int& operator=(const ap_int<_AP_W>& op2) {
Base::V = op2.V;
return *this;
}
inline ap_int& operator=(const volatile ap_int<_AP_W>& op2) {
Base::V = op2.V;
return *this;
}
inline void operator=(const ap_int<_AP_W>& op2) volatile { Base::V = op2.V; }
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 ap_uint() : Base() {}
template <int _AP_W2>
inline ap_uint(const ap_uint<_AP_W2>& op) {
Base::V = op.V;
}
template <int _AP_W2>
inline ap_uint(const ap_int<_AP_W2>& op) {
Base::V = op.V;
}
template <int _AP_W2>
inline ap_uint(const volatile ap_uint<_AP_W2>& op) {
Base::V = op.V;
}
template <int _AP_W2>
inline ap_uint(const volatile ap_int<_AP_W2>& op) {
Base::V = op.V;
}
# 236 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int.h"
template <int _AP_W2, bool _AP_S2>
inline ap_uint(const ap_range_ref<_AP_W2, _AP_S2>& ref) : Base(ref) {}
template <int _AP_W2, bool _AP_S2>
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 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 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 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 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 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 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 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 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 ap_uint(
const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op)
: Base(op) {}
inline ap_uint(bool val) { Base::V = val; }
inline ap_uint(char val) { Base::V = val; }
inline ap_uint(signed char val) { Base::V = val; }
inline ap_uint(unsigned char val) { Base::V = val; }
inline ap_uint(short val) { Base::V = val; }
inline ap_uint(unsigned short val) { Base::V = val; }
inline ap_uint(int val) { Base::V = val; }
inline ap_uint(unsigned int val) { Base::V = val; }
inline ap_uint(long val) { Base::V = val; }
inline ap_uint(unsigned long val) { Base::V = val; }
inline ap_uint(ap_slong val) { Base::V = val; }
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 ap_uint(const char* s) : Base(s) {}
inline ap_uint(const char* s, signed char rd) : Base(s, rd) {}
inline ap_uint& operator=(const ap_uint<_AP_W>& op2) {
Base::V = op2.V;
return *this;
}
inline ap_uint& operator=(const volatile ap_uint<_AP_W>& op2) {
Base::V = op2.V;
return *this;
}
inline void operator=(const ap_uint<_AP_W>& op2) volatile { Base::V = op2.V; }
inline void operator=(const volatile ap_uint<_AP_W>& op2) volatile {
Base::V = op2.V;
}
};
# 359 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int.h"
# 1 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_special.h" 1
# 55 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_special.h"
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdio" 1 3
# 39 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdio" 3
# 40 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdio" 3
# 56 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_special.h" 2
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 1 3
# 39 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 3
# 40 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 3
# 57 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_special.h" 2
namespace std {
template<typename _Tp> class complex;
}
namespace std {
# 89 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int_special.h"
template <int _AP_W>
class complex<ap_int<_AP_W> > {
public:
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()) {}
const _Tp& real() const { return _M_real; }
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;
};
# 222 "/data/tools/Xilinx/Vivado/2019.1/include/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();
}
}
# 360 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int.h" 2
# 1 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed.h" 1
# 55 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed.h"
# 1 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 1
# 62 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
# 1 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int.h" 1
# 63 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 2
# 78 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cfenv" 1 3
# 32 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cfenv" 3
# 33 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cfenv" 3
# 41 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cfenv" 3
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/fenv.h" 1 3
# 32 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/fenv.h" 3
# 33 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/fenv.h" 3
# 1 "/usr/include/fenv.h" 1 3 4
# 57 "/usr/include/fenv.h" 3 4
# 1 "/usr/include/bits/fenv.h" 1 3 4
# 24 "/usr/include/bits/fenv.h" 3 4
# 24 "/usr/include/bits/fenv.h" 3 4
enum
{
FE_INVALID =
0x01,
__FE_DENORM = 0x02,
FE_DIVBYZERO =
0x04,
FE_OVERFLOW =
0x08,
FE_UNDERFLOW =
0x10,
FE_INEXACT =
0x20
};
enum
{
FE_TONEAREST =
0,
FE_DOWNWARD =
0x400,
FE_UPWARD =
0x800,
FE_TOWARDZERO =
0xc00
};
typedef unsigned short int fexcept_t;
typedef struct
{
unsigned short int __control_word;
unsigned short int __unused1;
unsigned short int __status_word;
unsigned short int __unused2;
unsigned short int __tags;
unsigned short int __unused3;
unsigned int __eip;
unsigned short int __cs_selector;
unsigned int __opcode:11;
unsigned int __unused4:5;
unsigned int __data_offset;
unsigned short int __data_selector;
unsigned short int __unused5;
unsigned int __mxcsr;
}
fenv_t;
# 58 "/usr/include/fenv.h" 2 3 4
extern "C" {
extern int feclearexcept (int __excepts) throw ();
extern int fegetexceptflag (fexcept_t *__flagp, int __excepts) throw ();
extern int feraiseexcept (int __excepts) throw ();
extern int fesetexceptflag (const fexcept_t *__flagp, int __excepts) throw ();
extern int fetestexcept (int __excepts) throw ();
extern int fegetround (void) throw ();
extern int fesetround (int __rounding_direction) throw ();
extern int fegetenv (fenv_t *__envp) throw ();
extern int feholdexcept (fenv_t *__envp) throw ();
extern int fesetenv (const fenv_t *__envp) throw ();
extern int feupdateenv (const fenv_t *__envp) throw ();
# 122 "/usr/include/fenv.h" 3 4
extern int feenableexcept (int __excepts) throw ();
extern int fedisableexcept (int __excepts) throw ();
extern int fegetexcept (void) throw ();
}
# 37 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/fenv.h" 2 3
# 55 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/fenv.h" 3
namespace std
{
using ::fenv_t;
using ::fexcept_t;
using ::feclearexcept;
using ::fegetexceptflag;
using ::feraiseexcept;
using ::fesetexceptflag;
using ::fetestexcept;
using ::fegetround;
using ::fesetround;
using ::fegetenv;
using ::feholdexcept;
using ::fesetenv;
using ::feupdateenv;
}
# 42 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cfenv" 2 3
# 58 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cfenv" 3
namespace std
{
using ::fenv_t;
using ::fexcept_t;
using ::feclearexcept;
using ::fegetexceptflag;
using ::feraiseexcept;
using ::fesetexceptflag;
using ::fetestexcept;
using ::fegetround;
using ::fesetround;
using ::fegetenv;
using ::feholdexcept;
using ::fesetenv;
using ::feupdateenv;
}
# 79 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 2
# 99 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
# 99 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
template <typename _Tp1, typename _Tp2>
inline bool _AP_ctype_op_get_bit(_Tp1& var, const _Tp2& index) {
return !!(var & (1ull << (index)));
}
template <typename _Tp1, typename _Tp2, typename _Tp3>
inline _Tp1 _AP_ctype_op_set_bit(_Tp1& var, const _Tp2& index, const _Tp3& x) {
var |= (((x) ? 1ull : 0ull) << (index));
return var;
}
template <typename _Tp1, typename _Tp2, typename _Tp3>
inline _Tp1 _AP_ctype_op_get_range(_Tp1& var, const _Tp2& low,
const _Tp3& high) {
_Tp1 r = var;
ap_ulong mask = -1ll;
mask >>= (sizeof(_Tp1) * 8 - ((high) - (low) + 1));
r >>= (low);
r &= mask;
return r;
}
template <typename _Tp1, typename _Tp2, typename _Tp3, typename _Tp4>
inline _Tp1 _AP_ctype_op_set_range(_Tp1& var, const _Tp2& low, const _Tp3& high,
const _Tp4& x) {
ap_ulong mask = -1ll;
mask >>= (_AP_SIZE_ap_slong - ((high) - (low) + 1));
var &= ~(mask << (low));
var |= ((mask & x) << (low));
return var;
}
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;
};
# 154 "/data/tools/Xilinx/Vivado/2019.1/include/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_sim<_AP_W, _AP_S> {
public:
typedef ssdm_int_sim<_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:
void fromString(const std::string& val, unsigned char radix) {
do { if ((!(radix == 2 || radix == 8 || radix == 10 || radix == 16))) { fprintf(
# 220 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 220 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "ERROR: " "ap_fixed_base::fromString(%s, %d)", val.c_str(), radix); fprintf(
# 220 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 220 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "\n"); abort(); } } while (0)
;
Base::V = 0;
int startPos = 0;
int endPos = val.length();
int decPos = val.find(".");
if (decPos == -1) decPos = endPos;
bool isNegative = false;
if (val[0] == '-') {
isNegative = true;
++startPos;
} else if (val[0] == '+')
++startPos;
# 244 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
ap_fixed_base<((_AP_I) > (4) ? (_AP_I) : (4)) + 4, ((_AP_I) > (4) ? (_AP_I) : (4)) + 4, false>
integer_bits = 0;
unsigned shift = (radix == 16 ? 4 : radix == 8 ? 3 : radix == 2 ? 1 : 0);
bool sticky_int = false;
for (int i = startPos; i < decPos; i++) {
char cdigit = val[i];
if (cdigit == '\0') continue;
unsigned digit = ap_private_ops::decode_digit(cdigit, radix);
sticky_int |= integer_bits[((_AP_I) > (4) ? (_AP_I) : (4)) + 4 - 1] |
integer_bits[((_AP_I) > (4) ? (_AP_I) : (4)) + 4 - 2] |
integer_bits[((_AP_I) > (4) ? (_AP_I) : (4)) + 4 - 3] |
integer_bits[((_AP_I) > (4) ? (_AP_I) : (4)) + 4 - 4];
if (shift)
integer_bits <<= shift;
else
integer_bits *= radix;
integer_bits += digit;
}
integer_bits[((_AP_I) > (4) ? (_AP_I) : (4)) + 4 - 3] =
integer_bits[((_AP_I) > (4) ? (_AP_I) : (4)) + 4 - 3] | sticky_int;
ap_fixed_base<((_AP_W - _AP_I) > (0) ? (_AP_W - _AP_I) : (0)) + 4 + 4, 4, false> fractional_bits = 0;
bool sticky = false;
for (int i = endPos - 1; i >= decPos + 1; i--) {
char cdigit = val[i];
if (cdigit == '\0') continue;
unsigned digit = ap_private_ops::decode_digit(cdigit, radix);
fractional_bits += digit;
sticky |= fractional_bits[0] | fractional_bits[1] | fractional_bits[2] |
fractional_bits[3];
if (shift)
fractional_bits >>= shift;
else
fractional_bits /= radix;
}
fractional_bits[0] = fractional_bits[0] | sticky;
if (isNegative)
*this = -(integer_bits + fractional_bits);
else
*this = integer_bits + fractional_bits;
}
inline void report() {
if (!_AP_S && _AP_O == AP_WRAP_SM) {
fprintf(
# 320 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 320 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "ap_ufxied<...> cannot support AP_WRAP_SM.\n");
exit(1);
}
if (_AP_W > ((1024 + 1023) / 1024) * 1024) {
fprintf(
# 324 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 324 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
,
"[E] ap_%sfixed<%d, ...>: Bitwidth exceeds the "
"default max value %d. Please use macro "
"AP_INT_MAX_W to set a larger max value.\n",
_AP_S ? "" : "u", _AP_W, ((1024 + 1023) / 1024) * 1024);
exit(1);
}
}
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 = _AP_ROOT_op_set_bit(Base::V, _AP_W - 1, sign);
if (_AP_N > 1) {
ap_int_base<_AP_W, false> mask(-1);
if (sign) mask.V = 0;
Base::V =
_AP_ROOT_op_set_range(Base::V, _AP_W - _AP_N, _AP_W - 2, mask.V);
}
} else {
ap_int_base<_AP_W, false> mask(-1);
Base::V =
_AP_ROOT_op_set_range(Base::V, _AP_W - _AP_N, _AP_W - 1, mask.V);
}
} else if (_AP_O == AP_SAT_ZERO) {
Base::V = 0;
} else if (_AP_O == AP_WRAP_SM && _AP_S) {
bool Ro = (Base::V).get_bit((_AP_W - 1));
if (_AP_N == 0) {
if (lD != Ro) {
Base::V = ~Base::V;
Base::V = _AP_ROOT_op_set_bit(Base::V, _AP_W - 1, lD);
}
} else {
if (_AP_N == 1 && sign != Ro) {
Base::V = ~Base::V;
} else if (_AP_N > 1) {
bool lNo = (Base::V).get_bit((_AP_W - _AP_N));
if (lNo == sign) Base::V = ~Base::V;
ap_int_base<_AP_W, false> mask(-1);
if (sign) mask.V = 0;
Base::V =
_AP_ROOT_op_set_range(Base::V, _AP_W - _AP_N, _AP_W - 2, mask.V);
}
Base::V = _AP_ROOT_op_set_bit(Base::V, _AP_W - 1, sign);
}
} 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 bool quantization_adjust(bool qb, bool r, bool s) {
bool carry = (bool)(Base::V).get_bit((_AP_W - 1));
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 &= (Base::V).get_bit((0)) || r;
else if (_AP_Q == AP_TRN_ZERO)
qb = s && (qb || r);
Base::V += qb;
return carry && (!(bool)(Base::V).get_bit((_AP_W - 1)));
}
public:
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 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 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 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 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();
}
inline ap_fixed_base(const char* s, signed char rd = 0) {
unsigned char radix = rd;
std::string str = ap_private_ops::parseString(s, radix);
do { if ((radix == 0)) { fprintf(
# 464 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 464 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "ERROR: " "ap_fixed_base(const char* \"%s\", %d), str=%s, radix = %d", s, rd, str.c_str(), radix); fprintf(
# 464 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 464 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "\n"); abort(); } } while (0)
;
fromString(str, radix);
}
# 491 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
template <int _AP_W2, bool _AP_S2>
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 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 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 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 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();
}
# 535 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
inline ap_fixed_base(const bool x) { ap_fixed_base<(1), (1), (false)> tmp; tmp.V = x; *this = tmp; }
inline ap_fixed_base(const char x) { ap_fixed_base<(8), (8), (CHAR_IS_SIGNED)> tmp; tmp.V = x; *this = tmp; }
inline ap_fixed_base(const signed char x) { ap_fixed_base<(8), (8), (true)> tmp; tmp.V = x; *this = tmp; }
inline ap_fixed_base(const unsigned char x) { ap_fixed_base<(8), (8), (false)> tmp; tmp.V = x; *this = tmp; }
inline ap_fixed_base(const short x) { ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (true)> tmp; tmp.V = x; *this = tmp; }
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 ap_fixed_base(const int x) { ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (true)> tmp; tmp.V = x; *this = tmp; }
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 ap_fixed_base(const long x) { ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (true)> tmp; tmp.V = x; *this = tmp; }
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 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 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 = (ireg.V).get_bit((63));
ap_int_base<11 + 1, true> exp;
ap_int_base<11, false> exp_tmp;
exp_tmp.V =
(ireg.V).range((52 + 11 - 1), (52));
exp = exp_tmp - ((1L << (11 - 1L)) - 1L);
ap_int_base<52 + 2, true> man;
man.V = (ireg.V).range((52 - 1), (0));
do { if ((exp == ((1L << (11 - 1L)) - 1L) + 1 && man.V != 0)) { fprintf(
# 567 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 567 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "WARNING: " "assign NaN to fixed point value"); fprintf(
# 567 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 567 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "\n"); } } while (0)
;
man.V = _AP_ROOT_op_set_bit(man.V, 52, 1);
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)(man.V).get_bit((F2 - _AP_F - 1))
;
bool r =
(F2 > _AP_F + 1)
? (man.V).range(((F2 - _AP_F - 2 < _AP_W2) ? (F2 - _AP_F - 2) : (_AP_W2 - 1)), (0))
!= 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 = (Base::V).get_bit((_AP_W - 1));
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 ? (Base::V).range((_AP_W - 2), (0)) == 0
: true);
overflow_adjust(underflow, overflow, lD, neg_src);
}
}
report();
}
inline ap_fixed_base(float d) { *this = ap_fixed_base(double(d)); }
inline ap_fixed_base(half d) { *this = ap_fixed_base(double(d)); }
# 688 "/data/tools/Xilinx/Vivado/2019.1/include/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 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 = (op.V).get_bit((_AP_W2 - 1));
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 = (op.V).get_bit((F2 - _AP_F - 1));
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) ? ((op.V).range((hi), (0)) != 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 = (Base::V).get_bit((_AP_W - 1));
enum { pos1 = F2 - _AP_F + _AP_W, pos2 = F2 - _AP_F + _AP_W + 1 };
bool lD = (pos1 < _AP_W2 && pos1 >= 0) ? (op.V).get_bit((pos1))
: 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 = (op.V).range((_AP_W2 - 1), (pos2));
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 = (op.V).range((_AP_W2 - 1), (pos1));
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 ? (Base::V).range((_AP_W - 2), (0)) == 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 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 ap_fixed_base& setBits(ap_ulong bv) {
Base::V = bv;
return *this;
}
static inline ap_fixed_base bitsToFixed(ap_ulong bv) {
ap_fixed_base t;
t.V.set_bits(bv);
return t;
}
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 = (Base::V).range((_AP_W - 1), (_AP_W - _AP_I));
} else if (_AP_I > _AP_W) {
ret.V = (Base::V).range((_AP_W - 1), (0));
ret.V <<= (_AP_I - _AP_W);
}
# 848 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
if (Cnative && _AP_I < _AP_W) {
if (_AP_S && (Base::V).get_bit((_AP_W - 1)) && (_AP_I < _AP_W) &&
((Base::V).range((_AP_I < 0 ? _AP_W - 1 : _AP_W - _AP_I - 1), (0))
!= 0))
++ret;
} else {
}
return ret;
};
public:
template <int _AP_W2, bool _AP_S2>
inline operator ap_int_base<_AP_W2, _AP_S2>() const {
return ap_int_base<_AP_W2, _AP_S2>(to_ap_int_base());
}
inline char to_char() const { return to_ap_int_base().to_char(); }
inline int to_int() const { return to_ap_int_base().to_int(); }
inline unsigned to_uint() const { return to_ap_int_base().to_uint(); }
inline ap_slong to_int64() const { return to_ap_int_base().to_int64(); }
inline ap_ulong to_uint64() const { return to_ap_int_base().to_uint64(); }
inline double to_double() const {
do { if ((std::fegetround() !=
# 881 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
0
# 881 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
)) { fprintf(
# 881 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 881 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "WARNING: " "Only FE_TONEAREST is supported"); fprintf(
# 881 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 881 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "\n"); } } while (0)
;
enum { BITS = 52 + 11 + 1 };
if (!Base::V) return 0.0f;
bool s = _AP_S && (Base::V).get_bit((_AP_W - 1));
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) ?
((tmp.V).range((lsb_index - 2), (0)) != 0) : 0;
a |= (lsb_index >=0) ? (tmp.V).get_bit((lsb_index)) : 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 (_AP_ctype_op_get_bit(m, 52 + 1)) {
e += 1;
}
m = _AP_ctype_op_set_bit(m, BITS - 1, s);
m = _AP_ctype_op_set_range(m, 52, 52 + 11 - 1, e);
return rawBitsToDouble(m);
}
inline float to_float() const {
do { if ((std::fegetround() !=
# 931 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
0
# 931 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
)) { fprintf(
# 931 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 931 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "WARNING: " "Only FE_TONEAREST is supported"); fprintf(
# 931 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 931 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "\n"); } } while (0)
;
enum { BITS = 23 + 8 + 1 };
if (!Base::V) return 0.0f;
bool s = _AP_S && (Base::V).get_bit((_AP_W - 1));
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) ?
((tmp.V).range((lsb_index - 2), (0)) != 0) : 0;
a |= (lsb_index >=0) ? (tmp.V).get_bit((lsb_index)) : 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 (_AP_ctype_op_get_bit(m, 23 + 1)) {
e += 1;
}
m = _AP_ctype_op_set_bit(m, BITS - 1, s);
m = _AP_ctype_op_set_range(m, 23, 23 + 8 - 1, e);
return rawBitsToFloat(m);
}
inline half to_half() const {
do { if ((std::fegetround() !=
# 978 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
0
# 978 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
)) { fprintf(
# 978 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 978 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "WARNING: " "Only FE_TONEAREST is supported"); fprintf(
# 978 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 978 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "\n"); } } while (0)
;
enum { BITS = 10 + 5 + 1 };
if (!Base::V) return 0.0f;
bool s = _AP_S && (Base::V).get_bit((_AP_W - 1));
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) ?
((tmp.V).range((lsb_index - 2), (0)) != 0) : 0;
a |= (lsb_index >=0) ? (tmp.V).get_bit((lsb_index)) : 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 (_AP_ctype_op_get_bit(m, 10 + 1)) {
e += 1;
}
m = _AP_ctype_op_set_bit(m, BITS - 1, s);
m = _AP_ctype_op_set_range(m, 10, 10 + 5 - 1, e);
return rawBitsToHalf(m);
}
inline operator long double() const { return (long double)to_double(); }
inline operator double() const { return to_double(); }
inline operator float() const { return to_float(); }
inline operator half() const { return to_half(); }
inline operator bool() const { return (bool)Base::V != 0; }
inline operator char() const { return (char)to_int(); }
inline operator signed char() const { return (signed char)to_int(); }
inline operator unsigned char() const { return (unsigned char)to_uint(); }
inline operator short() const { return (short)to_int(); }
inline operator unsigned short() const { return (unsigned short)to_uint(); }
inline operator int() const { return to_int(); }
inline operator unsigned int() const { return to_uint(); }
inline operator long() const { return (long)to_int64(); }
inline operator unsigned long() const { return (unsigned long)to_uint64(); }
inline operator ap_ulong() const { return to_uint64(); }
inline operator ap_slong() const { return to_int64(); }
inline int length() const { return _AP_W; };
inline ap_ulong bits_to_uint64() const {
return (Base::V).to_uint64();
}
inline int countLeadingZeros() {
# 1104 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
return Base::V.countLeadingZeros();
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
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 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;
enum {F2 = _AP_W2-_AP_I2,
_W1=((_AP_W + ((F2) > (0) ? (F2) : (0)) + ((_AP_S2 && !_AP_S) ? 1 : 0)) > (_AP_W2 + ((_AP_S && !_AP_S2) ? 1 : 0)) ? (_AP_W + ((F2) > (0) ? (F2) : (0)) + ((_AP_S2 && !_AP_S) ? 1 : 0)) : (_AP_W2 + ((_AP_S && !_AP_S2) ? 1 : 0)))};
ap_int_base<_W1,_AP_S||_AP_S2> dividend,divisior;
ap_int_base<_W1,_AP_S> tmp1;
ap_int_base<_W1,_AP_S2> tmp2;
tmp1.V = Base::V;
tmp1.V <<= ((F2) > (0) ? (F2) : (0));
tmp2.V = op2.V;
dividend = tmp1;
divisior = tmp2;
r.V = ((_AP_S||_AP_S2) ? dividend.V.sdiv(divisior.V): dividend.V.udiv(divisior.V));
# 1177 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
return r;
}
# 1192 "/data/tools/Xilinx/Vivado/2019.1/include/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 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 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 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 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 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; }
# 1210 "/data/tools/Xilinx/Vivado/2019.1/include/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 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 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 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 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 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 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 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 ap_fixed_base& operator++() {
operator+=(ap_fixed_base<_AP_W - _AP_I + 1, 1, false>(1));
return *this;
}
inline ap_fixed_base& operator--() {
operator-=(ap_fixed_base<_AP_W - _AP_I + 1, 1, false>(1));
return *this;
}
inline const ap_fixed_base operator++(int) {
ap_fixed_base r(*this);
operator++();
return r;
}
inline const ap_fixed_base operator--(int) {
ap_fixed_base r(*this);
operator--();
return r;
}
inline ap_fixed_base operator+() { return *this; }
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 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 bool operator!() const { return Base::V == 0; }
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 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 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 ap_fixed_base operator<<(unsigned int sh) const {
ap_fixed_base r;
r.V = Base::V << sh;
# 1328 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
return r;
}
inline ap_fixed_base operator>>(unsigned int sh) const {
ap_fixed_base r;
r.V = Base::V >> sh;
# 1350 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
return r;
}
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 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 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 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 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 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 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 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 ap_fixed_base& operator<<=(const int sh) {
*this = operator<<(sh);
return *this;
}
inline ap_fixed_base& operator<<=(const unsigned int sh) {
*this = operator<<(sh);
return *this;
}
template <int _AP_W2, bool _AP_S2>
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 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 ap_fixed_base& operator>>=(const int sh) {
*this = operator>>(sh);
return *this;
}
inline ap_fixed_base& operator>>=(const unsigned int sh) {
*this = operator>>(sh);
return *this;
}
template <int _AP_W2, bool _AP_S2>
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 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;
}
# 1494 "/data/tools/Xilinx/Vivado/2019.1/include/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 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 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 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 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 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 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 bool operator >(double d) const { return to_double() > d; }
inline bool operator <(double d) const { return to_double() < d; }
inline bool operator >=(double d) const { return to_double() >= d; }
inline bool operator <=(double d) const { return to_double() <= d; }
inline bool operator ==(double d) const { return to_double() == d; }
inline bool operator !=(double d) const { return to_double() != d; }
inline af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> operator[](
unsigned index) {
do { if ((index >= _AP_W)) { fprintf(
# 1515 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 1515 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "WARNING: " "Attempting to read bit beyond MSB"); fprintf(
# 1515 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 1515 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "\n"); } } while (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 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) {
do { if ((index < 0)) { fprintf(
# 1522 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 1522 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "WARNING: " "Attempting to read bit with negative index"); fprintf(
# 1522 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 1522 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "\n"); } } while (0);
do { if ((index >= _AP_W)) { fprintf(
# 1523 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 1523 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "WARNING: " "Attempting to read bit beyond MSB"); fprintf(
# 1523 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 1523 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "\n"); } } while (0);
return af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>(this,
index.to_int());
}
inline bool operator[](unsigned index) const {
do { if ((index >= _AP_W)) { fprintf(
# 1529 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 1529 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "WARNING: " "Attempting to read bit beyond MSB"); fprintf(
# 1529 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 1529 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "\n"); } } while (0);
return (const_cast<ap_fixed_base*>(this)->V).get_bit((index));
}
inline af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> bit(
unsigned index) {
do { if ((index >= _AP_W)) { fprintf(
# 1535 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 1535 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "WARNING: " "Attempting to read bit beyond MSB"); fprintf(
# 1535 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 1535 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "\n"); } } while (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 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) {
do { if ((index < 0)) { fprintf(
# 1542 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 1542 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "WARNING: " "Attempting to read bit with negative index"); fprintf(
# 1542 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 1542 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "\n"); } } while (0);
do { if ((index >= _AP_W)) { fprintf(
# 1543 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 1543 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "WARNING: " "Attempting to read bit beyond MSB"); fprintf(
# 1543 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 1543 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "\n"); } } while (0);
return af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>(this,
index.to_int());
}
inline bool bit(unsigned index) const {
do { if ((index >= _AP_W)) { fprintf(
# 1549 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 1549 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "WARNING: " "Attempting to read bit beyond MSB"); fprintf(
# 1549 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 1549 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "\n"); } } while (0);
return (const_cast<ap_fixed_base*>(this)->V).get_bit((index));
}
template <int _AP_W2>
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) {
do { if ((index < _AP_I - _AP_W)) { fprintf(
# 1556 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 1556 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "WARNING: " "Attempting to read bit with negative index"); fprintf(
# 1556 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 1556 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "\n"); } } while (0)
;
do { if ((index >= _AP_I)) { fprintf(
# 1558 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 1558 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "WARNING: " "Attempting to read bit beyond MSB"); fprintf(
# 1558 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 1558 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "\n"); } } while (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 bool get_bit(int index) const {
do { if ((index >= _AP_I)) { fprintf(
# 1564 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 1564 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "WARNING: " "Attempting to read bit beyond MSB"); fprintf(
# 1564 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 1564 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "\n"); } } while (0);
do { if ((index < _AP_I - _AP_W)) { fprintf(
# 1565 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 1565 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "WARNING: " "Attempting to read bit beyond MSB"); fprintf(
# 1565 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 1565 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "\n"); } } while (0);
return (const_cast<ap_fixed_base*>(this)->V).get_bit((index + _AP_W - _AP_I))
;
}
# 1580 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
template <int _AP_W2>
inline bool get_bit(const ap_int_base<_AP_W2, true>& index) const {
do { if ((index >= _AP_I)) { fprintf(
# 1582 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 1582 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "WARNING: " "Attempting to read bit beyond MSB"); fprintf(
# 1582 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 1582 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "\n"); } } while (0);
do { if ((index < _AP_I - _AP_W)) { fprintf(
# 1583 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 1583 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "WARNING: " "Attempting to read bit beyond MSB"); fprintf(
# 1583 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 1583 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "\n"); } } while (0);
return (const_cast<ap_fixed_base*>(this)->V).get_bit((index.to_int() + _AP_W - _AP_I))
;
}
inline af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> range(int Hi,
int Lo) {
do { if (((Hi >= _AP_W) || (Lo >= _AP_W))) { fprintf(
# 1590 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 1590 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "WARNING: " "Out of bounds in range()"); fprintf(
# 1590 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 1590 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "\n"); } } while (0);
return af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>(this, Hi, Lo);
}
inline af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> range(
int Hi, int Lo) const {
do { if (((Hi >= _AP_W) || (Lo >= _AP_W))) { fprintf(
# 1597 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 1597 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "WARNING: " "Out of bounds in range()"); fprintf(
# 1597 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h" 3 4
stderr
# 1597 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
, "\n"); } } while (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 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 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 af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> range() {
return this->range(_AP_W - 1, 0);
}
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 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 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 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 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 bool is_zero() const { return Base::V == 0; }
inline bool is_neg() const {
if (_AP_S && (Base::V).get_bit((_AP_W - 1))) return true;
return false;
}
inline int wl() const { return _AP_W; }
inline int iwl() const { return _AP_I; }
inline ap_q_mode q_mode() const { return _AP_Q; }
inline ap_o_mode o_mode() const { return _AP_O; }
inline int n_bits() const { return _AP_N; }
# 1680 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
std::string to_string(unsigned char radix = 2, bool sign = _AP_S) const {
if (radix == 2) sign = false;
std::string str;
str.clear();
char step = 0;
bool isNeg = sign && (Base::V < 0);
ap_fixed_base<_AP_W + 1, _AP_I + 1> tmp(*this);
if (isNeg) {
tmp = -tmp;
str += '-';
}
std::string prefix;
switch (radix) {
case 2:
prefix = "0b";
step = 1;
break;
case 8:
prefix = "0o";
step = 3;
break;
case 16:
prefix = "0x";
step = 4;
break;
default:
break;
}
if (_AP_I > 0) {
ap_int_base<((_AP_I + 1) > (1) ? (_AP_I + 1) : (1)), false> int_part;
int_part.V = (tmp.V).range((_AP_W), (_AP_W - _AP_I))
;
str += int_part.to_string(radix, false);
} else {
str += prefix;
str += '0';
}
ap_fixed_base<((_AP_W - _AP_I) > (1) ? (_AP_W - _AP_I) : (1)), 0, false> frac_part = tmp;
if (radix == 10) {
if (frac_part != 0) {
str += ".";
while (frac_part != 0) {
char digit = (frac_part * radix).to_char();
str += static_cast<char>(digit + '0');
frac_part *= radix;
}
}
} else {
if (frac_part != 0) {
str += ".";
for (signed i = _AP_W - _AP_I - 1; i >= 0; i -= step) {
char digit = frac_part.range(i, ((0) > (i - step + 1) ? (0) : (i - step + 1))).to_char();
int offset = ((0) < (i - step + 1) ? (0) : (i - step + 1));
digit <<= -offset;
str += digit < 10 ? static_cast<char>(digit + '0')
: static_cast<char>(digit - 10 + 'a');
}
if (radix == 16)
str += "p0";
}
}
return str;
}
};
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,
int _AP_N>
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 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 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 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 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 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 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;
}
# 1869 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_base.h"
inline std::string scientificFormat(std::string& input) {
if (input.length() == 0) return input;
size_t decPosition = input.find('.');
if (decPosition == std::string::npos) decPosition = input.length();
size_t firstNonZeroPos = 0;
for (; input[firstNonZeroPos] > '9' || input[firstNonZeroPos] < '1';
firstNonZeroPos++)
;
int exp;
if (firstNonZeroPos > decPosition)
exp = decPosition - firstNonZeroPos;
else
exp = decPosition - firstNonZeroPos - 1;
std::string expString = "";
if (exp == 0)
;
else if (exp < 0) {
expString += "e-";
exp = -exp;
} else
expString += "e+";
if (exp < 10 && exp > 0) {
expString += '0';
expString += (char)('0' + exp);
} else if (exp != 0) {
std::string tmp;
std::ostringstream oss;
oss << exp;
tmp = oss.str();
expString += tmp;
}
int lastNonZeroPos = (int)(input.length() - 1);
for (; lastNonZeroPos >= 0; --lastNonZeroPos)
if (input[lastNonZeroPos] <= '9' && input[lastNonZeroPos] > '0') break;
std::string ans = "";
ans += input[firstNonZeroPos];
if (firstNonZeroPos != (size_t)lastNonZeroPos) {
ans += '.';
for (int i = firstNonZeroPos + 1; i <= lastNonZeroPos; i++)
if (input[i] != '.') ans += input[i];
}
ans += expString;
return ans;
}
inline std::string reduceToPrecision(std::string& input, int precision) {
bool isZero = true;
size_t inputLen = input.length();
for (size_t i = 0; i < inputLen && isZero; i++)
if (input[i] != '.' && input[i] != '0') isZero = false;
if (isZero) return "0";
int FirstNonZeroPos = 0;
int LastNonZeroPos = (int)inputLen - 1;
int truncBitPosition = 0;
size_t decPosition = input.find('.');
for (; input[FirstNonZeroPos] < '1' || input[FirstNonZeroPos] > '9';
FirstNonZeroPos++)
;
for (; input[LastNonZeroPos] < '1' || input[LastNonZeroPos] > '9';
LastNonZeroPos--)
;
if (decPosition == std::string::npos) decPosition = inputLen;
if ((int)decPosition > LastNonZeroPos) {
if (LastNonZeroPos - FirstNonZeroPos + 1 <= precision) return input;
truncBitPosition = FirstNonZeroPos + precision;
} else if ((int)decPosition < FirstNonZeroPos) {
if (LastNonZeroPos - FirstNonZeroPos + 1 <= precision) {
if (FirstNonZeroPos - decPosition - 1 < 4) {
return input;
} else {
if (input[0] == '-') {
std::string tmp = input.substr(1, inputLen - 1);
return std::string("-") + scientificFormat(tmp);
} else
return scientificFormat(input);
}
}
truncBitPosition = FirstNonZeroPos + precision;
} else {
if (LastNonZeroPos - FirstNonZeroPos <= precision) return input;
truncBitPosition = FirstNonZeroPos + precision + 1;
}
std::string ans = "";
std::string dupInput = "0";
if (input[0] == '-') {
ans += '-';
dupInput += input.substr(1, inputLen - 1);
} else {
dupInput += input.substr(0, inputLen);
++truncBitPosition;
}
bool carry = dupInput[truncBitPosition] > '4';
for (int i = truncBitPosition - 1; i >= 0 && carry; i--) {
if (dupInput[i] == '.') continue;
if (dupInput[i] == '9')
dupInput[i] = '0';
else {
++dupInput[i];
carry = false;
}
}
if (dupInput[0] == '1')
FirstNonZeroPos = 0;
else {
FirstNonZeroPos = 0;
while (dupInput[FirstNonZeroPos] < '1' || dupInput[FirstNonZeroPos] > '9')
++FirstNonZeroPos;
}
unsigned it = FirstNonZeroPos;
int NValidNumber = 0;
while (it < dupInput.length()) {
if (dupInput[it] == '.') {
++it;
continue;
}
++NValidNumber;
if (NValidNumber > precision) dupInput[it] = '0';
++it;
}
decPosition = dupInput.find('.');
if (decPosition == std::string::npos)
truncBitPosition = (int)dupInput.length();
else
for (truncBitPosition = (int)(dupInput.length() - 1); truncBitPosition >= 0;
--truncBitPosition) {
if (dupInput[truncBitPosition] == '.') break;
if (dupInput[truncBitPosition] != '0') {
truncBitPosition++;
break;
}
}
if (dupInput[0] == '1')
dupInput = dupInput.substr(0, truncBitPosition);
else
dupInput = dupInput.substr(1, truncBitPosition - 1);
decPosition = dupInput.find('.');
if (decPosition != std::string::npos) {
size_t it = 0;
for (it = decPosition + 1; dupInput[it] == '0'; it++)
;
if (it - decPosition - 1 < 4) {
ans += dupInput;
return ans;
} else {
ans += scientificFormat(dupInput);
return ans;
}
} else if ((int)(dupInput.length()) <= precision) {
ans += dupInput;
return ans;
}
ans += scientificFormat(dupInput);
return ans;
}
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,
int _AP_N>
inline void print(
const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& x) {
if (_AP_I > 0) {
ap_int_base<_AP_I, _AP_S> p1;
p1.V = x.V >> (_AP_W - _AP_I);
print(p1.V);
} else {
printf("0");
}
printf(".");
if (_AP_I < _AP_W) {
ap_int_base<_AP_W - _AP_I, false> p2;
p2.V = (x.V).range((_AP_W - _AP_I), (0));
print(p2.V, false);
}
}
# 2080 "/data/tools/Xilinx/Vivado/2019.1/include/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 std::ostream& operator<<(
std::ostream& out,
const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& x) {
unsigned width = out.width();
unsigned precision = out.precision();
char fill = out.fill();
std::string str = x.to_string(10, _AP_S);
str = reduceToPrecision(str, precision);
if (width > str.length()) {
for (unsigned i = 0; i < width - str.length(); ++i)
out << fill;
}
out << str;
return out;
}
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,
int _AP_N>
inline std::istream& operator>>(
std::istream& in,
ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& x) {
double d;
in >> d;
x = ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>(d);
return in;
}
# 2213 "/data/tools/Xilinx/Vivado/2019.1/include/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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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); }
# 2301 "/data/tools/Xilinx/Vivado/2019.1/include/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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed.h" 2
# 1 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_ref.h" 1
# 70 "/data/tools/Xilinx/Vivado/2019.1/include/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 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) {
do { if ((d_index < 0)) { fprintf(
# 85 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_ref.h" 3 4
stderr
# 85 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_ref.h"
, "WARNING: " "Index of bit vector (%d) cannot be negative.", d_index); fprintf(
# 85 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_ref.h" 3 4
stderr
# 85 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_ref.h"
, "\n"); } } while (0)
;
do { if ((d_index >= _AP_W)) { fprintf(
# 87 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_ref.h" 3 4
stderr
# 87 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_ref.h"
, "WARNING: " "Index of bit vector (%d) out of range (%d).", d_index, _AP_W); fprintf(
# 87 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_ref.h" 3 4
stderr
# 87 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_ref.h"
, "\n"); } } while (0)
;
}
inline af_bit_ref(ref_type* bv, int index = 0) : d_bv(*bv), d_index(index) {}
inline af_bit_ref(const ref_type* bv, int index = 0)
: d_bv(*const_cast<ref_type*>(bv)), d_index(index) {}
inline operator bool() const { return (d_bv.V).get_bit((d_index)); }
inline af_bit_ref& operator=(bool val) {
d_bv.V = _AP_ROOT_op_set_bit(d_bv.V, d_index, val);
return *this;
}
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 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 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 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 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 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 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 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 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 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 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 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 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 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 bool operator!=(
const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
return get() != op.get();
}
inline bool operator~() const {
bool bit = (d_bv.V).get_bit((d_index));
return bit ? false : true;
}
inline bool get() const { return (d_bv.V).get_bit((d_index)); }
inline int length() const { return 1; }
std::string to_string() const { return get() ? "1" : "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 std::ostream& operator<<(
std::ostream& os,
const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& x) {
os << x.to_string();
return os;
}
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 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 af_range_ref(ref_type* bv, int h, int l)
: d_bv(*bv), l_index(l), h_index(h) {
do { if ((h < 0 || l < 0)) { fprintf(
# 280 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_ref.h" 3 4
stderr
# 280 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_ref.h"
, "WARNING: " "Higher bound(%d) and lower(%d) bound cannot be negative.", h, l); fprintf(
# 280 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_ref.h" 3 4
stderr
# 280 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_ref.h"
, "\n"); } } while (0)
;
do { if ((h >= _AP_W || l >= _AP_W)) { fprintf(
# 283 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_ref.h" 3 4
stderr
# 283 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_ref.h"
, "WARNING: " "Higher bound(%d) or lower(%d) bound out of range.", h, l); fprintf(
# 283 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_ref.h" 3 4
stderr
# 283 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_ref.h"
, "\n"); } } while (0)
;
do { if ((h < l)) { fprintf(
# 285 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_ref.h" 3 4
stderr
# 285 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_ref.h"
, "WARNING: " "The bits selected will be returned in reverse order."); fprintf(
# 285 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_ref.h" 3 4
stderr
# 285 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_ref.h"
, "\n"); } } while (0);
}
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) {
do { if ((h < 0 || l < 0)) { fprintf(
# 292 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_ref.h" 3 4
stderr
# 292 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_ref.h"
, "WARNING: " "Higher bound(%d) and lower(%d) bound cannot be negative.", h, l); fprintf(
# 292 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_ref.h" 3 4
stderr
# 292 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_ref.h"
, "\n"); } } while (0)
;
do { if ((h >= _AP_W || l >= _AP_W)) { fprintf(
# 295 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_ref.h" 3 4
stderr
# 295 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_ref.h"
, "WARNING: " "Higher bound(%d) or lower(%d) bound out of range.", h, l); fprintf(
# 295 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_ref.h" 3 4
stderr
# 295 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_ref.h"
, "\n"); } } while (0)
;
do { if ((h < l)) { fprintf(
# 297 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_ref.h" 3 4
stderr
# 297 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_ref.h"
, "WARNING: " "The bits selected will be returned in reverse order."); fprintf(
# 297 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_ref.h" 3 4
stderr
# 297 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_ref.h"
, "\n"); } } while (0);
}
# 311 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_ref.h"
inline af_range_ref& operator=(const bool val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = _AP_ROOT_op_set_range(d_bv.V, l_index, h_index, loc.V); return *this; }
inline af_range_ref& operator=(const char val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = _AP_ROOT_op_set_range(d_bv.V, l_index, h_index, loc.V); return *this; }
inline af_range_ref& operator=(const signed char val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = _AP_ROOT_op_set_range(d_bv.V, l_index, h_index, loc.V); return *this; }
inline af_range_ref& operator=(const unsigned char val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = _AP_ROOT_op_set_range(d_bv.V, l_index, h_index, loc.V); return *this; }
inline af_range_ref& operator=(const short val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = _AP_ROOT_op_set_range(d_bv.V, l_index, h_index, loc.V); return *this; }
inline af_range_ref& operator=(const unsigned short val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = _AP_ROOT_op_set_range(d_bv.V, l_index, h_index, loc.V); return *this; }
inline af_range_ref& operator=(const int val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = _AP_ROOT_op_set_range(d_bv.V, l_index, h_index, loc.V); return *this; }
inline af_range_ref& operator=(const unsigned int val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = _AP_ROOT_op_set_range(d_bv.V, l_index, h_index, loc.V); return *this; }
inline af_range_ref& operator=(const long val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = _AP_ROOT_op_set_range(d_bv.V, l_index, h_index, loc.V); return *this; }
inline af_range_ref& operator=(const unsigned long val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = _AP_ROOT_op_set_range(d_bv.V, l_index, h_index, loc.V); return *this; }
inline af_range_ref& operator=(const ap_slong val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = _AP_ROOT_op_set_range(d_bv.V, l_index, h_index, loc.V); return *this; }
inline af_range_ref& operator=(const ap_ulong val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = _AP_ROOT_op_set_range(d_bv.V, l_index, h_index, loc.V); return *this; }
inline af_range_ref& operator=(const half val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = _AP_ROOT_op_set_range(d_bv.V, l_index, h_index, loc.V); return *this; }
inline af_range_ref& operator=(const float val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = _AP_ROOT_op_set_range(d_bv.V, l_index, h_index, loc.V); return *this; }
inline af_range_ref& operator=(const double val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = _AP_ROOT_op_set_range(d_bv.V, l_index, h_index, loc.V); return *this; }
inline af_range_ref& operator=(const char* val) {
const ap_int_base<_AP_W, false> tmp(val);
d_bv.V = _AP_ROOT_op_set_range(d_bv.V, l_index, h_index, tmp.V);
return *this;
}
template <int _AP_W3, bool _AP_S3>
inline af_range_ref& operator=(const ap_int_base<_AP_W3, _AP_S3>& val) {
d_bv.V = _AP_ROOT_op_set_range(d_bv.V, l_index, h_index, val.V);
return *this;
}
template <int _AP_W2, bool _AP_S2>
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 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 af_range_ref& operator=(
const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>&
val) {
d_bv.V = _AP_ROOT_op_set_range(d_bv.V, l_index, h_index, val.V);
return *this;
}
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 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 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 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 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 bool operator!=(const ap_range_ref<_AP_W2, _AP_S2>& op2) {
return !(operator==(op2));
}
template <int _AP_W2, bool _AP_S2>
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 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 bool operator<=(const ap_range_ref<_AP_W2, _AP_S2>& op2) {
return !(operator>(op2));
}
template <int _AP_W2, bool _AP_S2>
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 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 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 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 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 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 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
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 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 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 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
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
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 operator ap_ulong() const {
ap_int_base<_AP_W, false> ret;
ret.V = (d_bv.V).range((h_index), (l_index));
return ret.to_uint64();
}
inline operator ap_int_base<_AP_W, false>() const {
ap_int_base<_AP_W, false> ret;
ret.V = (d_bv.V).range((h_index), (l_index));
return ret;
}
inline ap_int_base<_AP_W, false> to_ap_int_base() const {
ap_int_base<_AP_W, false> ret;
ret.V = (d_bv.V).range((h_index), (l_index));
return ret;
}
inline char to_char() const {
return (char)((d_bv.V).range((h_index), (l_index)));
}
inline int to_int() const {
return (int)((d_bv.V).range((h_index), (l_index)));
}
inline unsigned to_uint() const {
return (unsigned)((d_bv.V).range((h_index), (l_index)));
}
inline long to_long() const {
return (long)((d_bv.V).range((h_index), (l_index)));
}
inline unsigned long to_ulong() const {
return (unsigned long)((d_bv.V).range((h_index), (l_index)));
}
inline ap_slong to_int64() const {
return (ap_slong)((d_bv.V).range((h_index), (l_index)));
}
inline ap_ulong to_uint64() const {
return (ap_ulong)((d_bv.V).range((h_index), (l_index)));
}
inline ap_int_base<_AP_W, false> get() const {
ap_int_base<_AP_W, false> ret;
ret.V = (d_bv.V).range((h_index), (l_index));
return ret;
}
template <int _AP_W2>
inline void set(const ap_int_base<_AP_W2, false>& val) {
d_bv.V = _AP_ROOT_op_set_range(d_bv.V, l_index, h_index, val.V);
}
inline int length() const {
return h_index >= l_index ? h_index - l_index + 1 : l_index - h_index + 1;
}
std::string to_string(signed char rd = 2) const {
ap_int_base<_AP_W, false> ret;
ret.V = (d_bv.V).range((h_index), (l_index));
return ret.to_string(rd);
}
};
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,
int _AP_N>
inline std::ostream& operator<<(
std::ostream& os,
const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& x) {
os << x.to_string();
return os;
}
# 696 "/data/tools/Xilinx/Vivado/2019.1/include/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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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); }
# 742 "/data/tools/Xilinx/Vivado/2019.1/include/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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 "/data/tools/Xilinx/Vivado/2019.1/include/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 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 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 ap_fixed(const volatile ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2>& op)
: Base(op) {}
# 111 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed.h"
template <int _AP_W2, bool _AP_S2>
inline ap_fixed(const ap_int_base<_AP_W2, _AP_S2>& op) : Base(op) {}
template <int _AP_W2, bool _AP_S2>
inline ap_fixed(const volatile ap_int_base<_AP_W2, _AP_S2>& op) : Base(op) {}
# 145 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed.h"
template <int _AP_W2, bool _AP_S2>
inline ap_fixed(const ap_bit_ref<_AP_W2, _AP_S2>& op) : Base(op) {}
template <int _AP_W2, bool _AP_S2>
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 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 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 ap_fixed(
const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op)
: Base(op) {}
inline ap_fixed(bool v) : Base(v) {}
inline ap_fixed(char v) : Base(v) {}
inline ap_fixed(signed char v) : Base(v) {}
inline ap_fixed(unsigned char v) : Base(v) {}
inline ap_fixed(short v) : Base(v) {}
inline ap_fixed(unsigned short v) : Base(v) {}
inline ap_fixed(int v) : Base(v) {}
inline ap_fixed(unsigned int v) : Base(v) {}
inline ap_fixed(long v) : Base(v) {}
inline ap_fixed(unsigned long v) : Base(v) {}
inline ap_fixed(ap_slong v) : Base(v) {}
inline ap_fixed(ap_ulong v) : Base(v) {}
inline ap_fixed(half v) : Base(v) {}
inline ap_fixed(float v) : Base(v) {}
inline ap_fixed(double v) : Base(v) {}
inline ap_fixed(const char* s) : Base(s) {}
inline ap_fixed(const char* s, signed char rd) : Base(s, rd) {}
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 void operator=(
const ap_fixed<_AP_W, _AP_I, _AP_Q, _AP_O, _AP_N>& op) volatile {
Base::V = op.V;
}
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 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 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 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 ap_ufixed(const volatile ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2>& op)
: Base(op) {}
# 276 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed.h"
template <int _AP_W2, bool _AP_S2>
inline ap_ufixed(const ap_int_base<_AP_W2, _AP_S2>& op) : Base(op) {}
template <int _AP_W2, bool _AP_S2>
inline ap_ufixed(const volatile ap_int_base<_AP_W2, _AP_S2>& op) : Base(op) {}
# 307 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed.h"
template <int _AP_W2, bool _AP_S2>
inline ap_ufixed(const ap_bit_ref<_AP_W2, _AP_S2>& op) : Base(op) {}
template <int _AP_W2, bool _AP_S2>
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 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 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 ap_ufixed(
const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op)
: Base(op) {}
inline ap_ufixed(bool v) : Base(v) {}
inline ap_ufixed(char v) : Base(v) {}
inline ap_ufixed(signed char v) : Base(v) {}
inline ap_ufixed(unsigned char v) : Base(v) {}
inline ap_ufixed(short v) : Base(v) {}
inline ap_ufixed(unsigned short v) : Base(v) {}
inline ap_ufixed(int v) : Base(v) {}
inline ap_ufixed(unsigned int v) : Base(v) {}
inline ap_ufixed(long v) : Base(v) {}
inline ap_ufixed(unsigned long v) : Base(v) {}
inline ap_ufixed(ap_slong v) : Base(v) {}
inline ap_ufixed(ap_ulong v) : Base(v) {}
inline ap_ufixed(half v) : Base(v) {}
inline ap_ufixed(float v) : Base(v) {}
inline ap_ufixed(double v) : Base(v) {}
inline ap_ufixed(const char* s) : Base(s) {}
inline ap_ufixed(const char* s, signed char rd) : Base(s, rd) {}
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 void operator=(
const ap_ufixed<_AP_W, _AP_I, _AP_Q, _AP_O, _AP_N>& op) volatile {
Base::V = op.V;
}
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 void operator=(const volatile ap_ufixed<_AP_W, _AP_I, _AP_Q, _AP_O,
_AP_N>& op) volatile {
Base::V = op.V;
}
};
# 398 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed.h"
# 1 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_special.h" 1
# 55 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_special.h"
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdio" 1 3
# 39 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdio" 3
# 40 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdio" 3
# 56 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_special.h" 2
# 1 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 1 3
# 39 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 3
# 40 "/data/tools/Xilinx/Vivado/2019.1/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 3
# 57 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_special.h" 2
namespace std {
template<typename _Tp> class complex;
}
namespace std {
# 89 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed_special.h"
template <int _AP_W, int _AP_I, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N>
class complex<ap_fixed<_AP_W, _AP_I, _AP_Q, _AP_O, _AP_N> > {
public:
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()) {}
const _Tp& real() const { return _M_real; }
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;
};
# 221 "/data/tools/Xilinx/Vivado/2019.1/include/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();
}
}
# 399 "/data/tools/Xilinx/Vivado/2019.1/include/ap_fixed.h" 2
# 368 "/data/tools/Xilinx/Vivado/2019.1/include/ap_int.h" 2
# 6 "/afs/cern.ch/user/p/piyush/work/bitonic64/src/bitonicSort.h" 2
using namespace std;
typedef ap_uint<32> din_t;
typedef ap_uint<8> dloop_t;
class GreaterSmaller{
public:
din_t greater, smaller;
};
GreaterSmaller AscendDescend(const din_t &x, const din_t &y);
void FourinSmallFirInc(const din_t &x0, const din_t &x1, const din_t &x2, const din_t &x3,
din_t &y0, din_t &y1, din_t &y2, din_t &y3);
void FourinGreatFirInc(const din_t &x0, const din_t &x1, const din_t &x2, const din_t &x3,
din_t &y0, din_t &y1, din_t &y2, din_t &y3);
void EightinSmallFirInc(const din_t &x0, const din_t &x1, const din_t &x2, const din_t &x3, const din_t &x4, const din_t &x5,
const din_t &x6, const din_t &x7, din_t &y0, din_t &y1, din_t &y2, din_t &y3, din_t &y4, din_t &y5, din_t &y6, din_t &y7);
void EightinGreatFirInc(const din_t &x8, const din_t &x9, const din_t &x10, const din_t &x11, const din_t &x12, const din_t &x13,
const din_t &x14, const din_t &x15, din_t &y8, din_t &y9, din_t &y10, din_t &y11, din_t &y12, din_t &y13, din_t &y14, din_t &y15);
void SixteenSmallFirInc(const din_t &x0, const din_t &x1, const din_t &x2, const din_t &x3, const din_t &x4, const din_t &x5,
const din_t &x6, const din_t &x7, const din_t &x8, const din_t &x9, const din_t &x10, const din_t &x11, const din_t &x12,
const din_t &x13, const din_t &x14, const din_t &x15, din_t &y0, din_t &y1, din_t &y2, din_t &y3, din_t &y4, din_t &y5, din_t &y6,
din_t &y7, din_t &y8, din_t &y9, din_t &y10, din_t &y11, din_t &y12, din_t &y13, din_t &y14, din_t &y15);
void SixteenGreatFirInc(const din_t &x16, const din_t &x17, const din_t &x18, const din_t &x19, const din_t &x20, const din_t &x21,
const din_t &x22, const din_t &x23, const din_t &x24, const din_t &x25, const din_t &x26, const din_t &x27, const din_t &x28,
const din_t &x29, const din_t &x30, const din_t &x31, din_t &y16, din_t &y17, din_t &y18, din_t &y19, din_t &y20, din_t &y21, din_t &y22,
din_t &y23, din_t &y24, din_t &y25, din_t &y26, din_t &y27, din_t &y28, din_t &y29, din_t &y30, din_t &y31);
void FourinSmallFirDec(const din_t &x0, const din_t &x1, const din_t &x2, const din_t &x3,
din_t &y0, din_t &y1, din_t &y2, din_t &y3);
void FourinGreatFirDec(const din_t &x0, const din_t &x1, const din_t &x2, const din_t &x3,
din_t &y0, din_t &y1, din_t &y2, din_t &y3);
void EightinSmallFirDec(const din_t &x0, const din_t &x1, const din_t &x2, const din_t &x3, const din_t &x4, const din_t &x5,
const din_t &x6, const din_t &x7, din_t &y0, din_t &y1, din_t &y2, din_t &y3, din_t &y4, din_t &y5, din_t &y6, din_t &y7);
void EightinGreatFirDec(const din_t &x8, const din_t &x9, const din_t &x10, const din_t &x11, const din_t &x12, const din_t &x13,
const din_t &x14, const din_t &x15, din_t &y8, din_t &y9, din_t &y10, din_t &y11, din_t &y12, din_t &y13, din_t &y14, din_t &y15);
void SixteenSmallFirDec(const din_t &x0, const din_t &x1, const din_t &x2, const din_t &x3, const din_t &x4, const din_t &x5,
const din_t &x6, const din_t &x7, const din_t &x8, const din_t &x9, const din_t &x10, const din_t &x11, const din_t &x12,
const din_t &x13, const din_t &x14, const din_t &x15, din_t &y0, din_t &y1, din_t &y2, din_t &y3, din_t &y4, din_t &y5, din_t &y6,
din_t &y7, din_t &y8, din_t &y9, din_t &y10, din_t &y11, din_t &y12, din_t &y13, din_t &y14, din_t &y15);
void SixteenGreatFirDec(const din_t &x16, const din_t &x17, const din_t &x18, const din_t &x19, const din_t &x20, const din_t &x21,
const din_t &x22, const din_t &x23, const din_t &x24, const din_t &x25, const din_t &x26, const din_t &x27, const din_t &x28,
const din_t &x29, const din_t &x30, const din_t &x31, din_t &y16, din_t &y17, din_t &y18, din_t &y19, din_t &y20, din_t &y21, din_t &y22,
din_t &y23, din_t &y24, din_t &y25, din_t &y26, din_t &y27, din_t &y28, din_t &y29, din_t &y30, din_t &y31);
void ThirtyTwoInSmallFir(const din_t &x0, const din_t &x1, const din_t &x2, const din_t &x3, const din_t &x4, const din_t &x5,
const din_t &x6, const din_t &x7, const din_t &x8, const din_t &x9, const din_t &x10, const din_t &x11, const din_t &x12,
const din_t &x13, const din_t &x14, const din_t &x15, const din_t &x16, const din_t &x17, const din_t &x18, const din_t &x19, const din_t &x20, const din_t &x21,
const din_t &x22, const din_t &x23, const din_t &x24, const din_t &x25, const din_t &x26, const din_t &x27, const din_t &x28,
const din_t &x29, const din_t &x30, const din_t &x31, din_t &y0, din_t &y1, din_t &y2, din_t &y3, din_t &y4, din_t &y5, din_t &y6,
din_t &y7, din_t &y8, din_t &y9, din_t &y10, din_t &y11, din_t &y12, din_t &y13, din_t &y14, din_t &y15, din_t &y16, din_t &y17, din_t &y18, din_t &y19, din_t &y20, din_t &y21, din_t &y22,
din_t &y23, din_t &y24, din_t &y25, din_t &y26, din_t &y27, din_t &y28, din_t &y29, din_t &y30, din_t &y31);
void bitonic32Inc(din_t in1[32], din_t out1[32]);
void bitonic32Dec(din_t in2[32], din_t out2[32]);
void bitonicSort64(din_t in[64], din_t out[64]);
# 2 "/afs/cern.ch/user/p/piyush/work/bitonic64/src/bitonic32Dec.cpp" 2
void bitonic32Dec(din_t in2[32], din_t out2[32]){
#pragma HLS PIPELINE II=9
#pragma HLS ARRAY_PARTITION variable=in2
#pragma HLS ARRAY_PARTITION variable=out2
GreaterSmaller result;
din_t a[32], b[32], c[32], d[32], e[32], f[32], g[32], h[32], l[32], m[32], n[32], o[32], p[32], q[32];
#pragma HLS ARRAY_PARTITION variable=a
#pragma HLS ARRAY_PARTITION variable=b
#pragma HLS ARRAY_PARTITION variable=c
#pragma HLS ARRAY_PARTITION variable=d
#pragma HLS ARRAY_PARTITION variable=e
#pragma HLS ARRAY_PARTITION variable=f
#pragma HLS ARRAY_PARTITION variable=g
#pragma HLS ARRAY_PARTITION variable=h
#pragma HLS ARRAY_PARTITION variable=l
#pragma HLS ARRAY_PARTITION variable=m
#pragma HLS ARRAY_PARTITION variable=n
#pragma HLS ARRAY_PARTITION variable=o
#pragma HLS ARRAY_PARTITION variable=p
#pragma HLS ARRAY_PARTITION variable=q
for(dloop_t i=0; i<32/4; i++){
#pragma HLS unroll
result = AscendDescend(in2[4*i], in2[4*i+1]);
a[4*i] = result.greater; a[4*i+1] = result.smaller;
}
for(dloop_t i=0; i<32/4; i++){
#pragma HLS unroll
result = AscendDescend(in2[4*i+2], in2[4*i+3]);
a[4*i+2] = result.smaller; a[4*i+3] = result.greater;
}
for(dloop_t i=0; i<32/8; i++){
#pragma HLS unroll
FourinSmallFirDec(a[8*i], a[8*i+1], a[8*i+2], a[8*i+3], b[8*i], b[8*i+1], b[8*i+2], b[8*i+3]);
FourinGreatFirDec(a[8*i+4], a[8*i+5], a[8*i+6], a[8*i+7], b[8*i+4], b[8*i+5], b[8*i+6], b[8*i+7]);
}
for(dloop_t i=0; i<32/8; i++){
#pragma HLS unroll
result = AscendDescend(b[8*i], b[8*i+1]);
c[8*i] = result.greater; c[8*i+1] = result.smaller;
result = AscendDescend(b[8*i+2], b[8*i+3]);
c[8*i+2] = result.greater; c[8*i+3] = result.smaller;
}
for(dloop_t i=0; i<32/8; i++){
#pragma HLS unroll
result = AscendDescend(b[8*i+4], b[8*i+5]);
c[8*i+4] = result.smaller; c[8*i+5] = result.greater;
result = AscendDescend(b[8*i+6], b[8*i+7]);
c[8*i+6] = result.smaller; c[8*i+7] = result.greater;
}
for(dloop_t i=0; i<32/16; i++){
EightinSmallFirDec(c[16*i+0], c[16*i+1], c[16*i+2], c[16*i+3], c[16*i+4], c[16*i+5], c[16*i+6], c[16*i+7],
d[16*i+0], d[16*i+1], d[16*i+2], d[16*i+3], d[16*i+4], d[16*i+5], d[16*i+6], d[16*i+7]);
EightinGreatFirDec(c[16*i+8], c[16*i+9], c[16*i+10], c[16*i+11], c[16*i+12], c[16*i+13], c[16*i+14], c[16*i+15],
d[16*i+8], d[16*i+9], d[16*i+10], d[16*i+11], d[16*i+12], d[16*i+13], d[16*i+14], d[16*i+15]);
}
for(dloop_t i=0; i<32/16; i++){
#pragma HLS unroll
FourinSmallFirDec(d[16*i], d[16*i+1], d[16*i+2], d[16*i+3], e[16*i], e[16*i+1], e[16*i+2], e[16*i+3]);
FourinSmallFirDec(d[16*i+4], d[16*i+5], d[16*i+6], d[16*i+7], e[16*i+4], e[16*i+5], e[16*i+6], e[16*i+7]);
FourinGreatFirDec(d[16*i+8], d[16*i+9], d[16*i+10], d[16*i+11], e[16*i+8], e[16*i+9], e[16*i+10], e[16*i+11]);
FourinGreatFirDec(d[16*i+12], d[16*i+13], d[16*i+14], d[16*i+15], e[16*i+12], e[16*i+13], e[16*i+14], e[16*i+15]);
}
for(dloop_t i=0; i<32/8; i++){
#pragma HLS unroll
result = AscendDescend(e[2*i], e[2*i+1]);
f[2*i] = result.greater; f[2*i+1] = result.smaller;
}
for(dloop_t i=0; i<32/8; i++){
#pragma HLS unroll
result = AscendDescend(e[2*i+8], e[2*i+9]);
f[2*i+8] = result.smaller; f[2*i+9] = result.greater;
}
for(dloop_t i=0; i<32/8; i++){
#pragma HLS unroll
result = AscendDescend(e[2*i+16], e[2*i+17]);
f[2*i+16] = result.greater; f[2*i+17] = result.smaller;
}
for(dloop_t i=0; i<32/8; i++){
#pragma HLS unroll
result = AscendDescend(e[2*i+24], e[2*i+25]);
f[2*i+24] = result.smaller; f[2*i+25] = result.greater;
}
SixteenSmallFirDec(f[0], f[1], f[2], f[3], f[4], f[5], f[6], f[7],
f[8], f[9], f[10], f[11], f[12], f[13], f[14], f[15],
g[0], g[1], g[2], g[3], g[4], g[5], g[6], g[7], g[8],
g[9], g[10], g[11], g[12], g[13], g[14], g[15]);
SixteenGreatFirDec(f[16], f[17], f[18], f[19], f[20], f[21], f[22], f[23],
f[24], f[25], f[26], f[27], f[28], f[29], f[30], f[31],
g[16], g[17], g[18], g[19], g[20], g[21], g[22], g[23], g[24],
g[25], g[26], g[27], g[28], g[29], g[30], g[31]);
for(dloop_t i=0; i<32/16; i++){
#pragma HLS unroll
EightinSmallFirDec(g[8*i], g[8*i+1], g[8*i+2], g[8*i+3], g[8*i+4], g[8*i+5], g[8*i+6], g[8*i+7],
h[8*i], h[8*i+1], h[8*i+2], h[8*i+3], h[8*i+4], h[8*i+5], h[8*i+6], h[8*i+7]);
}
for(dloop_t i=0; i<32/16; i++){
#pragma HLS unroll
EightinGreatFirDec(g[8*i+16], g[8*i+17], g[8*i+18], g[8*i+19], g[8*i+20], g[8*i+21], g[8*i+22], g[8*i+23],
h[8*i+16], h[8*i+17], h[8*i+18], h[8*i+19], h[8*i+20], h[8*i+21], h[8*i+22], h[8*i+23]);
}
for(dloop_t i=0; i<32/8; i++){
#pragma HLS unroll
FourinSmallFirDec(h[4*i], h[4*i+1], h[4*i+2], h[4*i+3], l[4*i], l[4*i+1], l[4*i+2], l[4*i+3]);
}
for(dloop_t i=0; i<32/8; i++){
#pragma HLS unroll
FourinGreatFirDec(h[4*i+16], h[4*i+17], h[4*i+18], h[4*i+19], l[4*i+16], l[4*i+17], l[4*i+18], l[4*i+19]);
}
for(dloop_t i=0; i<32/4; i++)
{
#pragma HLS unroll
result = AscendDescend(l[2*i], l[2*i+1]);
m[2*i] = result.greater; m[2*i+1] = result.smaller;
}
for(dloop_t i=0; i<32/4; i++){
#pragma HLS unroll
result = AscendDescend(l[2*i+16], l[2*i+17]);
m[2*i+16] = result.smaller; m[2*i+17] = result.greater;
}
for(dloop_t i=0; i<32/2; i++){
#pragma HLS unroll
result = AscendDescend(m[i], m[i+16]);
n[i] = result.greater; n[i+16] = result.smaller;
}
for(dloop_t i=0; i<32/16; i++){
#pragma HLS unroll
SixteenSmallFirDec(n[16*i], n[16*i+1], n[16*i+2], n[16*i+3], n[16*i+4], n[16*i+5], n[16*i+6], n[16*i+7],
n[16*i+8], n[16*i+9], n[16*i+10], n[16*i+11], n[16*i+12], n[16*i+13], n[16*i+14], n[16*i+15],
o[16*i+0], o[16*i+1], o[16*i+2], o[16*i+3], o[16*i+4], o[16*i+5], o[16*i+6], o[16*i+7], o[16*i+8],
o[16*i+9], o[16*i+10], o[16*i+11], o[16*i+12], o[16*i+13], o[16*i+14], o[16*i+15]);
}
for(dloop_t i=0; i<32/8; i++){
#pragma HLS unroll
EightinSmallFirDec(o[8*i], o[8*i+1], o[8*i+2], o[8*i+3], o[8*i+4], o[8*i+5], o[8*i+6], o[8*i+7],
p[8*i], p[8*i+1], p[8*i+2], p[8*i+3], p[8*i+4], p[8*i+5], p[8*i+6], p[8*i+7]);
}
for(dloop_t i=0; i<32/4; i++){
#pragma HLS unroll
FourinSmallFirDec(p[4*i], p[4*i+1], p[4*i+2], p[4*i+3], q[4*i], q[4*i+1], q[4*i+2], q[4*i+3]);
}
for(dloop_t i=0; i<32/2; i++){
#pragma HLS unroll
result = AscendDescend(q[2*i], q[2*i+1]);
out2[2*i] = result.greater; out2[2*i+1] = result.smaller;
}
}
| [
"piyush_kumar@uohyd.ac.in"
] | piyush_kumar@uohyd.ac.in |
3722f5d33d8e70174a2a53ce3b58cacd2830f112 | 99d054f93c3dd45a80e99be05f3f64c2c568ea5d | /Online Judges/URI/2631/main.cpp | a6b7ae520f9811177a46ddb2480efa6eb6f0e4e3 | [
"MIT"
] | permissive | AnneLivia/Competitive-Programming | 65972d72fc4a0b37589da408e52ada19889f7ba8 | f4057e4bce37a636c85875cc80e5a53eb715f4be | refs/heads/master | 2022-12-23T11:52:04.299919 | 2022-12-12T16:20:05 | 2022-12-12T16:20:05 | 117,617,504 | 74 | 21 | MIT | 2019-11-14T03:11:58 | 2018-01-16T01:58:28 | C++ | UTF-8 | C++ | false | false | 532 | cpp | #include <iostream>
#include <set>
using namespace std;
int main()
{
int qtd, va;
set<pair<int,string>>co;
string name;
while(cin >> qtd) {
co.clear();
while(qtd--) {
cin >> name >> va;
co.insert(make_pair(va,name));
}
set<pair<int,string>>::iterator it;
for(it = co.begin(); it != co.end(); it++) {
if(it != co.begin())
cout << " ";
cout << it->second;
}
cout << endl;
}
return 0;
}
| [
"annelivia16@gmail.com"
] | annelivia16@gmail.com |
4f8b45d69df90447a70f34981eb02398335b2e4e | 8b0aa0a3143f7f57da837dff6a7bb31f65005b9c | /export/linux/obj/include/hx/strings/AnsiState.h | d0fef990efa3377b605e45584dfdab2657437620 | [] | no_license | HedgehogFog/HaxePolygon | 124f58641ecf09f7cd5b13b612d01e843c4b7d45 | 0812c7d663985148e142611da197016b59492ad9 | refs/heads/master | 2020-04-26T02:26:59.219400 | 2019-03-01T07:38:25 | 2019-03-01T07:38:25 | 173,235,066 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | true | 2,407 | h | // Generated by Haxe 3.4.7
#ifndef INCLUDED_hx_strings_AnsiState
#define INCLUDED_hx_strings_AnsiState
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS2(hx,strings,AnsiState)
HX_DECLARE_CLASS2(hx,strings,AnsiToHtmlRenderMethod)
namespace hx{
namespace strings{
class HXCPP_CLASS_ATTRIBUTES AnsiState_obj : public hx::Object
{
public:
typedef hx::Object super;
typedef AnsiState_obj OBJ_;
AnsiState_obj();
public:
enum { _hx_ClassId = 0x121d64f0 };
void __construct( ::hx::strings::AnsiState copyFrom);
inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="hx.strings.AnsiState")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,true,"hx.strings.AnsiState"); }
static hx::ObjectPtr< AnsiState_obj > __new( ::hx::strings::AnsiState copyFrom);
static hx::ObjectPtr< AnsiState_obj > __alloc(hx::Ctx *_hx_ctx, ::hx::strings::AnsiState copyFrom);
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~AnsiState_obj();
HX_DO_RTTI_ALL;
hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
void __GetFields(Array< ::String> &outFields);
static void __register();
void __Mark(HX_MARK_PARAMS);
void __Visit(HX_VISIT_PARAMS);
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_HCSTRING("AnsiState","\x2e","\xd4","\xce","\xe3"); }
static ::String defaultCssClassesCallback( ::hx::strings::AnsiState state);
static ::Dynamic defaultCssClassesCallback_dyn();
::String bgcolor;
bool blink;
bool bold;
::String fgcolor;
bool underline;
bool isActive();
::Dynamic isActive_dyn();
void reset();
::Dynamic reset_dyn();
void copyFrom( ::hx::strings::AnsiState other);
::Dynamic copyFrom_dyn();
void setGraphicModeParameter(int param);
::Dynamic setGraphicModeParameter_dyn();
::String toCSS( ::hx::strings::AnsiToHtmlRenderMethod renderMethod);
::Dynamic toCSS_dyn();
};
} // end namespace hx
} // end namespace strings
#endif /* INCLUDED_hx_strings_AnsiState */
| [
"hedgehog_fogs@mail.ru"
] | hedgehog_fogs@mail.ru |
f1ba445f0854bc3d604fd115accf6d01d0006f89 | 29c0a5a7c52f7dfb5bb33c94022627bccedbd459 | /CPPStaticLibrary/Student.h | bdd976322103ad77207aa5e859d465cc28b548e5 | [] | no_license | pavlexander/cpp_clr_tests | 30ac72c57fe5cf0da019115ca148253e4d77455a | 16ff0b8d0f6302a6d35702e0ec8264346e16e6e7 | refs/heads/master | 2021-01-09T18:38:47.083201 | 2020-02-22T21:07:11 | 2020-02-22T21:07:11 | 242,410,896 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 540 | h | #pragma once
#include <cstring>
#include <iostream>
class Student
{
private:
char *_fullname;
double _gpa;
public:
Student(char *name, double gpa)
{
_fullname = new char[strlen(name) + 1];
//strcpy(_fullname, name);
strcpy_s(_fullname, strlen(name) + 1, name);
_gpa = gpa;
std::cout << "Name is " << _fullname << std::endl;
std::cout << "Gpa is " << _gpa << std::endl;
}
~Student()
{
delete[] _fullname;
}
double getGpa()
{
return _gpa;
}
char *getName()
{
return _fullname;
}
}; | [
"a.pavlenko@intrum.com"
] | a.pavlenko@intrum.com |
265296eb5cfbe615a5e7dec0e1678d1a8bc0a2b9 | 102eae403665433dc48f48196a7e9210ca344678 | /MultiThreads/Generated Files/winrt/impl/Windows.Security.ExchangeActiveSyncProvisioning.0.h | 2d73a28329bde5c9fcd9d457d45b161b44bfca25 | [] | no_license | AIchemists/multiThreads | 5fd583c46314296cc745d3afa23dbe1994dff9f6 | df57a18dff84cd51eda31184a9ba1c811d30e2c0 | refs/heads/master | 2022-12-18T16:09:57.390044 | 2020-09-22T01:57:58 | 2020-09-22T01:57:58 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 21,541 | h | // WARNING: Please don't edit this file. It was generated by C++/WinRT v2.0.200917.4
#ifndef WINRT_Windows_Security_ExchangeActiveSyncProvisioning_0_H
#define WINRT_Windows_Security_ExchangeActiveSyncProvisioning_0_H
WINRT_EXPORT namespace winrt::Windows::Foundation
{
template <typename TResult> struct __declspec(empty_bases) IAsyncOperation;
}
WINRT_EXPORT namespace winrt::Windows::Security::ExchangeActiveSyncProvisioning
{
enum class EasDisallowConvenienceLogonResult : int32_t
{
NotEvaluated = 0,
Compliant = 1,
CanBeCompliant = 2,
RequestedPolicyIsStricter = 3,
};
enum class EasEncryptionProviderType : int32_t
{
NotEvaluated = 0,
WindowsEncryption = 1,
OtherEncryption = 2,
};
enum class EasMaxInactivityTimeLockResult : int32_t
{
NotEvaluated = 0,
Compliant = 1,
CanBeCompliant = 2,
RequestedPolicyIsStricter = 3,
InvalidParameter = 4,
};
enum class EasMaxPasswordFailedAttemptsResult : int32_t
{
NotEvaluated = 0,
Compliant = 1,
CanBeCompliant = 2,
RequestedPolicyIsStricter = 3,
InvalidParameter = 4,
};
enum class EasMinPasswordComplexCharactersResult : int32_t
{
NotEvaluated = 0,
Compliant = 1,
CanBeCompliant = 2,
RequestedPolicyIsStricter = 3,
RequestedPolicyNotEnforceable = 4,
InvalidParameter = 5,
CurrentUserHasBlankPassword = 6,
AdminsHaveBlankPassword = 7,
UserCannotChangePassword = 8,
AdminsCannotChangePassword = 9,
LocalControlledUsersCannotChangePassword = 10,
ConnectedAdminsProviderPolicyIsWeak = 11,
ConnectedUserProviderPolicyIsWeak = 12,
ChangeConnectedAdminsPassword = 13,
ChangeConnectedUserPassword = 14,
};
enum class EasMinPasswordLengthResult : int32_t
{
NotEvaluated = 0,
Compliant = 1,
CanBeCompliant = 2,
RequestedPolicyIsStricter = 3,
RequestedPolicyNotEnforceable = 4,
InvalidParameter = 5,
CurrentUserHasBlankPassword = 6,
AdminsHaveBlankPassword = 7,
UserCannotChangePassword = 8,
AdminsCannotChangePassword = 9,
LocalControlledUsersCannotChangePassword = 10,
ConnectedAdminsProviderPolicyIsWeak = 11,
ConnectedUserProviderPolicyIsWeak = 12,
ChangeConnectedAdminsPassword = 13,
ChangeConnectedUserPassword = 14,
};
enum class EasPasswordExpirationResult : int32_t
{
NotEvaluated = 0,
Compliant = 1,
CanBeCompliant = 2,
RequestedPolicyIsStricter = 3,
RequestedExpirationIncompatible = 4,
InvalidParameter = 5,
UserCannotChangePassword = 6,
AdminsCannotChangePassword = 7,
LocalControlledUsersCannotChangePassword = 8,
};
enum class EasPasswordHistoryResult : int32_t
{
NotEvaluated = 0,
Compliant = 1,
CanBeCompliant = 2,
RequestedPolicyIsStricter = 3,
InvalidParameter = 4,
};
enum class EasRequireEncryptionResult : int32_t
{
NotEvaluated = 0,
Compliant = 1,
CanBeCompliant = 2,
NotProvisionedOnAllVolumes = 3,
DeFixedDataNotSupported = 4,
FixedDataNotSupported = 4,
DeHardwareNotCompliant = 5,
HardwareNotCompliant = 5,
DeWinReNotConfigured = 6,
LockNotConfigured = 6,
DeProtectionSuspended = 7,
ProtectionSuspended = 7,
DeOsVolumeNotProtected = 8,
OsVolumeNotProtected = 8,
DeProtectionNotYetEnabled = 9,
ProtectionNotYetEnabled = 9,
NoFeatureLicense = 10,
OsNotProtected = 11,
UnexpectedFailure = 12,
};
struct IEasClientDeviceInformation;
struct IEasClientDeviceInformation2;
struct IEasClientSecurityPolicy;
struct IEasComplianceResults;
struct IEasComplianceResults2;
struct EasClientDeviceInformation;
struct EasClientSecurityPolicy;
struct EasComplianceResults;
}
namespace winrt::impl
{
template <> struct category<Windows::Security::ExchangeActiveSyncProvisioning::IEasClientDeviceInformation>{ using type = interface_category; };
template <> struct category<Windows::Security::ExchangeActiveSyncProvisioning::IEasClientDeviceInformation2>{ using type = interface_category; };
template <> struct category<Windows::Security::ExchangeActiveSyncProvisioning::IEasClientSecurityPolicy>{ using type = interface_category; };
template <> struct category<Windows::Security::ExchangeActiveSyncProvisioning::IEasComplianceResults>{ using type = interface_category; };
template <> struct category<Windows::Security::ExchangeActiveSyncProvisioning::IEasComplianceResults2>{ using type = interface_category; };
template <> struct category<Windows::Security::ExchangeActiveSyncProvisioning::EasClientDeviceInformation>{ using type = class_category; };
template <> struct category<Windows::Security::ExchangeActiveSyncProvisioning::EasClientSecurityPolicy>{ using type = class_category; };
template <> struct category<Windows::Security::ExchangeActiveSyncProvisioning::EasComplianceResults>{ using type = class_category; };
template <> struct category<Windows::Security::ExchangeActiveSyncProvisioning::EasDisallowConvenienceLogonResult>{ using type = enum_category; };
template <> struct category<Windows::Security::ExchangeActiveSyncProvisioning::EasEncryptionProviderType>{ using type = enum_category; };
template <> struct category<Windows::Security::ExchangeActiveSyncProvisioning::EasMaxInactivityTimeLockResult>{ using type = enum_category; };
template <> struct category<Windows::Security::ExchangeActiveSyncProvisioning::EasMaxPasswordFailedAttemptsResult>{ using type = enum_category; };
template <> struct category<Windows::Security::ExchangeActiveSyncProvisioning::EasMinPasswordComplexCharactersResult>{ using type = enum_category; };
template <> struct category<Windows::Security::ExchangeActiveSyncProvisioning::EasMinPasswordLengthResult>{ using type = enum_category; };
template <> struct category<Windows::Security::ExchangeActiveSyncProvisioning::EasPasswordExpirationResult>{ using type = enum_category; };
template <> struct category<Windows::Security::ExchangeActiveSyncProvisioning::EasPasswordHistoryResult>{ using type = enum_category; };
template <> struct category<Windows::Security::ExchangeActiveSyncProvisioning::EasRequireEncryptionResult>{ using type = enum_category; };
template <> inline constexpr auto& name_v<Windows::Security::ExchangeActiveSyncProvisioning::EasClientDeviceInformation> = L"Windows.Security.ExchangeActiveSyncProvisioning.EasClientDeviceInformation";
template <> inline constexpr auto& name_v<Windows::Security::ExchangeActiveSyncProvisioning::EasClientSecurityPolicy> = L"Windows.Security.ExchangeActiveSyncProvisioning.EasClientSecurityPolicy";
template <> inline constexpr auto& name_v<Windows::Security::ExchangeActiveSyncProvisioning::EasComplianceResults> = L"Windows.Security.ExchangeActiveSyncProvisioning.EasComplianceResults";
template <> inline constexpr auto& name_v<Windows::Security::ExchangeActiveSyncProvisioning::EasDisallowConvenienceLogonResult> = L"Windows.Security.ExchangeActiveSyncProvisioning.EasDisallowConvenienceLogonResult";
template <> inline constexpr auto& name_v<Windows::Security::ExchangeActiveSyncProvisioning::EasEncryptionProviderType> = L"Windows.Security.ExchangeActiveSyncProvisioning.EasEncryptionProviderType";
template <> inline constexpr auto& name_v<Windows::Security::ExchangeActiveSyncProvisioning::EasMaxInactivityTimeLockResult> = L"Windows.Security.ExchangeActiveSyncProvisioning.EasMaxInactivityTimeLockResult";
template <> inline constexpr auto& name_v<Windows::Security::ExchangeActiveSyncProvisioning::EasMaxPasswordFailedAttemptsResult> = L"Windows.Security.ExchangeActiveSyncProvisioning.EasMaxPasswordFailedAttemptsResult";
template <> inline constexpr auto& name_v<Windows::Security::ExchangeActiveSyncProvisioning::EasMinPasswordComplexCharactersResult> = L"Windows.Security.ExchangeActiveSyncProvisioning.EasMinPasswordComplexCharactersResult";
template <> inline constexpr auto& name_v<Windows::Security::ExchangeActiveSyncProvisioning::EasMinPasswordLengthResult> = L"Windows.Security.ExchangeActiveSyncProvisioning.EasMinPasswordLengthResult";
template <> inline constexpr auto& name_v<Windows::Security::ExchangeActiveSyncProvisioning::EasPasswordExpirationResult> = L"Windows.Security.ExchangeActiveSyncProvisioning.EasPasswordExpirationResult";
template <> inline constexpr auto& name_v<Windows::Security::ExchangeActiveSyncProvisioning::EasPasswordHistoryResult> = L"Windows.Security.ExchangeActiveSyncProvisioning.EasPasswordHistoryResult";
template <> inline constexpr auto& name_v<Windows::Security::ExchangeActiveSyncProvisioning::EasRequireEncryptionResult> = L"Windows.Security.ExchangeActiveSyncProvisioning.EasRequireEncryptionResult";
template <> inline constexpr auto& name_v<Windows::Security::ExchangeActiveSyncProvisioning::IEasClientDeviceInformation> = L"Windows.Security.ExchangeActiveSyncProvisioning.IEasClientDeviceInformation";
template <> inline constexpr auto& name_v<Windows::Security::ExchangeActiveSyncProvisioning::IEasClientDeviceInformation2> = L"Windows.Security.ExchangeActiveSyncProvisioning.IEasClientDeviceInformation2";
template <> inline constexpr auto& name_v<Windows::Security::ExchangeActiveSyncProvisioning::IEasClientSecurityPolicy> = L"Windows.Security.ExchangeActiveSyncProvisioning.IEasClientSecurityPolicy";
template <> inline constexpr auto& name_v<Windows::Security::ExchangeActiveSyncProvisioning::IEasComplianceResults> = L"Windows.Security.ExchangeActiveSyncProvisioning.IEasComplianceResults";
template <> inline constexpr auto& name_v<Windows::Security::ExchangeActiveSyncProvisioning::IEasComplianceResults2> = L"Windows.Security.ExchangeActiveSyncProvisioning.IEasComplianceResults2";
template <> inline constexpr guid guid_v<Windows::Security::ExchangeActiveSyncProvisioning::IEasClientDeviceInformation>{ 0x54DFD981,0x1968,0x4CA3,{ 0xB9,0x58,0xE5,0x95,0xD1,0x65,0x05,0xEB } }; // 54DFD981-1968-4CA3-B958-E595D16505EB
template <> inline constexpr guid guid_v<Windows::Security::ExchangeActiveSyncProvisioning::IEasClientDeviceInformation2>{ 0xFFB35923,0xBB26,0x4D6A,{ 0x81,0xBC,0x16,0x5A,0xEE,0x0A,0xD7,0x54 } }; // FFB35923-BB26-4D6A-81BC-165AEE0AD754
template <> inline constexpr guid guid_v<Windows::Security::ExchangeActiveSyncProvisioning::IEasClientSecurityPolicy>{ 0x45B72362,0xDFBA,0x4A9B,{ 0xAC,0xED,0x6F,0xE2,0xAD,0xCB,0x64,0x20 } }; // 45B72362-DFBA-4A9B-ACED-6FE2ADCB6420
template <> inline constexpr guid guid_v<Windows::Security::ExchangeActiveSyncProvisioning::IEasComplianceResults>{ 0x463C299C,0x7F19,0x4C66,{ 0xB4,0x03,0xCB,0x45,0xDD,0x57,0xA2,0xB3 } }; // 463C299C-7F19-4C66-B403-CB45DD57A2B3
template <> inline constexpr guid guid_v<Windows::Security::ExchangeActiveSyncProvisioning::IEasComplianceResults2>{ 0x2FBE60C9,0x1AA8,0x47F5,{ 0x88,0xBB,0xCB,0x3E,0xF0,0xBF,0xFB,0x15 } }; // 2FBE60C9-1AA8-47F5-88BB-CB3EF0BFFB15
template <> struct default_interface<Windows::Security::ExchangeActiveSyncProvisioning::EasClientDeviceInformation>{ using type = Windows::Security::ExchangeActiveSyncProvisioning::IEasClientDeviceInformation; };
template <> struct default_interface<Windows::Security::ExchangeActiveSyncProvisioning::EasClientSecurityPolicy>{ using type = Windows::Security::ExchangeActiveSyncProvisioning::IEasClientSecurityPolicy; };
template <> struct default_interface<Windows::Security::ExchangeActiveSyncProvisioning::EasComplianceResults>{ using type = Windows::Security::ExchangeActiveSyncProvisioning::IEasComplianceResults; };
template <> struct abi<Windows::Security::ExchangeActiveSyncProvisioning::IEasClientDeviceInformation>
{
struct __declspec(novtable) type : inspectable_abi
{
virtual int32_t __stdcall get_Id(winrt::guid*) noexcept = 0;
virtual int32_t __stdcall get_OperatingSystem(void**) noexcept = 0;
virtual int32_t __stdcall get_FriendlyName(void**) noexcept = 0;
virtual int32_t __stdcall get_SystemManufacturer(void**) noexcept = 0;
virtual int32_t __stdcall get_SystemProductName(void**) noexcept = 0;
virtual int32_t __stdcall get_SystemSku(void**) noexcept = 0;
};
};
template <> struct abi<Windows::Security::ExchangeActiveSyncProvisioning::IEasClientDeviceInformation2>
{
struct __declspec(novtable) type : inspectable_abi
{
virtual int32_t __stdcall get_SystemHardwareVersion(void**) noexcept = 0;
virtual int32_t __stdcall get_SystemFirmwareVersion(void**) noexcept = 0;
};
};
template <> struct abi<Windows::Security::ExchangeActiveSyncProvisioning::IEasClientSecurityPolicy>
{
struct __declspec(novtable) type : inspectable_abi
{
virtual int32_t __stdcall get_RequireEncryption(bool*) noexcept = 0;
virtual int32_t __stdcall put_RequireEncryption(bool) noexcept = 0;
virtual int32_t __stdcall get_MinPasswordLength(uint8_t*) noexcept = 0;
virtual int32_t __stdcall put_MinPasswordLength(uint8_t) noexcept = 0;
virtual int32_t __stdcall get_DisallowConvenienceLogon(bool*) noexcept = 0;
virtual int32_t __stdcall put_DisallowConvenienceLogon(bool) noexcept = 0;
virtual int32_t __stdcall get_MinPasswordComplexCharacters(uint8_t*) noexcept = 0;
virtual int32_t __stdcall put_MinPasswordComplexCharacters(uint8_t) noexcept = 0;
virtual int32_t __stdcall get_PasswordExpiration(int64_t*) noexcept = 0;
virtual int32_t __stdcall put_PasswordExpiration(int64_t) noexcept = 0;
virtual int32_t __stdcall get_PasswordHistory(uint32_t*) noexcept = 0;
virtual int32_t __stdcall put_PasswordHistory(uint32_t) noexcept = 0;
virtual int32_t __stdcall get_MaxPasswordFailedAttempts(uint8_t*) noexcept = 0;
virtual int32_t __stdcall put_MaxPasswordFailedAttempts(uint8_t) noexcept = 0;
virtual int32_t __stdcall get_MaxInactivityTimeLock(int64_t*) noexcept = 0;
virtual int32_t __stdcall put_MaxInactivityTimeLock(int64_t) noexcept = 0;
virtual int32_t __stdcall CheckCompliance(void**) noexcept = 0;
virtual int32_t __stdcall ApplyAsync(void**) noexcept = 0;
};
};
template <> struct abi<Windows::Security::ExchangeActiveSyncProvisioning::IEasComplianceResults>
{
struct __declspec(novtable) type : inspectable_abi
{
virtual int32_t __stdcall get_Compliant(bool*) noexcept = 0;
virtual int32_t __stdcall get_RequireEncryptionResult(int32_t*) noexcept = 0;
virtual int32_t __stdcall get_MinPasswordLengthResult(int32_t*) noexcept = 0;
virtual int32_t __stdcall get_DisallowConvenienceLogonResult(int32_t*) noexcept = 0;
virtual int32_t __stdcall get_MinPasswordComplexCharactersResult(int32_t*) noexcept = 0;
virtual int32_t __stdcall get_PasswordExpirationResult(int32_t*) noexcept = 0;
virtual int32_t __stdcall get_PasswordHistoryResult(int32_t*) noexcept = 0;
virtual int32_t __stdcall get_MaxPasswordFailedAttemptsResult(int32_t*) noexcept = 0;
virtual int32_t __stdcall get_MaxInactivityTimeLockResult(int32_t*) noexcept = 0;
};
};
template <> struct abi<Windows::Security::ExchangeActiveSyncProvisioning::IEasComplianceResults2>
{
struct __declspec(novtable) type : inspectable_abi
{
virtual int32_t __stdcall get_EncryptionProviderType(int32_t*) noexcept = 0;
};
};
template <typename D>
struct consume_Windows_Security_ExchangeActiveSyncProvisioning_IEasClientDeviceInformation
{
[[nodiscard]] WINRT_IMPL_AUTO(winrt::guid) Id() const;
[[nodiscard]] WINRT_IMPL_AUTO(hstring) OperatingSystem() const;
[[nodiscard]] WINRT_IMPL_AUTO(hstring) FriendlyName() const;
[[nodiscard]] WINRT_IMPL_AUTO(hstring) SystemManufacturer() const;
[[nodiscard]] WINRT_IMPL_AUTO(hstring) SystemProductName() const;
[[nodiscard]] WINRT_IMPL_AUTO(hstring) SystemSku() const;
};
template <> struct consume<Windows::Security::ExchangeActiveSyncProvisioning::IEasClientDeviceInformation>
{
template <typename D> using type = consume_Windows_Security_ExchangeActiveSyncProvisioning_IEasClientDeviceInformation<D>;
};
template <typename D>
struct consume_Windows_Security_ExchangeActiveSyncProvisioning_IEasClientDeviceInformation2
{
[[nodiscard]] WINRT_IMPL_AUTO(hstring) SystemHardwareVersion() const;
[[nodiscard]] WINRT_IMPL_AUTO(hstring) SystemFirmwareVersion() const;
};
template <> struct consume<Windows::Security::ExchangeActiveSyncProvisioning::IEasClientDeviceInformation2>
{
template <typename D> using type = consume_Windows_Security_ExchangeActiveSyncProvisioning_IEasClientDeviceInformation2<D>;
};
template <typename D>
struct consume_Windows_Security_ExchangeActiveSyncProvisioning_IEasClientSecurityPolicy
{
[[nodiscard]] WINRT_IMPL_AUTO(bool) RequireEncryption() const;
WINRT_IMPL_AUTO(void) RequireEncryption(bool value) const;
[[nodiscard]] WINRT_IMPL_AUTO(uint8_t) MinPasswordLength() const;
WINRT_IMPL_AUTO(void) MinPasswordLength(uint8_t value) const;
[[nodiscard]] WINRT_IMPL_AUTO(bool) DisallowConvenienceLogon() const;
WINRT_IMPL_AUTO(void) DisallowConvenienceLogon(bool value) const;
[[nodiscard]] WINRT_IMPL_AUTO(uint8_t) MinPasswordComplexCharacters() const;
WINRT_IMPL_AUTO(void) MinPasswordComplexCharacters(uint8_t value) const;
[[nodiscard]] WINRT_IMPL_AUTO(Windows::Foundation::TimeSpan) PasswordExpiration() const;
WINRT_IMPL_AUTO(void) PasswordExpiration(Windows::Foundation::TimeSpan const& value) const;
[[nodiscard]] WINRT_IMPL_AUTO(uint32_t) PasswordHistory() const;
WINRT_IMPL_AUTO(void) PasswordHistory(uint32_t value) const;
[[nodiscard]] WINRT_IMPL_AUTO(uint8_t) MaxPasswordFailedAttempts() const;
WINRT_IMPL_AUTO(void) MaxPasswordFailedAttempts(uint8_t value) const;
[[nodiscard]] WINRT_IMPL_AUTO(Windows::Foundation::TimeSpan) MaxInactivityTimeLock() const;
WINRT_IMPL_AUTO(void) MaxInactivityTimeLock(Windows::Foundation::TimeSpan const& value) const;
WINRT_IMPL_AUTO(Windows::Security::ExchangeActiveSyncProvisioning::EasComplianceResults) CheckCompliance() const;
WINRT_IMPL_AUTO(Windows::Foundation::IAsyncOperation<Windows::Security::ExchangeActiveSyncProvisioning::EasComplianceResults>) ApplyAsync() const;
};
template <> struct consume<Windows::Security::ExchangeActiveSyncProvisioning::IEasClientSecurityPolicy>
{
template <typename D> using type = consume_Windows_Security_ExchangeActiveSyncProvisioning_IEasClientSecurityPolicy<D>;
};
template <typename D>
struct consume_Windows_Security_ExchangeActiveSyncProvisioning_IEasComplianceResults
{
[[nodiscard]] WINRT_IMPL_AUTO(bool) Compliant() const;
[[nodiscard]] WINRT_IMPL_AUTO(Windows::Security::ExchangeActiveSyncProvisioning::EasRequireEncryptionResult) RequireEncryptionResult() const;
[[nodiscard]] WINRT_IMPL_AUTO(Windows::Security::ExchangeActiveSyncProvisioning::EasMinPasswordLengthResult) MinPasswordLengthResult() const;
[[nodiscard]] WINRT_IMPL_AUTO(Windows::Security::ExchangeActiveSyncProvisioning::EasDisallowConvenienceLogonResult) DisallowConvenienceLogonResult() const;
[[nodiscard]] WINRT_IMPL_AUTO(Windows::Security::ExchangeActiveSyncProvisioning::EasMinPasswordComplexCharactersResult) MinPasswordComplexCharactersResult() const;
[[nodiscard]] WINRT_IMPL_AUTO(Windows::Security::ExchangeActiveSyncProvisioning::EasPasswordExpirationResult) PasswordExpirationResult() const;
[[nodiscard]] WINRT_IMPL_AUTO(Windows::Security::ExchangeActiveSyncProvisioning::EasPasswordHistoryResult) PasswordHistoryResult() const;
[[nodiscard]] WINRT_IMPL_AUTO(Windows::Security::ExchangeActiveSyncProvisioning::EasMaxPasswordFailedAttemptsResult) MaxPasswordFailedAttemptsResult() const;
[[nodiscard]] WINRT_IMPL_AUTO(Windows::Security::ExchangeActiveSyncProvisioning::EasMaxInactivityTimeLockResult) MaxInactivityTimeLockResult() const;
};
template <> struct consume<Windows::Security::ExchangeActiveSyncProvisioning::IEasComplianceResults>
{
template <typename D> using type = consume_Windows_Security_ExchangeActiveSyncProvisioning_IEasComplianceResults<D>;
};
template <typename D>
struct consume_Windows_Security_ExchangeActiveSyncProvisioning_IEasComplianceResults2
{
[[nodiscard]] WINRT_IMPL_AUTO(Windows::Security::ExchangeActiveSyncProvisioning::EasEncryptionProviderType) EncryptionProviderType() const;
};
template <> struct consume<Windows::Security::ExchangeActiveSyncProvisioning::IEasComplianceResults2>
{
template <typename D> using type = consume_Windows_Security_ExchangeActiveSyncProvisioning_IEasComplianceResults2<D>;
};
}
#endif
| [
"jicheng@yahoo.com"
] | jicheng@yahoo.com |
5f795223f3f012a6446a199dc40c5b57c40fbffb | 94000d447528bd85d2c2abe4a787c370b00f7229 | /projects/lineintro/src/arx/Image.h | 77a2097800fe57dc1ab0177a600358a27e48349c | [] | no_license | elrinor/chaos-devices | 72ea8c55a2a8a77300d3dba402b316e0801d8338 | 40d30e059c8b9a2d80f28048e39634934c1d1f0b | refs/heads/master | 2023-08-05T01:39:38.908343 | 2021-09-17T18:33:16 | 2021-09-17T18:33:16 | 33,127,293 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 70,865 | h | /** @file ArX Image Processing Library.
*
* Currently supported data types for images:
* <ul>
* <li> unsigned char
* <li> float
* </ul>
*
* Currently supported numbers of channels:
* <ul>
* <li> C1
* <li> C3 (through Color3 template)
* <li> AC4 (through Color4 template)
* </ul>
*/
#ifndef __ARX_IMAGE_H__
#define __ARX_IMAGE_H__
#include "config.h"
#include <utility>
#include <exception>
#include <cassert>
#include <string>
#include <fstream>
#include "smart_ptr.h"
#include "Utility.h"
#include "Mpl.h"
#include "LinearAlgebra.h"
#include "Memory.h"
#ifdef ARX_USE_IPPI
# include <ipp.h>
#endif
#ifdef ARX_USE_OPENCV
# include <cxcore.h>
#endif
#ifdef ARX_USE_CIPPIMAGE
# include <ippimage.h>
#endif
namespace arx {
// -------------------------------------------------------------------------- //
// Operators
// -------------------------------------------------------------------------- //
/** Operators struct contains some functors which can ease
* implementation of overloaded operators for complex data types. */
template<class T>
struct Operators {
#define DEFINE_BINARY_OPERATOR(OP_NAME, RET_TYPE, OP) \
struct OP_NAME { \
RET_TYPE operator()(const T& l, const T& r) const { \
return OP; \
} \
};
// TODO: merge with ones defined in LinearAlgebra
// TODO: use std::divides etc...
DEFINE_BINARY_OPERATOR(Mul, T, l * r)
DEFINE_BINARY_OPERATOR(Div, T, l / r)
DEFINE_BINARY_OPERATOR(Add, T, l + r)
DEFINE_BINARY_OPERATOR(Sub, T, l - r)
#undef DEFINE_BINARY_OPERATOR
};
// -------------------------------------------------------------------------- //
// Colors
// -------------------------------------------------------------------------- //
/** This metafunction determines whether the given datatype is supported. */
template<class T> struct is_datatype_supported: public arx::or_<arx::is_same<T, float>, arx::is_same<T, unsigned char> > {};
/** Defines min() and max() functions for supported simple color types. */
template<class T> struct color_limits;
template<> struct color_limits<unsigned char> {
static unsigned char min() { return 0; }
static unsigned char max() { return 255; }
};
template<> struct color_limits<float> {
static float min() { return 0.0f; }
static float max() { return 1.0f; }
};
/** Data storage class for Color3 */
template<class T>
struct Color3Data {
enum { static_size = 3, processed_size = 3 };
union {
T asArray[3];
struct {
T b, g, r;
};
};
};
/** Data storage class for Color4 */
template<class T>
struct Color4Data {
enum { static_size = 4, processed_size = 3 };
union {
T asArray[4];
struct {
T b, g, r, a;
};
};
};
/** Base class for all composite colors. */
template<class T, template<class> class Base, class Derived>
struct ColorBase: public Base<T> {
private:
STATIC_ASSERT((is_datatype_supported<T>::value));
template<int i, class Operator, class Y>
void performOne(const Y& v, const Operator& op) {
this->asArray[i] = op(this->asArray[i], v);
}
template<int i, class Operator, class Y, class OtherDerived>
void performOne(const ColorBase<Y, Base, OtherDerived>& that, const Operator& op) {
this->asArray[i] = op(this->asArray[i], that.asArray[i]);
}
template<int size, class Operator, class Param>
struct performer {
void operator()(ColorBase& l, const Operator& op, const Param& r) {
l.performOne<size - 1>(r, op);
performer<size - 1, Operator, Param>()(l, op, r);
}
};
template<class Operator, class Param>
struct performer<0, Operator, Param> {
void operator()(ColorBase& l, const Operator& op, const Param& r) {
return;
}
};
struct AlphaMul {
T operator()(const T& l, const T& r) const {
return l * r / color_limits<T>::max();
}
};
public:
typedef T data_type;
template<class Operator, class Param>
Derived& perform(const Operator& op, const Param& r) {
performer<processed_size, Operator, Param>()(*this, op, r);
return static_cast<Derived&>(*this);
}
Derived& operator*=(const T& v) {
return perform(Operators<T>::Mul(), v);
}
Derived& operator/=(const T& v) {
return perform(Operators<T>::Div(), v);
}
Derived& operator+=(const Derived& that) {
return perform(Operators<T>::Add(), static_cast<const ColorBase&>(that));
}
Derived& operator-=(const Derived& that) {
return perform(Operators<T>::Sub(), static_cast<const ColorBase&>(that));
}
Derived& alphaMul(const data_type& alpha) {
return perform(AlphaMul(), alpha);
}
};
template<class T, template<class> class B, class D>
D operator+(const ColorBase<T, B, D>& l, const ColorBase<T, B, D>& r) {
return ColorBase<T, B, D>(l) += static_cast<const D&>(r);
}
template<class T, template<class> class B, class D>
D operator-(const ColorBase<T, B, D>& l, const ColorBase<T, B, D>& r) {
return ColorBase<T, B, D>(l) -= static_cast<const D&>(r);
}
template<class T, template<class> class B, class D, class Y>
D operator*(const ColorBase<T, B, D>& l, const Y& r) {
return ColorBase<T, B, D>(l) *= r;
}
template<class T, template<class> class B, class D, class Y>
D operator*(const Y& l, const ColorBase<T, B, D>& r) {
return ColorBase<T, B, D>(r) *= l;
}
template<class T, template<class> class B, class D, class Y>
D operator/(const ColorBase<T, B, D>& l, const Y& r) {
return ColorBase<T, B, D>(l) /= r;
}
/** Class representing RGB triad. */
template<class T>
struct Color3: public ColorBase<T, Color3Data, Color3<T> > {
Color3() { r = g = b = color_limits<T>::min(); }
explicit Color3(const T& v) { r = g = b = v; }
Color3(const T& cr, const T& cg, const T& cb) { r = cr; g = cg; b = cb; }
};
/** Class representing RGBA quad. */
template<class T>
struct Color4: public ColorBase<T, Color4Data, Color4<T> > {
Color4(): { r = g = b = color_limits<T>::min(); a = color_limits<T>::max(); }
explicit Color4(const T& v) { r = g = b = v; a = color_limits<T>::max(); }
Color4(const T& cr, const T& cg, const T& cb, const T& ca = color_limits<T>::max()) { r = cr; g = cg; b = cb; a = ca; }
};
/** This metafunction determines the number of channels in a color type. */
template<class T> struct channels: public arx::int_<1> { STATIC_ASSERT((is_datatype_supported<T>::value)); };
template<class T> struct channels<Color3<T> >: public arx::int_<3> {};
template<class T> struct channels<Color4<T> >: public arx::int_<4> {};
/** This metafunction determines the datatype of a given color type.
* For example, for <tt>Color3<float></tt> it will return <tt>float</tt>. */
template<class T> struct datatype: public arx::identity<T> { STATIC_ASSERT((is_datatype_supported<T>::value)); };
template<class T> struct datatype<Color3<T> >: public arx::identity<T> {};
template<class T> struct datatype<Color4<T> >: public arx::identity<T> {};
/** This metafunction returns color type with the given datatype and number of channels. */
template<class datatype, int channels> struct compose_color;
template<class datatype> struct compose_color<datatype, 1>: public arx::identity<datatype> {};
template<class datatype> struct compose_color<datatype, 3>: public arx::identity<Color3<datatype> > {};
template<class datatype> struct compose_color<datatype, 4>: public arx::identity<Color4<datatype> > {};
/* Color typedefs. */
typedef Color3<float> Color3f;
typedef Color3<unsigned char> Color3b;
typedef Color4<float> Color4f;
typedef Color4<unsigned char> Color4b;
/** This metafunction determines whether the given color type is supported. */
template<class T> struct is_color_supported: public is_datatype_supported<T> {};
template<class T> struct is_color_supported<Color3<T> >: public is_datatype_supported<T> {};
template<class T> struct is_color_supported<Color4<T> >: public is_datatype_supported<T> {};
// -------------------------------------------------------------------------- //
// Color Conversion
// -------------------------------------------------------------------------- //
/** Implementation of <tt>color_cast</tt>.
*
* @see color_cast */
template<class ToColor, class FromColor>
struct color_cast_impl {
typedef typename datatype<ToColor>::type ToDataType;
typedef typename datatype<FromColor>::type FromDataType;
struct cast_C1_C1 {
ToColor operator()(const FromColor& c) {
return static_cast<ToColor>(c * color_limits<ToDataType>::max() / color_limits<FromDataType>::max());
}
};
struct cast_C4_C4 {
ToColor operator()(const FromColor& c) {
return ToColor(color_cast<ToDataType>(c.r), color_cast<ToDataType>(c.g), color_cast<ToDataType>(c.b), color_cast<ToDataType>(c.a));
}
};
struct cast_C1_C34 {
ToColor operator()(const FromColor& c) {
return static_cast<ToColor>(0.299f * color_cast<ToDataType>(c.r) + 0.587f * color_cast<ToDataType>(c.g) + 0.114f * color_cast<ToDataType>(c.b));
}
};
struct cast_C34_C1 {
ToColor operator()(const FromColor& c) {
return ToColor(color_cast<ToDataType>(c));
}
};
struct cast_C34_C34 {
ToColor operator()(const FromColor& c) {
return ToColor(color_cast<ToDataType>(c.r), color_cast<ToDataType>(c.g), color_cast<ToDataType>(c.b));
}
};
struct cast_EQ {
ToColor operator()(const FromColor& c) {
return c;
}
};
template<int toChannels, int fromChannels> struct cast;
template<> struct cast<1, 1>: public cast_C1_C1 {};
template<> struct cast<1, 3>: public cast_C1_C34 {};
template<> struct cast<1, 4>: public cast_C1_C34 {};
template<> struct cast<3, 1>: public cast_C34_C1 {};
template<> struct cast<3, 3>: public cast_C34_C34 {};
template<> struct cast<3, 4>: public cast_C34_C34 {};
template<> struct cast<4, 1>: public cast_C34_C1 {};
template<> struct cast<4, 3>: public cast_C34_C34 {};
template<> struct cast<4, 4>: public cast_C4_C4 {};
ToColor operator()(const FromColor& c) {
return arx::if_<arx::is_same<ToColor, FromColor>, cast_EQ, cast<channels<ToColor>::value, channels<FromColor>::value> >::type()(c);
}
};
/** Cast operator for colors.
*
* @param c Color to convert.
*
* @param ToColor Color type to convert to.
* @param FromColor Color type to convert from. */
template<class ToColor, class FromColor>
ToColor color_cast(const FromColor& c) {
return color_cast_impl<ToColor, FromColor>()(c);
}
// -------------------------------------------------------------------------- //
// Color Operations
// -------------------------------------------------------------------------- //
namespace detail {
/** Implementation of <tt>alpha</tt> function for color types without alpha channel.
*
* @see alpha */
template<class Color, bool isColor4>
struct alpha_impl {
typename datatype<Color>::type operator()(const Color& c) const {
return color_limits<datatype<Color>::type>::max();
}
};
/** Implementation of <tt>alpha</tt> function for <tt>Color4</tt>.
*
* @see alpha */
template<class Color>
struct alpha_impl<Color, true> {
typename datatype<Color>::type operator()(const Color& c) const {
return c.a;
}
};
} // namespace detail
/** @returns Alpha component of the given color, even in case it does not actually have alpha channel. */
template<class Color>
static typename datatype<Color>::type alpha(const Color& c) {
return detail::alpha_impl<Color, channels<Color>::value == 4>()(c);
}
namespace detail {
/** Implementation of <tt>withAlpha</tt> for color types without alpha channel.
*
* @see withAlpha */
template<class Color, bool isColor4>
struct with_alpha_impl {
Color operator()(const Color& c, typename datatype<Color>::type alpha) const {
return c;
}
};
/** Implementation of <tt>withAlpha</tt> for <tt>Color4</tt>.
*
* @see withAlpha */
template<class Color>
struct with_alpha_impl<Color, true> {
Color operator()(const Color& c, typename datatype<Color>::type alpha) const {
return Color(c.r, c.g, c.b, alpha);
}
};
} // namespace detail
/** Replaces alpha component of a given color with a given value.
*
* @param c Color to replace alpha component in.
* @param alpha New value for alpha component.
* @return Newly created color object with alpha component set to the value given. */
template<class Color>
static Color withAlpha(const Color& c, typename datatype<Color>::type alpha) {
return detail::with_alpha_impl<Color, channels<Color>::value == 4>()(c, alpha);
}
namespace detail {
/** Implementation of <tt>alphaMul</tt> for multi-channel color types.
*
* @see alphaMul */
template<class Color, bool isColor1>
struct alpha_mul_impl {
Color operator()(const Color& c, typename datatype<Color>::type alpha) const {
return Color(c).alphaMul(alpha);
}
};
/** Implementation of <tt>alphaMul</tt> for 1-channel color types.
*
* @see alphaMul */
template<class Color>
struct alpha_mul_impl<Color, true> {
Color operator()(const Color& c, typename datatype<Color>::type alpha) const {
return c * alpha / color_limits<c>::max();
}
};
} // namespace detail
/** Implementation of <tt>alphaMul</tt> as a functor.
*
* @see alphaMul */
template<class Color>
struct alpha_mul {
Color operator()(const Color& c, typename datatype<Color>::type alpha) const {
return detail::alpha_mul_impl<Color, channels<Color>::value == 1>()(c, alpha);
}
};
/** Multiplies given color value by a given alpha (opacity) value. Takes result normalization into account.
*
* @param c Color to multiply.
* @param alpha Alpha value. */
template<class Color>
static Color alphaMul(const Color& c, typename datatype<Color>::type alpha) {
return alpha_mul<Color>()(c, alpha);
}
// -------------------------------------------------------------------------- //
// Blend functions
// -------------------------------------------------------------------------- //
/** BlendFunc structure contains all blending functors. */
struct BlendFunc {
struct detail {
/** Conditional functor call. */
template<bool cond, class L, class R, class Op>
struct op_if {
L operator()(const L& l, const R& r, const Op& op) const {
return op(l, r);
}
};
/** Conditional functor call. */
template<class L, class R, class Op>
struct op_if<false, L, R, Op> {
L operator()(const L& l, const R& r, const Op& op) const {
return l;
}
};
/** Performs alpha multiplication if the given condition cond is true.
*
* @see alphaMul */
template<bool cond, class Color>
static Color alphaMulIf(const Color& c, typename datatype<Color>::type alpha) {
return op_if<cond, Color, typename datatype<Color>::type, alpha_mul<Color> >()(c, alpha, alpha_mul<Color>());
}
};
/** OVER implements occlusion blending - r occludes l. <p>
*
* Alpha value: \f$ R_\alpha + (1 - R_\alpha) * L_\alpha \f$ <p>
*
* Color value: \f$ (R * R_\alpha + L * (1 - R_\alpha) * L_\alpha) / Result_\alpha \f$ <p> */
template<bool resultPremul = false, bool lPremul = false, bool rPremul = false>
struct OVER: public detail {
template<class LeftColor, class RightDataType>
LeftColor operator()(const LeftColor& l, const Color4<RightDataType>& r) const {
typedef typename datatype<LeftColor>::type LeftDataType;
const LeftDataType One = color_limits<LeftDataType>::max();
const LeftDataType rAlpha = color_cast<LeftDataType>(alpha(r));
const LeftDataType OneMinusRAlpha = One - rAlpha;
const LeftDataType resultAlpha = rAlpha + OneMinusRAlpha * alpha(l) / One;
return
withAlpha(
alphaMulIf<!resultPremul>(
color_cast<LeftColor>(alphaMulIf<!rPremul>(r, alpha(r))) + alphaMul(alphaMulIf<!lPremul && channels<LeftColor>::value == 4>(l, alpha(l)), OneMinusRAlpha),
sqr(One) / resultAlpha
),
resultAlpha
);
}
};
/** PLUS implements blending without precedence. <p>
*
* Alpha value: \f$ R_\alpha + L_\alpha \f$ <p>
*
* Color value: \f$ (R * R_\alpha + L * L_\alpha) / Result_\alpha \f$ <p> */
template<bool resultPremul = false, bool lPremul = false, bool rPremul = false>
struct PLUS: public detail {
template<class LeftColor, class RightDataType>
LeftColor operator()(const LeftColor& l, const Color4<RightDataType>& r) const {
typedef typename datatype<LeftColor>::type LeftDataType;
const LeftDataType One = color_limits<LeftDataType>::max();
const LeftDataType resultAlpha = alpha(l) + color_cast<LeftDataType>(alpha(r));
return
withAlpha(
alphaMulIf<!resultPremul>(
alphaMulIf<!lPremul && channels<LeftColor>::value == 4>(l, alpha(l)) + color_cast<LeftColor>(alphaMulIf<!rPremul>(r, alpha(r))),
sqr(One) / resultAlpha
),
resultAlpha
);
}
};
/** NOBLEND implements normal drawing without blending. <p>
*
* Alpha value: \f$ R_\alpha \f$ <p>
*
* Color value: \f$ R \f$ <p> */
struct NOBLEND {
template<class LeftColor, class RightColor>
LeftColor operator()(const LeftColor& l, const RightColor& r) const {
return color_cast<LeftColor>(r);
}
};
};
// -------------------------------------------------------------------------- //
// Forwards
// -------------------------------------------------------------------------- //
template<class Color, class Derived, bool derivedMaterialized> class GenericImageBase;
class Image3b;
// -------------------------------------------------------------------------- //
// Protectors
// -------------------------------------------------------------------------- //
/** Using this metafunction, expression types can protect materialized types from writing during
* expression evaluation. This is done by storing them by value, not by reference. By-value storage
* increments reference counter of materialized type, and therefore prohibits writing to it. */
template<class T> struct WriteProtected {
typedef typename arx::if_c<T::materialized, T, T&>::type type;
};
/** Using this metafunction, expression types can protect materialized types from writing during
* expression evaluation basing on run-time conditions. Type returned by this metafunction will not
* always be readable, but it will always be constructible from T and T-assignable. */
template<class T> struct WriteProtectedUnreadable {
struct Nothing { Nothing() {} Nothing(const T&) {} Nothing& operator=(const T& that) { return *this; } };
typedef typename arx::if_c<T::materialized, T, Nothing>::type type;
};
// -------------------------------------------------------------------------- //
// Expressions
// -------------------------------------------------------------------------- //
/** Expression for image difference. */
template<class L, class R> class GenericImageDifference: public GenericImageBase<typename L::color_type, GenericImageDifference<L, R>, false> {
private:
const L& l;
const R& r;
STATIC_ASSERT((arx::is_same<typename L::color_type, typename R::color_type>::value));
public:
typedef typename L::color_type color_type;
GenericImageDifference(const L& l, const R& r): l(l), r(r) {
if(l.getWidth() != r.getWidth() || l.getHeight() != r.getHeight())
throw std::runtime_error("Could not subtract images with different sizes.");
}
int getWidth() const { return l.getWidth(); }
int getHeight() const { return l.getHeight(); }
color_type getPixelInterpolated(float x, float y) const {
return l.getPixelInterpolated(x, y) - r.getPixelInterpolated(x, y);
}
color_type getPixel(int x, int y) const {
return l.getPixel(x, y) - r.getPixel(x, y);
}
};
/** Expression for image resizing. */
template<class L> class GenericImageResize: public GenericImageBase<typename L::color_type, GenericImageResize<L>, false> {
private:
float widthRatio;
float heightRatio;
int height;
int width;
const L& l;
/** In case we're upscaling, we need to protect ourselves from the cases like <tt>img = img.resize(2, 2)</tt> when there is enough place in
* image internal buffer. Such assignment will write pixels ahead, giving a mess instead of a desired result. */
typename WriteProtectedUnreadable<L>::type protection;
public:
typedef typename L::color_type color_type;
GenericImageResize(const L& l, float widthRatio, float heightRatio): l(l), widthRatio(widthRatio), heightRatio(heightRatio) {
/* TODO: check these values... */
static const float epsMod = 1.0e-5f;
static const float epsCheck = 1.0e-4f;
if(widthRatio <= 0 || heightRatio <= 0)
throw std::runtime_error("Could not resize with non-positive scale factor.");
/* Protect from write-ahead. */
if(widthRatio > 1 || heightRatio > 1)
protection = l;
/* Calculate target size. */
this->width = std::max(1, (int) (l.getWidth() * widthRatio));
this->height = std::max(1, (int) (l.getHeight() * heightRatio));
/* Problem: with calls to getPixelInterpolated we must stay in [0, W) x [0, H) rectangle.
* This is resolved by slightly tweaking the factors... */
if(width > 1 && (width - 1) / widthRatio > l.getWidth() - 1 - epsCheck)
this->widthRatio = (float) (width - 1) / (l.getWidth() - 1) + epsMod;
if(height > 1 && (height - 1) / heightRatio > l.getHeight() - 1 - epsCheck)
this->heightRatio = (float) (height - 1) / (l.getHeight() - 1) + epsMod;
}
int getWidth() const { return this->width; }
int getHeight() const { return this->height; }
color_type getPixelInterpolated(float x, float y) const {
return l.getPixelInterpolated(x / widthRatio, y / heightRatio); /* TODO: try to replace / with * and test */
}
color_type getPixel(int x, int y) const {
return l.getPixelInterpolated(x / widthRatio, y / heightRatio); /* TODO: try to replace / with * and test */
}
};
/** Expression for image downscaling with constant integer factor. */
template<class L, int n> class GenericImageResizeDownNx: public GenericImageBase<typename L::color_type, GenericImageResizeDownNx<L, n>, false> {
private:
const L& l;
STATIC_ASSERT((n > 0));
public:
typedef typename L::color_type color_type;
GenericImageResizeDownNx(const L& l): l(l) {}
int getWidth() const { return std::max(1, l.getWidth() / n); }
int getHeight() const { return std::max(1, l.getHeight() / n); }
color_type getPixelInterpolated(float x, float y) const {
return l.getPixelIterpolated(x * n, y * n);
}
color_type getPixel(int x, int y) const {
return l.getPixel(x * n, y * n);
}
};
/** Expression for image color conversion. */
template<class L, class ToColor> class GenericImageConvert: public GenericImageBase<ToColor, GenericImageConvert<L, ToColor>, false> {
private:
const L& l;
public:
typedef ToColor color_type;
GenericImageConvert(const L& l): l(l) {}
int getWidth() const { return l.getWidth(); }
int getHeight() const { return l.getHeight(); }
color_type getPixelInterpolated(float x, float y) const {
return color_cast<color_type>(l.getPixelInterpolated(x, y));
}
color_type getPixel(int x, int y) const {
return color_cast<color_type>(l.getPixel(x, y));
}
};
// -------------------------------------------------------------------------- //
// Image Compositions
// -------------------------------------------------------------------------- //
/** Composition of a color from one image and alpha channel from another. */
template<class DataType, class ColorSource, class AlphaSource> class ImageAlphaComposition:
public GenericImageBase<Color4<DataType>, ImageAlphaComposition<DataType, ColorSource, AlphaSource>, false> {
private:
const ColorSource& color;
const AlphaSource& alpha;
STATIC_ASSERT((channels<typename AlphaSource::color_type>::value == 1));
public:
typedef Color4<DataType> color_type;
ImageAlphaComposition(const ColorSource& color, const AlphaSource& alpha): color(color), alpha(alpha) {
if(color.getWidth() != alpha.getWidth() || color.getHeight() != alpha.getHeight())
throw std::runtime_error("Could not compose images with different sizes.");
}
int getWidth() const { return alpha.getWidth(); }
int getHeight() const { return alpha.getHeight(); }
color_type getPixelInterpolated(float x, float y) const {
return withAlpha(color_cast<color_type>(color.getPixelInterpolated(x, y)), color_cast<DataType>(alpha.getPixelInterpolated(x, y)));
}
color_type getPixel(int x, int y) const {
return withAlpha(color_cast<color_type>(color.getPixel(x, y)), color_cast<DataType>(alpha.getPixel(x, y)));
}
};
/** Factory function for ImageAlphaComposition.
*
* @see ImageAlphaComposition */
template<class DataType, class ColorSource, class AlphaSource>
ImageAlphaComposition<DataType, ColorSource, AlphaSource> createImageAlphaComposition(const ColorSource& color, const AlphaSource& alpha) {
return ImageAlphaComposition<DataType, ColorSource, AlphaSource>(color, alpha);
}
/** Constant image. */
template<class Color> class ImageConstComposition: public GenericImageBase<Color, ImageConstComposition<Color>, false> {
private:
Color color;
int width;
int height;
public:
typedef Color color_type;
ImageConstComposition(int width, int height, const Color& color): color(color), width(width), height(height) {}
int getWidth() const { return width; }
int getHeight() const { return height; }
color_type getPixelInterpolated(float x, float y) const {
return color;
}
color_type getPixel(int x, int y) const {
return color;
}
};
/** Factory function for ImageConstComposition.
*
* @see ImageConstComposition */
template<class Color>
ImageConstComposition<Color> createImageConstComposition(int width, int height, const Color& color) {
return ImageConstComposition<Color>(width, height, color);
}
// -------------------------------------------------------------------------- //
// Image Conversion
// -------------------------------------------------------------------------- //
/** This metafunction returns whether the given class is an image class (i.e. derived from GenericImageBase).
* It may not work correctly in some cases, however, and is used only to distinguish color and image classes. */
template<class Class>
struct is_image {
template<class ToColor, class Derived, bool materialized>
static char check(const GenericImageBase<ToColor, Derived, materialized>& that);
static int check(...);
static Class c;
enum { value = sizeof(check(c)) == sizeof(char) };
};
/** Implementation of image_cast for conversion to given color type. Returns expression template, no actual image allocation is performed.
* Specialize if you need special behavior for conversion between some of the color type combinations. */
template<class FromImage, class ToColor, class FromColor>
struct image_cast_impl_base {
typedef GenericImageConvert<FromImage, ToColor> return_type;
return_type operator()(const FromImage& that) const {
return return_type(that);
}
};
namespace detail {
/** Implementation of image_cast for conversion to given image type. Converts given image to ToImage type, allocating memory for it if necessary.
* Actual implementation calls image_cast to color type. */
template<class ToImage, class FromImage, bool is_image>
struct image_cast_impl2 {
typedef ToImage return_type;
return_type operator()(const FromImage& that) const {
return_type result = image_cast<ToImage::color_type>(that);
return result;
}
};
/** Implementation of image_cast for conversion to given color type. Delegates everything to image_cast_impl_base.
*
* @see image_cast_impl_base */
template<class ToColor, class FromImage>
struct image_cast_impl2<ToColor, FromImage, false>: public image_cast_impl_base<FromImage, ToColor, typename FromImage::color_type> {};
} // namespace detail
/** Default implementation of color_cast - determines whether casting to color or to an image type and delegates everything to image_cast_impl2.
* Specialize if you need special behavior. */
template<class ToImageOrColor, class FromImage>
struct image_cast_impl {
typedef detail::image_cast_impl2<ToImageOrColor, FromImage, is_image<ToImageOrColor>::value> impl;
typedef typename impl::return_type return_type;
return_type operator()(const FromImage& that) const {
return impl()(that);
}
};
/** Cast operator for images. Image can be casted to another image type, or to a color type. If casting to an image type,
* memory will be allocated if necessary. Cast to color type will return expression template, which means that no allocation will be performed.
*
* @param ToImageOrColor Image or color type to convert to.
* @param FromImage Image type to convert from. */
template<class ToImageOrColor, class FromImage>
typename image_cast_impl<ToImageOrColor, FromImage>::return_type image_cast(const FromImage& that) {
return image_cast_impl<ToImageOrColor, FromImage>()(that);
}
// -------------------------------------------------------------------------- //
// Allocators
// -------------------------------------------------------------------------- //
/** Helper functor that wraps several ippiMalloc functions and gives a convenient interface
* to access them not by name, but by pixel size. Dispatch is done statically, via template
* specialization. Default implementation for non-standard pixel sizes is also provided. <p>
*
* @param size Pixel size in bytes. */
template<unsigned int pixel_size> struct ImageAllocator {
void* operator()(int widthPixels, int heightPixels, int* pStepBytes) const {
*pStepBytes = (widthPixels * pixel_size + 32 - 1) & -32;
return aligned_malloc(*pStepBytes * heightPixels, 32);
}
void operator()(void* ptr) const {
aligned_free(ptr);
}
};
#ifdef USE_IPPI_MALLOC
# define SPECIALIZE_IPPIMALLOC(SIZE, NAME) \
template<> struct ImageAllocator<SIZE> { \
void* operator()(int widthPixels, int heightPixels, int* pStepBytes) { \
return static_cast<void*>(NAME(widthPixels, heightPixels, pStepBytes)); \
} \
void operator()(void* ptr) { \
ippiFree(ptr); \
} \
};
SPECIALIZE_IPPIMALLOC(1, ippiMalloc_8u_C1)
SPECIALIZE_IPPIMALLOC(2, ippiMalloc_16u_C1)
SPECIALIZE_IPPIMALLOC(3, ippiMalloc_8u_C3)
SPECIALIZE_IPPIMALLOC(4, ippiMalloc_32f_C1)
SPECIALIZE_IPPIMALLOC(6, ippiMalloc_16u_C3)
SPECIALIZE_IPPIMALLOC(8, ippiMalloc_32f_C2)
SPECIALIZE_IPPIMALLOC(12, ippiMalloc_32f_C3)
SPECIALIZE_IPPIMALLOC(16, ippiMalloc_32f_C4)
# undef SPECIALIZE_IPPIMALLOC
#endif
// -------------------------------------------------------------------------- //
// Deallocators
// -------------------------------------------------------------------------- //
/** Abstract base class for image deallocators. */
class ImageDeallocator {
public:
virtual void operator()() = 0;
};
/** ImageDeallocator that does nothing - useful for creating "views" into other image types. */
class EmptyImageDeallocator: public ImageDeallocator {
public:
virtual void operator()() {};
};
/** ImageDeallocator that uses the same routine as GenericImageData class.
*
* @param size Pixel size in bytes.
*
* @see ImageAllocator */
template<int pixel_size>
class DefaultImageDeallocator {
private:
void* pixels;
public:
DefaultImageDeallocator(void* pixels): pixels(pixels) {}
virtual void operator()() {
/* We're presuming that ImageAllocator is stateless. */
ImageAllocator<pixel_size>()(this->pixels);
}
};
#ifdef USE_OPENCV
/** ImageDeallocator for IplImage class. Used for implementation of "strict ownership" semantics. */
class IplDeallocator: public ImageDeallocator {
private:
IplImage* iplImage;
public:
IplDeallocator(IplImage* iplImage): iplImage(iplImage) {}
virtual void operator()() {
cvReleaseImage(&this->iplImage);
}
};
#endif
// -------------------------------------------------------------------------- //
// GenericImageData
// -------------------------------------------------------------------------- //
/** Internal class that stores all image information and handles data allocation and deallocation.
*
* @param pixel_size Size of a single image pixel in bytes. */
template<int pixel_size>
struct GenericImageData: public arx::noncopyable {
void* pixels; /**< Pointer to pixel buffer. */
int width; /**< Width of an image in pixels. */
int height; /**< Height of an image in pixels. */
int bufferWidth; /**< Width of an image buffer in pixels. */
int bufferHeight; /**< Height of an image buffer in pixels. */
int wStep; /**< Size of aligned image row in bytes. */
ImageDeallocator* deallocator; /**< ImageDeallocator to use with this image. */
/** Constructor. */
GenericImageData(int width, int height): width(width), height(height), deallocator(NULL) {
assert(width > 0 && height > 0);
/* Allocate memory. */
this->pixels = ImageAllocator<pixel_size>()(width, height, &this->wStep);
/* Store actual buffer size. */
this->bufferHeight = this->height;
this->bufferWidth = this->wStep / pixel_size;
}
/** Constructor. */
GenericImageData(int width, int height, int wStep, void* pixels, ImageDeallocator* deallocator):
width(width), height(height), wStep(wStep), pixels(pixels), deallocator(deallocator) {
assert(width > 0 && height > 0 && wStep >= (width * pixel_size) && pixels != NULL);
}
/** Destructor. */
~GenericImageData() {
if(deallocator == NULL) {
ImageAllocator<pixel_size>()(this->pixels);
} else {
(*this->deallocator)();
delete this->deallocator;
}
}
};
// -------------------------------------------------------------------------- //
// GenericImage
// -------------------------------------------------------------------------- //
/** Base class for all images. Can be used directly, or derived from.
*
* @param Color Class representing single pixel in an image.
* @param Derived Derived class, if any. */
template<class Color, class Derived = void> class GenericImage:
public GenericImageBase<Color, typename arx::if_<arx::is_same<Derived, void>, GenericImage<Color, Derived>, Derived>::type, true> {
public:
typedef Color color_type; /**< Type of a single pixel. */
enum { pixel_size = sizeof(color_type) /**< Size in bytes of a single pixel. */ };
typedef typename datatype<color_type>::type color_data_type; /**< Type of one channel of a pixel. */
protected:
typedef GenericImage base_type; /**< Base type for easy access in derived classes. */
typedef GenericImageData<pixel_size> storage_type; /**< Storage type. */
typedef typename arx::if_<arx::is_same<Derived, void>, base_type, Derived>::type derived_type; /**< Derived type, or this type, if none. */
private:
arx::shared_ptr<storage_type> data; /**< Shared data. */
template<class OtherColor, class OtherDerived> friend class GenericImage;
protected:
/** @return reference to pixel at (x, y) */
color_type& getPixelReference(int x, int y) const {
assert(x >= 0 && y >= 0 && x < this->data->width && y < this->data->height);
return *reinterpret_cast<color_type*>(reinterpret_cast<char*>(this->data->pixels) + y * this->data->wStep + x * pixel_size);
}
/** Sets the pixel at (x, y) to given value. If the pixel lies outside the image boundaries, does nothing. */
void checkedSetPixel(int x, int y, const color_type& value) {
if(x < 0 || x >= this->data->width || y < 0 || y >= this->data->height)
return;
setPixel(x, y, value);
}
#if defined(ARX_USE_IPPI) || defined(ARX_USE_CIPPIMAGE)
/** Factory function for IppiSize */
static IppiSize ippiSize(int width, int height) {
IppiSize size = {width, height};
return size;
}
/** Factory function for IppiRect */
static IppiRect ippiRect(int x, int y, int width, int height) {
IppiRect rect = {x, y, width, height};
return rect;
}
#endif
public:
/** Constructor. Creates uninitialized image. */
GenericImage() {}
/** Constructor. Allocates an image of size width x height.
*
* @param width Image width in pixels.
* @param height Image height in pixels. */
GenericImage(int width, int height): data(new storage_type(width, height)) {}
/** Constructor. Does not allocate image data buffer, but uses provided one instead.
* You can implement ownership semantics by providing appropriate deallocator.
* Please note that in case deallocator == NULL, standard deallocation routine is used.
*
* @param width Image width in pixels.
* @param height Image height in pixels.
* @param wStep Size of aligned image row in bytes.
* @param pixels Pointer to image data buffer.
* @param deallocator ImageDeallocator to use with this image instance. */
GenericImage(int width, int height, int wStep, void* pixels, ImageDeallocator* deallocator):
data(new storage_type(width, height, wStep, pixels, deallocator)) {}
/** @return true if image data is allocated, false otherwise. */
bool isNull() const { return this->data.get() == NULL; }
/** @return Image width in pixels. */
int getWidth() const { return this->data->width; }
/** @return Image height in pixels. */
int getHeight() const { return this->data->height; }
/** @return Size of aligned image row in bytes. */
int getWStep() const { return this->data->wStep; }
/** @return Pointer to image row y. */
const color_type* getRow(int y) const { return &getPixelReference(0, y); }
/** @return Pointer to image row y. */
color_type* getRow(int y) { return &getPixelReference(0, y); }
/** @return Pointer to image data buffer. */
const color_data_type* getPixelData() const { return (color_data_type *) &getPixelReference(0, 0); }
/** @return Pointer to image data buffer. */
color_data_type* getPixelData() { return (color_data_type *) &getPixelReference(0, 0); }
/** @return Pointer to pixel at (x, y). */
const color_data_type* getPixelDataAt(int x, int y) const { return (color_data_type *) &getPixelReference(x, y); }
/** @return Pointer to pixel at (x, y). */
color_data_type* getPixelDataAt(int x, int y) { return (color_data_type *) &getPixelReference(x, y); }
#if defined(USE_IPPI) || defined(USE_CIPPIMAGE)
/** @return IppiSize of this image. */
IppiSize getIppiSize() const { return ippiSize(this->data->width, this->data->height); }
/** @return IppiRect containing this image. */
IppiRect getIppiRect() const { return ippiRect(0, 0, this->data->width, this->data->height); }
#endif
/** @return Pixel at (x, y), interpolated linearly. */
color_type getPixelInterpolated(float x, float y) const {
int ix = (int) x;
int iy = (int) y;
float fx = x - ix;
float fy = y - iy;
return (1 - fy) * ((1 - fx) * getPixel(ix, iy ) + fx * getPixel(ix + 1, iy )) +
fy * ((1 - fx) * getPixel(ix, iy + 1) + fx * getPixel(ix + 1, iy + 1));
}
/** @return Pixel at (x, y). */
const color_type& getPixel(int x, int y) const {
return getPixelReference(x, y);
}
/** Sets the pixel at (x, y) to value. */
void setPixel(int x, int y, const color_type& value) {
getPixelReference(x, y) = value;
}
/** Draws a line that connects two points (x1, y1) and (x2, y2) using the given color value. */
void drawLine(int x1, int y1, int x2, int y2, const color_type& value) {
int dx, dy;
if(x1 == x2 && y1 == y2) {
checkedSetPixel(x1, y1, value);
} else if(abs(x2 - x1) > abs(y2 - y1)) {
if(x1 > x2) {
std::swap(x1, x2);
std::swap(y1, y2);
}
dx = x2 - x1;
dy = y2 - y1;
for(int i = x1; i <= x2; i++)
checkedSetPixel(i, y1 + (i - x1) * dy / dx, value);
} else {
if(y1 > y2) {
std::swap(x1, x2);
std::swap(y1, y2);
}
dx = x2 - x1;
dy = y2 - y1;
for(int i = y1; i <= y2; i++)
checkedSetPixel(x1 + (i - y1) * dx / dy, i, value);
}
}
/** Loads an image from a file. */
static derived_type loadFromFile(const std::string& fileName) {
return Image3b::loadFromFile(fileName).convert<color_type>();
}
/** Sets all pixels of an image to a value.
*
* @param value Constant value assigned to each pixel in the image. */
void fill(const color_type& value) {
for(int y = 0; y < this->getHeight(); y++)
for(int x = 0; x < this->getWidth(); x++)
this->setPixel(x, y, value);
}
/** Draws the given image on this image, so that the upper-left corner of the given image is drawn at (x, y).
* Takes alpha component into account.
*
* @param that Image to draw.
* @param x, y Coordinates of an upper-left corner of the given image relative to this image.
* @param blendFunc Blending function to use. */
template<class OtherColor, class OtherDerived, bool otherMaterialized, class BlendFunction>
void drawBlended(const GenericImageBase<OtherColor, OtherDerived, otherMaterialized>& givenThat, int x, int y, const BlendFunction& blendFunc) {
const OtherDerived& that = static_cast<const OtherDerived&>(givenThat);
int x0 = x, x1 = min(x + that.getWidth(), this->getWidth());
int y0 = y, y1 = min(y + that.getHeight(), this->getHeight());
for(int iy = y0; iy < y1; iy++)
for(int ix = x0; ix < x1; ix++)
this->setPixel(ix, iy, blendFunc(this->getPixel(ix, iy), that.getPixel(ix - x, iy - y)));
}
/** Draws the given image on this image, so that the upper-left corner of the given image is drawn at (x, y).
*
* @param that Image to draw.
* @param x, y Coordinates of an upper-left corner of the given image relative to this image. */
template<class OtherColor, class OtherDerived, bool otherMaterialized>
void draw(const GenericImageBase<OtherColor, OtherDerived, otherMaterialized>& that, int x, int y) {
return drawBlended(that, x, y, BlendFunc::NOBLEND());
}
/** Convenient overload for standard non-premultiplied occlusion blending. Uses BlendFunc::OVER<> as blending function.
*
* @param that Image to draw.
* @param x, y Coordinates of an upper-left corner of the given image relative to this image.
*
* @see drawBlended */
template<class OtherDataType, class OtherDerived, bool otherMaterialized>
void drawBlended(const GenericImageBase<Color4<OtherDataType>, OtherDerived, otherMaterialized>& that, int x, int y) {
drawBlended(that, x, y, BlendFunc::OVER<>());
}
/** Draws the given image on this image using the given matrix for coordinate transformation.
* Takes alpha component into account.
*
* @param that Image to draw.
* @param m Transformation matrix.
* @param blendFunc Blending function to use. */
template<class OtherColor, class OtherDerived, bool otherMaterialized, class BlendFunction>
void drawBlended(const GenericImageBase<OtherColor, OtherDerived, otherMaterialized>& givenThat, const arx::Matrix3f& m, const BlendFunction& blendFunc) {
using namespace arx;
using namespace std;
const OtherDerived& that = static_cast<const OtherDerived&>(givenThat);
Vector3f v[4];
v[0] = m * Vector3f(0, 0, 1);
v[1] = m * Vector3f((float) that.getWidth(), 0, 1);
v[2] = m * Vector3f((float) that.getWidth(), (float) that.getHeight(), 1);
v[3] = m * Vector3f(0, (float) that.getHeight(), 1);
for(int i = 0; i < 4; i++)
v[i] /= v[i][2];
int x0 = (int) max(min(min(v[0][0], v[1][0]), min(v[2][0], v[3][0])), 0.0f);
int x1 = (int) min(max(max(v[0][0], v[1][0]), max(v[2][0], v[3][0])) + 1.0f, (float) this->getWidth());
int y0 = (int) max(min(min(v[0][1], v[1][1]), min(v[2][1], v[3][1])), 0.0f);
int y1 = (int) min(max(max(v[0][1], v[1][1]), max(v[2][1], v[3][1])) + 1.0f, (float) this->getHeight());
Matrix3f m_1 = m.inverse();
for(int y = y0; y < y1; y++) {
for(int x = x0; x < x1; x++) {
Vector3f v = m_1 * Vector3f((float) x, (float) y, 1);
v /= v[2];
if(v[0] >= 0 && v[0] < that.getWidth() - 1 && v[1] >= 0 && v[1] < that.getHeight() - 1)
this->setPixel(x, y, blendFunc(this->getPixel(x, y), that.getPixelInterpolated(v[0], v[1])));
}
}
}
/** Draws the given image on this image using the given matrix for coordinate transformation.
*
* @param that Image to draw.
* @param m Transformation matrix. */
template<class OtherColor, class OtherDerived, bool otherMaterialized>
void draw(const GenericImageBase<OtherColor, OtherDerived, otherMaterialized>& that, const arx::Matrix3f& m) {
drawBlended(that, m, BlendFunc::NOBLEND());
}
/** Convenient overload for standard non-premultiplied occlusion blending. Uses BlendFunc::OVER<> as blending function.
*
* @param that Image to draw.
* @param m Transformation matrix.
*
* @see drawBlended */
template<class OtherColor, class OtherDerived, bool otherMaterialized>
void drawBlended(const GenericImageBase<OtherColor, OtherDerived, otherMaterialized>& that, const arx::Matrix3f& m) {
drawBlended(that, m, BlendFunc::OVER<>());
}
/** Like operator=, but always performs copying. */
template<class OtherDerived, bool otherMaterialized>
derived_type& assign(const GenericImageBase<color_type, OtherDerived, otherMaterialized>& givenThat) {
const OtherDerived& that = static_cast<const OtherDerived&>(givenThat);
/* Check whether it's possible to use our current memory. If not, allocate new. */
if(!this->data || !this->data.unique() || this->data->bufferWidth < that.getWidth() || this->data->bufferHeight < that.getHeight())
this->data.reset(new storage_type(that.getWidth(), that.getHeight()));
/* Assign. */
for(int y = 0; y < that.getHeight(); y++)
for(int x = 0; x < that.getWidth(); x++)
this->setPixel(x, y, that.getPixel(x, y));
/* Change size. We need to do it AFTER assignment because it can be referenced from inside the expression.
* It is not needed in case we have allocated data anew, but I don't see any point in protecting it with if. */
this->data->width = that.getWidth();
this->data->height = that.getHeight();
return this->derived();
}
/** Image assignment. */
template<class OtherDerived, bool otherMaterialized>
derived_type& operator= (const GenericImageBase<color_type, OtherDerived, otherMaterialized>& givenThat) {
const OtherDerived& that = static_cast<const OtherDerived&>(givenThat);
/*if(this->getWidth() != that.getWidth() || this->getHeight() != that.getHeight())
throw std::runtime_error("Could not assign images with different sizes.");*/
if(otherMaterialized) {
/* If we're both materialized then it's just pointer assignment. */
this->data = that.materialize().data; /* We use materialize() just to make the compiler happy. It does nothing here. */
} else {
/* Else perform data copying. */
this->assign(that);
}
return this->derived();
}
/** We need to override default operator=. */
derived_type& operator= (const GenericImage& that) {
return this->operator=<derived_type, true>(that);
}
/** Image copy construction. */
template<class OtherDerived, bool otherMaterialized>
GenericImage(const GenericImageBase<color_type, OtherDerived, otherMaterialized>& that) {
*this = that;
}
/** We need to override default copy constructor. */
GenericImage(const GenericImage& that) {
*this = that;
}
};
// -------------------------------------------------------------------------- //
// GenericImageBase
// -------------------------------------------------------------------------- //
/** Base class for all image expressions.
*
* @param Color Class representing single pixel in an image.
* @param Derived Derived class. Must define getWidth, getHeight, getPixel, getPixelInterpolated.
* @param derivedMaterialized Is derived class materialized? */
template<class Color, class Derived, bool derivedMaterialized> class GenericImageBase {
public:
/** Type of a single pixel of an image. */
typedef Color color_type;
/** Determines whether Derived class provides materialized interface (i.e. direct data manipulation routines). */
enum { materialized = derivedMaterialized };
private:
struct materialize_materialized {
Derived& operator()(GenericImageBase& that) const {
assert(materialized);
return that.derived();
}
};
struct materialize_unmaterialized {
GenericImage<color_type> operator()(GenericImageBase& that) const {
assert(!materialized);
GenericImage<color_type> result = that.derived();
return result;
}
};
template<class OtherColor, class OtherDerived, bool otherMaterialized> friend class GenericImageBase;
protected:
/** Downcasts GenericImageBase to Derived class. */
Derived& derived() { return *static_cast<Derived*>(this); }
/** Downcasts GenericImageBase to Derived class. */
const Derived& derived() const { return *static_cast<const Derived*>(this); }
typedef typename arx::if_c<materialized, Derived, GenericImage<color_type> >::type materialized_type;
/* For materialize() - it must return a reference to current image instance. */
typedef typename arx::if_c<materialized, materialized_type&, materialized_type>::type materialized_ref_type;
typedef typename arx::if_c<materialized, const materialized_type&, materialized_type>::type materialized_const_ref_type;
/** Returns suitable size of a Gaussian kernel for the given sigma (standard deviation of the Gaussian distribution). */
static int getGaussianKernelSize(float sigma) {
return max(3, ((int) (sigma * ARX_GAUSS_TRUNCATE)) * 2 + 1);
}
public:
/** Performs image subtraction.
*
* @param that Image to subtract.
* @return Newly created image containing difference. */
template<class OtherDerived, bool otherMaterialized>
GenericImageDifference<Derived, OtherDerived> sub(const GenericImageBase<color_type, OtherDerived, otherMaterialized>& that) const {
return GenericImageDifference<Derived, OtherDerived>(this->derived(), that.derived());
}
/** Resizes the image.
*
* @param widthRatio Factor by which the x dimension of the image is changed.
* @param heightRatio Factor by which the y dimension of the image is changed.
* @return Newly created resized image. */
GenericImageResize<Derived> resize(float widthRatio, float heightRatio) const {
return GenericImageResize<Derived>(this->derived(), widthRatio, heightRatio);
}
/** Downscales an image by a factor of 2 using nearest neighbour interpolation.
*
* @return Newly created downscaled image. */
template<int n>
GenericImageResizeDownNx<Derived, n> resizeDownNN() const {
return GenericImageResizeDownNx<Derived, n>(this->derived());
}
/** Filters an image using a Gaussian kernel.
*
* @param sigma Standard deviation of the Gaussian distribution.
* @return Newly created filtered image. */
materialized_type gaussianBlur(float sigma) const {
materialized_type me = this->derived().materialize(); /* Because we reference each pixel several times. */
typedef typename compose_color<float, channels<color_type>::value>::type pixel_super_type;
int kernelSize = min(199, getGaussianKernelSize(sigma));
float kernel[200], sum = 0.0f;
for(int i = 0; i <= kernelSize; i++) {
int x = i - kernelSize / 2;
kernel[i] = exp(- x * x / (2.0f * sigma * sigma));
sum += kernel[i];
}
for(int i = 0; i < kernelSize; i++)
kernel[i] /= sum;
materialized_type tmp(me.getWidth(), me.getHeight());
tmp.fill(color_type());
for(int y = 0; y < me.getHeight(); y++) {
for(int x = 0; x < me.getWidth(); x++) {
float sum = 0.0f;
int x0 = max(0, x - kernelSize / 2);
int x1 = min(me.getWidth(), x + kernelSize / 2 + 1);
pixel_super_type pixel = pixel_super_type();
for(int xx = x0; xx < x1; xx++) {
pixel = pixel + pixel_super_type(me.getPixel(xx, y)) * kernel[kernelSize / 2 + xx - x];
sum += kernel[kernelSize / 2 + xx - x];
}
tmp.setPixel(x, y, color_type(pixel / sum));
}
}
materialized_type result(me.getWidth(), me.getHeight());
result.fill(color_type());
for(int y = 0; y < me.getHeight(); y++) {
for(int x = 0; x < me.getWidth(); x++) {
float sum = 0.0f;
int y0 = max(0, y - kernelSize / 2);
int y1 = min(me.getHeight(), y + kernelSize / 2 + 1);
pixel_super_type pixel = pixel_super_type();
for(int yy = y0; yy < y1; yy++) {
pixel = pixel + pixel_super_type(tmp.getPixel(x, yy)) * kernel[kernelSize / 2 + yy - y];
sum += kernel[kernelSize / 2 + yy - y];
}
result.setPixel(x, y, color_type(pixel / sum));
}
}
return result;
}
/** Materializes an image, i.e. allocates in image buffer in case it didn't existed to allow direct data manipulation.
*
* @return Materialized copy of this image in case it wasn't materialized, or image itself otherwise. */
materialized_ref_type materialize() {
return arx::if_c<materialized, materialize_materialized, materialize_unmaterialized>::type()(*this);
}
/** Materializes an image, i.e. allocates in image buffer in case it didn't existed to allow direct data manipulation.
*
* @return Materialized copy of this image in case it wasn't materialized, or image itself otherwise. */
materialized_const_ref_type materialize() const {
return const_cast<GenericImageBase*>(this)->materialize();
}
/** Works like materialize, but always allocates a new image.
*
* @return Newly allocated copy of this image. */
materialized_type clone() const {
materialized_type result;
result.assign(this->derived());
return result;
}
/** Converts this image to another color type. Use image_cast if you need to convert to another image type.
*
* @param OtherColor Color type to convert to. */
template<class OtherColor>
typename image_cast_impl_base<Derived, OtherColor, color_type>::return_type convert() const {
STATIC_ASSERT((!is_image<OtherColor>::value)); /* We better prohibit it. */
return image_cast_impl_base<Derived, OtherColor, color_type>()(this->derived());
}
/** Saves an image to a file. */
void saveToFile(const std::string& fileName) const {
image_cast<Image3b>(this->derived()).saveToFile(fileName);
}
int getWidth() const { return derived().getWidth(); }
int getHeight() const { return derived().getHeight(); }
color_type getPixelInterpolated(float x, float y) const {
return derived().getPixelInterpolated(x, y);
}
color_type getPixel(int x, int y) const {
return derived().getPixel(x, y);
}
};
// -------------------------------------------------------------------------- //
// BMP loading & saving
// -------------------------------------------------------------------------- //
namespace detail {
#pragma pack(push, 1)
struct BMPHeader {
short type; /**< File type = 0x4D42 */
int size;
short reserved1;
short reserved2;
int offset; /**< Offset from file start to bitmap data */
};
struct BMPInfoHeader {
int size; /**< Size of this structure in bytes */
int width;
int height;
short planes; /**< Should be equal to 1 */
short bitsPerPixel;
unsigned compression; /**< Compression flags ( 0 - no compression ) */
unsigned imageSize; /**< Size of image in bytes */
int xPelsPerMeter;
int yPelsPerMeter;
int clrUsed;
int clrImportant;
};
struct BMPPaletteItem {
unsigned char blue;
unsigned char green;
unsigned char red;
unsigned char unused;
};
#pragma pack(pop)
template<class Derived>
inline GenericImage<Color3b, Derived> loadBmp24bit(const std::string& fileName) {
BMPHeader hdr;
BMPInfoHeader infoHdr;
std::ifstream f(fileName.c_str(), std::ios_base::in | std::ios_base::binary);
if(!f.is_open())
throw std::runtime_error("Could not open image file \"" + fileName + "\"");
std::string errorMsg = "Error while reading image file \"" + fileName + "\": ";
if(f.read((char *) &hdr, sizeof(hdr)).gcount() != sizeof(hdr))
throw std::runtime_error(errorMsg + "could not read bitmap header");
if(hdr.type != 0x4D42)
throw std::runtime_error(errorMsg + "not a bitmap file");
if(f.read((char *) &infoHdr, sizeof(infoHdr)).gcount() != sizeof(infoHdr))
throw std::runtime_error(errorMsg + "could not read bitmap info header");
if(infoHdr.bitsPerPixel != 24)
throw std::runtime_error(errorMsg + "non-truecolor bitmaps are not supported");
if(infoHdr.compression != 0)
throw std::runtime_error(errorMsg + "compressed bitmaps are not supported");
f.seekg(hdr.offset);
if(f.fail())
throw std::runtime_error(errorMsg + "seek failed");
GenericImage<Color3b, Derived> result(infoHdr.width, infoHdr.height);
int bmpStep = (result.getWidth() * 3 + 3) & -4;
/* read bottom-up BMP */
char *ptr = (char *) result.getRow(result.getHeight() - 1);
for(int i = 0; i < result.getHeight(); i++)
if(f.read(ptr - i * result.getWStep(), bmpStep).gcount() != bmpStep)
throw std::runtime_error(errorMsg + "read failed");
return result;
}
template<class Derived>
inline void saveBmp24bit(GenericImage<Color3b, Derived> image, const std::string& fileName) {
BMPHeader hdr;
BMPInfoHeader infoHdr;
std::ofstream f(fileName.c_str(), std::ios_base::out | std::ios_base::binary);
if(!f.is_open())
throw std::runtime_error("Could not open image file \"" + fileName + "\"");
int bmpStep = (image.getWidth() * 3 + 3) & -4;
int imageSize = bmpStep * image.getHeight() + sizeof(BMPHeader) + sizeof(BMPInfoHeader);
hdr.type = 0x4D42;
hdr.size = imageSize;
hdr.reserved1 = 0;
hdr.reserved2 = 0;
hdr.offset = sizeof(BMPHeader) + sizeof(BMPInfoHeader);
std::string errorMsg = "Error while reading image file \"" + fileName + "\": ";
f.write((char *) &hdr, sizeof(hdr));
infoHdr.size = sizeof(BMPInfoHeader);
infoHdr.width = image.getWidth();
infoHdr.height = image.getHeight();
infoHdr.planes = 1;
infoHdr.bitsPerPixel = 24;
infoHdr.compression = 0;
infoHdr.imageSize = imageSize;
infoHdr.xPelsPerMeter = 0;
infoHdr.yPelsPerMeter = 0;
infoHdr.clrUsed = 0;
infoHdr.clrImportant = 0;
f.write((char *) &infoHdr, sizeof(infoHdr));
/* write bottom-up BMP */
char *ptr = (char *) image.getRow(image.getHeight() - 1);
for(int i = 0; i < image.getHeight(); i++)
f.write(ptr - i * image.getWStep(), bmpStep);
}
} // namspace detail
// -------------------------------------------------------------------------- //
// Helpers
// -------------------------------------------------------------------------- //
/** Helper macro used in classes derived from GenericImage. */
#define IMAGE_DERIVE(NAME) \
private: \
explicit NAME(const base_type& base): base_type(base) {} \
friend class base_type; \
public: \
NAME() {} \
NAME(int width, int height): base_type(width, height) {} \
NAME(int width, int height, int wStep, void* pixels, ImageDeallocator* deallocator): \
base_type(width, height, wStep, pixels, deallocator) {} \
NAME(const NAME& that): base_type(that) {} \
\
template<class OtherDerived, bool otherMaterialized> \
NAME(const GenericImageBase<color_type, OtherDerived, otherMaterialized>& that): \
base_type(that) {} \
\
template<class OtherDerived, bool otherMaterialized> \
NAME& operator=(const GenericImageBase<color_type, OtherDerived, otherMaterialized>& that) { \
return base_type::operator=(that); \
} \
\
NAME& operator= (const NAME& that) { \
return base_type::operator=(that); \
}
// -------------------------------------------------------------------------- //
// Image1b
// -------------------------------------------------------------------------- //
/** Single-channel byte image. */
class Image1b: public GenericImage<unsigned char, Image1b> {
IMAGE_DERIVE(Image1b)
public:
};
// -------------------------------------------------------------------------- //
// Image3b
// -------------------------------------------------------------------------- //
/** Three-channel byte image. */
class Image3b: public GenericImage<Color3b, Image3b> {
IMAGE_DERIVE(Image3b)
public:
static Image3b loadFromFile(const std::string& fileName) {
#ifdef USE_OPENCV
IplImage *iplImage = cvLoadImage(fileName.c_str(), CV_LOAD_IMAGE_COLOR);
if(iplImage == NULL)
throw std::runtime_error("Could not open image file \"" + fileName + "\"");
return Image3b(iplImage->width, iplImage->height, iplImage->widthStep, iplImage->imageData, new IplDeallocator(iplImage));
#else
return detail::loadBmp24bit<Image3b>(fileName);
#endif
}
void saveToFile(const std::string& fileName) const {
#ifdef USE_OPENCV
IplImage *iplImage = cvCreateImageHeader(cvSize(this->getWidth(), this->getHeight()), IPL_DEPTH_8U, 3);
iplImage->widthStep = this->getWStep();
iplImage->imageData = (char *) this->getPixelData();
cvSaveImage(fileName.c_str(), iplImage);
cvReleaseImageHeader(&iplImage);
#else
detail::saveBmp24bit(*this, fileName);
#endif
}
};
// -------------------------------------------------------------------------- //
// Image4b
// -------------------------------------------------------------------------- //
/** Four-channel byte image. */
class Image4b: public GenericImage<Color4b, Image4b> {
IMAGE_DERIVE(Image4b)
public:
};
// -------------------------------------------------------------------------- //
// Image1f
// -------------------------------------------------------------------------- //
/** Single-channel float image. */
class Image1f: public GenericImage<float, Image1f> {
IMAGE_DERIVE(Image1f)
public:
};
// -------------------------------------------------------------------------- //
// Image3f
// -------------------------------------------------------------------------- //
/** Three-channel float image. */
class Image3f: public GenericImage<Color3f, Image3f> {
IMAGE_DERIVE(Image3f)
public:
};
// -------------------------------------------------------------------------- //
// Image4f
// -------------------------------------------------------------------------- //
/** Four-channel float image. */
class Image4f: public GenericImage<Color4f, Image4f> {
IMAGE_DERIVE(Image4f)
public:
};
/* Clean up. */
#undef IMAGE_DERIVE
// -------------------------------------------------------------------------- //
// Converter specializations.
// -------------------------------------------------------------------------- //
#ifdef USE_CIPPIMAGE
/** Cast specialization for conversion of Image1f to CIppImage*.
* Please note that you must delete the newly created CIppImage instance manually. */
template<>
struct image_cast_impl<CIppImage*, Image1f> {
typedef CIppImage* return_type;
return_type operator()(const Image1f& that) {
CIppImage* result = new CIppImage();
result->Alloc(that.getIppiSize(), 1, 8);
ippiScale_32f8u_C1R(that.getPixelData(), that.getWStep(), result->getData(), result->Step(), that.getIppiSize(), 0.0f, 1.0f);
return result;
}
};
/** Cast specialization for conversion of Image3f to CIppImage*.
* Please note that you must delete the newly created CIppImage instance manually. */
template<>
struct image_cast_impl<CIppImage*, Image3f> {
typedef CIppImage* return_type;
return_type operator()(const Image3f& that) {
CIppImage* result = new CIppImage();
result->Alloc(that.getIppiSize(), 3, 8);
ippiScale_32f8u_C3R(that.getPixelData(), that.getWStep(), result->getData(), result->Step(), that.getIppiSize(), 0.0f, 1.0f);
return result;
}
};
#endif // USE_CIPPIMAGE
} // namespace arx
#endif // __ARX_IMAGE_H__
| [
"ru.elric@gmail.com"
] | ru.elric@gmail.com |
6efc61c539c1ce657b273480dd4ddbacbc04dadf | 2593fe77ac639d7504993c5aa5572df80451ec9e | /Array ADT/tempCodeRunnerFile.cpp | dfc399461cbc08044ed33ab2474361200ac1da65 | [] | no_license | jaimit25/Cpp_dsa | 873d02b2f4519fbe76bf8101ad557e1b8f472917 | b05a284a028c931b9814ac727aaee1b9d59962e1 | refs/heads/master | 2023-08-19T00:34:30.781252 | 2021-10-04T10:31:38 | 2021-10-04T10:31:38 | 373,571,184 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 92 | cpp |
// for (int i = val.length-1; i < val.length ; i-- ){
// val.A[i] = val.A[i-1];
// } | [
"jaimitpanchal@JAIMITs-MacBook-Air.local"
] | jaimitpanchal@JAIMITs-MacBook-Air.local |
66a2a0cd7136091b5b0f778bf9bc2a6e33a6fbab | e9ce970d4690c49acd5141e5608925924c41eca6 | /CPP/HelloCpp2/chapter_38/namespace_divid.cpp | f9052bbcfd40c6fb43f2ac51751f0ab373eeef7f | [
"MIT"
] | permissive | hrntsm/study-language | 8422f2fa5ad45521031dd32334463736107a012f | 922578a5321d70c26b935e6052f400125e15649c | refs/heads/main | 2023-08-30T02:10:26.585375 | 2021-11-18T12:47:58 | 2021-11-18T12:47:58 | 341,214,562 | 1 | 0 | MIT | 2021-02-23T01:41:40 | 2021-02-22T13:45:32 | Python | UTF-8 | C++ | false | false | 341 | cpp | #include <iostream>
using namespace std;
namespace Kitten
{
class Kitty
{
};
const char *str = "Kitty on your lap\n";
}
namespace Kitten
{
void sakura()
{
cout << "CC Sakura\n";
};
} // namespace Kitten
int main()
{
Kitten::Kitty obj;
cout << Kitten::str;
Kitten::sakura();
return 0;
} | [
"contact@hrntsm.com"
] | contact@hrntsm.com |
19a6e83e1becee3fee6765dc8ccdebdda7f71303 | 8f4cc085e96342a1ca9f82822f9cc26d0fe1ac77 | /LAB3/CODE/Sequence1.cpp | a73428b5a01006bca9306edf382bd9832336072a | [] | no_license | josueRodriguez18/CS264 | 21599cd489d4e15bd5d07642016603833ab11af4 | ac7ac1d24da75c2fd7e53f671e2d3558b98c27e2 | refs/heads/master | 2020-03-22T03:37:23.904079 | 2019-12-18T18:48:04 | 2019-12-18T18:48:04 | 139,442,349 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 367 | cpp | #include<iostream>
using namespace std;
int main(){
int size;
cout << "Please input the size of the sequence: ";
cin >> size;
double *p = new double[size];
cout << "\n Please input your sequence elements now: ";
for(int i = 0; i < size; i++){
cin >> p[i];
}
for(int i = size - 1; 0 <= i; i++){
cout << endl << p[i];
}
return 0;
} | [
"josue.a.rodriguez@ttu.edu"
] | josue.a.rodriguez@ttu.edu |
a96c2b5db7092baddba4c6d62e1f2110a5341e34 | e9d3bd92027e63033929ab9dc97f38473f8ef0ef | /GTE/Samples/Physics/FreeTopFixedTip/FreeTopFixedTipWindow3.h | a2dee9a04ac9f399a328fb9712d7786028c12030 | [
"BSL-1.0"
] | permissive | cbullo/GeometricTools | 77107de654a012649d05ea248caefe581cc7fde4 | 53d82425c3d27a4301f7390754c7fc440734d53f | refs/heads/master | 2023-08-27T22:05:04.268917 | 2021-10-19T20:48:34 | 2021-10-19T20:48:34 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,246 | h | // David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
#pragma once
#include <Applications/Window3.h>
#include <Applications/Timer.h>
#include "PhysicsModule.h"
using namespace gte;
//#define FREE_TOP_FIXED_TIP_SINGLE_STEP
class FreeTopFixedTipWindow3 : public Window3
{
public:
FreeTopFixedTipWindow3(Parameters& parameters);
virtual void OnIdle() override;
virtual bool OnCharPress(unsigned char key, int x, int y) override;
private:
bool SetEnvironment();
void InitializeModule();
void CreateScene();
void CreateFloor();
void CreateAxisVertical();
void CreateTop();
void CreateAxisTop();
void PhysicsTick();
void GraphicsTick();
// The scene graph.
std::shared_ptr<Node> mScene, mTopRoot;
std::shared_ptr<RasterizerState> mWireState;
std::vector<std::shared_ptr<Visual>> mVisuals;
// The physics system.
PhysicsModule mModule;
float mMaxPhi;
// Support for clamping the frame rate.
Timer mMotionTimer;
double mLastUpdateTime;
};
| [
"deberly@geometrictools.com"
] | deberly@geometrictools.com |
f26b77874c4cddb0809f599e7b99f974361cd718 | 49ff67e45878b59ae0cd181e4934f4f885894649 | /Source/GCC4/LUAScripting/ScriptEvent.h | c3bb8c4acb3214410a9ba8bceaa7763e923e6e8f | [] | no_license | Flyling96/GameCode4_Study | ceb151320f0488d98600606f0793b21b478f3de2 | 67ea1de112b2aebcaf55969f4d62f127a8ddca47 | refs/heads/master | 2020-04-03T09:40:51.881485 | 2018-10-29T08:21:34 | 2018-10-29T08:21:34 | 155,172,955 | 4 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 9,178 | h | #pragma once
//========================================================================
// ScriptEvent.h
//
// Part of the GameCode4 Application
//
// GameCode4 is the sample application that encapsulates much of the source code
// discussed in "Game Coding Complete - 4th Edition" by Mike McShaffry and David
// "Rez" Graham, published by Charles River Media.
// ISBN-10: 1133776574 | ISBN-13: 978-1133776574
//
// If this source code has found it's way to you, and you think it has helped you
// in any way, do the authors a favor and buy a new copy of the book - there are
// detailed explanations in it that compliment this code well. Buy a copy at Amazon.com
// by clicking here:
// http://www.amazon.com/gp/product/1133776574/ref=olp_product_details?ie=UTF8&me=&seller=
//
// There's a companion web site at http://www.mcshaffry.com/GameCode/
//
// The source code is managed and maintained through Google Code:
// http://code.google.com/p/gamecode4/
//
// (c) Copyright 2012 Michael L. McShaffry and David Graham
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser GPL v3
// as published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
// http://www.gnu.org/licenses/lgpl-3.0.txt for more details.
//
// You should have received a copy of the GNU Lesser GPL v3
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
//
//========================================================================
//---------------------------------------------------------------------------------------------------------------------
// DOCUMENTATION:
//
// Chapter 12. page 380
//
// ====================================
// Script Events: Overview
//
// This system provides the glue that allows events to be sent to or received by the script. There is some C++ setup
// involved but once done, event passing between the boundary becomes completely transparent.
//
// ====================================
// Setup (C++):
//
// In order to make an event able to be seen & processed by the script, you must follow four steps:
// 1) Inherit your event class from ScriptEvent
// 2) Implement VBuildEventData() and VBuildEventFromScript() if necessary (see the comments above their prototypes
// for details)
// 3) Call the EXPORT_FOR_SCRIPT_EVENT() macro in your event subclass declaration
// 4) Call the REGISTER_SCRIPT_EVENT() macro in Application::RegisterScriptEvents() or the game-specific subclass
// override, as appropriate
//
// Once done, your event should be visible to the script. In script, the EventType table will contain a member indexed
// by the event type string containing the event id. This id matches the EventType for the appropriate event.
//
// ====================================
// Sending Events from Script:
//
// To send an event from script, you will need to create a table that contains the necessary data, then call the
// exported QueueEvent() or SendEvent() function. The first parameter is the event type (from the EventType table)
// and the second parameter is the table.
//
// In C++, this table is assigned to the m_eventData variable and used by your VBuildEventFromScript() implementation
// to fill out your C++ members. If something goes wrong, return false and the event won't be sent. If you don't
// need to receive the event on the C++ side, it doesn't matter and you can keep the default implementation of
// VBuildEventFromScript().
//
// Events are received on the C++ side as normal. Inherit from EventListener and register for the appropriate event
// type. Your receiver doesn't know nor does it care where the event came from.
//
// ====================================
// Receiving Events in Script:
//
// To register an event listener in script, call the exported RegisterEventListener() function. The first parameter
// is the event type (from the EventType table) and the second parameter is the callback function that's called every
// time the event is triggered. The callback function should take a table as its only parameter and return nothing:
// function EventCallback(eventData)
//
// RegisterEventListener() returns an id to your listener. When you no longer wish to receive an event, call the
// exported RemoveEventListener() function and pass it this id. If you don't need to ever stop listening for the
// event, it's safe to discard the id and let C++ clean it up on program exit. If your function goes out of scope,
// you will still incur the performance cost of receiving the event, though no other ill effects will occur.
//
// Internally on the C++ side, a ScriptEventListener object is created and registered as a proxy for each script
// listener. When it receives the event, it calls your ScriptEvent::VBuildEventData() to build the m_eventData table.
// It then calls your registered script function, passing this table in as a parameter. Note that if you don't need
// the event to be able to be received by the script, you don't need to override VBuildEventData().
//---------------------------------------------------------------------------------------------------------------------
#include "../EventManager/EventManager.h"
#include "LuaPlus.h"
class ScriptEvent;
typedef ScriptEvent* (*CreateEventForScriptFunctionType)(void); // function ptr typedef to create a script event
//---------------------------------------------------------------------------------------------------------------------
// These macros implement exporting events to script.
//---------------------------------------------------------------------------------------------------------------------
#define REGISTER_SCRIPT_EVENT(eventClass, eventType) \
ScriptEvent::RegisterEventTypeWithScript(#eventClass, eventType); \
ScriptEvent::AddCreationFunction(eventType, &eventClass::CreateEventForScript)
#define EXPORT_FOR_SCRIPT_EVENT(eventClass) \
public: \
static ScriptEvent* CreateEventForScript(void) \
{ \
return new eventClass; \
}
//---------------------------------------------------------------------------------------------------------------------
// Script event base class. This class is meant to be subclassed by any event that can be sent or received by the
// script. Note that these events are not limited to script and can be received just fine by C++ listeners.
// Furthermore, since the Script data isn't built unless being received by a script listener, there's no worry about
// performance.
//---------------------------------------------------------------------------------------------------------------------
class ScriptEvent : public BaseEventData
{
typedef std::map<EventType, CreateEventForScriptFunctionType> CreationFunctions;
static CreationFunctions s_creationFunctions;
bool m_eventDataIsValid;
protected:
LuaPlus::LuaObject m_eventData;
public:
// construction
ScriptEvent(void) { m_eventDataIsValid = false; }
// script event data, which should only be called from the appropriate ScriptExports functions
LuaPlus::LuaObject GetEventData(void); // called when event is sent from C++ to script
bool SetEventData(LuaPlus::LuaObject eventData); // called when event is sent from script to C++
// Static helper functions for registering events with the script. You should call the REGISTER_SCRIPT_EVENT()
// macro instead of calling this function directly. Any class that needs to be exported also needs to call the
// EXPORT_FOR_SCRIPT_EVENT() inside the class declaration.
static void RegisterEventTypeWithScript(const char* key, EventType type);
static void AddCreationFunction(EventType type, CreateEventForScriptFunctionType pCreationFunctionPtr);
static ScriptEvent* CreateEventFromScript(EventType type);
protected:
// This function must be overridden if you want to fire this event from C++ and have it received by the script.
// If you only fire the event from the script side, this function will never be called. It's purpose is to
// fill in the m_eventData member, which is then passed to the script callback function in the listener. This
// is only called the first time GetEventData() is called. If the event is script-only, this function does not
// need to be overridden.
virtual void VBuildEventData(void);
// This function must be overridden if you want to fire this event from Script and have it received by C++. If
// you only fire this event from script and have it received by the script, it doesn't matter since m_eventData
// will just be passed straight through. Its purpose is to fill in any C++ member variables using the data in
// m_eventData (which is valid at the time of the call). It is called when the event is fired from the script.
// Return false if the data is invalid in some way, which will keep the event from actually firing.
virtual bool VBuildEventFromScript(void) { return true; }
};
| [
"963452757@qq.com"
] | 963452757@qq.com |
d6c1b5d1afd2bff52883a3ff4685a1942c15169c | 0a61b0d042340404440c9616427e8521a32e2ade | /Generator.h | 5c73af4f5fe8f43a254531fa7d5495529b35a1ba | [] | no_license | wisnia01/World-simulation | a030c1d97e0ba2b793b3e5fb859c231f14e36aab | 5805fa8694b362786d341dc08d39acc57b914e47 | refs/heads/main | 2023-05-24T00:37:20.838086 | 2021-06-17T20:26:45 | 2021-06-17T20:26:45 | 377,952,603 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 192 | h | #pragma once
#include <iostream>
#include "World.h"
using namespace std;
class Generator
{
private:
World* world;
public:
Generator(World* world);
void Generate();
void GenerateSet();
}; | [
"83726628+wisnia01@users.noreply.github.com"
] | 83726628+wisnia01@users.noreply.github.com |
b4d66219ea6539b4dd93566217de3366808e56f8 | d09aff8aa64ca3481f5956c4cb03553bbc0b99cd | /livepush/src/main/cpp/include/queue/readerwriterqueue.h | 053e680f528d59613d92a4f881c9e01546c6d309 | [] | no_license | yuyisummer/Live_Rtmp2 | 68440fe7293aa968c2c81546b6d175d2a3cf581f | c60c4bd766f97cd7f727cdd2a8091bf7055b186f | refs/heads/master | 2020-03-27T04:55:53.215650 | 2017-11-07T11:36:48 | 2017-11-07T11:36:48 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 26,532 | h | #pragma once
#include "atomicops.h"
#include <type_traits>
#include <utility>
#include <cassert>
#include <stdexcept>
#include <new>
#include <cstdint>
#include <cstdlib> // For malloc/free/abort & size_t
#if __cplusplus > 199711L || _MSC_VER >= 1700 // C++11 or VS2012
#include <chrono>
#endif
// A lock-free queue for a single-consumer, single-producer architecture.
// The queue is also wait-free in the common path (except if more memory
// needs to be allocated, in which case malloc is called).
// Allocates memory sparingly (O(lg(n) times, amortized), and only once if
// the original maximum size estimate is never exceeded.
// Tested on x86/x64 processors, but semantics should be correct for all
// architectures (given the right implementations in atomicops.h), provided
// that aligned integer and pointer accesses are naturally atomic.
// Note that there should only be one consumer thread and producer thread;
// Switching roles of the threads, or using multiple consecutive threads for
// one role, is not safe unless properly synchronized.
// Using the queue exclusively from one thread is fine, though a bit silly.
#ifndef MOODYCAMEL_CACHE_LINE_SIZE
#define MOODYCAMEL_CACHE_LINE_SIZE 64
#endif
#ifndef MOODYCAMEL_EXCEPTIONS_ENABLED
#if (defined(_MSC_VER) && defined(_CPPUNWIND)) || (defined(__GNUC__) && defined(__EXCEPTIONS)) || (!defined(_MSC_VER) && !defined(__GNUC__))
#define MOODYCAMEL_EXCEPTIONS_ENABLED
#endif
#endif
#ifdef AE_VCPP
#pragma warning(push)
#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
#pragma warning(disable: 4820) // padding was added
#pragma warning(disable: 4127) // conditional expression is constant
#endif
namespace moodycamel {
template<typename T, size_t MAX_BLOCK_SIZE = 512>
class ReaderWriterQueue
{
// Design: Based on a queue-of-queues. The low-level queues are just
// circular buffers with front and tail indices indicating where the
// next element to dequeue is and where the next element can be enqueued,
// respectively. Each low-level queue is called a "block". Each block
// wastes exactly one element's worth of space to keep the design simple
// (if front == tail then the queue is empty, and can't be full).
// The high-level queue is a circular linked list of blocks; again there
// is a front and tail, but this time they are pointers to the blocks.
// The front block is where the next element to be dequeued is, provided
// the block is not empty. The back block is where elements are to be
// enqueued, provided the block is not full.
// The producer thread owns all the tail indices/pointers. The consumer
// thread owns all the front indices/pointers. Both threads read each
// other's variables, but only the owning thread updates them. E.g. After
// the consumer reads the producer's tail, the tail may change before the
// consumer is done dequeuing an object, but the consumer knows the tail
// will never go backwards, only forwards.
// If there is no room to enqueue an object, an additional block (of
// equal size to the last block) is added. Blocks are never removed.
public:
// Constructs a queue that can hold maxSize elements without further
// allocations. If more than MAX_BLOCK_SIZE elements are requested,
// then several blocks of MAX_BLOCK_SIZE each are reserved (including
// at least one extra buffer block).
explicit ReaderWriterQueue(size_t maxSize = 15)
#ifndef NDEBUG
: enqueuing(false)
,dequeuing(false)
#endif
{
assert(maxSize > 0);
assert(MAX_BLOCK_SIZE == ceilToPow2(MAX_BLOCK_SIZE) && "MAX_BLOCK_SIZE must be a power of 2");
assert(MAX_BLOCK_SIZE >= 2 && "MAX_BLOCK_SIZE must be at least 2");
Block* firstBlock = nullptr;
largestBlockSize = ceilToPow2(maxSize + 1); // We need a spare slot to fit maxSize elements in the block
if (largestBlockSize > MAX_BLOCK_SIZE * 2) {
// We need a spare block in case the producer is writing to a different block the consumer is reading from, and
// wants to enqueue the maximum number of elements. We also need a spare element in each block to avoid the ambiguity
// between front == tail meaning "empty" and "full".
// So the effective number of slots that are guaranteed to be usable at any time is the block size - 1 times the
// number of blocks - 1. Solving for maxSize and applying a ceiling to the division gives us (after simplifying):
size_t initialBlockCount = (maxSize + MAX_BLOCK_SIZE * 2 - 3) / (MAX_BLOCK_SIZE - 1);
largestBlockSize = MAX_BLOCK_SIZE;
Block* lastBlock = nullptr;
for (size_t i = 0; i != initialBlockCount; ++i) {
auto block = make_block(largestBlockSize);
if (block == nullptr) {
#ifdef MOODYCAMEL_EXCEPTIONS_ENABLED
throw std::bad_alloc();
#else
abort();
#endif
}
if (firstBlock == nullptr) {
firstBlock = block;
}
else {
lastBlock->next = block;
}
lastBlock = block;
block->next = firstBlock;
}
}
else {
firstBlock = make_block(largestBlockSize);
if (firstBlock == nullptr) {
#ifdef MOODYCAMEL_EXCEPTIONS_ENABLED
throw std::bad_alloc();
#else
abort();
#endif
}
firstBlock->next = firstBlock;
}
frontBlock = firstBlock;
tailBlock = firstBlock;
// Make sure the reader/writer threads will have the initialized memory setup above:
fence(memory_order_sync);
}
// Note: The queue should not be accessed concurrently while it's
// being deleted. It's up to the user to synchronize this.
~ReaderWriterQueue()
{
// Make sure we get the latest version of all variables from other CPUs:
fence(memory_order_sync);
// Destroy any remaining objects in queue and free memory
Block* frontBlock_ = frontBlock;
Block* block = frontBlock_;
do {
Block* nextBlock = block->next;
size_t blockFront = block->front;
size_t blockTail = block->tail;
for (size_t i = blockFront; i != blockTail; i = (i + 1) & block->sizeMask) {
auto element = reinterpret_cast<T*>(block->data + i * sizeof(T));
element->~T();
(void)element;
}
auto rawBlock = block->rawThis;
block->~Block();
std::free(rawBlock);
block = nextBlock;
} while (block != frontBlock_);
}
// Enqueues a copy of element if there is room in the queue.
// Returns true if the element was enqueued, false otherwise.
// Does not allocate memory.
AE_FORCEINLINE bool try_enqueue(T const& element)
{
return inner_enqueue<CannotAlloc>(element);
}
// Enqueues a moved copy of element if there is room in the queue.
// Returns true if the element was enqueued, false otherwise.
// Does not allocate memory.
AE_FORCEINLINE bool try_enqueue(T&& element)
{
return inner_enqueue<CannotAlloc>(std::forward<T>(element));
}
// Enqueues a copy of element on the queue.
// Allocates an additional block of memory if needed.
// Only fails (returns false) if memory allocation fails.
AE_FORCEINLINE bool enqueue(T const& element)
{
return inner_enqueue<CanAlloc>(element);
}
// Enqueues a moved copy of element on the queue.
// Allocates an additional block of memory if needed.
// Only fails (returns false) if memory allocation fails.
AE_FORCEINLINE bool enqueue(T&& element)
{
return inner_enqueue<CanAlloc>(std::forward<T>(element));
}
// Attempts to dequeue an element; if the queue is empty,
// returns false instead. If the queue has at least one element,
// moves front to result using operator=, then returns true.
template<typename U>
bool try_dequeue(U& result)
{
#ifndef NDEBUG
ReentrantGuard guard(this->dequeuing);
#endif
// High-level pseudocode:
// Remember where the tail block is
// If the front block has an element in it, dequeue it
// Else
// If front block was the tail block when we entered the function, return false
// Else advance to next block and dequeue the item there
// Note that we have to use the value of the tail block from before we check if the front
// block is full or not, in case the front block is empty and then, before we check if the
// tail block is at the front block or not, the producer fills up the front block *and
// moves on*, which would make us skip a filled block. Seems unlikely, but was consistently
// reproducible in practice.
// In order to avoid overhead in the common case, though, we do a double-checked pattern
// where we have the fast path if the front block is not empty, then read the tail block,
// then re-read the front block and check if it's not empty again, then check if the tail
// block has advanced.
Block* frontBlock_ = frontBlock.load();
size_t blockTail = frontBlock_->localTail;
size_t blockFront = frontBlock_->front.load();
if (blockFront != blockTail || blockFront != (frontBlock_->localTail = frontBlock_->tail.load())) {
fence(memory_order_acquire);
non_empty_front_block:
// Front block not empty, dequeue from here
auto element = reinterpret_cast<T*>(frontBlock_->data + blockFront * sizeof(T));
result = std::move(*element);
element->~T();
blockFront = (blockFront + 1) & frontBlock_->sizeMask;
fence(memory_order_release);
frontBlock_->front = blockFront;
}
else if (frontBlock_ != tailBlock.load()) {
fence(memory_order_acquire);
frontBlock_ = frontBlock.load();
blockTail = frontBlock_->localTail = frontBlock_->tail.load();
blockFront = frontBlock_->front.load();
fence(memory_order_acquire);
if (blockFront != blockTail) {
// Oh look, the front block isn't empty after all
goto non_empty_front_block;
}
// Front block is empty but there's another block ahead, advance to it
Block* nextBlock = frontBlock_->next;
// Don't need an acquire fence here since next can only ever be set on the tailBlock,
// and we're not the tailBlock, and we did an acquire earlier after reading tailBlock which
// ensures next is up-to-date on this CPU in case we recently were at tailBlock.
size_t nextBlockFront = nextBlock->front.load();
size_t nextBlockTail = nextBlock->localTail = nextBlock->tail.load();
fence(memory_order_acquire);
// Since the tailBlock is only ever advanced after being written to,
// we know there's for sure an element to dequeue on it
assert(nextBlockFront != nextBlockTail);
AE_UNUSED(nextBlockTail);
// We're done with this block, let the producer use it if it needs
fence(memory_order_release); // Expose possibly pending changes to frontBlock->front from last dequeue
frontBlock = frontBlock_ = nextBlock;
compiler_fence(memory_order_release); // Not strictly needed
auto element = reinterpret_cast<T*>(frontBlock_->data + nextBlockFront * sizeof(T));
result = std::move(*element);
element->~T();
nextBlockFront = (nextBlockFront + 1) & frontBlock_->sizeMask;
fence(memory_order_release);
frontBlock_->front = nextBlockFront;
}
else {
// No elements in current block and no other block to advance to
return false;
}
return true;
}
// Returns a pointer to the front element in the queue (the one that
// would be removed next by a call to `try_dequeue` or `pop`). If the
// queue appears empty at the time the method is called, nullptr is
// returned instead.
// Must be called only from the consumer thread.
T* peek()
{
#ifndef NDEBUG
ReentrantGuard guard(this->dequeuing);
#endif
// See try_dequeue() for reasoning
Block* frontBlock_ = frontBlock.load();
size_t blockTail = frontBlock_->localTail;
size_t blockFront = frontBlock_->front.load();
if (blockFront != blockTail || blockFront != (frontBlock_->localTail = frontBlock_->tail.load())) {
fence(memory_order_acquire);
non_empty_front_block:
return reinterpret_cast<T*>(frontBlock_->data + blockFront * sizeof(T));
}
else if (frontBlock_ != tailBlock.load()) {
fence(memory_order_acquire);
frontBlock_ = frontBlock.load();
blockTail = frontBlock_->localTail = frontBlock_->tail.load();
blockFront = frontBlock_->front.load();
fence(memory_order_acquire);
if (blockFront != blockTail) {
goto non_empty_front_block;
}
Block* nextBlock = frontBlock_->next;
size_t nextBlockFront = nextBlock->front.load();
fence(memory_order_acquire);
assert(nextBlockFront != nextBlock->tail.load());
return reinterpret_cast<T*>(nextBlock->data + nextBlockFront * sizeof(T));
}
return nullptr;
}
// Removes the front element from the queue, if any, without returning it.
// Returns true on success, or false if the queue appeared empty at the time
// `pop` was called.
bool pop()
{
#ifndef NDEBUG
ReentrantGuard guard(this->dequeuing);
#endif
// See try_dequeue() for reasoning
Block* frontBlock_ = frontBlock.load();
size_t blockTail = frontBlock_->localTail;
size_t blockFront = frontBlock_->front.load();
if (blockFront != blockTail || blockFront != (frontBlock_->localTail = frontBlock_->tail.load())) {
fence(memory_order_acquire);
non_empty_front_block:
auto element = reinterpret_cast<T*>(frontBlock_->data + blockFront * sizeof(T));
element->~T();
blockFront = (blockFront + 1) & frontBlock_->sizeMask;
fence(memory_order_release);
frontBlock_->front = blockFront;
}
else if (frontBlock_ != tailBlock.load()) {
fence(memory_order_acquire);
frontBlock_ = frontBlock.load();
blockTail = frontBlock_->localTail = frontBlock_->tail.load();
blockFront = frontBlock_->front.load();
fence(memory_order_acquire);
if (blockFront != blockTail) {
goto non_empty_front_block;
}
// Front block is empty but there's another block ahead, advance to it
Block* nextBlock = frontBlock_->next;
size_t nextBlockFront = nextBlock->front.load();
size_t nextBlockTail = nextBlock->localTail = nextBlock->tail.load();
fence(memory_order_acquire);
assert(nextBlockFront != nextBlockTail);
AE_UNUSED(nextBlockTail);
fence(memory_order_release);
frontBlock = frontBlock_ = nextBlock;
compiler_fence(memory_order_release);
auto element = reinterpret_cast<T*>(frontBlock_->data + nextBlockFront * sizeof(T));
element->~T();
nextBlockFront = (nextBlockFront + 1) & frontBlock_->sizeMask;
fence(memory_order_release);
frontBlock_->front = nextBlockFront;
}
else {
// No elements in current block and no other block to advance to
return false;
}
return true;
}
// Returns the approximate number of items currently in the queue.
// Safe to call from both the producer and consumer threads.
inline size_t size_approx() const
{
size_t result = 0;
Block* frontBlock_ = frontBlock.load();
Block* block = frontBlock_;
do {
fence(memory_order_acquire);
size_t blockFront = block->front.load();
size_t blockTail = block->tail.load();
result += (blockTail - blockFront) & block->sizeMask;
block = block->next.load();
} while (block != frontBlock_);
return result;
}
private:
enum AllocationMode { CanAlloc, CannotAlloc };
template<AllocationMode canAlloc, typename U>
bool inner_enqueue(U&& element)
{
#ifndef NDEBUG
ReentrantGuard guard(this->enqueuing);
#endif
// High-level pseudocode (assuming we're allowed to alloc a new block):
// If room in tail block, add to tail
// Else check next block
// If next block is not the head block, enqueue on next block
// Else create a new block and enqueue there
// Advance tail to the block we just enqueued to
Block* tailBlock_ = tailBlock.load();
size_t blockFront = tailBlock_->localFront;
size_t blockTail = tailBlock_->tail.load();
size_t nextBlockTail = (blockTail + 1) & tailBlock_->sizeMask;
if (nextBlockTail != blockFront || nextBlockTail != (tailBlock_->localFront = tailBlock_->front.load())) {
fence(memory_order_acquire);
// This block has room for at least one more element
char* location = tailBlock_->data + blockTail * sizeof(T);
new (location) T(std::forward<U>(element));
fence(memory_order_release);
tailBlock_->tail = nextBlockTail;
}
else {
fence(memory_order_acquire);
if (tailBlock_->next.load() != frontBlock) {
// Note that the reason we can't advance to the frontBlock and start adding new entries there
// is because if we did, then dequeue would stay in that block, eventually reading the new values,
// instead of advancing to the next full block (whose values were enqueued first and so should be
// consumed first).
fence(memory_order_acquire); // Ensure we get latest writes if we got the latest frontBlock
// tailBlock is full, but there's a free block ahead, use it
Block* tailBlockNext = tailBlock_->next.load();
size_t nextBlockFront = tailBlockNext->localFront = tailBlockNext->front.load();
nextBlockTail = tailBlockNext->tail.load();
fence(memory_order_acquire);
// This block must be empty since it's not the head block and we
// go through the blocks in a circle
assert(nextBlockFront == nextBlockTail);
tailBlockNext->localFront = nextBlockFront;
char* location = tailBlockNext->data + nextBlockTail * sizeof(T);
new (location) T(std::forward<U>(element));
tailBlockNext->tail = (nextBlockTail + 1) & tailBlockNext->sizeMask;
fence(memory_order_release);
tailBlock = tailBlockNext;
}
else if (canAlloc == CanAlloc) {
// tailBlock is full and there's no free block ahead; create a new block
auto newBlockSize = largestBlockSize >= MAX_BLOCK_SIZE ? largestBlockSize : largestBlockSize * 2;
auto newBlock = make_block(newBlockSize);
if (newBlock == nullptr) {
// Could not allocate a block!
return false;
}
largestBlockSize = newBlockSize;
new (newBlock->data) T(std::forward<U>(element));
assert(newBlock->front == 0);
newBlock->tail = newBlock->localTail = 1;
newBlock->next = tailBlock_->next.load();
tailBlock_->next = newBlock;
// Might be possible for the dequeue thread to see the new tailBlock->next
// *without* seeing the new tailBlock value, but this is OK since it can't
// advance to the next block until tailBlock is set anyway (because the only
// case where it could try to read the next is if it's already at the tailBlock,
// and it won't advance past tailBlock in any circumstance).
fence(memory_order_release);
tailBlock = newBlock;
}
else if (canAlloc == CannotAlloc) {
// Would have had to allocate a new block to enqueue, but not allowed
return false;
}
else {
assert(false && "Should be unreachable code");
return false;
}
}
return true;
}
// Disable copying
ReaderWriterQueue(ReaderWriterQueue const&) { }
// Disable assignment
ReaderWriterQueue& operator=(ReaderWriterQueue const&) { }
AE_FORCEINLINE static size_t ceilToPow2(size_t x)
{
// From http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
--x;
x |= x >> 1;
x |= x >> 2;
x |= x >> 4;
for (size_t i = 1; i < sizeof(size_t); i <<= 1) {
x |= x >> (i << 3);
}
++x;
return x;
}
template<typename U>
static AE_FORCEINLINE char* align_for(char* ptr)
{
const std::size_t alignment = std::alignment_of<U>::value;
return ptr + (alignment - (reinterpret_cast<std::uintptr_t>(ptr) % alignment)) % alignment;
}
private:
#ifndef NDEBUG
struct ReentrantGuard
{
ReentrantGuard(bool& _inSection)
: inSection(_inSection)
{
assert(!inSection && "ReaderWriterQueue does not support enqueuing or dequeuing elements from other elements' ctors and dtors");
inSection = true;
}
~ReentrantGuard() { inSection = false; }
private:
ReentrantGuard& operator=(ReentrantGuard const&);
private:
bool& inSection;
};
#endif
struct Block
{
// Avoid false-sharing by putting highly contended variables on their own cache lines
weak_atomic<size_t> front; // (Atomic) Elements are read from here
size_t localTail; // An uncontended shadow copy of tail, owned by the consumer
char cachelineFiller0[MOODYCAMEL_CACHE_LINE_SIZE - sizeof(weak_atomic<size_t>) - sizeof(size_t)];
weak_atomic<size_t> tail; // (Atomic) Elements are enqueued here
size_t localFront;
char cachelineFiller1[MOODYCAMEL_CACHE_LINE_SIZE - sizeof(weak_atomic<size_t>) - sizeof(size_t)]; // next isn't very contended, but we don't want it on the same cache line as tail (which is)
weak_atomic<Block*> next; // (Atomic)
char* data; // Contents (on heap) are aligned to T's alignment
const size_t sizeMask;
// size must be a power of two (and greater than 0)
Block(size_t const& _size, char* _rawThis, char* _data)
: front(0), localTail(0), tail(0), localFront(0), next(nullptr), data(_data), sizeMask(_size - 1), rawThis(_rawThis)
{
}
private:
// C4512 - Assignment operator could not be generated
Block& operator=(Block const&);
public:
char* rawThis;
};
static Block* make_block(size_t capacity)
{
// Allocate enough memory for the block itself, as well as all the elements it will contain
auto size = sizeof(Block) + std::alignment_of<Block>::value - 1;
size += sizeof(T) * capacity + std::alignment_of<T>::value - 1;
auto newBlockRaw = static_cast<char*>(std::malloc(size));
if (newBlockRaw == nullptr) {
return nullptr;
}
auto newBlockAligned = align_for<Block>(newBlockRaw);
auto newBlockData = align_for<T>(newBlockAligned + sizeof(Block));
return new (newBlockAligned) Block(capacity, newBlockRaw, newBlockData);
}
private:
weak_atomic<Block*> frontBlock; // (Atomic) Elements are enqueued to this block
char cachelineFiller[MOODYCAMEL_CACHE_LINE_SIZE - sizeof(weak_atomic<Block*>)];
weak_atomic<Block*> tailBlock; // (Atomic) Elements are dequeued from this block
size_t largestBlockSize;
#ifndef NDEBUG
bool enqueuing;
bool dequeuing;
#endif
};
// Like ReaderWriterQueue, but also providees blocking operations
template<typename T, size_t MAX_BLOCK_SIZE = 512>
class BlockingReaderWriterQueue
{
private:
typedef ::moodycamel::ReaderWriterQueue<T, MAX_BLOCK_SIZE> ReaderWriterQueue;
public:
explicit BlockingReaderWriterQueue(size_t maxSize = 15)
: inner(maxSize)
{ }
// Enqueues a copy of element if there is room in the queue.
// Returns true if the element was enqueued, false otherwise.
// Does not allocate memory.
AE_FORCEINLINE bool try_enqueue(T const& element)
{
if (inner.try_enqueue(element)) {
sema.signal();
return true;
}
return false;
}
// Enqueues a moved copy of element if there is room in the queue.
// Returns true if the element was enqueued, false otherwise.
// Does not allocate memory.
AE_FORCEINLINE bool try_enqueue(T&& element)
{
if (inner.try_enqueue(std::forward<T>(element))) {
sema.signal();
return true;
}
return false;
}
// Enqueues a copy of element on the queue.
// Allocates an additional block of memory if needed.
// Only fails (returns false) if memory allocation fails.
AE_FORCEINLINE bool enqueue(T const& element)
{
if (inner.enqueue(element)) {
sema.signal();
return true;
}
return false;
}
// Enqueues a moved copy of element on the queue.
// Allocates an additional block of memory if needed.
// Only fails (returns false) if memory allocation fails.
AE_FORCEINLINE bool enqueue(T&& element)
{
if (inner.enqueue(std::forward<T>(element))) {
sema.signal();
return true;
}
return false;
}
// Attempts to dequeue an element; if the queue is empty,
// returns false instead. If the queue has at least one element,
// moves front to result using operator=, then returns true.
template<typename U>
bool try_dequeue(U& result)
{
if (sema.tryWait()) {
bool success = inner.try_dequeue(result);
assert(success);
AE_UNUSED(success);
return true;
}
return false;
}
// Attempts to dequeue an element; if the queue is empty,
// waits until an element is available, then dequeues it.
template<typename U>
void wait_dequeue(U& result)
{
sema.wait();
bool success = inner.try_dequeue(result);
AE_UNUSED(result);
assert(success);
AE_UNUSED(success);
}
// Attempts to dequeue an element; if the queue is empty,
// waits until an element is available up to the specified timeout,
// then dequeues it and returns true, or returns false if the timeout
// expires before an element can be dequeued.
// Using a negative timeout indicates an indefinite timeout,
// and is thus functionally equivalent to calling wait_dequeue.
template<typename U>
bool wait_dequeue_timed(U& result, std::int64_t timeout_usecs)
{
if (!sema.wait(timeout_usecs)) {
return false;
}
bool success = inner.try_dequeue(result);
AE_UNUSED(result);
assert(success);
AE_UNUSED(success);
return true;
}
#if __cplusplus > 199711L || _MSC_VER >= 1700
// Attempts to dequeue an element; if the queue is empty,
// waits until an element is available up to the specified timeout,
// then dequeues it and returns true, or returns false if the timeout
// expires before an element can be dequeued.
// Using a negative timeout indicates an indefinite timeout,
// and is thus functionally equivalent to calling wait_dequeue.
template<typename U, typename Rep, typename Period>
inline bool wait_dequeue_timed(U& result, std::chrono::duration<Rep, Period> const& timeout)
{
return wait_dequeue_timed(result, std::chrono::duration_cast<std::chrono::microseconds>(timeout).count());
}
#endif
// Returns a pointer to the front element in the queue (the one that
// would be removed next by a call to `try_dequeue` or `pop`). If the
// queue appears empty at the time the method is called, nullptr is
// returned instead.
// Must be called only from the consumer thread.
AE_FORCEINLINE T* peek()
{
return inner.peek();
}
// Removes the front element from the queue, if any, without returning it.
// Returns true on success, or false if the queue appeared empty at the time
// `pop` was called.
AE_FORCEINLINE bool pop()
{
if (sema.tryWait()) {
bool result = inner.pop();
assert(result);
AE_UNUSED(result);
return true;
}
return false;
}
// Returns the approximate number of items currently in the queue.
// Safe to call from both the producer and consumer threads.
AE_FORCEINLINE size_t size_approx() const
{
return sema.availableApprox();
}
private:
// Disable copying & assignment
BlockingReaderWriterQueue(ReaderWriterQueue const&) { }
BlockingReaderWriterQueue& operator=(ReaderWriterQueue const&) { }
private:
ReaderWriterQueue inner;
spsc_sema::LightweightSemaphore sema;
};
} // end namespace moodycamel
#ifdef AE_VCPP
#pragma warning(pop)
#endif
| [
"836426852@qq.com"
] | 836426852@qq.com |
3cb5cf41d2c9807566bcca3a3cf367e96ce1edb8 | ac140a854c180f0c6c0ff0f35518c18e32a43758 | /CppConcurrencyInAction/paragraph_3_3_1.cpp | cec310f678b3670a57e3e166af04b6b634931160 | [] | no_license | klasing/MnistExample | 53bd4e6316b513889acd77a5549082863c643435 | 720479f6768c15fa6e63fafd415b5a2bcff3dfa9 | refs/heads/master | 2020-04-22T00:29:18.102857 | 2019-06-30T18:41:17 | 2019-06-30T18:41:17 | 169,981,063 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 343 | cpp | #include <iostream>
#include "listing_3_11.cpp"
#include "listing_3_12.cpp"
using namespace std;
inline void paragraph_3_3_1() {
cout << "3.3.1 Protecting shared data during initialization" << endl;
cout << "--------------------------------------------------" << endl;
ns_listing_3_11::listing_3_11();
ns_listing_3_12::listing_3_12();
} | [
"klasing1959@gmail.com"
] | klasing1959@gmail.com |
1f03d1d369e86761b2728fed13733364044ce5fa | 96a393d01fd3e2543a7e2e99dffa0ec4d80c73fb | /Project2/main.cpp | 5d8422ea8bab6217b73a605a615820f86853d8ab | [] | no_license | KareshiKraise/CartoonRendering | 3a54a4bfb3e220218833a9a53e471d2a89062b95 | 9bca3ed0aa752e4d6937e333f8e8faa3370a0a2b | refs/heads/main | 2023-03-30T12:06:03.213228 | 2021-04-01T19:38:55 | 2021-04-01T19:38:55 | 353,805,615 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 10,767 | cpp | #include <iostream>
#include <GL/glew.h>
#include <GL/freeglut.h>
#include <GLM/glm.hpp>
#include "compileShaders.h"
#include <GLM/vec3.hpp>
#include <GLM/vec4.hpp>
#include <GLM/mat4x4.hpp>
#include <GLM/gtc/matrix_transform.hpp>
#include <GLM/gtc/type_ptr.hpp>
#include <GLM/gtx/rotate_vector.hpp>
#include <algorithm>
#include "Mesh.h"
bool is_hatching = 0;
GLfloat red[] = {1.0f, 0.0f, 0.0f, 1.0f};
GLfloat gray[] = {0.2f , 0.2f, 0.2f ,1.0f};
ShaderLoader my_program;
ShaderLoader aux_program;
GLuint vao;
GLuint vbo_pos;
GLuint vbo_ind;
GLsizei IndexCount;
int last_mx = 0, last_my = 0, cur_mx = 0, cur_my = 0;
int WDIM = 512;
float FOV = 60.0f;
glm::mat4 Model = glm::mat4(1.0f);
bool arcball = false;
GLfloat TessLevelInner = 1.0;
GLfloat TessLevelOuter = 1.0;
Mesh myModel;
glm::vec4 Ambient = { 0.15f, 0.15f, 0.15f, 1.0f };
glm::vec3 LightColor = {1.0f, 1.0f, 1.0f};
//10 10 -1
glm::vec3 LightDirection = {150.0f, 150.0f, 150.0f};
glm::vec3 CameraPos = { 150.0f, 150.0f, -150.0f };
float Shininess = 10.0f;
float Strength = 0.1f;
int has_relief = 0;
float rot_over;
void mousewheel(int button, int dir, int x, int y)
{
if (dir > 0)
{
FOV += 2.0f;
}
else
{
FOV -= 2.0f;
}
return;
}
void keyboard(unsigned char key, int x, int y)
{
switch (key)
{
case 't':
case 'T':
if(TessLevelInner <= 7.0) TessLevelInner += 1.0;
break;
case 'r':
case 'R':
if (TessLevelOuter <= 7.0) TessLevelOuter += 1.0;
break;
case '+':
FOV += 2.0f;
break;
case '-':
FOV -= 2.0f;
break;
case 'w':
case 'W':
CameraPos += glm::vec3(0.0f ,0.0f, 1.0f);
break;
case 'a':
case 'A':
CameraPos += glm::vec3(1.0f, 0.0f, 0.0f);
break;
case 's':
case 'S':
CameraPos += glm::vec3(0.0f, 0.0f, -1.0f);
break;
case 'd':
case 'D':
CameraPos += glm::vec3(-1.0f, 0.0f, 0.0f);
break;
}
}
void onMouse(int button, int state, int x, int y) {
if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN) {
arcball = true;
last_mx = cur_mx = x;
last_my = cur_my = y;
//std::cout << "clicked the left button" << std::endl;
}
else {
arcball = false;
}
}
void onMotion(int x, int y) {
if (arcball)
{
cur_mx = x;
cur_my = y;
//std::cout << "last x" << last_mx << "cur x" << cur_mx << std::endl;
//std::cout << "last y" << last_my << "cur y" << cur_my << std::endl;
}
}
glm::vec3 get_arcball_vector(int x, int y) {
glm::vec3 P = glm::vec3(1.0 * x / WDIM * 2 - 1.0, 1.0*y / WDIM * 2 - 1.0, 0);
P.y = -P.y;
float OP_squared = P.x * P.x + P.y * P.y;
if (OP_squared <= 1 * 1) {
P.z = sqrt(1 * 1 - OP_squared);
}
else {
P = glm::normalize(P);
}
return P;
}
void initshaders(void) {
// my_program.enableTess(true);
if (is_hatching == 0)
{
aux_program.loadShader("sillouete.vertex", "sillouete.frag");
my_program.loadShader("kirby.vertex", "kirby.frag");
}
else
{
my_program.loadShader("hatching.vertex", "hatching.frag");
}
//glPointSize(30.0f);
//glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
}
void make_cube(void) {
static const GLfloat g_vertex_buffer_data[] = {
-1.0f,-1.0f,-1.0f, // triangle 1 : begin
-1.0f,-1.0f, 1.0f,
-1.0f, 1.0f, 1.0f, // triangle 1 : end
1.0f, 1.0f,-1.0f, // triangle 2 : begin
-1.0f,-1.0f,-1.0f,
-1.0f, 1.0f,-1.0f, // triangle 2 : end
1.0f,-1.0f, 1.0f,
-1.0f,-1.0f,-1.0f,
1.0f,-1.0f,-1.0f,
1.0f, 1.0f,-1.0f,
1.0f,-1.0f,-1.0f,
-1.0f,-1.0f,-1.0f,
-1.0f,-1.0f,-1.0f,
-1.0f, 1.0f, 1.0f,
-1.0f, 1.0f,-1.0f,
1.0f,-1.0f, 1.0f,
-1.0f,-1.0f, 1.0f,
-1.0f,-1.0f,-1.0f,
-1.0f, 1.0f, 1.0f,
-1.0f,-1.0f, 1.0f,
1.0f,-1.0f, 1.0f,
1.0f, 1.0f, 1.0f,
1.0f,-1.0f,-1.0f,
1.0f, 1.0f,-1.0f,
1.0f,-1.0f,-1.0f,
1.0f, 1.0f, 1.0f,
1.0f,-1.0f, 1.0f,
1.0f, 1.0f, 1.0f,
1.0f, 1.0f,-1.0f,
-1.0f, 1.0f,-1.0f,
1.0f, 1.0f, 1.0f,
-1.0f, 1.0f,-1.0f,
-1.0f, 1.0f, 1.0f,
1.0f, 1.0f, 1.0f,
-1.0f, 1.0f, 1.0f,
1.0f,-1.0f, 1.0f
};
glGenBuffers(1, &vbo_pos);
glBindBuffer(GL_ARRAY_BUFFER, vbo_pos);
glBufferData(GL_ARRAY_BUFFER, sizeof(g_vertex_buffer_data), g_vertex_buffer_data, GL_STATIC_DRAW);
initshaders();
};
void resize(int w, int h) {
glViewport(0, 0, w, h);
glutPostRedisplay();
}
void idlefunc()
{
//
if (cur_mx != last_mx || cur_my != last_my)
{
glm::vec3 va = get_arcball_vector(last_mx, last_my);
glm::vec3 vb = get_arcball_vector(cur_mx, cur_my);
float angle = acos(std::min(1.0f, glm::dot(va, vb)));
angle = angle*0.03;
glm::vec3 axis_in_camera_coord = glm::cross(va, vb);
Model = glm::rotate(Model, glm::degrees(angle), axis_in_camera_coord);
last_mx = cur_mx;
last_my = cur_my;
}
glutPostRedisplay();
}
void render()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glm::mat4 Projection = glm::perspective(glm::radians(FOV), ((float)(WDIM) / (float)(WDIM)), 0.1f, 1000.0f);
//30, 7, -10
glm::mat4 Camera = glm::lookAt(CameraPos, glm::vec3(0, 0, 0), glm::vec3(0, 1, 0));
glm::mat4 ModelView = Model * Camera;
glm::mat3 NormalMatrix = glm::transpose(glm::inverse(glm::mat3(ModelView)));
if (is_hatching == 0)
{
glUseProgram(aux_program.program);
//glEnable(GL_CULL_FACE);
glCullFace(GL_FRONT);
glDepthMask(GL_TRUE);
glm::vec3 auxiliarCol = { 0.0,0.0,0.0 };
GLuint ouniID = glGetUniformLocation(aux_program.program, "auxiliar");
glUniform3fv(ouniID, 1, glm::value_ptr(auxiliarCol));
GLuint oMatrixID = glGetUniformLocation(aux_program.program, "M");
glUniformMatrix4fv(oMatrixID, 1, GL_FALSE, &Model[0][0]);
oMatrixID = glGetUniformLocation(aux_program.program, "V");
glUniformMatrix4fv(oMatrixID, 1, GL_FALSE, &Camera[0][0]);
oMatrixID = glGetUniformLocation(aux_program.program, "P");
glUniformMatrix4fv(oMatrixID, 1, GL_FALSE, &Projection[0][0]);
myModel.render();
//glUseProgram(0);
glUseProgram(my_program.program);
//glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
//glDepthMask(GL_FALSE);
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_TRUE);
//glCullFace(GL_BACK);
//glEnable(GL_DEPTH_TEST);
//glDepthMask(GL_TRUE);
GLuint MatrixID = glGetUniformLocation(my_program.program, "M");
glUniformMatrix4fv(MatrixID, 1, GL_FALSE, &Model[0][0]);
MatrixID = glGetUniformLocation(my_program.program, "V");
glUniformMatrix4fv(MatrixID, 1, GL_FALSE, &Camera[0][0]);
MatrixID = glGetUniformLocation(my_program.program, "P");
glUniformMatrix4fv(MatrixID, 1, GL_FALSE, &Projection[0][0]);
MatrixID = glGetUniformLocation(my_program.program, "NormalMatrix");
glUniformMatrix3fv(MatrixID, 1, GL_FALSE, &NormalMatrix[0][0]);
GLuint uniID = glGetUniformLocation(my_program.program, "Ambient");
glUniform4fv(uniID, 1, glm::value_ptr(Ambient));
uniID = glGetUniformLocation(my_program.program, "LightColor");
glUniform3fv(uniID, 1, glm::value_ptr(LightColor));
uniID = glGetUniformLocation(my_program.program, "CameraPos");
glUniform3fv(uniID, 1, glm::value_ptr(CameraPos));
uniID = glGetUniformLocation(my_program.program, "LightDirection");
glUniform3fv(uniID, 1, glm::value_ptr(LightDirection));
//uniID = glGetUniformLocation(my_program.program, "Shininess");
//glUniform1f(uniID, Shininess);
//uniID = glGetUniformLocation(my_program.program, "Strength");
//glUniform1f(uniID, Strength );
//uniID = glGetUniformLocation(my_program.program, "has_relief");
//glUniform1i(uniID, has_relief);
uniID = glGetUniformLocation(my_program.program, "tex");
glUniform1i(uniID, 0);
myModel.render();
//glEnableVertexAttribArray(0);
//glBindBuffer(GL_ARRAY_BUFFER, vbo_pos); //para testes com o cubo premade
//glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
//glDrawArrays(GL_PATCHES, 0, 12*3);
}
else
{
glUseProgram(my_program.program);
GLuint uniID = glGetUniformLocation(my_program.program, "LightColor");
glUniform3fv(uniID, 1, glm::value_ptr(LightColor));
uniID = glGetUniformLocation(my_program.program, "CameraPos");
glUniform3fv(uniID, 1, glm::value_ptr(CameraPos));
uniID = glGetUniformLocation(my_program.program, "LightDirection");
glUniform3fv(uniID, 1, glm::value_ptr(LightDirection));
GLuint oMatrixID = glGetUniformLocation(my_program.program, "NormalMatrix");
glUniformMatrix3fv(oMatrixID, 1, GL_FALSE, &NormalMatrix[0][0]);
oMatrixID = glGetUniformLocation(my_program.program, "M");
glUniformMatrix4fv(oMatrixID, 1, GL_FALSE, &Model[0][0]);
oMatrixID = glGetUniformLocation(my_program.program, "V");
glUniformMatrix4fv(oMatrixID, 1, GL_FALSE, &Camera[0][0]);
oMatrixID = glGetUniformLocation(my_program.program, "P");
glUniformMatrix4fv(oMatrixID, 1, GL_FALSE, &Projection[0][0]);
uniID = glGetUniformLocation(my_program.program, "tex");
glUniform1i(uniID, 0);
uniID = glGetUniformLocation(my_program.program, "tex1");
glUniform1i(uniID, 1);
uniID = glGetUniformLocation(my_program.program, "tex2");
glUniform1i(uniID, 2);
uniID = glGetUniformLocation(my_program.program, "tex3");
glUniform1i(uniID, 3);
uniID = glGetUniformLocation(my_program.program, "tex4");
glUniform1i(uniID, 4);
uniID = glGetUniformLocation(my_program.program, "tex5");
glUniform1i(uniID, 5);
myModel.render();
}
glUseProgram(0);
glutSwapBuffers();
}
void initGL(int w_size, int *argc, char **argv) {
glutInit(argc, argv);
glutInitWindowSize(w_size, w_size);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
glutCreateWindow("CELL SHADING TEST");
glClearColor(1.0, 1.0, 1.0, 1.0);
int err = glewInit();
if (GLEW_OK != err) {
printf("Error: %s\n", glewGetErrorString(err));
}
//glPolygonMode(GL_FRONT, GL_LINE);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glFrontFace(GL_CCW);
glEnable(GL_DEPTH_TEST);
glutDisplayFunc(render);
glutReshapeFunc(resize);
glutIdleFunc(idlefunc);
glutKeyboardFunc(keyboard);
glutMouseFunc(onMouse);
glutMotionFunc(onMotion);
glutMouseWheelFunc(mousewheel);
}
int main(int argc, char **argv) {
initGL(WDIM, &argc, argv);
printf("Cell shading - 0 ; Hatching - 1");
std::cin >> is_hatching;
//make_cube();
if (!is_hatching)
{
myModel.loadfile("Kirby/kirby.obj");
myModel.loadtex("Kirby/dd489eac.png");
}
else
{
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
myModel.loadfile("Kirby/bola.obj");
myModel.loadtex("Kirby/hatching/hatch1.png");
myModel.loadtex("Kirby/hatching/hatch2.png");
myModel.loadtex("Kirby/hatching/hatch3.png");
myModel.loadtex("Kirby/hatching/hatch4.png");
myModel.loadtex("Kirby/hatching/hatch5.png");
myModel.loadtex("Kirby/hatching/hatch6.png");
//myModelloadNormalMap("Kirby/TesteHatch/stripes2.png");
//myModel.loadHeigthDepthMap("Kirby/TesteHatch/stripes3.png");
}
initshaders();
glutMainLoop();
return 0;
}
| [
"vitormoraesaranha@gmail.com"
] | vitormoraesaranha@gmail.com |
8e8f33564d0307df0cb70bf91bb130162e07fa0d | 47924ba23873d82a0af084b6956929b45f163f0f | /game/scrollhandler.h | 796b30e30c05df4d5c254dab5a723364f3be8276 | [] | no_license | pedlop01/camelot | 78d3fc5e20f322ba1f7596c70dd10e0302ebb9b7 | abb83e9e6b02a0946dc5ad3c0330cad4d09aa1bf | refs/heads/master | 2020-12-14T12:58:28.028948 | 2020-01-18T16:09:52 | 2020-01-18T16:09:52 | 234,752,403 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,536 | h | // Class automatically generated by Dev-C++ New Class wizard
#ifndef SCROLLHANDLER_H
#define SCROLLHANDLER_H
#include <assert.h>
#include "defines.h"
#include "entradasortida.h"
#define NORMAL 0
#define FAST_ADVANCE 1
#define NORMAL_ADVANCE 2
#define RECOMPUTE_SCROLL_X 0
#define FAST_ADVANCE_LEFT 1
#define FAST_ADVANCE_RIGHT 2
#define NORMAL_ADVANCE_LEFT 3
#define NORMAL_ADVANCE_RIGHT 4
#define RECOMPUTE_SCROLL_Y 0
#define FAST_ADVANCE_UP 1
#define FAST_ADVANCE_DOWN 2
#define NORMAL_ADVANCE_UP 3
#define NORMAL_ADVANCE_DOWN 4
using namespace std;
class scrollInfo
{
public:
unsigned int scrollStartX;
unsigned int scrollStartY;
unsigned int worldSizeX;
unsigned int worldSizeY;
unsigned int screenSizeX;
unsigned int screenSizeY;
public:
scrollInfo();
~scrollInfo();
};
class ScrollHandler
{
private:
scrollInfo scrollLimitsInfo[20];
unsigned int currentScrollInfo;
unsigned int currentScrollZones;
// Last saved screen and warrior positions
unsigned int screenCoordX;
unsigned int screenCoordY;
unsigned int warriorCoordX;
unsigned int warriorCoordY;
unsigned int warriorSentido;
unsigned int savedScreenCoordX;
unsigned int savedScreenCoordY;
unsigned int stateX;
unsigned int stateY;
unsigned int state;
unsigned int fastVelX;
unsigned int fastVelY;
public:
ScrollHandler(); // class constructor
~ScrollHandler(); // class destructor
void init(char *file,
unsigned int ssx, unsigned int ssy,
unsigned int wcx, unsigned int wcy, unsigned int ws,
unsigned int fvx, unsigned int fvy);
void supervisor(unsigned int wcx, unsigned int wcy, unsigned int ww, unsigned int ws, int &scx, int &scy, int &wscx, int &wscy);
void normalScrollX(unsigned int wcx, unsigned int wcy, unsigned int ws, int &scx, int &scy, int &wscx, int &wscy);
void normalScrollY(unsigned int wcx, unsigned int wcy, unsigned int ws, int &scx, int &scy, int &wscx, int &wscy);
void normalScroll(unsigned int wcx, unsigned int wcy, unsigned int ws, int &scx, int &scy, int &wscx, int &wscy);
void fastScroll(unsigned int wcx, unsigned int wcy, unsigned int ws, int &scx, int &scy, int &wscx, int &wscy);
//void newHandler(unsigned int wcx, unsigned int wcy, unsigned int ws, int &scx, int &scy, int &wscx, int &wscy);
};
#endif // SCROLLHANDLER_H
| [
"pit_ter@hotmail.com"
] | pit_ter@hotmail.com |
8d83c8c3feda3f8e2d1d79c5678e9693da178d4a | 141566e481987a01285e695e050939a6faac5c2f | /LAB_5/LAB_5/main.cpp | e284c3a253a5367a2a3db3a183826a0ecfaf9056 | [] | no_license | AnjeyNov/APK | ad3fbe4da934f2dfb5d2d791d5ad70878c4306c9 | 6e618ebc75f5820dd61b53375b3c319866a12fe5 | refs/heads/master | 2020-04-25T10:57:33.070549 | 2019-04-03T06:57:44 | 2019-04-03T06:57:44 | 172,728,104 | 1 | 0 | null | null | null | null | WINDOWS-1251 | C++ | false | false | 5,555 | cpp | #include <dos.h>
#include <ctype.h>
#include <stdio.h>
#include <conio.h>
#include <string.h>
#include <stdlib.h>
int milsec = 0;
void interrupt(*oldI70h)(...);
void interrupt newI70h(...) {
milsec++;
outp(0x70, 0x0C); // Если регистр C не будет прочитан после IRQ 8,
inp(0x71); // тогда прерывание не случится снова
outp(0x20, 0x20); // Посылаем контроллеру прерываний (master)
// сигнал EOI (end of interrupt)
outp(0xA0, 0x20); // Посылаем второму контроллеру прерываний(slave)
// сигнал EOI (end of interrupt)
}
void interrupt(*oldI4Ah)(...);
void interrupt newI4Ah(...) {
short value;
oldI4Ah();
outp(0x43, 0xB6); // 10 11 011 0
value = 1193180 / 850;
outp(0x42, (unsigned char)value);
outp(0x42, (unsigned char)(value >> 8));
outp(0x61, (inp(0x61) | 3));
delay(1000);
outp(0x61, inp(0x61) & 0xFC);
outp(0x20, 0x20);
}
unsigned char get_param(int reg)
{
unsigned char result;
outp(0x70, reg);
result = inp(0x71);
return result;
}
void wait() {
do {
outp(0x70, 0x0A);
} while (inp(0x71) & 0x80);
}
void disableUpdate() {
wait();
outp(0x70, 0x0B);
outp(0x71, (inp(0x71) | 0x80));
printf("Time update was disabled\n");
}
void enableUpdate() {
wait();
outp(0x70, 0x0B);
outp(0x71, (inp(0x71) & 0x7F));
printf("Time update was enabled\n");
}
int inputInt(int min, int max) {
int number;
do {
fflush(stdin);
} while (!scanf("%d", &number) || number<min || number>max);
return number;
}
int getInt(int BCD) {
return BCD % 16 + BCD / 16 * 10;
}
unsigned char getBCDcode(int IntNumber) {
return (unsigned char)((IntNumber / 10) << 4) | (IntNumber % 10);
}
void set_param(int value, int reg, int min, int max)
{
value = inputInt(min, max);
outp(0x70, reg);
outp(0x71, getBCDcode(value));
}
void getTotal()
{
char months[13][12] = { {"Unknown"},{"January"},{"February"},{"March"},{"April"},{"May"},{"June"},{"July"},{"August"},{"September"},{"October"},{"November"},{"December"} };
char weekdays[8][12] = { "Unknown","Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday" };
unsigned char hour, minute, second, year, month, day, weekday;
disableUpdate();
printf("The result of data and time:\n");
hour = get_param(0x04);
minute = get_param(0x02);
second = get_param(0x00);
year = get_param(0x09);
month = get_param(0x08);
day = get_param(0x07);
weekday = get_param(0x06);
printf("Time: %d:%d:%d\nData: %s %d,20%d - %s\n", getInt(hour), getInt(minute), getInt(second), months[getInt(month)], getInt(day), getInt(year), weekdays[getInt(weekday)]);
enableUpdate();
}
void setTotal()
{
int value;
disableUpdate();
printf("\nHour: ");
set_param(value, 0x04, 0, 24);
printf("\nMinutes: ");
set_param(value, 0x02, 0, 60);
printf("\nSeconds: ");
set_param(value, 0x00, 0, 60);
printf("\nDay of week: ");
set_param(value, 0x06, 1, 7);
printf("\nDay of month: ");
set_param(value, 0x07, 1, 31);
printf("\nMonth: ");
set_param(value, 0x08, 1, 12);
enableUpdate();
printf("Time is successfully set\n");
}
void delayTime() {
unsigned long delayPeriod;
unsigned char value;
_disable();
oldI70h = getvect(0x70);
setvect(0x70, newI70h);
_enable();
printf("\nEnter delay time in milliseconds: ");
scanf("%ld", &delayPeriod);
printf("Delaying ...");
// Размаскирование линии сигнала запроса от ЧРВ
value = inp(0xA1) & 0xFE; // 0xFE = 11111110, бит 0 в 0,
// чтобы разрешить прерывания от ЧРВ
// Включение периодического прерывания
outp(0xA1, value);
outp(0x70, 0x0B); // Выбираем регистр B
value = inp(0x71) | 0x40; // Читаем содержимое регистра B, 6-й бит регистра B устанавливаем в 1
outp(0x70, 0x0B); // Выбираем регистр B
outp(0x71, value);
milsec = 0;
while (milsec != delayPeriod);
printf("\nEnd delay of %d ms\n", milsec);
_disable();
setvect(0x70, oldI70h);
_enable();
enableUpdate();
}
void setAlarm()
{
int value;
disableUpdate();
printf("Enter hour: ");
value = inputInt(0, 24);
outp(0x70, 0x05);
outp(0x71, getBCDcode(value));
printf("Enter minute: ");
value = inputInt(0, 60);
outp(0x70, 0x03);
outp(0x71, getBCDcode(value));
printf("Enter second: ");
value = inputInt(0, 60);
outp(0x70, 0x01);
outp(0x71, getBCDcode(value));
outp(0x70, 0x0B);
outp(0x71, (inp(0x71) | 0x20));
enableUpdate();
printf("Alarm is set\n");
}
void viewAlarm()
{
unsigned char value;
disableUpdate();
outp(0x70, 0x05);
value = inp(0x71);
printf("Alarm - %d:", getInt(value));
outp(0x70, 0x03);
value = inp(0x71);
printf("%d:", getInt(value));
outp(0x70, 0x01);
value = inp(0x71);
printf("%d\n", getInt(value));
enableUpdate();
}
int main()
{
char choose, value;
oldI4Ah = getvect(0x4A);
setvect(0x4A, newI4Ah);
while (choose != '0') {
clrscr();
printf("\n1)Time info\n2)Set time\n3)Set alarm time\n4)Delay time(alarm clocks set)");
printf("\n5)Show alarm clocks\n0)Leave away\n");
choose = getch();
switch (choose) {
case '1': getTotal(); break;
case '2': setTotal(); break;
case '3': delayTime(); break;
case '4': setAlarm(); break;
case '5': viewAlarm(); break;
case '0': break;
}
getch();
}
setvect(0x4A, oldI4Ah);
return 0;
} | [
"AnjeyNov@gmail.com"
] | AnjeyNov@gmail.com |
50860ea3565a87a0723d9212074db8a76eb61c6c | 48383a2959bb131fc5c104153786347ef77f8bb8 | /SuperReads_RNA/global-1/jellyfish/include/jellyfish/atomic_gcc.hpp | f888dd585bbcf5635454e71d5d58143d14f08114 | [
"GPL-3.0-only",
"LicenseRef-scancode-free-unknown",
"MIT",
"GPL-1.0-or-later",
"GPL-3.0-or-later"
] | permissive | gpertea/stringtie | 1d0402ca2b5a004df1012c153d495a485e9e2ffd | 545ec76fed1de4c826dc3c96256076ea372ad427 | refs/heads/master | 2023-03-03T02:33:27.977486 | 2023-03-02T21:25:02 | 2023-03-02T21:25:02 | 25,170,618 | 319 | 82 | MIT | 2022-12-05T14:44:24 | 2014-10-13T17:59:11 | C++ | UTF-8 | C++ | false | false | 1,851 | hpp | /* This file is part of Jellyfish.
Jellyfish 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.
Jellyfish is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Jellyfish. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __JELLYFISH_ATOMIC_GCC_HPP__
#define __JELLYFISH_ATOMIC_GCC_HPP__
namespace atomic
{
class gcc
{
public:
template<typename T>
static inline T cas(volatile T *ptr, T oval, T nval) {
return __sync_val_compare_and_swap(ptr, oval, nval);
}
template<typename T>
static inline T set(T *ptr, T nval) {
return __sync_lock_test_and_set(ptr, nval);
}
template<typename T>
static inline T add_fetch(volatile T *ptr, T x) {
T ncount = *ptr, count;
do {
count = ncount;
ncount = cas((T *)ptr, count, count + x);
} while(ncount != count);
return count + x;
}
template<typename T>
static inline T fetch_add(volatile T *ptr, T x) {
T ncount = *ptr, count;
do {
count = ncount;
ncount = cas((T *)ptr, count, (T)(count + x));
} while(ncount != count);
return count;
}
template<typename T>
static inline T set_to_max(volatile T *ptr, T x) {
T count = *ptr;
while(x > count) {
T ncount = cas(ptr, count, x);
if(ncount == count)
return x;
count = ncount;
}
return count;
}
};
}
#endif
| [
"geo.pertea@gmail.com"
] | geo.pertea@gmail.com |
10f518d5a4a8bb88b49473e72b38f23bf8981305 | 21553f6afd6b81ae8403549467230cdc378f32c9 | /arm/cortex/Freescale/MKE14D7/include/arch/reg/i2c0.hpp | 4cba5ab8c2a9ebfee48b61350d9272bb26cbf699 | [] | no_license | digint/openmptl-reg-arm-cortex | 3246b68dcb60d4f7c95a46423563cab68cb02b5e | 88e105766edc9299348ccc8d2ff7a9c34cddacd3 | refs/heads/master | 2021-07-18T19:56:42.569685 | 2017-10-26T11:11:35 | 2017-10-26T11:11:35 | 108,407,162 | 3 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 7,225 | hpp | /*
* OpenMPTL - C++ Microprocessor Template Library
*
* This program is a derivative representation of a CMSIS System View
* Description (SVD) file, and is subject to the corresponding license
* (see "Freescale CMSIS-SVD License Agreement.pdf" in the parent directory).
*
* 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.
*/
////////////////////////////////////////////////////////////////////////
//
// Import from CMSIS-SVD: "Freescale/MKE14D7.svd"
//
// name: MKE14D7
// version: 1.6
// description: MKE14D7 Freescale Microcontroller
// --------------------------------------------------------------------
//
// C++ Header file, containing architecture specific register
// declarations for use in OpenMPTL. It has been converted directly
// from a CMSIS-SVD file.
//
// https://digint.ch/openmptl
// https://github.com/posborne/cmsis-svd
//
#ifndef ARCH_REG_I2C0_HPP_INCLUDED
#define ARCH_REG_I2C0_HPP_INCLUDED
#warning "using untested register declarations"
#include <register.hpp>
namespace mptl {
/**
* Inter-Integrated Circuit
*/
struct I2C0
{
static constexpr reg_addr_t base_addr = 0x40047000;
/**
* I2C Address Register 1
*/
struct A1
: public reg< uint8_t, base_addr + 0, rw, 0 >
{
using type = reg< uint8_t, base_addr + 0, rw, 0 >;
using RESERVED = regbits< type, 0, 1 >; /**< no description available */
using AD = regbits< type, 1, 7 >; /**< Address */
};
/**
* I2C Frequency Divider register
*/
struct F
: public reg< uint8_t, base_addr + 0x1, rw, 0 >
{
using type = reg< uint8_t, base_addr + 0x1, rw, 0 >;
using ICR = regbits< type, 0, 6 >; /**< ClockRate */
using MULT = regbits< type, 6, 2 >; /**< no description available */
};
/**
* I2C Control Register 1
*/
struct C1
: public reg< uint8_t, base_addr + 0x2, rw, 0 >
{
using type = reg< uint8_t, base_addr + 0x2, rw, 0 >;
using DMAEN = regbits< type, 0, 1 >; /**< DMA Enable */
using WUEN = regbits< type, 1, 1 >; /**< Wakeup Enable */
using RSTA = regbits< type, 2, 1 >; /**< Repeat START */
using TXAK = regbits< type, 3, 1 >; /**< Transmit Acknowledge Enable */
using TX = regbits< type, 4, 1 >; /**< Transmit Mode Select */
using MST = regbits< type, 5, 1 >; /**< Master Mode Select */
using IICIE = regbits< type, 6, 1 >; /**< I2C Interrupt Enable */
using IICEN = regbits< type, 7, 1 >; /**< I2C Enable */
};
/**
* I2C Status register
*/
struct S
: public reg< uint8_t, base_addr + 0x3, rw, 0x80 >
{
using type = reg< uint8_t, base_addr + 0x3, rw, 0x80 >;
using RXAK = regbits< type, 0, 1 >; /**< Receive Acknowledge */
using IICIF = regbits< type, 1, 1 >; /**< Interrupt Flag */
using SRW = regbits< type, 2, 1 >; /**< Slave Read/Write */
using RAM = regbits< type, 3, 1 >; /**< Range Address Match */
using ARBL = regbits< type, 4, 1 >; /**< Arbitration Lost */
using BUSY = regbits< type, 5, 1 >; /**< Bus Busy */
using IAAS = regbits< type, 6, 1 >; /**< Addressed As A Slave */
using TCF = regbits< type, 7, 1 >; /**< Transfer Complete Flag */
};
/**
* I2C Data I/O register
*/
struct D
: public reg< uint8_t, base_addr + 0x4, rw, 0 >
{
using type = reg< uint8_t, base_addr + 0x4, rw, 0 >;
using DATA = regbits< type, 0, 8 >; /**< Data */
};
/**
* I2C Control Register 2
*/
struct C2
: public reg< uint8_t, base_addr + 0x5, rw, 0 >
{
using type = reg< uint8_t, base_addr + 0x5, rw, 0 >;
using AD = regbits< type, 0, 3 >; /**< Slave Address */
using RMEN = regbits< type, 3, 1 >; /**< Range Address Matching Enable */
using SBRC = regbits< type, 4, 1 >; /**< Slave Baud Rate Control */
using HDRS = regbits< type, 5, 1 >; /**< High Drive Select */
using ADEXT = regbits< type, 6, 1 >; /**< Address Extension */
using GCAEN = regbits< type, 7, 1 >; /**< General Call Address Enable */
};
/**
* I2C Programmable Input Glitch Filter register
*/
struct FLT
: public reg< uint8_t, base_addr + 0x6, rw, 0 >
{
using type = reg< uint8_t, base_addr + 0x6, rw, 0 >;
// fixme: Field name equals parent register name: FLT
using FLT_ = regbits< type, 0, 5 >; /**< I2C Programmable Filter Factor */
using STOPIE = regbits< type, 5, 1 >; /**< I2C Bus Stop Interrupt Enable */
using STOPF = regbits< type, 6, 1 >; /**< I2C Bus Stop Detect Flag */
using SHEN = regbits< type, 7, 1 >; /**< Stop Hold Enable */
};
/**
* I2C Range Address register
*/
struct RA
: public reg< uint8_t, base_addr + 0x7, rw, 0 >
{
using type = reg< uint8_t, base_addr + 0x7, rw, 0 >;
using RESERVED = regbits< type, 0, 1 >; /**< no description available */
using RAD = regbits< type, 1, 7 >; /**< Range Slave Address */
};
/**
* I2C SMBus Control and Status register
*/
struct SMB
: public reg< uint8_t, base_addr + 0x8, rw, 0 >
{
using type = reg< uint8_t, base_addr + 0x8, rw, 0 >;
using SHTF2IE = regbits< type, 0, 1 >; /**< SHTF2 Interrupt Enable */
using SHTF2 = regbits< type, 1, 1 >; /**< SCL High Timeout Flag 2 */
using SHTF1 = regbits< type, 2, 1 >; /**< SCL High Timeout Flag 1 */
using SLTF = regbits< type, 3, 1 >; /**< SCL Low Timeout Flag */
using TCKSEL = regbits< type, 4, 1 >; /**< Timeout Counter Clock Select */
using SIICAEN = regbits< type, 5, 1 >; /**< Second I2C Address Enable */
using ALERTEN = regbits< type, 6, 1 >; /**< SMBus Alert Response Address Enable */
using FACK = regbits< type, 7, 1 >; /**< Fast NACK/ACK Enable */
};
/**
* I2C Address Register 2
*/
struct A2
: public reg< uint8_t, base_addr + 0x9, rw, 0xC2 >
{
using type = reg< uint8_t, base_addr + 0x9, rw, 0xC2 >;
using RESERVED = regbits< type, 0, 1 >; /**< no description available */
using SAD = regbits< type, 1, 7 >; /**< SMBus Address */
};
/**
* I2C SCL Low Timeout Register High
*/
struct SLTH
: public reg< uint8_t, base_addr + 0xa, rw, 0 >
{
using type = reg< uint8_t, base_addr + 0xa, rw, 0 >;
using SSLT = regbits< type, 0, 8 >; /**< no description available */
};
/**
* I2C SCL Low Timeout Register Low
*/
struct SLTL
: public reg< uint8_t, base_addr + 0xb, rw, 0 >
{
using type = reg< uint8_t, base_addr + 0xb, rw, 0 >;
using SSLT = regbits< type, 0, 8 >; /**< no description available */
};
};
} // namespace mptl
#endif // ARCH_REG_I2C0_HPP_INCLUDED
| [
"axel@tty0.ch"
] | axel@tty0.ch |
407931e15d413d373aa6ac097b6d212d06215c25 | 0577a46d8d28e1fd8636893bbdd2b18270bb8eb8 | /chromium/gpu/command_buffer/service/shared_image/external_vk_image_overlay_representation.cc | 93c037710cca0e4cd32f7b1ffe3cd1764aa0b708 | [
"BSD-3-Clause"
] | permissive | ric2b/Vivaldi-browser | 388a328b4cb838a4c3822357a5529642f86316a5 | 87244f4ee50062e59667bf8b9ca4d5291b6818d7 | refs/heads/master | 2022-12-21T04:44:13.804535 | 2022-12-17T16:30:35 | 2022-12-17T16:30:35 | 86,637,416 | 166 | 41 | BSD-3-Clause | 2021-03-31T18:49:30 | 2017-03-29T23:09:05 | null | UTF-8 | C++ | false | false | 3,086 | cc | // Copyright 2020 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "gpu/command_buffer/service/shared_image/external_vk_image_overlay_representation.h"
#include "build/build_config.h"
#if BUILDFLAG(IS_FUCHSIA)
#include "gpu/vulkan/fuchsia/vulkan_fuchsia_ext.h"
#endif
#include "components/viz/common/gpu/vulkan_context_provider.h"
#include "gpu/vulkan/vulkan_implementation.h"
namespace gpu {
ExternalVkImageOverlayImageRepresentation::
ExternalVkImageOverlayImageRepresentation(SharedImageManager* manager,
ExternalVkImageBacking* backing,
MemoryTypeTracker* tracker)
: gpu::OverlayImageRepresentation(manager, backing, tracker),
vk_image_backing_(backing) {}
ExternalVkImageOverlayImageRepresentation::
~ExternalVkImageOverlayImageRepresentation() = default;
bool ExternalVkImageOverlayImageRepresentation::BeginReadAccess(
gfx::GpuFenceHandle& acquire_fence) {
DCHECK(read_begin_semaphores_.empty());
if (!vk_image_backing_->BeginAccess(/*readonly=*/true,
&read_begin_semaphores_,
/*is_gl=*/false)) {
return false;
}
GetAcquireFence(acquire_fence);
return true;
}
void ExternalVkImageOverlayImageRepresentation::EndReadAccess(
gfx::GpuFenceHandle release_fence) {
ExternalSemaphore read_end_semaphore;
// Not every window manager provides us with release fence or they are not
// importable to Vulkan. On these systems it's safe to access the image after
// EndReadAccess without waiting for the fence.
if (!release_fence.is_null()) {
read_end_semaphore = ExternalSemaphore::CreateFromHandle(
vk_image_backing_->context_provider(),
SemaphoreHandle(std::move(release_fence)));
}
vk_image_backing_->EndAccess(/*readonly=*/true, std::move(read_end_semaphore),
/*is_gl=*/false);
// All pending semaphores have been waited on directly or indirectly. They can
// be reused when the next submitted GPU work is done by GPU.
vk_image_backing_->ReturnPendingSemaphoresWithFenceHelper(
std::move(read_begin_semaphores_));
read_begin_semaphores_.clear();
}
gl::GLImage* ExternalVkImageOverlayImageRepresentation::GetGLImage() {
NOTREACHED();
return nullptr;
}
void ExternalVkImageOverlayImageRepresentation::GetAcquireFence(
gfx::GpuFenceHandle& fence) {
const VkDevice& device = vk_image_backing_->context_provider()
->GetDeviceQueue()
->GetVulkanDevice();
if (!read_begin_semaphores_.empty()) {
DCHECK(read_begin_semaphores_.size() == 1);
DCHECK(read_begin_semaphores_.front().is_valid());
fence = vk_image_backing_->vulkan_implementation()
->GetSemaphoreHandle(
device, read_begin_semaphores_.front().GetVkSemaphore())
.ToGpuFenceHandle();
}
}
} // namespace gpu
| [
"mathieu.caroff@free.fr"
] | mathieu.caroff@free.fr |
4ac4d85e8814c73a72574767c4368766064e448f | 8709b4be66d510f7abb4c086ecd3725e7687ce73 | /main.cu | c8969b8a3aa2ed2f0b0884ab41b1a59f88e0b6ce | [] | no_license | bijojoseph16/CSC512FreeLaunch | 450fdf6684c83b9781c5a116017c145ec15a9151 | 3573300fe2c345e98b922d434d8605e49577cff2 | refs/heads/master | 2021-09-06T02:29:18.410024 | 2018-02-01T18:13:30 | 2018-02-01T18:13:30 | 115,538,475 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 22,046 | cu | /** Minimum spanning tree -*- C++ -*-
* @file
* @section License
*
* Galois, a framework to exploit amorphous data-parallelism in irregular
* programs.
*
* Copyright (C) 2013, The University of Texas at Austin. All rights reserved.
* UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS
* SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF
* PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF
* DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH
* RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances
* shall University be liable for incidental, special, indirect, direct or
* consequential damages or loss of profits, interruption of business, or
* related expenses which may arise from use of Software or Documentation,
* including but not limited to those resulting from defects in Software and/or
* Documentation, or loss or inaccuracy of data of any kind.
*
* @Description
* Computes minimum spanning tree of a graph using Boruvka's algorithm.
*
* @author Rupesh Nasre <nasre@ices.utexas.edu>
* @author Sreepathi Pai <sreepai@ices.utexas.edu>
*/
#include "lonestargpu.h"
#include "gbar.cuh"
#include "cuda_launch_config.hpp"
#include "devel.h"
__device__ unsigned user_getOutDegree(unsigned int* noutgoing,unsigned nnodes,unsigned src) {
if (src < nnodes) {
return noutgoing[src];
}
unsigned id = blockIdx.x * blockDim.x + threadIdx.x;
printf("Error: %s(%d): thread %d, node %d out of bounds %d.\n", __FILE__, __LINE__, id, src, nnodes);
return 0;
}
__device__ unsigned user_getInDegree(unsigned int* nincoming,unsigned nnodes,unsigned dst) {
if (dst < nnodes) {
return nincoming[dst];
}
unsigned id = blockIdx.x * blockDim.x + threadIdx.x;
printf("Error: %s(%d): thread %d, node %d out of bounds %d.\n", __FILE__, __LINE__, id, dst, nnodes);
return 0;
}
__device__ unsigned user_getFirstEdge(unsigned *noutgoing,unsigned int* srcsrc,unsigned int* psrc,unsigned int nnodes,unsigned src);
__device__ unsigned user_getDestination(unsigned *noutgoing,unsigned *edgessrcdst,unsigned int* srcsrc,unsigned *psrc,unsigned int nnodes,unsigned nedges,unsigned src, unsigned nthedge) {
unsigned id = blockIdx.x * blockDim.x + threadIdx.x;
if (src < nnodes && nthedge < user_getOutDegree(noutgoing,nnodes,src)) {
unsigned edge = user_getFirstEdge(noutgoing,srcsrc,psrc,nnodes,src) + nthedge;
if (edge && edge < nedges + 1) {
return edgessrcdst[edge];
}
////printf("Error: %s(%d): thread %d, node %d: edge %d out of bounds %d.\n", __FILE__, __LINE__, id, src, edge, nedges + 1);
return nnodes;
}
/* if (src < nnodes) {
printf("Error: %s(%d): thread %d, node %d: edge %d out of bounds %d.\n", __FILE__, __LINE__, id, src, nthedge, getOutDegree(src));
} else {
printf("Error: %s(%d): thread %d, node %d out of bounds %d.\n", __FILE__, __LINE__, id, src, nnodes);
}*/
return nnodes;
}
__device__ foru user_getWeight(unsigned *noutgoing,foru* edgessrcwt,unsigned *srcsrc,unsigned *psrc,unsigned int nnodes,unsigned nedges,unsigned src, unsigned nthedge) {
unsigned id = blockIdx.x * blockDim.x + threadIdx.x;
if (src < nnodes && nthedge < user_getOutDegree(noutgoing,nnodes,src)) {
unsigned edge = user_getFirstEdge(noutgoing,srcsrc,psrc,nnodes,src) + nthedge;
if (edge && edge < nedges + 1) {
return edgessrcwt[edge];
}
////printf("Error: %s(%d): thread %d, node %d: edge %d out of bounds %d.\n", __FILE__, __LINE__, id, src, edge, nedges + 1);
return MYINFINITY;
}
/* if (src < nnodes) {
printf("Error: %s(%d): thread %d, node %d: edge %d out of bounds %d.\n", __FILE__, __LINE__, id, src, nthedge, getOutDegree(src));
} else {
printf("Error: %s(%d): thread %d, node %d out of bounds %d.\n", __FILE__, __LINE__, id, src, nnodes);
}*/
return MYINFINITY;
}
__device__ unsigned user_getFirstEdge(unsigned *noutgoing,unsigned int* srcsrc,unsigned int* psrc,unsigned int nnodes,unsigned src) {
unsigned id = blockIdx.x * blockDim.x + threadIdx.x;
if (src < nnodes) {
unsigned srcnout = user_getOutDegree(noutgoing,nnodes,src);
if (srcnout > 0 && srcsrc[src] < nnodes) {
return psrc[srcsrc[src]];
}
//printf("Error: %s(%d): thread %d, edge %d out of bounds %d.\n", __FILE__, __LINE__, id, 0, srcnout);
return 0;
}
printf("Error: %s(%d): thread %d, node %d out of bounds %d.\n", __FILE__, __LINE__, id, src, nnodes);
return 0;
}
__device__ unsigned user_getMinEdge(unsigned *noutgoing,foru* edgessrcwt,unsigned *srcsrc,unsigned *psrc,unsigned nnodes,unsigned nedges,unsigned src) {
unsigned id = blockIdx.x * blockDim.x + threadIdx.x;
if (src < nnodes) {
unsigned srcnout = user_getOutDegree(noutgoing,nnodes,src);
if (srcnout > 0) {
unsigned minedge = 0;
foru minwt = user_getWeight(noutgoing,edgessrcwt,srcsrc,psrc,nnodes,nedges,src, 0);
for (unsigned ii = 1; ii < srcnout; ++ii) {
foru wt = user_getWeight(noutgoing,edgessrcwt,srcsrc,psrc,nnodes,nedges,src, ii);
if (wt < minwt) {
minedge = ii;
minwt = wt;
}
}
return minedge;
}
printf("Error: %s(%d): thread %d, edge %d out of bounds %d.\n", __FILE__, __LINE__, id, 0, srcnout);
return 0;
}
printf("Error: %s(%d): thread %d, node %d out of bounds %d.\n", __FILE__, __LINE__, id, src, nnodes);
return 0;
}
__global__ void dinit(unsigned *mstwt, Graph graph, ComponentSpace cs, foru *eleminwts, foru *minwtcomponent, unsigned *partners, unsigned *phores, bool *processinnextiteration, unsigned *goaheadnodeofcomponent, unsigned inpid) {
unsigned id = blockIdx.x * blockDim.x + threadIdx.x;
if (inpid < graph.nnodes) id = inpid;
if (id < graph.nnodes) {
eleminwts[id] = MYINFINITY;
minwtcomponent[id] = MYINFINITY;
goaheadnodeofcomponent[id] = graph.nnodes;
phores[id] = 0;
partners[id] = id;
processinnextiteration[id] = false;
}
}
__device__ bool isBoss(unsigned *ele2comp,unsigned element) {
return atomicCAS(&ele2comp[element],element,element) == element;
}
__device__ unsigned user_find(unsigned int* ele2comp,unsigned lelement, bool compresspath= true) {
// do we need to worry about concurrency in this function?
// for other finds, no synchronization necessary as the data-structure is a tree.
// for other unifys, synchornization is not required considering that unify is going to affect only bosses, while find is going to affect only non-bosses.
unsigned element = lelement;
while (isBoss(ele2comp,element) == false) {
element = ele2comp[element];
}
if (compresspath) ele2comp[lelement] = element; // path compression.
return element;
}
__global__ void dfindelemin(unsigned *mstwt, Graph graph, ComponentSpace cs, foru *eleminwts, foru *minwtcomponent, unsigned *partners, unsigned *phore, bool *processinnextiteration, unsigned *goaheadnodeofcomponent, unsigned inpid) {
unsigned id = blockIdx.x * blockDim.x + threadIdx.x;
if (inpid < graph.nnodes) id = inpid;
if (id < graph.nnodes) {
// if I have a cross-component edge,
// find my minimum wt cross-component edge,
// inform my boss about this edge e (atomicMin).
unsigned src = id;
unsigned srcboss = cs.find(src);
unsigned dstboss = graph.nnodes;
foru minwt = MYINFINITY;
unsigned degree = graph.getOutDegree(src);
for (unsigned ii = 0; ii < degree; ++ii) {
foru wt = graph.getWeight(src, ii);
if (wt < minwt) {
unsigned dst = graph.getDestination(src, ii);
unsigned tempdstboss = cs.find(dst);
if (srcboss != tempdstboss) { // cross-component edge.
minwt = wt;
dstboss = tempdstboss;
}
}
}
dprintf("\tminwt[%d] = %d\n", id, minwt);
eleminwts[id] = minwt;
partners[id] = dstboss;
if (minwt < minwtcomponent[srcboss] && srcboss != dstboss) {
// inform boss.
foru oldminwt = atomicMin(&minwtcomponent[srcboss], minwt);
// if (oldminwt > minwt && minwtcomponent[srcboss] == minwt)
// {
// goaheadnodeofcomponent[srcboss],id); // threads with same wt edge will race.
// dprintf("\tpartner[%d(%d)] = %d init, eleminwts[id]=%d\n", id, srcboss, dstboss, eleminwts[id]);
// }
}
}
}
__global__ void dfindelemin2(unsigned *mstwt, unsigned nnodes,unsigned nedges,unsigned *noutgoing,unsigned *nincoming,unsigned *edgessrcdst,foru *edgessrcwt, unsigned *srcsrc,unsigned *psrc,
unsigned *ele2comp, foru *eleminwts, foru *minwtcomponent, unsigned *partners, unsigned *phore, bool *processinnextiteration, unsigned *goaheadnodeofcomponent, unsigned inpid) {
unsigned id = blockIdx.x * blockDim.x + threadIdx.x;
if (id < nnodes) {
unsigned src = id;
unsigned srcboss = user_find(ele2comp,src);//cs.find(src);
if(eleminwts[id] == minwtcomponent[srcboss] && srcboss != partners[id] && partners[id] != nnodes)
{ //printf("%d %d\n",id,threadIdx.x);
unsigned degree = user_getOutDegree(noutgoing,nnodes,src);
for (unsigned ii = 0; ii < degree; ++ii) {
foru wt = user_getWeight(noutgoing,edgessrcwt,srcsrc,psrc,nnodes,nedges,src, ii);
if (wt == eleminwts[id]) {
unsigned dst = user_getDestination(noutgoing,edgessrcdst,srcsrc,psrc,nnodes,nedges,src, ii);
unsigned tempdstboss = user_find(ele2comp,dst);//cs.find(dst);
if (tempdstboss == partners[id]) { // cross-component edge.
//atomicMin(&goaheadnodeofcomponent[srcboss], id);
if(atomicCAS(&goaheadnodeofcomponent[srcboss], nnodes, id) == nnodes)
{
//printf("%d: adding %d\n", id, eleminwts[id]);
//atomicAdd(wt2, eleminwts[id]);
}
}
}
}
}
}
}
//#include "child.cu"
//Remove the include statement for chid.cu and added contents of file
__global__ void child(unsigned *noutgoing,unsigned *ele2comp,unsigned *partners,unsigned id,foru *edgessrcwt,unsigned *edgessrcdst,unsigned *srcsrc,unsigned *psrc,bool *processinnextiteration,unsigned nnodes,unsigned nedges,unsigned minwt_node,foru minwt,bool minwt_found,unsigned degree)
{
unsigned ii = threadIdx.x + blockIdx.x*blockDim.x;
if(ii<degree){
foru wt = user_getWeight(noutgoing,edgessrcwt,srcsrc,psrc,nnodes,nedges,minwt_node, ii);
if (wt == minwt) {
minwt_found = true;
unsigned dst = user_getDestination(noutgoing,edgessrcdst,srcsrc,psrc,nnodes,nedges,minwt_node, ii);
unsigned tempdstboss = user_find(ele2comp,dst);
if(tempdstboss == partners[minwt_node] && tempdstboss != id)
{
processinnextiteration[minwt_node] = true;
return;
}
}
}
}
//#include "verify.cu"
//Remove the include statement and add the function body of verify.cu
__global__ void verify_min_elem(unsigned *mstwt, unsigned nnodes,unsigned nedges,unsigned *noutgoing,unsigned *nincoming,unsigned *edgessrcdst,foru *edgessrcwt, unsigned *srcsrc,unsigned *psrc,unsigned *ele2comp, foru *eleminwts, foru *minwtcomponent, unsigned *partners, unsigned *phore, bool *processinnextiteration, unsigned *goaheadnodeofcomponent, unsigned inpid ) {
unsigned id = blockIdx.x * blockDim.x + threadIdx.x;
if (inpid < nnodes) id = inpid;
if (id < nnodes) {
if(isBoss(ele2comp,id))
{
if(goaheadnodeofcomponent[id] == nnodes)
{
return;
}
unsigned minwt_node = goaheadnodeofcomponent[id];
unsigned degree = user_getOutDegree(noutgoing,nnodes,minwt_node);
foru minwt = minwtcomponent[id];
if(minwt == MYINFINITY)
return;
bool minwt_found = false;
child<<<(degree+31)/32,32>>>(noutgoing,ele2comp,partners,id,edgessrcwt,edgessrcdst,srcsrc,psrc,processinnextiteration,nnodes,nedges,minwt_node,minwt,minwt_found,degree); // only the last two arguments were modified before this call within this function
}
}
}
__global__ void elim_dups(unsigned *mstwt, Graph graph, ComponentSpace cs, foru *eleminwts, foru *minwtcomponent, unsigned *partners, unsigned *phore, bool *processinnextiteration, unsigned *goaheadnodeofcomponent, unsigned inpid) {
unsigned id = blockIdx.x * blockDim.x + threadIdx.x;
if (inpid < graph.nnodes) id = inpid;
if (id < graph.nnodes) {
if(processinnextiteration[id])
{
unsigned srcc = cs.find(id);
unsigned dstc = partners[id];
if(minwtcomponent[dstc] == eleminwts[id])
{
if(id < goaheadnodeofcomponent[dstc])
{
processinnextiteration[id] = false;
//printf("duplicate!\n");
}
}
}
}
}
__global__ void dfindcompmin(unsigned *mstwt, Graph graph, ComponentSpace cs, foru *eleminwts, foru *minwtcomponent, unsigned *partners, unsigned *phores, bool *processinnextiteration, unsigned *goaheadnodeofcomponent, unsigned inpid) {
unsigned id = blockIdx.x * blockDim.x + threadIdx.x;
if (inpid < graph.nnodes) id = inpid;
if (id < graph.nnodes) {
if(partners[id] == graph.nnodes)
return;
unsigned srcboss = cs.find(id);
unsigned dstboss = cs.find(partners[id]);
if (id != partners[id] && srcboss != dstboss && eleminwts[id] != MYINFINITY && minwtcomponent[srcboss] == eleminwts[id] && dstboss != id && goaheadnodeofcomponent[srcboss] == id) { // my edge is min outgoing-component edge.
if(!processinnextiteration[id]);
//printf("whoa!\n");
//= true;
}
else
{
if(processinnextiteration[id]);
//printf("whoa2!\n");
}
}
}
__global__ void dfindcompmintwo(unsigned *mstwt, Graph graph, ComponentSpace csw, foru *eleminwts, foru *minwtcomponent, unsigned *partners, unsigned *phores, bool *processinnextiteration, unsigned *goaheadnodeofcomponent, unsigned inpid, GlobalBarrier gb, bool *repeat, unsigned *count) {
unsigned tid = blockIdx.x * blockDim.x + threadIdx.x;
unsigned id, nthreads = blockDim.x * gridDim.x;
if (inpid < graph.nnodes) id = inpid;
unsigned up = (graph.nnodes + nthreads - 1) / nthreads * nthreads;
unsigned srcboss, dstboss;
for(id = tid; id < up; id += nthreads) {
if(id < graph.nnodes && processinnextiteration[id])
{
srcboss = csw.find(id);
dstboss = csw.find(partners[id]);
}
gb.Sync();
if (id < graph.nnodes && processinnextiteration[id] && srcboss != dstboss) {
dprintf("trying unify id=%d (%d -> %d)\n", id, srcboss, dstboss);
if (csw.unify(srcboss, dstboss)) {
atomicAdd(mstwt, eleminwts[id]);
atomicAdd(count, 1);
dprintf("u %d -> %d (%d)\n", srcboss, dstboss, eleminwts[id]);
processinnextiteration[id] = false;
eleminwts[id] = MYINFINITY; // mark end of processing to avoid getting repeated.
}
else {
*repeat = true;
}
dprintf("\tcomp[%d] = %d.\n", srcboss, csw.find(srcboss));
}
gb.Sync();
}
}
int main(int argc, char *argv[]) {
unsigned *mstwt, hmstwt = 0;
int iteration = 0;
Graph hgraph, graph;
KernelConfig kconf;
unsigned *partners, *phores;
foru *eleminwts, *minwtcomponent;
bool *processinnextiteration;
unsigned *goaheadnodeofcomponent;
const int nSM = kconf.getNumberOfSMs();
double starttime, endtime;
GlobalBarrierLifetime gb;
const size_t compmintwo_res = maximum_residency(dfindcompmintwo, 384, 0);
gb.Setup(nSM * compmintwo_res);
if (argc != 2) {
printf("Usage: %s <graph>\n", argv[0]);
exit(1);
}
hgraph.read(argv[1]);
hgraph.cudaCopy(graph);
//graph.print();
kconf.setProblemSize(graph.nnodes);
ComponentSpace cs(graph.nnodes);
if (cudaMalloc((void **)&mstwt, sizeof(unsigned)) != cudaSuccess) CudaTest("allocating mstwt failed");
CUDA_SAFE_CALL(cudaMemcpy(mstwt, &hmstwt, sizeof(hmstwt), cudaMemcpyHostToDevice)); // mstwt = 0.
if (cudaMalloc((void **)&eleminwts, graph.nnodes * sizeof(foru)) != cudaSuccess) CudaTest("allocating eleminwts failed");
if (cudaMalloc((void **)&minwtcomponent, graph.nnodes * sizeof(foru)) != cudaSuccess) CudaTest("allocating minwtcomponent failed");
if (cudaMalloc((void **)&partners, graph.nnodes * sizeof(unsigned)) != cudaSuccess) CudaTest("allocating partners failed");
if (cudaMalloc((void **)&phores, graph.nnodes * sizeof(unsigned)) != cudaSuccess) CudaTest("allocating phores failed");
if (cudaMalloc((void **)&processinnextiteration, graph.nnodes * sizeof(bool)) != cudaSuccess) CudaTest("allocating processinnextiteration failed");
if (cudaMalloc((void **)&goaheadnodeofcomponent, graph.nnodes * sizeof(unsigned)) != cudaSuccess) CudaTest("allocating goaheadnodeofcomponent failed");
kconf.setMaxThreadsPerBlock();
unsigned prevncomponents, currncomponents = graph.nnodes;
bool repeat = false, *grepeat;
CUDA_SAFE_CALL(cudaMalloc(&grepeat, sizeof(bool) * 1));
CUDA_SAFE_CALL(cudaMemcpy(grepeat, &repeat, sizeof(bool) * 1, cudaMemcpyHostToDevice));
unsigned edgecount = 0, *gedgecount;
CUDA_SAFE_CALL(cudaMalloc(&gedgecount, sizeof(unsigned) * 1));
CUDA_SAFE_CALL(cudaMemcpy(gedgecount, &edgecount, sizeof(unsigned) * 1, cudaMemcpyHostToDevice));
printf("finding mst.\n");
starttime = rtclock();
do {
++iteration;
prevncomponents = currncomponents;
dinit <<<kconf.getNumberOfBlocks(), kconf.getNumberOfBlockThreads()>>> (mstwt, graph, cs, eleminwts, minwtcomponent, partners, phores, processinnextiteration, goaheadnodeofcomponent, graph.nnodes);
//printf("0 %d\n", cs.numberOfComponentsHost());
CudaTest("dinit failed");
cudaDeviceSetCacheConfig(cudaFuncCachePreferL1);
dfindelemin <<<kconf.getNumberOfBlocks(), kconf.getNumberOfBlockThreads()>>> (mstwt, graph, cs, eleminwts, minwtcomponent, partners, phores, processinnextiteration, goaheadnodeofcomponent, graph.nnodes);
struct timespec t1,t2;
CudaTest("dfindelemin failed");
clock_gettime(CLOCK_MONOTONIC,&t1);
dfindelemin2 <<<kconf.getNumberOfBlocks(), kconf.getNumberOfBlockThreads()>>> (mstwt, graph.nnodes,graph.nedges,graph.noutgoing,graph.nincoming,graph.edgessrcdst,graph.edgessrcwt,graph.srcsrc,graph.psrc,
cs.ele2comp, eleminwts, minwtcomponent, partners, phores, processinnextiteration, goaheadnodeofcomponent, graph.nnodes);
cudaDeviceSynchronize();
clock_gettime(CLOCK_MONOTONIC,&t2);
CudaTest("dfindelemin2 failed");
cudaDeviceSetLimit(cudaLimitDevRuntimePendingLaunchCount, 4096);
cudaDeviceSynchronize();
clock_gettime(CLOCK_MONOTONIC,&t1);
//#include "callVerify.cu"
//Added contents of file in callVerify.cu
verify_min_elem <<<kconf.getNumberOfBlocks(), kconf.getNumberOfBlockThreads()>>> (mstwt, graph.nnodes,graph.nedges,graph.noutgoing,graph.nincoming,graph.edgessrcdst,graph.edgessrcwt,graph.srcsrc,graph.psrc,
cs.ele2comp, eleminwts, minwtcomponent, partners, phores, processinnextiteration, goaheadnodeofcomponent, graph.nnodes);
cudaDeviceSynchronize();
clock_gettime(CLOCK_MONOTONIC,&t2);
printf("kernel verify time %fs\n",t2.tv_sec-t1.tv_sec+(t2.tv_nsec-t1.tv_nsec)/1e9);
//elim_dups <<<kconf.getNumberOfBlocks(), kconf.getNumberOfBlockThreads()>>> (mstwt, graph, cs, eleminwts, minwtcomponent, partners, phores, processinnextiteration, goaheadnodeofcomponent, graph.nnodes);
CudaTest("dfindelemin failed");
if(debug) print_comp_mins(cs, graph, minwtcomponent, goaheadnodeofcomponent, partners, processinnextiteration);
//printf("1 %d\n", cs.numberOfComponentsHost());
//dfindcompmin <<<kconf.getNumberOfBlocks(), kconf.getNumberOfBlockThreads()>>> (mstwt, graph, cs, eleminwts, minwtcomponent, partners, phores, processinnextiteration, goaheadnodeofcomponent, graph.nnodes);
//CudaTest("dfindcompmin failed");
//printf("2 %d\n", cs.numberOfComponentsHost());
//cudaThreadSynchronize();
//printf("\n");
//cs.copy(cs2);
// if(debug) {
// cs.dump_to_file("components.txt");
// for(int i = 0; i < cs.nelements; i++) {
// dfindcompmintwo_serial <<<1, 1>>> (mstwt, graph, cs2, cs, eleminwts, minwtcomponent, partners, phores, processinnextiteration, goaheadnodeofcomponent, i, gb, grepeat, gedgecount);
// }
do {
repeat = false;
CUDA_SAFE_CALL(cudaMemcpy(grepeat, &repeat, sizeof(bool) * 1, cudaMemcpyHostToDevice));
dfindcompmintwo <<<nSM * compmintwo_res, 384>>> (mstwt, graph, cs, eleminwts, minwtcomponent, partners, phores, processinnextiteration, goaheadnodeofcomponent, graph.nnodes, gb, grepeat, gedgecount);
CudaTest("dfindcompmintwo failed");
CUDA_SAFE_CALL(cudaMemcpy(&repeat, grepeat, sizeof(bool) * 1, cudaMemcpyDeviceToHost));
} while (repeat); // only required for quicker convergence?
currncomponents = cs.numberOfComponentsHost();
CUDA_SAFE_CALL(cudaMemcpy(&hmstwt, mstwt, sizeof(hmstwt), cudaMemcpyDeviceToHost));
CUDA_SAFE_CALL(cudaMemcpy(&edgecount, gedgecount, sizeof(unsigned) * 1, cudaMemcpyDeviceToHost));
printf("\titeration %d, number of components = %d (%d), mstwt = %u mstedges = %u\n", iteration, currncomponents, prevncomponents, hmstwt, edgecount);
} while (currncomponents != prevncomponents);
CUDA_SAFE_CALL(cudaDeviceSynchronize());
endtime = rtclock();
printf("\tmstwt = %u, iterations = %d.\n", hmstwt, iteration);
printf("\t%s result: weight: %u, components: %u, edges: %u\n", argv[1], hmstwt, currncomponents, edgecount);
printf("\truntime [mst] = %f ms.\n", 1000 * (endtime - starttime));
// cleanup left to the OS.
return 0;
}
| [
"bjoseph4@ncsu.edu"
] | bjoseph4@ncsu.edu |
cc34e5625f6b91051501bab006ee0e6447662eca | 5df1a677af9379c9a82f1b29359a65ad8cbc385e | /Atcoder/AGC/AGC019/mogai.cpp | 4743ff4f27b70dd837d0d895502a1413d664e3d1 | [] | no_license | heyshb/Competitive-Programming | 92741a4e7234e1ebce685c1b870f1287bee18f1a | 363ef78d950afb53f0e5f1d2329f27dd7b9a44c2 | refs/heads/master | 2021-12-15T03:12:37.676111 | 2021-12-01T14:32:25 | 2021-12-01T14:32:25 | 122,315,094 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,214 | cpp | #include<bits/stdc++.h>
#define y1 olweradfas
#define y2 qweoisasdk
#define x1 poeriuweor
#define x2 poriewioru
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
const int MM = 1e9 + 7;
const double eps = 1e-8;
const int MAXN = 2e6 + 10;
int n, m;
void prework(){
}
void read(){
}
int bet(int x,int y,int x1,int y1,int x2,int y2)
{
if (x1 > x2) swap(x1,x2);
if (y1 > y2) swap(y1,y2);
return (x>=x1 && x<=x2 && y>=y1 && y<=y2);
}
int x1, y1, x2, y2;
int x[MAXN], y[MAXN];
int b[MAXN];
const double PI = acos(-1);
void gao1(){
int flag = 0;
for (int i = 1; i <= n; i++)
if (x[i] == x1 && y1 < y[i] && y[i] < y2)
flag++;
printf("%.15f\n", 100 * (y2 - y1) + flag * (PI * 10 - 20));
}
#define _cp(a,b) ((a)<(b))
int subseq(int n, int a[]) {
static int b[MAXN + 1];
int i, l, r, m, ret = 0;
//cout << n << endl; fflush(stdout);
for (i = 0; i < n; b[l] = i++, ret += (l> ret)) {
for (m = ((l = 1) + (r = ret)) >> 1; l <= r; m = (l + r) >> 1) {
if (_cp(a[b[m]], a[i])) {
l = m + 1;
} else {
r = m - 1;
}
}
}
return ret;
}
void solve(int casi){
// cout << "Case #" << casi << ": ";
//freopen("C.in","r",stdin);
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
scanf("%d", &n);
for (int i = 1; i <= n; i++){
scanf("%d%d", &x[i], &y[i]);
}
if ((x1 == x2) && (y1 == y2)){
puts("0");
return ;
}
//for (int i=1;i<=n;i++)printf("%d %d\n",x[i],y[i]);
vector<PII> a;
for (int i = 1; i <= n; i++){
if (bet(x[i],y[i],x1,y1,x2,y2)){
a.push_back(PII(abs(x[i] - x1), abs(y[i] - y1)));
}
}
x2 -= x1, y2 -= y1;
x2 = abs(x2);
y2 = abs(y2);
sort(a.begin(), a.end());
for (int i = 0; i < a.size(); i++)
b[i] = a[i].second;
int ret = subseq(a.size(), b);
//cout << ret << endl;
assert(ret <= min(y2,x2) + 1);
if (ret < min(y2, x2) + 1)
printf("%.15f\n", 100.0 * (x2 + y2) - (20 - 5 * PI) * ret);
else
printf("%.15f\n", 100.0 * (x2 + y2) - (20 - 5 * PI) * ret + 5 * PI);
}
void printans(){
}
int main(){
// std::ios::sync_with_stdio(false);
prework();
int T = 1;
// cin>>T;
for(int i = 1; i <= T; i++){
read();
solve(i);
printans();
}
return 0;
}
| [
"heyshb@vip.qq.com"
] | heyshb@vip.qq.com |
7c8638e3ca37bc602e3c31260439b9c6a006f54e | 5703f5cff7ca6173bd572cb0ac5b2c349b9e28aa | /project-a/1/rawsocket.cpp | 7940dff5ef88ce6ee7c83813cfc630d8f0f54562 | [] | no_license | yuratwc/NetworkProgramming-2020 | f14276b7a938ec11d50570701b9c43a5c2dc2be6 | 45569ad3ee07e811c6c1b7a2e98e28be39602be2 | refs/heads/master | 2022-12-25T14:20:29.488285 | 2020-09-25T01:36:48 | 2020-09-25T01:36:48 | 290,655,735 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,597 | cpp | #include "rawsocket.hpp"
mac_addr::mac_addr() {}
mac_addr::mac_addr(u_int8_t ptr[6]) {
for(int i = 0; i < 6; i++) {
addr[i] = (char)ptr[i];
}
}
mac_addr::mac_addr(const mac_addr& mac) {
for(int i = 0; i < 6; i++)
addr[i] = mac.addr[i];
}
void mac_addr::set(char mac[6]) {
for(int i = 0; i < 6; i++)
addr[i] = mac[i];
}
bool mac_addr::empty() const {
for(int i = 0; i < 6; i++)
if(addr[i] != 0)
return false;
return true;
}
bool mac_addr::is_cast_addr() const {
for(int i = 0; i < 6; i++)
if(addr[i] != 0xFF)
return false;
return true;
}
std::string mac_addr::str() const {
std::stringstream ss;
for (int i = 0; i < 6; i++) {
int nm = addr[i] & 0xFF;
ss << std::hex << std::setw(2) << std::setfill('0') << nm;
if(i != 5) {
ss << ':';
}
}
return ss.str();
}
raw_socket::raw_socket(std::string device_name) : socket_ptr(-1), device_name(device_name) {}
bool raw_socket::init() {
this->socket_ptr = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
if(this->socket_ptr < 0) {
perror("create-socket");
return false;
}
struct ifreq ifr;
const char* device_chars = this->device_name.c_str();
std::strncpy(ifr.ifr_name, device_chars, sizeof( ifr.ifr_name)-1);
if (ioctl(socket_ptr, SIOCGIFINDEX, &ifr) == -1) {
perror("get-socket-info");
return false;
}
//std::cout<<"socket-id:"<<this->socket_ptr<<"/"<<device_name<<std::endl;
struct packet_mreq mreq;
std::memset(&mreq, 0, sizeof(mreq));
mreq.mr_type = PACKET_MR_PROMISC;
mreq.mr_ifindex = ifr.ifr_ifindex;
if ((setsockopt(this->socket_ptr, SOL_PACKET, PACKET_ADD_MEMBERSHIP, (void *)&mreq, sizeof(mreq))) < 0)
{
perror("setsockopt");
return false;
}
struct sockaddr_ll sa;
std::memset(&sa, 0, sizeof(sa));
sa.sll_family = PF_PACKET;
sa.sll_protocol = htons(ETH_P_ALL);
sa.sll_ifindex = ifr.ifr_ifindex;
int binded = bind(this->socket_ptr, (struct sockaddr *)&sa, sizeof(sa));
if (binded == -1) {
perror("socket-bind");
close(this->socket_ptr);
return false;
}
return true;
}
ssize_t raw_socket::write_to(char* buf, size_t size) const {
return write(this->socket_ptr, buf, size);
}
void raw_socket::listen(std::function<bool(char(&buffer)[BUFFER_SIZE], int)> action) {
//void (*const action)(char(&buffer)[BUFFER_SIZE], size_t)
int size = 0;
char buf[BUFFER_SIZE];
ioctl(this->socket_ptr, FIONBIO, 1); //set non-blocking mode
while(this->socket_ptr != -1 && !this->exit_listen) {
if((size = read(this->socket_ptr, buf, sizeof(buf))) < 0) {
if(errno != EAGAIN) {
if(this->exit_listen) {
break;
}
perror("listen socket");
}
}
if(!action(buf, size))
break;
}
this->exit_listen = false;
}
void raw_socket::end_listen() {
this->exit_listen = true;
}
void raw_socket::dispose() {
if(this->socket_ptr != -1) {
int ptr = this->socket_ptr;
this->socket_ptr = -1;
shutdown(ptr, 2);
close(ptr);
}
}
raw_socket::~raw_socket() {
if(this->socket_ptr != -1)
this->dispose();
}
std::string ip2str(in_addr_t ip) {
std::stringstream ss;
for(int i = 0; i < 4; i++) {
ss << ((ip >> (8 * i)) & 0xFF);
if(i != 3) {
ss << '.';
}
}
return ss.str();
} | [
"sstawashi@gmail.com"
] | sstawashi@gmail.com |
8cb3d3a521c382c7340aa0ed1c15075a7c72dba2 | 00306216906858239223b8bbe999c8fa36e10739 | /aws-cpp-sdk-waf-regional/include/aws/waf-regional/model/ListResourcesForWebACLRequest.h | 54ae536ffa6060b629c955578fa7560529b1f29a | [
"MIT",
"Apache-2.0",
"JSON"
] | permissive | pcacjr/aws-sdk-cpp | ceea79f54b5656b1e6a7257aa8d37fb6d2609951 | 90eb0ee4be28ac23efc10c8eedf21235f9a37402 | refs/heads/master | 2021-01-19T05:48:16.578394 | 2017-09-25T00:36:13 | 2017-09-25T00:36:13 | 87,451,109 | 0 | 0 | null | 2017-04-06T16:26:57 | 2017-04-06T16:26:57 | null | UTF-8 | C++ | false | false | 3,317 | h | /*
* Copyright 2010-2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
#pragma once
#include <aws/waf-regional/WAFRegional_EXPORTS.h>
#include <aws/waf-regional/WAFRegionalRequest.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <utility>
namespace Aws
{
namespace WAFRegional
{
namespace Model
{
/**
*/
class AWS_WAFREGIONAL_API ListResourcesForWebACLRequest : public WAFRegionalRequest
{
public:
ListResourcesForWebACLRequest();
// Service request name is the Operation name which will send this request out,
// each operation should has unique request name, so that we can get operation's name from this request.
// Note: this is not true for response, multiple operations may have the same response name,
// so we can not get operation's name from response.
inline virtual const char* GetServiceRequestName() override { return "ListResourcesForWebACL"; }
Aws::String SerializePayload() const override;
Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
/**
* <p>The unique identifier (ID) of the web ACL for which to list the associated
* resources.</p>
*/
inline const Aws::String& GetWebACLId() const{ return m_webACLId; }
/**
* <p>The unique identifier (ID) of the web ACL for which to list the associated
* resources.</p>
*/
inline void SetWebACLId(const Aws::String& value) { m_webACLIdHasBeenSet = true; m_webACLId = value; }
/**
* <p>The unique identifier (ID) of the web ACL for which to list the associated
* resources.</p>
*/
inline void SetWebACLId(Aws::String&& value) { m_webACLIdHasBeenSet = true; m_webACLId = std::move(value); }
/**
* <p>The unique identifier (ID) of the web ACL for which to list the associated
* resources.</p>
*/
inline void SetWebACLId(const char* value) { m_webACLIdHasBeenSet = true; m_webACLId.assign(value); }
/**
* <p>The unique identifier (ID) of the web ACL for which to list the associated
* resources.</p>
*/
inline ListResourcesForWebACLRequest& WithWebACLId(const Aws::String& value) { SetWebACLId(value); return *this;}
/**
* <p>The unique identifier (ID) of the web ACL for which to list the associated
* resources.</p>
*/
inline ListResourcesForWebACLRequest& WithWebACLId(Aws::String&& value) { SetWebACLId(std::move(value)); return *this;}
/**
* <p>The unique identifier (ID) of the web ACL for which to list the associated
* resources.</p>
*/
inline ListResourcesForWebACLRequest& WithWebACLId(const char* value) { SetWebACLId(value); return *this;}
private:
Aws::String m_webACLId;
bool m_webACLIdHasBeenSet;
};
} // namespace Model
} // namespace WAFRegional
} // namespace Aws
| [
"henso@amazon.com"
] | henso@amazon.com |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.