blob_id stringlengths 40 40 | directory_id stringlengths 40 40 | path stringlengths 4 201 | content_id stringlengths 40 40 | detected_licenses listlengths 0 85 | license_type stringclasses 2
values | repo_name stringlengths 7 100 | snapshot_id stringlengths 40 40 | revision_id stringlengths 40 40 | branch_name stringclasses 260
values | visit_date timestamp[us] | revision_date timestamp[us] | committer_date timestamp[us] | github_id int64 11.4k 681M ⌀ | star_events_count int64 0 209k | fork_events_count int64 0 110k | gha_license_id stringclasses 17
values | gha_event_created_at timestamp[us] | gha_created_at timestamp[us] | gha_language stringclasses 80
values | src_encoding stringclasses 28
values | language stringclasses 1
value | is_vendor bool 1
class | is_generated bool 2
classes | length_bytes int64 8 9.86M | extension stringclasses 52
values | content stringlengths 8 9.86M | authors listlengths 1 1 | author stringlengths 0 119 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
af7d7483878080541704e01337c5947c284fa75f | 15d9395e396ff48ac9788fd4ad085ce807a4c477 | /SpriteComponent.hpp | c8cc0bee41c42f4f39b940a5c0fc0c56adfc848e | [
"MIT"
] | permissive | legau1000/MyGameEngine | 2a8aae3a4dd4be73e999ab1c5db1ebe116d7a78f | 11457e4f8428b4ef4548dbe7fbe0cbce24171ad0 | refs/heads/master | 2023-02-23T00:01:57.007233 | 2021-01-29T14:47:52 | 2021-01-29T14:47:52 | 327,371,406 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 465 | hpp | #pragma once
#include "Component.hpp"
class SpriteComponent: public Component
{
public:
SpriteComponent(const std::string& name, const std::string& mesh);
SpriteComponent(const std::string& name, const std::string& mesh, const std::string& material);
~SpriteComponent();
const std::string getName();
const std::string getMesh();
const std::string getMaterial();
private:
const std::string _name;
const std::string _mesh;
const std::string _material;
};
| [
"legau1000@gmail.com"
] | legau1000@gmail.com |
b4f5ca7b547ab8eae80051c6de846c750a5ecb4a | 7a3ae5cd51b02af62e41d4e306eb9bce995e1535 | /keep/sources/paintpanelmainwindow.cpp | 59f5810fd1419298170725e1bfe876fc55a77f8a | [] | no_license | nicktogo/WeDay | 0a5b8f314d9f3edad0683f44b24c6220cb560c90 | 62ac92f96f38b09eda3f377b755ecff6d3237b80 | refs/heads/master | 2021-01-10T07:07:47.501898 | 2016-01-09T18:42:10 | 2016-01-09T18:42:10 | 49,336,660 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 9,057 | cpp | #include "keep/headers/paintpanelmainwindow.h"
#include "ui_notepaintpanelmainwindow.h"
#include <QDebug>
#include <QPainter>
#include <QColor>
#include <QColorDialog>
#include <QPalette>
#include <QDateTime>
#include <QVector>
#include <QList>
#include <QPen>
#include <QFileDialog>
/*** 定义存储界面上所有图形的容器 */
QList<PaintPanelMainWindow *> picList;
/*** 定义存储界面上画笔的容器 */
QList<PaintPanelMainWindow *> poiList;
PaintPanelMainWindow::PaintPanelMainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::PaintPanelMainWindow)
{
ui->setupUi(this);
/** 设置随机数的种子,把当前时间的秒作为随机数种子 */
qsrand(QDateTime::currentDateTime().time().msec());
/*** 设置线的初始颜色为黑色 */
lineColor = Qt::black;
/*** 设置填充的初始颜色为白色 */
fillColor = QColor(240,240,240);
/*** 设置画笔的粗细默认为1 */
ui->lineSelectSpinBox->setValue(1);
lineThickness = ui->lineSelectSpinBox->value();
/*** 初始化清屏状态位 */
isClear = false;
/*** 在直线的状态下默认，填充颜色按钮不可用 */
ui->fillColorPushButton->setDisabled(true);
/*** 画笔的时候判断当前的这条线是否结束 */
isLineEnd = false;
}
PaintPanelMainWindow::~PaintPanelMainWindow()
{
delete ui;
}
/** 画图函数 */
void PaintPanelMainWindow::paintEvent(QPaintEvent *pEvent)
{
/*** 消除警告 */
pEvent->setAccepted(true);
/** this是必须有的，说明是在现在的窗口上画的 */
QPainter painter(this);
/*** 判断现在是否处于清屏状态 */
if(false == isClear)
{
QPen penNow(lineColor, lineThickness);
painter.setPen(penNow);
/*** 先画出当前的那一个 图形的形状*/
switch(ui->shapSelectComboBox->currentIndex())
{
/*** 直线 */
case 0 :
{
painter.drawLine(poi1.rx(), poi1.ry(),
poi2.rx(), poi2.ry());
break;
}
/*** 圆形 */
case 1 :
{
/*** 设置图形内部颜色 */
painter.setBrush(fillColor);
painter.drawEllipse(poi1.rx(), poi1.ry(),
poi2.rx() - poi1.rx(),poi2.ry() - poi1.ry());
break;
}
/*** 长方形 */
case 2 :
{
/*** 设置图形内部颜色 */
painter.setBrush(fillColor);
painter.drawRect(poi1.rx(), poi1.ry(),
poi2.rx() - poi1.rx(),poi2.ry() - poi1.ry());
break;
}
/*** 自己写字 */
case 3:
{
break;
}
default:
{
qDebug() << "the linethickness is wrong!";
}
}//switch(ui->shapSelectComboBox->currentIndex())
/*** 如果有画笔画的图形，要把这部分图形要画出来 */
}
else
{
isClear = false;
}
/*** 画出所有的图形 */
foreach(PaintPanelMainWindow *pTemp,picList)
{
/*** step1 得到线的颜色和粗细*/
QPen pen(pTemp->lineColor,pTemp->lineThickness);
painter.setPen(pen);
/*** step3 画图形的形状*/
switch(pTemp->shape)
{
/*** 直线 */
case 0 :
{
painter.drawLine(pTemp->poi1.rx(), pTemp->poi1.ry(),
pTemp->poi2.rx(), pTemp->poi2.ry());
break;
}
/*** 圆形 */
case 1 :
{
/*** 设置图形内部颜色 */
painter.setBrush(pTemp->fillColor);
painter.drawEllipse(pTemp->poi1.rx(), pTemp->poi1.ry(),
pTemp->poi2.rx() - pTemp->poi1.rx(),pTemp->poi2.ry() - pTemp->poi1.ry());
break;
}
/*** 长方形 */
case 2 :
{
/*** 设置图形内部颜色 */
painter.setBrush(pTemp->fillColor);
painter.drawRect(pTemp->poi1.rx(), pTemp->poi1.ry(),
pTemp->poi2.rx() - pTemp->poi1.rx(),pTemp->poi2.ry() - pTemp->poi1.ry());
break;
}
/*** 自己写字 */
case 3:
{
break;
}
default:
{
qDebug() << "the linethickness is wrong!";
}
}
}
for(QList<PaintPanelMainWindow *>::size_type index = 0; index < (poiList.size() - 1); index ++)
{
/*** 设置画笔的颜色 */
QPen penPoi(poiList[index]->lineColor,poiList[index]->lineThickness);
painter.setPen(penPoi);
if(false == poiList[index]->isLineEnd)
{
painter.drawLine(poiList[index]->poi.rx(), poiList[index]->poi.ry(),
poiList[index + 1]->poi.rx(),poiList[index + 1]->poi.ry());
}
}
}
/** 选择线条的颜色 */
void PaintPanelMainWindow::on_lineColorPushButton_clicked()
{
QColor color = QColorDialog::getColor();
lineColor = color;
if(color.isValid())
{
/** 把颜色在frame上显示出来 */
QPalette p = ui->lineColorFrame->palette();
p.setColor(QPalette::Background,color);
ui->lineColorFrame->setPalette(p);
}
}
/** 选择封闭图形填充色的颜色 */
void PaintPanelMainWindow::on_fillColorPushButton_clicked()
{
QColor color = QColorDialog::getColor();
fillColor = color;
if(color.isValid())
{
/** 把颜色在frame上显示出来 */
QPalette p = ui->fillColorFrame->palette();
p.setColor(QPalette::Background,color);
ui->fillColorFrame->setPalette(p);
}
}
/*** 鼠标按下 */
void PaintPanelMainWindow::mousePressEvent(QMouseEvent *mEvent)
{
/*** 如果是画笔状态 */
if(shape == 3)
{
/*** 画笔 */
poi = mEvent->pos();
PaintPanelMainWindow *pNew = new PaintPanelMainWindow;
pNew->poi = poi;
pNew->isLineEnd = false;
pNew->lineColor = lineColor;
pNew->lineThickness = lineThickness;
poiList << pNew;
}
else
{
/*** 画图形 */
poi1 = mEvent->pos();
}
}
/*** 鼠标移动 */
void PaintPanelMainWindow::mouseMoveEvent(QMouseEvent *mEvent)
{
/*** 如果是画笔状态 */
if(shape == 3)
{
/*** 画笔 */
poi = mEvent->pos();
PaintPanelMainWindow *pNew = new PaintPanelMainWindow;
pNew->poi = poi;
pNew->isLineEnd = false;
pNew->lineColor = lineColor;
pNew->lineThickness = lineThickness;
poiList << pNew;
}
else
{
poi2 = mEvent->pos();
}
update();
}
/*** 鼠标释放 */
void PaintPanelMainWindow::mouseReleaseEvent(QMouseEvent *mEvent)
{
/*** 如果是画笔状态 */
if(shape == 3)
{
/*** 画笔 */
poi = mEvent->pos();
PaintPanelMainWindow *pNew = new PaintPanelMainWindow;
pNew->poi = poi;
pNew->isLineEnd = true;
pNew->lineColor = lineColor;
pNew->lineThickness = lineThickness;
poiList << pNew;
}
else
{
poi2 = mEvent->pos();
PaintPanelMainWindow *pNew = new PaintPanelMainWindow;
pNew->poi1 = poi1;
pNew->poi2 = poi2;
pNew->shape = ui->shapSelectComboBox->currentIndex();
/*** 得到现在线条的颜色 */
pNew->lineColor = lineColor;
pNew->fillColor = fillColor;
pNew->lineThickness = ui->lineSelectSpinBox->value();
/** 把这个对象写入链表中 */
picList << pNew;
}
}
/*** 得到线条的粗细 */
void PaintPanelMainWindow::on_lineSelectSpinBox_valueChanged(const QString &arg1)
{
lineThickness = arg1.toInt();
}
void PaintPanelMainWindow::on_shapSelectComboBox_currentIndexChanged(int index)
{
shape = index;
/*** 如果是直线或者写字状态，没有填充色 */
if(shape == 0 || shape == 3)
{
ui->fillColorPushButton->setDisabled(true);
}
else
{
ui->fillColorPushButton->setEnabled(true);
}
}
/*** 清屏 */
void PaintPanelMainWindow::on_clearPushButton_clicked()
{
/*** 删除链表 */
while (!picList.isEmpty())
delete picList.takeFirst();
/*** 删除链表 */
while (!poiList.isEmpty())
delete poiList.takeFirst();
/*** 把清屏状态位置为true */
isClear = true;
update();
}
/*** 回退按钮 */
void PaintPanelMainWindow::on_delPushButton_clicked()
{
/*** 判断链表是否为空 */
if(!picList.isEmpty())
{
delete picList.takeLast();
}
isClear = true;
update();
}
| [
"gnick1995@gmail.com"
] | gnick1995@gmail.com |
bf0876adf300c6fa53619b299476fbe59ced912d | 5298705370c757d8846d409382f7dcb8450d48b8 | /wbs/src/FileManager/InputDirectoryManager.h | 4cbf41734de41dc3ee4ad172ccbc13266e4ebc5f | [
"MIT"
] | permissive | RNCan/WeatherBasedSimulationFramework | 3d63b6a5fd1548cc5e5bac840f9e7c5f442dcdb0 | 05719614d2460a8929066fb920517f75a6a3ed04 | refs/heads/master | 2023-07-19T21:37:08.139215 | 2023-07-13T02:29:11 | 2023-07-13T02:29:11 | 51,245,634 | 7 | 2 | null | null | null | null | WINDOWS-1250 | C++ | false | false | 880 | h | //******************************************************************************
// Project: Weather-based simulation framework (WBSF)
// Programmer: Rémi Saint-Amant
//
// It under the terms of the GNU General Public License as published by
// the Free Software Foundation
// It is provided "as is" without express or implied warranty.
//******************************************************************************
#pragma once
#include "DirectoryManager.h"
namespace WBSF
{
class CInputDirectoryManager : public CDirectoryManager
{
public:
static const char* SUB_DIR_NAME;
CInputDirectoryManager(const std::string& projectPath = "");
CInputDirectoryManager(const CInputDirectoryManager& DM);
virtual ~CInputDirectoryManager(void);
CInputDirectoryManager& operator=(const CInputDirectoryManager& NDM);
};
} | [
"Tigroux74@hotmail.com"
] | Tigroux74@hotmail.com |
a964d2e10307d9a3811647c2bf265067648bdf2a | 58ed28b8c68834074fda9528004de712641a6596 | /yarp/include/geometry_msgs_Point.h | 99c882e3824aed6f77e74fc88f27f875c6c7d105 | [] | no_license | tunaonur/icub_object_grasping | 505fa944c9d6748a3f3fd4d9a1dd15f37c5a4c6e | 25af09b1276bae2715f621f969343659512cb4b1 | refs/heads/master | 2021-01-09T20:41:18.619452 | 2016-08-16T08:01:16 | 2016-08-16T08:01:16 | 65,728,689 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,379 | h | // This is an automatically generated file.
// Generated from this geometry_msgs_Point.msg definition:
// # This contains the position of a point in free space
// float64 x
// float64 y
// float64 z
//
// Instances of this class can be read and written with YARP ports,
// using a ROS-compatible format.
#ifndef YARPMSG_TYPE_geometry_msgs_Point
#define YARPMSG_TYPE_geometry_msgs_Point
#include <string>
#include <vector>
#include <yarp/os/Wire.h>
#include <yarp/os/idl/WireTypes.h>
#include "TickTime.h"
#include "std_msgs_Header.h"
class geometry_msgs_Point : public yarp::os::idl::WirePortable {
public:
yarp::os::NetFloat64 x;
yarp::os::NetFloat64 y;
yarp::os::NetFloat64 z;
geometry_msgs_Point() {
}
bool readBare(yarp::os::ConnectionReader& connection) {
// *** x ***
x = connection.expectDouble();
// *** y ***
y = connection.expectDouble();
// *** z ***
z = connection.expectDouble();
return !connection.isError();
}
bool readBottle(yarp::os::ConnectionReader& connection) {
connection.convertTextMode();
yarp::os::idl::WireReader reader(connection);
if (!reader.readListHeader(3)) return false;
// *** x ***
x = reader.expectDouble();
// *** y ***
y = reader.expectDouble();
// *** z ***
z = reader.expectDouble();
return !connection.isError();
}
using yarp::os::idl::WirePortable::read;
bool read(yarp::os::ConnectionReader& connection) {
if (connection.isBareMode()) return readBare(connection);
return readBottle(connection);
}
bool writeBare(yarp::os::ConnectionWriter& connection) {
// *** x ***
connection.appendDouble(x);
// *** y ***
connection.appendDouble(y);
// *** z ***
connection.appendDouble(z);
return !connection.isError();
}
bool writeBottle(yarp::os::ConnectionWriter& connection) {
connection.appendInt(BOTTLE_TAG_LIST);
connection.appendInt(3);
// *** x ***
connection.appendInt(BOTTLE_TAG_DOUBLE);
connection.appendDouble((double)x);
// *** y ***
connection.appendInt(BOTTLE_TAG_DOUBLE);
connection.appendDouble((double)y);
// *** z ***
connection.appendInt(BOTTLE_TAG_DOUBLE);
connection.appendDouble((double)z);
connection.convertTextMode();
return !connection.isError();
}
using yarp::os::idl::WirePortable::write;
bool write(yarp::os::ConnectionWriter& connection) {
if (connection.isBareMode()) return writeBare(connection);
return writeBottle(connection);
}
// This class will serialize ROS style or YARP style depending on protocol.
// If you need to force a serialization style, use one of these classes:
typedef yarp::os::idl::BareStyle<geometry_msgs_Point> rosStyle;
typedef yarp::os::idl::BottleStyle<geometry_msgs_Point> bottleStyle;
// Give source text for class, ROS will need this
yarp::os::ConstString getTypeText() {
return "# This contains the position of a point in free space\n\
float64 x\n\
float64 y\n\
float64 z\n\
";
}
// Name the class, ROS will need this
yarp::os::Type getType() {
yarp::os::Type typ = yarp::os::Type::byName("geometry_msgs/Point","geometry_msgs/Point");
typ.addProperty("md5sum",yarp::os::Value("4a842b65f413084dc2b10fb484ea7f17"));
typ.addProperty("message_definition",yarp::os::Value(getTypeText()));
return typ;
}
};
#endif
| [
"tkelestemur@gmail.com"
] | tkelestemur@gmail.com |
a1ed9e5f56dc2651b3ea00b0577b33818df74695 | 8e726a6c8cf183196bfa9b90dded168aa4e523de | /libjson/_internal/Source/JSONWorker.cpp | b284a4d2a7759091e35c1ecf41aa60c4d18c416c | [
"BSD-2-Clause"
] | permissive | kr0st/fplog | 3642735982c25a4b9b9c3de99abf2ca40b828908 | e9726716e79b2bf27598c1ae32acc5a6d907b09a | refs/heads/master | 2021-01-23T09:30:08.408641 | 2018-04-15T16:54:02 | 2018-04-15T16:54:02 | 16,255,127 | 0 | 0 | null | 2017-04-21T16:40:17 | 2014-01-26T15:12:43 | C++ | UTF-8 | C++ | false | false | 24,369 | cpp | #include "JSONWorker.h"
bool used_ascii_one = false; //used to know whether or not to check for intermediates when writing, once flipped, can't be unflipped
inline json_char ascii_one(void) json_nothrow {
used_ascii_one = true;
return JSON_TEXT('\1');
}
#ifdef JSON_READ_PRIORITY
JSONNode JSONWorker::parse(const json_string & json) json_throws(std::invalid_argument) {
json_auto<json_char> s;
size_t len;
s.set(RemoveWhiteSpace(json, len, true));
return _parse_unformatted(s.ptr, s.ptr + len);
}
JSONNode JSONWorker::parse_unformatted(const json_string & json) json_throws(std::invalid_argument) {
#if defined JSON_DEBUG || defined JSON_SAFE
#ifndef JSON_NO_EXCEPTIONS
JSON_ASSERT_SAFE((json[0] == JSON_TEXT('{')) || (json[0] == JSON_TEXT('[')), JSON_TEXT("Not JSON!"), throw std::invalid_argument(json_global(EMPTY_STD_STRING)););
#else
JSON_ASSERT_SAFE((json[0] == JSON_TEXT('{')) || (json[0] == JSON_TEXT('[')), JSON_TEXT("Not JSON!"), return JSONNode(JSON_NULL););
#endif
#endif
return _parse_unformatted(json.data(), json.data() + json.length());
}
JSONNode JSONWorker::_parse_unformatted(const json_char * json, const json_char * const end) json_throws(std::invalid_argument) {
#ifdef JSON_COMMENTS
json_char firstchar = *json;
json_string _comment;
json_char * runner = (json_char*)json;
if (json_unlikely(firstchar == JSON_TEMP_COMMENT_IDENTIFIER)){ //multiple comments will be consolidated into one
newcomment:
while(*(++runner) != JSON_TEMP_COMMENT_IDENTIFIER){
JSON_ASSERT(runner != end, JSON_TEXT("Removing white space failed"));
_comment += *runner;
}
firstchar = *(++runner); //step past the trailing tag
if (json_unlikely(firstchar == JSON_TEMP_COMMENT_IDENTIFIER)){
_comment += JSON_TEXT('\n');
goto newcomment;
}
}
#else
const json_char firstchar = *json;
#endif
switch (firstchar){
case JSON_TEXT('{'):
case JSON_TEXT('['):
#if defined JSON_DEBUG || defined JSON_SAFE
if (firstchar == JSON_TEXT('[')){
if (json_unlikely(*(end - 1) != JSON_TEXT(']'))){
JSON_FAIL(JSON_TEXT("Missing final ]"));
break;
}
} else {
if (json_unlikely(*(end - 1) != JSON_TEXT('}'))){
JSON_FAIL(JSON_TEXT("Missing final }"));
break;
}
}
#endif
#ifdef JSON_COMMENTS
JSONNode foo(json_string(runner, end - runner));
foo.set_comment(_comment);
return JSONNode(true, foo); //forces it to simply return the original interal, even with ref counting off
#else
return JSONNode(json_string(json, end - json));
#endif
}
JSON_FAIL(JSON_TEXT("Not JSON!"));
#ifndef JSON_NO_EXCEPTIONS
throw std::invalid_argument(json_global(EMPTY_STD_STRING));
#else
return JSONNode(JSON_NULL);
#endif
}
#endif
#define QUOTECASE()\
case JSON_TEXT('\"'):\
while (*(++p) != JSON_TEXT('\"')){\
JSON_ASSERT_SAFE(*p, JSON_TEXT("Null terminator inside of a quotation"), return json_string::npos;);\
}\
break;
#if defined(JSON_DEBUG) || defined(JSON_SAFE)
#define NULLCASE(error)\
case JSON_TEXT('\0'):\
JSON_FAIL_SAFE(error, return json_string::npos;);\
break;
#else
#define NULLCASE(error)
#endif
#define BRACKET(left, right)\
case left: {\
size_t brac = 1;\
while (brac){\
switch (*(++p)){\
case right:\
--brac;\
break;\
case left:\
++brac;\
break;\
QUOTECASE()\
NULLCASE(JSON_TEXT("Null terminator inside of a bracket"))\
}\
}\
break;}\
case right:\
return json_string::npos;
#if defined(JSON_READ_PRIORITY) || defined(JSON_STREAM)
#if (JSON_READ_PRIORITY == HIGH) && (!(defined(JSON_LESS_MEMORY)))
#define FIND_NEXT_RELEVANT(ch, vt, po) JSONWorker::FindNextRelevant<ch>(vt, po)
template<json_char ch>
size_t JSONWorker::FindNextRelevant(const json_string & value_t, const size_t pos) json_nothrow {
#else
#define FIND_NEXT_RELEVANT(ch, vt, po) JSONWorker::FindNextRelevant(ch, vt, po)
size_t JSONWorker::FindNextRelevant(json_char ch, const json_string & value_t, const size_t pos) json_nothrow {
#endif
json_string::const_iterator start = value_t.begin();
json_string::const_iterator e = value_t.end();
for (json_string::const_iterator p = value_t.begin() + pos; p != e; ++p){
if (json_unlikely(*p == ch)) return p - start;
switch (*p){
BRACKET(JSON_TEXT('['), JSON_TEXT(']'))
BRACKET(JSON_TEXT('{'), JSON_TEXT('}'))
QUOTECASE()
}
};
return json_string::npos;
}
#endif
#ifdef JSON_COMMENTS
#define COMMENT_DELIMITER() *runner++ = JSON_TEMP_COMMENT_IDENTIFIER
#define AND_RUNNER ,runner
inline void SingleLineComment(const json_char * & p, const json_char * const end, json_char * & runner) json_nothrow {
//It is okay to add two '\5' characters here because at minimun the # and '\n' are replaced, so it's at most the same size
COMMENT_DELIMITER();
while((++p != end) && (*p != JSON_TEXT('\n'))){
*runner++ = *p;
}
COMMENT_DELIMITER();
}
#else
#define COMMENT_DELIMITER() (void)0
#define AND_RUNNER
#endif
#ifndef JSON_STRICT
inline void SingleLineComment(const json_char * & p, const json_char * const end) json_nothrow {
while((++p != end) && (*p != JSON_TEXT('\n')));
}
#endif
#if defined(JSON_LESS_MEMORY) && defined(JSON_READ_PRIORITY)
#define PRIVATE_REMOVEWHITESPACE(T, value_t, escapeQuotes, len) private_RemoveWhiteSpace(T, value_t, escapeQuotes, len)
json_char * private_RemoveWhiteSpace(bool T, const json_string & value_t, bool escapeQuotes, size_t & len) json_nothrow {
#else
#define PRIVATE_REMOVEWHITESPACE(T, value_t, escapeQuotes, len) private_RemoveWhiteSpace<T>(value_t, escapeQuotes, len)
template<bool T>
json_char * private_RemoveWhiteSpace(const json_string & value_t, bool escapeQuotes, size_t & len) json_nothrow {
#endif
json_char * result;
json_char * runner = result = json_malloc<json_char>(value_t.length() + 1); //dealing with raw memory is faster than adding to a json_string
JSON_ASSERT(result != 0, json_global(ERROR_OUT_OF_MEMORY));
const json_char * const end = value_t.data() + value_t.length();
for(const json_char * p = value_t.data(); p != end; ++p){
switch(*p){
case JSON_TEXT(' '): //defined as white space
case JSON_TEXT('\t'): //defined as white space
case JSON_TEXT('\n'): //defined as white space
case JSON_TEXT('\r'): //defined as white space
break;
#ifndef JSON_STRICT
case JSON_TEXT('/'): //a C comment
if (*(++p) == JSON_TEXT('*')){ //a multiline comment
if (T) COMMENT_DELIMITER();
while ((*(++p) != JSON_TEXT('*')) || (*(p + 1) != JSON_TEXT('/'))){
if(p == end){
COMMENT_DELIMITER();
goto endofrunner;
}
if (T) *runner++ = *p;
}
++p;
if (T) COMMENT_DELIMITER();
break;
}
//Should be a single line C comment, so let it fall through to use the bash comment stripper
JSON_ASSERT_SAFE(*p == JSON_TEXT('/'), JSON_TEXT("stray / character, not quoted, or a comment"), goto endofrunner;);
case JSON_TEXT('#'): //a bash comment
if (T){
SingleLineComment(p, end AND_RUNNER);
} else {
SingleLineComment(p, end);
}
break;
#endif
case JSON_TEXT('\"'): //a quote
*runner++ = JSON_TEXT('\"');
while(*(++p) != JSON_TEXT('\"')){ //find the end of the quotation, as white space is preserved within it
if(p == end) goto endofrunner;
switch(*p){
case JSON_TEXT('\\'):
*runner++ = JSON_TEXT('\\');
if (escapeQuotes){
*runner++ = (*++p == JSON_TEXT('\"')) ? ascii_one() : *p; //an escaped quote will reak havoc will all of my searching functions, so change it into an illegal character in JSON for convertion later on
} else {
*runner++ = *++p;
}
break;
default:
*runner++ = *p;
break;
}
}
//no break, let it fall through so that the trailing quote gets added
default:
JSON_ASSERT_SAFE((json_uchar)*p >= 32, JSON_TEXT("Invalid JSON character detected (lo)"), goto endofrunner;);
JSON_ASSERT_SAFE((json_uchar)*p <= 126, JSON_TEXT("Invalid JSON character detected (hi)"), goto endofrunner;);
*runner++ = *p;
break;
}
}
endofrunner:
len = runner - result;
return result;
}
#ifdef JSON_READ_PRIORITY
json_char * JSONWorker::RemoveWhiteSpace(const json_string & value_t, size_t & len, bool escapeQuotes) json_nothrow {
json_char * result = PRIVATE_REMOVEWHITESPACE(true, value_t, escapeQuotes, len);
result[len] = JSON_TEXT('\0');
return result;
}
#endif
json_char * JSONWorker::RemoveWhiteSpaceAndCommentsC(const json_string & value_t, bool escapeQuotes) json_nothrow {
size_t len;
json_char * result = PRIVATE_REMOVEWHITESPACE(false, value_t, escapeQuotes, len);
result[len] = JSON_TEXT('\0');
return result;
}
json_string JSONWorker::RemoveWhiteSpaceAndComments(const json_string & value_t, bool escapeQuotes) json_nothrow {
json_auto<json_char> s;
size_t len;
s.set(PRIVATE_REMOVEWHITESPACE(false, value_t, escapeQuotes, len));
return json_string(s.ptr, len);
}
#ifdef JSON_READ_PRIORITY
/*
These three functions analyze json_string literals and convert them into std::strings
This includes dealing with special characters and utf characters
*/
#ifdef JSON_UNICODE
inline json_uchar SurrogatePair(const json_uchar hi, const json_uchar lo) json_pure;
inline json_uchar SurrogatePair(const json_uchar hi, const json_uchar lo) json_nothrow {
JSON_ASSERT(sizeof(unsigned int) == 4, JSON_TEXT("size of unsigned int is not 32-bit"));
JSON_ASSERT(sizeof(json_uchar) == 4, JSON_TEXT("size of json_char is not 32-bit"));
return (((hi << 10) & 0x1FFC00) + 0x10000) | lo & 0x3FF;
}
void JSONWorker::UTF(const json_char * & pos, json_string & result, const json_char * const end) json_nothrow {
JSON_ASSERT_SAFE(((long)end - (long)pos) > 4, JSON_TEXT("UTF will go out of bounds"), return;);
json_uchar first = UTF8(pos, end);
if (json_unlikely((first > 0xD800) && (first < 0xDBFF) &&
(*(pos + 1) == '\\') && (*(pos + 2) == 'u'))){
const json_char * original_pos = pos; //if the 2nd character is not correct I need to roll back the iterator
pos += 2;
json_uchar second = UTF8(pos, end);
//surrogate pair, not two characters
if (json_unlikely((second > 0xDC00) && (second < 0xDFFF))){
result += SurrogatePair(first, second);
} else {
pos = original_pos;
}
} else {
result += first;
}
}
#endif
json_uchar JSONWorker::UTF8(const json_char * & pos, const json_char * const end) json_nothrow {
JSON_ASSERT_SAFE(((unsigned long long)end - (unsigned long long)pos) > 4, JSON_TEXT("UTF will go out of bounds"), return JSON_TEXT('\0'););
#ifdef JSON_UNICODE
++pos;
json_uchar temp = Hex(pos) << 8;
++pos;
return temp | Hex(pos);
#else
JSON_ASSERT(*(pos + 1) == JSON_TEXT('0'), JSON_TEXT("wide utf character (hihi)"));
JSON_ASSERT(*(pos + 2) == JSON_TEXT('0'), JSON_TEXT("wide utf character (hilo)"));
pos += 3;
return Hex(pos);
#endif
}
json_char JSONWorker::Hex(const json_char * & pos) json_nothrow {
/*
takes the numeric value of the next two characters and convert them
\u0058 becomes 0x58
In case of \u, it's SpecialChar's responsibility to move past the first two chars
as this method is also used for \x
*/
//First character
json_uchar hi = *pos++ - 48;
if (hi > 48){ //A-F don't immediately follow 0-9, so have to pull them down a little
hi -= 39;
} else if (hi > 9){ //neither do a-f
hi -= 7;
}
//second character
json_uchar lo = *pos - 48;
if (lo > 48){ //A-F don't immediately follow 0-9, so have to pull them down a little
lo -= 39;
} else if (lo > 9){ //neither do a-f
lo -= 7;
}
//combine them
return (json_char)((hi << 4) | lo);
}
#ifndef JSON_STRICT
inline json_char FromOctal(const json_char * & str, const json_char * const end) json_nothrow {
JSON_ASSERT_SAFE(((unsigned long long)end - (unsigned long long)str) > 3, JSON_TEXT("Octal will go out of bounds"), return JSON_TEXT('\0'););
str += 2;
return (json_char)(((((json_uchar)(*(str - 2) - 48))) << 6) | (((json_uchar)(*(str - 1) - 48)) << 3) | ((json_uchar)(*str - 48)));
}
#endif
void JSONWorker::SpecialChar(const json_char * & pos, const json_char * const end, json_string & res) json_nothrow {
JSON_ASSERT_SAFE(pos != end, JSON_TEXT("Special char termantion"), return;);
/*
Since JSON uses forward slash escaping for special characters within strings, I have to
convert these escaped characters into C characters
*/
switch(*pos){
case JSON_TEXT('\1'): //quote character (altered by RemoveWhiteSpace)
res += JSON_TEXT('\"');
break;
case JSON_TEXT('t'): //tab character
res += JSON_TEXT('\t');
break;
case JSON_TEXT('n'): //newline character
res += JSON_TEXT('\n');
break;
case JSON_TEXT('r'): //return character
res += JSON_TEXT('\r');
break;
case JSON_TEXT('\\'): //backslash
res += JSON_TEXT('\\');
break;
case JSON_TEXT('/'): //forward slash
res += JSON_TEXT('/');
break;
case JSON_TEXT('b'): //backspace
res += JSON_TEXT('\b');
break;
case JSON_TEXT('f'): //formfeed
res += JSON_TEXT('\f');
break;
case JSON_TEXT('v'): //vertical tab
res += JSON_TEXT('\v');
break;
case JSON_TEXT('u'): //utf character
#ifdef JSON_UNICODE
UTF(pos, res, end);
#else
res += UTF8(pos, end);
#endif
break;
#ifndef JSON_STRICT
case JSON_TEXT('x'): //hexidecimal ascii code
JSON_ASSERT_SAFE(((unsigned long long)end - (unsigned long long)pos) > 3, JSON_TEXT("Hex will go out of bounds"), res += JSON_TEXT('\0'); return;);
res += Hex(++pos);
break;
#ifdef __GNUC__
case JSON_TEXT('0') ... JSON_TEXT('7'):
#else
//octal encoding
case JSON_TEXT('0'):
case JSON_TEXT('1'):
case JSON_TEXT('2'):
case JSON_TEXT('3'):
case JSON_TEXT('4'):
case JSON_TEXT('5'):
case JSON_TEXT('6'):
case JSON_TEXT('7'):
#endif
res += FromOctal(pos, end);
break;
default:
res += *pos;
break;
#elif defined(JSON_DEBUG)
default:
JSON_FAIL(JSON_TEXT("Unsupported escaped character"));
break;
#endif
}
}
#ifdef JSON_LESS_MEMORY
inline void doflag(const internalJSONNode * flag, bool which, bool x) json_nothrow {
if (json_likely(which)){
flag -> _name_encoded = x;
} else {
flag -> _string_encoded = x;
}
}
json_string JSONWorker::FixString(const json_string & value_t, const internalJSONNode * flag, bool which) json_nothrow {
#define setflag(x) doflag(flag, which, x)
#else
json_string JSONWorker::FixString(const json_string & value_t, bool & flag) json_nothrow {
#define setflag(x) flag = x
#endif
//Do things like unescaping
setflag(false);
json_string res;
res.reserve(value_t.length()); //since it goes one character at a time, want to reserve it first so that it doens't have to reallocating
const json_char * const end = value_t.data() + value_t.length();
for(const json_char * p = value_t.data(); p != end; ++p){
switch (*p){
case JSON_TEXT('\\'):
setflag(true);
SpecialChar(++p, end, res);
break;
default:
res += *p;
break;
}
}
shrinkString(res); //because this is actually setting something to be stored, shrink it it need be
return res;
}
#endif
#ifdef JSON_UNICODE
#ifdef JSON_ESCAPE_WRITES
json_string JSONWorker::toSurrogatePair(json_uchar C) json_nothrow {
JSON_ASSERT(sizeof(unsigned int) == 4, JSON_TEXT("size of unsigned int is not 32-bit"));
JSON_ASSERT(sizeof(unsigned short) == 2, JSON_TEXT("size of unsigned short is not 16-bit"));
JSON_ASSERT(sizeof(json_uchar) == 4, JSON_TEXT("json_char is not 32-bit"));
//Compute the high surrogate
unsigned short HiSurrogate = 0xD800 | (((unsigned short)((unsigned int)((C >> 16) & 31)) - 1) << 6) | ((unsigned short)C) >> 10;
//compute the low surrogate
unsigned short LoSurrogate = (unsigned short) (0xDC00 | ((unsigned short)C & 1023));
json_string res;
res += toUTF8(HiSurrogate);
res += toUTF8(LoSurrogate);
return res;
}
#endif
#endif
#ifdef JSON_ESCAPE_WRITES
json_string JSONWorker::toUTF8(json_uchar p) json_nothrow {
#ifdef JSON_UNICODE
if (json_unlikely(p > 0xFFFF)) return toSurrogatePair(p);
#endif
json_string res(JSON_TEXT("\\u"));
#ifdef JSON_UNICODE
START_MEM_SCOPE
json_uchar hihi = ((p & 0xF000) >> 12) + 48;
if (hihi > 57) hihi += 7; //A-F don't immediately follow 0-9, so have to further adjust those
json_uchar hilo = ((p & 0x0F00) >> 8) + 48;
if (hilo > 57) hilo += 7; //A-F don't immediately follow 0-9, so have to further adjust those
res += hihi;
res += hilo;
END_MEM_SCOPE
json_uchar hi = ((p & 0x00F0) >> 4) + 48;
#else
res += JSON_TEXT("00");
json_uchar hi = (p >> 4) + 48;
#endif
//convert the character to be escaped into two digits between 0 and 15
if (hi > 57) hi += 7; //A-F don't immediately follow 0-9, so have to further adjust those
json_uchar lo = (p & 0x000F) + 48;
if (lo > 57) lo += 7; //A-F don't immediately follow 0-9, so have to further adjust those
res += hi;
res += lo;
return res;
}
#endif
void JSONWorker::UnfixString(const json_string & value_t, bool flag, json_string & res) json_nothrow {
if (!flag){
res += value_t;
return;
}
//Re-escapes a json_string so that it can be written out into a JSON file
const json_char * const end = value_t.data() + value_t.length();
for(const json_char * p = value_t.data(); p != end; ++p){
switch(*p){
case JSON_TEXT('\"'): //quote character
res += JSON_TEXT("\\\"");
break;
case JSON_TEXT('\\'): //backslash
res += JSON_TEXT("\\\\");
break;
#ifdef JSON_ESCAPE_WRITES
case JSON_TEXT('\t'): //tab character
res += JSON_TEXT("\\t");
break;
case JSON_TEXT('\n'): //newline character
res += JSON_TEXT("\\n");
break;
case JSON_TEXT('\r'): //return character
res += JSON_TEXT("\\r");
break;
case JSON_TEXT('/'): //forward slash
res += JSON_TEXT("\\/");
break;
case JSON_TEXT('\b'): //backspace
res += JSON_TEXT("\\b");
break;
case JSON_TEXT('\f'): //formfeed
res += JSON_TEXT("\\f");
break;
default:
{
if (json_unlikely(((json_uchar)(*p) < 32) || ((json_uchar)(*p) > 126))){
res += toUTF8((json_uchar)(*p));
} else {
res += *p;
}
}
break;
#else
default:
res += *p;
break;
#endif
}
}
}
#ifdef JSON_READ_PRIORITY
//Create a childnode
#ifdef JSON_COMMENTS
#define ARRAY_PARAM bool array //Just to supress warnings
#else
#define ARRAY_PARAM bool
#endif
inline void JSONWorker::NewNode(const internalJSONNode * parent, const json_string & name, const json_string & value, ARRAY_PARAM) json_nothrow {
#ifdef JSON_COMMENTS
JSONNode * child;
START_MEM_SCOPE
json_string _comment;
START_MEM_SCOPE
const json_char * runner = ((array) ? value.data() : name.data());
#ifdef JSON_DEBUG
const json_char * const end = runner + value.length();
#endif
if (json_unlikely(*runner == JSON_TEMP_COMMENT_IDENTIFIER)){ //multiple comments will be consolidated into one
size_t count;
const json_char * start;
newcomment:
count = 0;
start = runner + 1;
while(*(++runner) != JSON_TEMP_COMMENT_IDENTIFIER){
JSON_ASSERT(runner != end, JSON_TEXT("Removing white space failed"));
++count;
}
if (count) _comment += json_string(start, count);
if (json_unlikely(*(++runner) == JSON_TEMP_COMMENT_IDENTIFIER)){ //step past the trailing tag
_comment += JSON_TEXT('\n');
goto newcomment;
}
}
internalJSONNode * myinternal;
if (array){
myinternal = internalJSONNode::newInternal(name, runner);
} else {
myinternal = internalJSONNode::newInternal(++runner, value);
}
child = JSONNode::newJSONNode(myinternal);
END_MEM_SCOPE
child -> set_comment(_comment);
END_MEM_SCOPE
const_cast<internalJSONNode*>(parent) -> CHILDREN -> push_back(child); //attach it to the parent node
#else
if (name.empty()){
const_cast<internalJSONNode*>(parent) -> CHILDREN -> push_back(JSONNode::newJSONNode(internalJSONNode::newInternal(name, value))); //attach it to the parent node
} else {
const_cast<internalJSONNode*>(parent) -> CHILDREN -> push_back(JSONNode::newJSONNode(internalJSONNode::newInternal(json_string(name.begin() + 1, name.end()), value))); //attach it to the parent node
}
#endif
}
//Create a subarray
void JSONWorker::DoArray(const internalJSONNode * parent, const json_string & value_t) json_nothrow {
//This takes an array and creates nodes out of them
JSON_ASSERT(!value_t.empty(), JSON_TEXT("DoArray is empty"));
JSON_ASSERT_SAFE(value_t[0] == JSON_TEXT('['), JSON_TEXT("DoArray is not an array"), parent -> Nullify(); return;);
if (json_unlikely(value_t.length() <= 2)) return; // just a [] (blank array)
#ifdef JSON_SAFE
json_string newValue; //share this so it has a reserved buffer
#endif
size_t starting = 1; //ignore the [
//Not sure what's in the array, so we have to use commas
for(size_t ending = FIND_NEXT_RELEVANT(JSON_TEXT(','), value_t, 1);
ending != json_string::npos;
ending = FIND_NEXT_RELEVANT(JSON_TEXT(','), value_t, starting)){
#ifdef JSON_SAFE
newValue.assign(value_t.begin() + starting, value_t.begin() + ending);
JSON_ASSERT_SAFE(FIND_NEXT_RELEVANT(JSON_TEXT(':'), newValue, 0) == json_string::npos, JSON_TEXT("Key/Value pairs are not allowed in arrays"), parent -> Nullify(); return;);
NewNode(parent, json_global(EMPTY_JSON_STRING), newValue, true);
#else
NewNode(parent, json_global(EMPTY_JSON_STRING), json_string(value_t.begin() + starting, value_t.begin() + ending), true);
#endif
starting = ending + 1;
}
//since the last one will not find the comma, we have to add it here, but ignore the final ]
#ifdef JSON_SAFE
newValue.assign(value_t.begin() + starting, value_t.end() - 1);
JSON_ASSERT_SAFE(FIND_NEXT_RELEVANT(JSON_TEXT(':'), newValue, 0) == json_string::npos, JSON_TEXT("Key/Value pairs are not allowed in arrays"), parent -> Nullify(); return;);
NewNode(parent, json_global(EMPTY_JSON_STRING), newValue, true);
#else
NewNode(parent, json_global(EMPTY_JSON_STRING), json_string(value_t.begin() + starting, value_t.end() - 1), true);
#endif
}
//Create all child nodes
void JSONWorker::DoNode(const internalJSONNode * parent, const json_string & value_t) json_nothrow {
//This take a node and creates its members and such
JSON_ASSERT(!value_t.empty(), JSON_TEXT("DoNode is empty"));
JSON_ASSERT_SAFE(value_t[0] == JSON_TEXT('{'), JSON_TEXT("DoNode is not an node"), parent -> Nullify(); return;);
if (json_unlikely(value_t.length() <= 2)) return; // just a {} (blank node)
size_t name_ending = FIND_NEXT_RELEVANT(JSON_TEXT(':'), value_t, 1); //find where the name ends
JSON_ASSERT_SAFE(name_ending != json_string::npos, JSON_TEXT("Missing :"), parent -> Nullify(); return;);
json_string name(value_t.begin() + 1, value_t.begin() + name_ending - 1); //pull the name out
for (size_t value_ending = FIND_NEXT_RELEVANT(JSON_TEXT(','), value_t, name_ending), //find the end of the value
name_starting = 1; //ignore the {
value_ending != json_string::npos;
value_ending = FIND_NEXT_RELEVANT(JSON_TEXT(','), value_t, name_ending)){
NewNode(parent, name, json_string(value_t.begin() + name_ending + 1, value_t.begin() + value_ending), false);
name_starting = value_ending + 1;
name_ending = FIND_NEXT_RELEVANT(JSON_TEXT(':'), value_t, name_starting);
JSON_ASSERT_SAFE(name_ending != json_string::npos, JSON_TEXT("Missing :"), parent -> Nullify(); return;);
name.assign(value_t.begin() + name_starting, value_t.begin() + name_ending - 1);
}
//since the last one will not find the comma, we have to add it here
NewNode(parent, name, json_string(value_t.begin() + name_ending + 1, value_t.end() - 1), false);
}
#endif
| [
"kr0st@bioreactor.me"
] | kr0st@bioreactor.me |
ec327d0e1b69926220635cebb0fb8db96b355d81 | b7d94577d69d3d0a67d6f2d00f9fe2618bee4308 | /tkEngine/EffekseerRuntime130/src/EffekseerRendererDX11/EffekseerRenderer/EffekseerRendererDX11.VertexBuffer.h | 62727d0e0b2972645b2d9f5547a95eab1c2ad44f | [] | no_license | MurakamiS/GameProject | 85fb743e7101eee85d7adac89ac792bed5679d81 | 8c1bc159258641d39bde52a130256a84757a5c4a | refs/heads/master | 2021-04-06T01:06:17.418292 | 2018-07-13T06:34:56 | 2018-07-13T06:34:56 | 125,322,751 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,007 | h |
#pragma once
//----------------------------------------------------------------------------------
// Include
//----------------------------------------------------------------------------------
#include "EffekseerRendererDX11.RendererImplemented.h"
#include "../../EffekseerRendererCommon/EffekseerRenderer.VertexBufferBase.h"
#include "EffekseerRendererDX11.DeviceObject.h"
//-----------------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------------
namespace EffekseerRendererDX11
{
//-----------------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------------
class VertexBuffer
: public DeviceObject
, public ::EffekseerRenderer::VertexBufferBase
{
private:
ID3D11Buffer* m_buffer;
void* m_lockedResource;
uint32_t m_vertexRingOffset;
bool m_ringBufferLock;
int32_t m_ringLockedOffset;
int32_t m_ringLockedSize;
VertexBuffer( RendererImplemented* renderer, ID3D11Buffer* buffer, int size, bool isDynamic );
public:
virtual ~VertexBuffer();
static VertexBuffer* Create( RendererImplemented* renderer, int size, bool isDynamic );
ID3D11Buffer* GetInterface() { return m_buffer; }
public: // デバイス復旧用
virtual void OnLostDevice();
virtual void OnResetDevice();
public:
void Lock();
bool RingBufferLock( int32_t size, int32_t& offset, void*& data );
bool TryRingBufferLock(int32_t size, int32_t& offset, void*& data);
void Unlock();
};
//-----------------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------------
}
//-----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------- | [
"kbc17b21@stu.kawahara.ac.jp"
] | kbc17b21@stu.kawahara.ac.jp |
3d943c3c5b5818f1726032601e4e4b7c95490173 | c6a98b8e273e69533009e5073a505508e3a0c2c5 | /Problems/Codeforces/MayIAddALetter.cpp | 4816374e726f3f6029604d601a766316a6d4c36a | [] | no_license | BenjaminRubio/CompetitiveProgramming | 5c72a9b803e66e194fd7fe8a26d0d81d14a7fc5c | 33ba1125a2eb5ba4d6f9cbc8522c92432bc92b0d | refs/heads/master | 2023-06-08T19:43:44.069793 | 2023-05-27T18:53:32 | 2023-05-27T18:53:32 | 176,643,093 | 16 | 5 | null | null | null | null | UTF-8 | C++ | false | false | 2,219 | cpp | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)n; i++)
#define pb push_back
#define ff first
#define ss second
int N;
string R, S, Q;
ll B = 1777771, M = 999727999, P = 325255434;
vector<ll> b, H, I;
ll get(int l, int r)
{
ll h = (H[r] - H[l] + M) % M;
return (1LL * h * I[l]) % M;
}
struct Suff
{
int i = 0;
Suff() {}
Suff(int i) : i(i) {}
int lcp(const Suff &s) const
{
if (i == 0 || s.i == 0) return 1;
int l = 1, r = min(i, s.i) + 1;
while (l < r)
{
int m = (l + r) / 2;
if (get(i - m, i) != get(s.i - m, s.i)) r = m;
else l = m + 1;
}
return l;
}
bool operator<(const Suff &s) const
{
int l = lcp(s);
return l <= min(i, s.i) ? R[i - l] < R[s.i - l] : i < s.i;
}
};
int main()
{
ios::sync_with_stdio(0); cin.tie(0);
I.resize(2e5 + 1); b.resize(2e5 + 1);
I[0] = 1; rep(k, 2e5) I[k + 1] = (1LL * I[k] * P) % M;
b[0] = 1; rep(k, 2e5) b[k + 1] = (b[k] * B) % M;
cin >> S >> Q;
N = S.size(); S += Q;
stack<ll> ans; ans.push(0);
set<Suff> s; R = S;
H.assign(S.size(), 0); int l = 0; stack<set<Suff>::iterator> its;
rep(i, S.size())
{
if (S[i] == '-') { ans.pop(); s.erase(its.top()); its.pop(); l--; }
else
{
R[l] = S[i];
H[l + 1] = (H[l] + b[l] * S[i]) % M;
Suff ss(++l);
its.push(s.insert(ss).ff);
auto it = its.top();
Suff sa, sb, sc, sd; int c = 0;
if (it != s.begin()) sb = *(--it), c++;
if (it != s.begin()) sa = *(--it), c++;
rep(_, c) it++; c = 0;
if (++it != s.end()) sc = *it, c++;
if (it != s.end() && ++it != s.end()) sd = *it, c++;
ll aux = ans.top();
int ab = sa.lcp(sb), bc = sb.lcp(sc), cd = sc.lcp(sd), bs = sb.lcp(ss), cs = sc.lcp(ss);
aux -= max(bc - ab, 0) + max(cd - bc, 0);
aux += max(bs - ab, 0) + max(cs - bs, 0) + max(cd - cs, 0);
ans.push(aux);
}
if (i >= N - 1) cout << ans.top() << '\n';
}
}
| [
"benja.rubio.o@gmail.com"
] | benja.rubio.o@gmail.com |
002bc3ad94eb7182c5000530e5122cba322ecbd4 | 07e2fea8dccbd5a9c00c768cfbc95a56fafeba8e | /Codes/Trapping Rain Water.cpp | cee48fbd53276b2cf4e264dc39a9d4fb6b2571ea | [] | no_license | AllenZYoung/LeetCode | 2f6345db8e588172a9334c65060435605836e82b | 3a3ea2775242eae656997c571fdbcad6a518b5cd | refs/heads/master | 2020-12-27T11:17:41.688208 | 2016-11-28T15:06:10 | 2016-11-28T15:06:10 | 44,184,438 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 529 | cpp | class Solution {
public:
int trap(vector<int>& height) {
int left = 0, right = height.size()-1;
int res = 0;
int MaxL = 0, MaxR = 0;
while (left <= right) {
if (height[left] <= height[right]) {
if (height[left] >= MaxL) MaxL = height[left];
else res += MaxL-height[left];
left++;
} else {
if (height[right] >= MaxR) MaxR = height[right];
else res += MaxR - height[right];
right--;
}
}
return res;
}
}; | [
"allenzyoung97@gmail.com"
] | allenzyoung97@gmail.com |
f598ca96eb2e5f3e19d46c39132f4d751d67fc30 | cf5dd4707e0b47c67d88768ffc38f0f74cf33f60 | /build/VentTrackS_automoc.dir/moc_MainWindow.cpp | b1e04b92058cc682b5905e6f63393c1d1bfe4262 | [
"MIT"
] | permissive | GranitGuri/Tracking | 722a67ae5e1b2140020c5fdb6dd2e13259e3e2fa | a171046d22a85e3c5518733b4b090528dca0244e | refs/heads/master | 2020-05-24T03:50:44.016679 | 2019-07-18T14:32:37 | 2019-07-18T14:32:37 | 187,074,775 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,105 | cpp | /****************************************************************************
** Meta object code from reading C++ file 'MainWindow.h'
**
** Created by: The Qt Meta Object Compiler version 67 (Qt 5.7.1)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/
#include "../../MainWindow.h"
#include <QtCore/qbytearray.h>
#include <QtCore/qmetatype.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'MainWindow.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 67
#error "This file was generated using the moc from 5.7.1. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif
QT_BEGIN_MOC_NAMESPACE
struct qt_meta_stringdata_MainWindow_t {
QByteArrayData data[15];
char stringdata0[97];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
qptrdiff(offsetof(qt_meta_stringdata_MainWindow_t, stringdata0) + ofs \
- idx * sizeof(QByteArrayData)) \
)
static const qt_meta_stringdata_MainWindow_t qt_meta_stringdata_MainWindow = {
{
QT_MOC_LITERAL(0, 0, 10), // "MainWindow"
QT_MOC_LITERAL(1, 11, 8), // "xChanged"
QT_MOC_LITERAL(2, 20, 0), // ""
QT_MOC_LITERAL(3, 21, 1), // "x"
QT_MOC_LITERAL(4, 23, 8), // "yChanged"
QT_MOC_LITERAL(5, 32, 1), // "y"
QT_MOC_LITERAL(6, 34, 8), // "zChanged"
QT_MOC_LITERAL(7, 43, 1), // "z"
QT_MOC_LITERAL(8, 45, 8), // "tChanged"
QT_MOC_LITERAL(9, 54, 1), // "t"
QT_MOC_LITERAL(10, 56, 8), // "slotExit"
QT_MOC_LITERAL(11, 65, 7), // "changeX"
QT_MOC_LITERAL(12, 73, 7), // "changeY"
QT_MOC_LITERAL(13, 81, 7), // "changeZ"
QT_MOC_LITERAL(14, 89, 7) // "changeT"
},
"MainWindow\0xChanged\0\0x\0yChanged\0y\0"
"zChanged\0z\0tChanged\0t\0slotExit\0changeX\0"
"changeY\0changeZ\0changeT"
};
#undef QT_MOC_LITERAL
static const uint qt_meta_data_MainWindow[] = {
// content:
7, // revision
0, // classname
0, 0, // classinfo
9, 14, // methods
0, 0, // properties
0, 0, // enums/sets
0, 0, // constructors
0, // flags
4, // signalCount
// signals: name, argc, parameters, tag, flags
1, 1, 59, 2, 0x06 /* Public */,
4, 1, 62, 2, 0x06 /* Public */,
6, 1, 65, 2, 0x06 /* Public */,
8, 1, 68, 2, 0x06 /* Public */,
// slots: name, argc, parameters, tag, flags
10, 0, 71, 2, 0x0a /* Public */,
11, 1, 72, 2, 0x0a /* Public */,
12, 1, 75, 2, 0x0a /* Public */,
13, 1, 78, 2, 0x0a /* Public */,
14, 1, 81, 2, 0x0a /* Public */,
// signals: parameters
QMetaType::Void, QMetaType::Int, 3,
QMetaType::Void, QMetaType::Int, 5,
QMetaType::Void, QMetaType::Int, 7,
QMetaType::Void, QMetaType::Int, 9,
// slots: parameters
QMetaType::Void,
QMetaType::Void, QMetaType::Int, 3,
QMetaType::Void, QMetaType::Int, 5,
QMetaType::Void, QMetaType::Int, 7,
QMetaType::Void, QMetaType::Int, 9,
0 // eod
};
void MainWindow::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
MainWindow *_t = static_cast<MainWindow *>(_o);
Q_UNUSED(_t)
switch (_id) {
case 0: _t->xChanged((*reinterpret_cast< int(*)>(_a[1]))); break;
case 1: _t->yChanged((*reinterpret_cast< int(*)>(_a[1]))); break;
case 2: _t->zChanged((*reinterpret_cast< int(*)>(_a[1]))); break;
case 3: _t->tChanged((*reinterpret_cast< int(*)>(_a[1]))); break;
case 4: _t->slotExit(); break;
case 5: _t->changeX((*reinterpret_cast< int(*)>(_a[1]))); break;
case 6: _t->changeY((*reinterpret_cast< int(*)>(_a[1]))); break;
case 7: _t->changeZ((*reinterpret_cast< int(*)>(_a[1]))); break;
case 8: _t->changeT((*reinterpret_cast< int(*)>(_a[1]))); break;
default: ;
}
} else if (_c == QMetaObject::IndexOfMethod) {
int *result = reinterpret_cast<int *>(_a[0]);
void **func = reinterpret_cast<void **>(_a[1]);
{
typedef void (MainWindow::*_t)(int );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&MainWindow::xChanged)) {
*result = 0;
return;
}
}
{
typedef void (MainWindow::*_t)(int );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&MainWindow::yChanged)) {
*result = 1;
return;
}
}
{
typedef void (MainWindow::*_t)(int );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&MainWindow::zChanged)) {
*result = 2;
return;
}
}
{
typedef void (MainWindow::*_t)(int );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&MainWindow::tChanged)) {
*result = 3;
return;
}
}
}
}
const QMetaObject MainWindow::staticMetaObject = {
{ &QMainWindow::staticMetaObject, qt_meta_stringdata_MainWindow.data,
qt_meta_data_MainWindow, qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};
const QMetaObject *MainWindow::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *MainWindow::qt_metacast(const char *_clname)
{
if (!_clname) return Q_NULLPTR;
if (!strcmp(_clname, qt_meta_stringdata_MainWindow.stringdata0))
return static_cast<void*>(const_cast< MainWindow*>(this));
return QMainWindow::qt_metacast(_clname);
}
int MainWindow::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 < 9)
qt_static_metacall(this, _c, _id, _a);
_id -= 9;
} else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 9)
*reinterpret_cast<int*>(_a[0]) = -1;
_id -= 9;
}
return _id;
}
// SIGNAL 0
void MainWindow::xChanged(int _t1)
{
void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
// SIGNAL 1
void MainWindow::yChanged(int _t1)
{
void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
QMetaObject::activate(this, &staticMetaObject, 1, _a);
}
// SIGNAL 2
void MainWindow::zChanged(int _t1)
{
void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
QMetaObject::activate(this, &staticMetaObject, 2, _a);
}
// SIGNAL 3
void MainWindow::tChanged(int _t1)
{
void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
QMetaObject::activate(this, &staticMetaObject, 3, _a);
}
QT_END_MOC_NAMESPACE
| [
"granitguri.gg@gmail.com"
] | granitguri.gg@gmail.com |
f0f3a8202ea534d3877323d26ce3ac95e2828927 | 360212283a19657d43cf9870c4e2d1a29a22b80f | /Holiday.h | cf2c983797a9e83727174208778699c4249fbd03 | [
"MIT"
] | permissive | enojoker/RatesLib | 425233842969a4c4bbe4eb34150f00ea49b621ad | 4564c270ca9cfd05d8d2238266b762f2e75b3286 | refs/heads/main | 2023-04-09T08:05:28.623475 | 2021-04-16T11:54:15 | 2021-04-16T11:54:15 | 358,583,205 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,298 | h | #pragma once
#include <string>
#include <set>
#include <boost/date_time/gregorian/gregorian.hpp>
#include <fstream>
typedef boost::gregorian::date date;
typedef boost::gregorian::date_duration date_dur;
class Holiday {
private:
std::string holiday_code;
std::set<date> holidays;
public:
Holiday() {
holiday_code = "US_SIFMA";
std::fstream file;
file.open("Holidays.txt", std::ios::in);
if (file.is_open()) {
std::string tp;
while (getline(file, tp)) {
holidays.insert(boost::gregorian::from_string(tp));
}
file.close();
}
}
bool is_holiday(const date& day) const {
auto it = this->holidays.find(day);
return it != this->holidays.end();
}
};
date busday_adj(const date& sd, const Holiday& holidays) {
date current = sd;
date_dur one_day_dur = date_dur(1);
while (holidays.is_holiday(current) || current.day_of_week() == 0 || current.day_of_week() == 6) {
current = current + one_day_dur;
}
return current;
}
date bus_day_shift(const date& sd, const int& shift, const Holiday& holidays) {
date current = sd;
if (shift == 0) {
return busday_adj(current, holidays);
}
for (int i = 0; i < shift; i++) {
current = busday_adj(current, holidays);
current = current + date_dur(1);
}
current = busday_adj(current, holidays);
return current;
} | [
"heng.tan1989@gmail.com"
] | heng.tan1989@gmail.com |
e87366502bc854424523df416e5d8e67725096d2 | 15ba4aefaad5ee8d7f1d7bfb3709c289315432f6 | /1.7/字符串p型编码.cpp | ac3b2700fa0562c3508a388163f2568f8fca3919 | [
"MIT"
] | permissive | tangxiangru/NOIP | e48b253e19eca82082dd7d9dfd3d75141930e238 | 6c756df37e5cb6105f5d5eb0fd9b03a4ef8407e4 | refs/heads/master | 2022-03-01T22:55:06.509064 | 2019-09-07T05:11:46 | 2019-09-07T05:11:46 | 194,476,273 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 286 | cpp | #include<iostream>
#include<string>
using namespace std;
int main(){
string s;
cin >> s;
int count = 1;
s[s.length()] = -1;
for(int i = 0; i < s.length(); i++){
if(s[i] != s[i + 1]){
cout << count << s[i] - '0' ;
count = 1;
}
else{
count ++ ;
}
}
return 0;
}
| [
"871607149@qq.com"
] | 871607149@qq.com |
f68fdb0712bc8d24859d85f7c97e258aca5dc253 | 1aa599eaac8db3a794c66d0718cdd3aa8b0a6620 | /MyProjects/OOP/OOP/Practical 2/OOP Practical ex/teacher.cpp | 6a8d5f397bd2c19a8616924f7fa0ea0c6ea7936d | [] | no_license | pechdaniel/MyProjects | ed609bc44bdec4bff6c539387add9793f8dd9595 | 4d55b6723d45e59bad432d5a2f415b6ac70c76b1 | refs/heads/master | 2020-04-13T02:46:02.610777 | 2019-01-22T15:55:39 | 2019-01-22T15:55:39 | 162,911,177 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 319 | cpp | #include "teacher.h"
#include <sstream>
#include <string>
using namespace std;
std::string Teacher::toString()
{
int i = 0;
stringstream buff;
buff << "Name: " << name << ", Groups: ";
for (i = 0; i < groups.size() - 1; i++)
buff << groups[i] << ", ";
buff << groups[i];
return buff.str();
}
| [
"noreply@github.com"
] | noreply@github.com |
f715c92f62d33a627dedbaaf588e1c5ca62348a7 | fae8d039fcc05b986c5771901834deee1aa3b916 | /BOJ/BruteFroce/14889. 스타트와 링크.cpp | 16b5703189d2cb2105008c1372e9c88600e75139 | [] | no_license | eastgerm/eastgerm-algo | 558ce3dd7fa7bbf51ffe9210197a76e947afb634 | 3b4552e2dff860345ffabd6ffa6ab07bab968634 | refs/heads/master | 2020-09-02T16:44:14.273204 | 2020-05-12T10:35:20 | 2020-05-12T10:35:20 | 219,261,135 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,002 | cpp | //
// Created by kimdong on 2018-09-07.
//
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;
int N = 0;
int S[20][20] = { 0 };
vector<int> team1;
int total = 0;
int Min = 1000001;
void input();
void teamPick();
void match();
void check();
void output();
int chanSign(int a, int b);
int banddang(int a);
int main()
{
ios_base::sync_with_stdio(false);
input();
teamPick();
match();
output();
return 0;
}
void input() {
cin >> N;
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++) {
cin >> S[i][j];
total += S[i][j];
}
}
void teamPick() {
team1.assign(N, 1);
for (int i = 0; i < N / 2; i++)
team1[i] = 0;
}
void match() {
for(int loof=0;loof<banddang(N);loof++){
check();
next_permutation(team1.begin(), team1.end());
}
}
void check() {
int tsum1 = 0; int tsum2 = 0;
int tres = 0;
for (int i = 0; i < N; i++) {
if (!team1[i]) {
for (int j = 0; j < N; j++)
if (!team1[j])
tsum1 += S[i][j];
}
else {
for (int j = 0; j < N; j++)
if (team1[j])
tsum2 += S[i][j];
}
}
tres = chanSign(tsum1, tsum2);
Min = Min < tres ? Min : tres;
}
void output() {
cout << Min << endl;
}
int chanSign(int a, int b) {
if (a - b >= 0)
return a - b;
else
return b - a;
}
int banddang(int a) {
if (a == 2)
return 2 / 2;
else if (a == 4)
return 6 / 2;
else if (a == 6)
return 20 / 2;
else if (a == 8)
return 70 / 2;
else if (a == 10)
return 252 / 2;
else if (a == 12)
return 924 / 2;
else if (a == 14)
return 3432 / 2;
else if (a == 16)
return 12870 / 2;
else if (a == 18)
return 48620 / 2;
else if (a == 20)
return 184756 / 2;
else
return -1;
} | [
"dowk0331@gmail.com"
] | dowk0331@gmail.com |
c408c4def5231df1981e6f95c56c66472d4d9bf0 | 8f53a505489984b9490a9d09c22cfe9fa98872fb | /Source/FiftyMinInside/GuidedRocket.h | 8627a2a5e95a5eaead8602774a02a40921be0efe | [] | no_license | QuentinSauvage/50-Inside | b3163416ec4d16e359baed023f241a0654f65caf | 3689cac6b3e5bdcbcb8b543bbc10a56d498859f8 | refs/heads/master | 2020-12-13T08:43:07.201946 | 2020-08-01T10:29:39 | 2020-08-01T10:29:39 | 234,362,132 | 1 | 0 | null | 2020-03-18T13:49:49 | 2020-01-16T16:26:57 | C++ | UTF-8 | C++ | false | false | 1,296 | h | // Fill out your copyright notice in the Description page of Project Settings.
#pragma once
#include "CoreMinimal.h"
#include "Bullet.h"
#include "GameFramework/Pawn.h"
#include "GuidedRocket.generated.h"
UCLASS()
class FIFTYMININSIDE_API AGuidedRocket : public APawn
{
GENERATED_BODY()
public:
AGuidedRocket();
UFUNCTION()
virtual void OnBulletHit(AActor* SelfActor, AActor* OtherActor, FVector NormalImpulse, const FHitResult& Hit);
protected:
UPROPERTY(EditAnywhere, Category = "Components")
UStaticMeshComponent* BulletMesh;
UPROPERTY(EditAnywhere, Category = "Components")
class UProjectileMovementComponent* BulletMovement;
UPROPERTY(EditAnywhere, Category = Damage)
TSubclassOf<UDamageType> DamageType;
UPROPERTY(EditAnywhere, Category = Damage)
TSubclassOf<class ABulletExplosion> BulletExplosion;
UPROPERTY(EditAnywhere, Category = Damage)
float DamageValue;
UPROPERTY(EditAnywhere, Category = "Components")
class UParticleSystem* SpawnParticle;
UFUNCTION(BlueprintImplementableEvent, Category = "Rendering")
void ClearRenderTexture();
UPROPERTY(EditAnywhere, Category = "Components")
class USoundBase* SpawnSound;
UPROPERTY(EditAnywhere, Category = "Components")
class USoundBase* DestroyedSound;
virtual void BeginPlay() override;
};
| [
"sauvage.quentin62@gmail.com"
] | sauvage.quentin62@gmail.com |
69a9013dc5c8edc5ac9239bbf33b8413d52d0cc8 | 17d7b7d1bb29269734f5f4b5872f916e9951f050 | /include/ResourceType.h | 4e17d4a3e62c28b424cfe05c93f7b7c5733c4e5a | [] | no_license | Marneus68/WorkingTitle | a61b6e98d4a4d54b4418d26719168e6b5a70f0f4 | 142bdfd73a7359819bfd5e35a9db6acd29d3fc10 | refs/heads/master | 2021-01-14T09:29:08.550721 | 2015-10-02T11:27:54 | 2015-10-02T11:27:54 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 392 | h | #ifndef __RESOURCETYPE_H__
#define __RESOURCETYPE_H__
#include <map>
#include <string>
namespace wot {
enum class ResourceType {
NONE,
TEXT,
IMAGE,
BUTTON,
SCREEN,
SCENE
};
class ResourceTypeNames {
public:
static std::map<ResourceType, std::string> names;
};
} /* wot */
#endif /* __RESOURCETYPE_H__ */
| [
"duane.bekaert@gmail.com"
] | duane.bekaert@gmail.com |
15a785ac958bc2d7e0241aabf7b17883d355a575 | a3db71946c2fdcdee8cab60ecf1fcdf80806db57 | /src/Misc.h | eb5a44278e1dd5516d72c6aa5973ef7c90787f72 | [
"MIT"
] | permissive | Luckshya/httpreq-sqmod | e0b98ab57d806c35499f13cb23dc80a6ed7ecb99 | 51dba401a202b2beabed26d3b27b105852e4cd5a | refs/heads/master | 2021-04-17T04:13:10.402074 | 2020-11-28T15:20:25 | 2020-11-28T15:20:25 | 249,412,057 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 360 | h | #pragma once
// ------------------------------------------------------------------------------------------------
#include <mutex>
#include <future>
#include <vector>
// ------------------------------------------------------------------------------------------------
namespace SqHTTP {
void refreshFutureHolder();
void clearFuture();
} // Namespace - SqHTTP | [
"luckshyaverma@gmail.com"
] | luckshyaverma@gmail.com |
865ad463204b92cf8bed6ad88c361ded21685b7c | d2975f0a22606579e7f881d0483ffbfa26ccfe63 | /TASARIMCI/tasarim_secimi.h | 8d5051cc22ee61c41c69dabf6dce229d9c78708f | [] | no_license | adakteknoloji/FRAMEWORK | 0e07720dea2607f4a62329e3c73b4b108dbf1b78 | 2bc6bde6fd79d2393b95945e158b7866203e578b | refs/heads/master | 2021-03-27T17:39:01.747267 | 2018-11-07T13:57:57 | 2018-11-07T13:57:57 | 4,813,227 | 2 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 521 | h | #ifndef TASARIM_SECIMI_H
#define TASARIM_SECIMI_H
#include <QDialog>
#include <QTableWidget>
#include "secim_kerneli.h"
class TASARIM_SECIMI : public SECIM_KERNELI
{
public:
TASARIM_SECIMI(int * secilen_id,int belge_id,QWidget* parent = 0);
~TASARIM_SECIMI() {}
private:
int m_belge_id;
int * m_secilen_id;
void FILL_TABLE ();
int SINGLE_LINE_SELECTED (int selected_row_number);
};
#endif // TASARIM_SECIMI_H
| [
"cavit.vural@adak.com.tr"
] | cavit.vural@adak.com.tr |
b109b467dcb587ded036bd14a6e5bfbbcadb6f79 | 01a09a9d585e1e3bbc0429752bb5a9f3e2e66fe9 | /parcial1/parcial1ejercico12/main.cpp | 72cb492d7674aeee11e8884a07eb4a1480e63ce4 | [] | no_license | sergio19hernandez/clasefebrero13 | 9f5c55c97e79830d0b0face45ac520fc855ef36f | 5c67c0459bdf221fe077e74a0dc987acc6fb9814 | refs/heads/master | 2021-04-30T05:24:34.345409 | 2018-03-21T04:57:52 | 2018-03-21T04:57:52 | 121,414,198 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 922 | cpp | #include <iostream>//biblioteca de entrada y salida de datos
using namespace std;//caracteres especiales
//algoritmo que calcula el sueldo segun lo que se gane
int main()
{
//variable definition
float sueldo=0;
float total=0;
cout << "ingrese el la cantidad de sueldo : ";
//ingreso de datos de usuario
cin >> sueldo;
//condicion para calcular el pago
if(sueldo<=1000)
{
total=(sueldo-(sueldo*0.10));
cout << "sueldo con un descuento del 10%: "<< total;
}
else if(sueldo>1000 && sueldo<2000)
{
total=(sueldo-(sueldo*0.05));
cout << "total con un descuento del 5%: "<< total;
}
else
{
total=(sueldo-(sueldo*0.03));
cout << "sueldo con un descuento del 3%: "<< total;
}
return 0;
}
| [
"sergio32491999@gmail.com"
] | sergio32491999@gmail.com |
125e3ab060dd5d584cf4de5d750c1af7fc1abbcc | 0afe19dc19d0646271aab90596a3617d749e6786 | /luna/emulator/utility.cpp | 42b35e13a69891b0236515b43f0cb9540e8e6ee5 | [
"ISC"
] | permissive | byuubackup/ares | 8654d8d39a9b2cc75e1cc030fd70b6854ac0cd1f | b6e807b54f69ad18a4788868b9de33a752ea7458 | refs/heads/master | 2022-12-04T18:12:38.720148 | 2020-07-25T02:06:51 | 2020-07-25T02:06:51 | 282,349,863 | 7 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 333 | cpp | #include <nall/encode/png.hpp>
auto Emulator::captureScreenshot(const uint32_t* data, uint pitch, uint width, uint height) -> void {
string filename{Path::desktop(), "luna ", chrono::local::datetime().transform(":", "-"), ".png"};
Encode::PNG::RGB8(filename, data, pitch, width, height);
showMessage("Captured screenshot");
}
| [
"byuu_backup@protonmail.com"
] | byuu_backup@protonmail.com |
8121f47b33fffc68788b3be6e01fe314df1fe667 | 422daddefcc797d62a9169cbac3ecc7551c8e182 | /TLS/HTTP/BitIterator.h | e0e1f67be729dccb9abf352d5afeb56072b2448a | [] | no_license | ladnir/TLS | a209bd24b8b1a526586e5994703990e58c09efc3 | 0b5865bd9cdb01643dd753702de3b874ac13db9b | refs/heads/master | 2021-01-23T12:17:01.728142 | 2014-11-04T06:05:01 | 2014-11-04T06:05:01 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,960 | h | #pragma once
#include "LNA.h"
#include <windows.h> // WinApi header
template<class T>
class BitIterator
{
public:
//BitIterator(const FiniteField<T>&);
BitIterator(const LNA&);
void goToBit(const int&);
void goToMSB();
void goToLSB();
bool isInRnage() const;
//bool hasLesserBits() const;
//bool hasGreaterBits() const;
inline bool operator*() const;
BitIterator<T>& operator++();
BitIterator<T>& operator--();
bool operator<=(const BitIterator<T>&) const;
bool operator>=(const BitIterator<T>&) const;
bool operator==(const BitIterator<T>&) const;
void flipBit();
//private:
//const FiniteField<T>& mNumber;
const LNA& mNumber;
LNA::T mMask;
int mWordIdx;
int mBitIdx;
};
template<class T>
BitIterator<T>::BitIterator(const LNA& field)
: mNumber(field)
, mWordIdx(0)
, mBitIdx(0)
, mMask(1)
{}
template<class T>
void BitIterator<T>::goToBit(const int& idx)
{
mBitIdx = idx % (int) mNumber.mWordSize;
mWordIdx = idx / (int) mNumber.mWordSize;
mMask = ((T)1) << mBitIdx;
assert(mMask);
assert(mWordIdx < mNumber.mWordCount);
}
template<class T>
void BitIterator<T>::goToMSB()
{
goToBit((int)mNumber.mWordCount * (int)mNumber.mWordSize - 1);
}
template<class T>
void BitIterator<T>::goToLSB()
{
mBitIdx = 0;
mWordIdx = 0;
mMask = 1;
}
template<class T>
bool BitIterator<T>::isInRnage() const
{
return (mBitIdx >= 0 &&
mWordIdx >= 0 &&
mBitIdx < mNumber.mWordSize &&
mWordIdx < mNumber.mWordCount);
}
//template<class T>
//bool BitIterator<T>::hasLesserBits() const
//{
// return mWordIdx == 0
// && mBitIdx == 0;
//}
//
//template<class T>
//bool BitIterator<T>::hasGreaterBits() const
//{
// return mWordIdx == (mNumber.mWordCount - 1)
// && mBitIdx == (mNumber.mWordSize - 1);
//}
template<class T>
bool BitIterator<T>::operator*() const
{
assert(mMask);
return ((mNumber[mWordIdx] & mMask) != 0);
}
template<class T>
BitIterator<T>& BitIterator<T>::operator++()
{
if (mBitIdx != mNumber.mWordSize - 1){
// shift the mask inside a word
mBitIdx++;
mMask <<= 1;
}
else{
// shift the mask to the start
// of the next work
mWordIdx++;
mBitIdx = 0;
mMask = (T)1;
}
//__asm{ rol mMask, 1 }
return *this;
}
template<class T>
BitIterator<T>& BitIterator<T>::operator--()
{
if (mBitIdx != 0){
// shift the mask inside a word
mBitIdx--;
mMask >>= 1;
}
else{
// shift the mask to the start
// of the next work
mWordIdx--;
mBitIdx = (int)mNumber.mWordSize - 1;
mMask = (T)(1) << (mNumber.mWordSize - 1);
}
//__asm{ ror mMask, 1 }
return *this;
}
template<class T>
bool BitIterator<T>::operator<=(const BitIterator<T>& rhs) const
{
if (mWordIdx < rhs.mWordIdx) return true;
if (mWordIdx == rhs.mWordIdx && mBitIdx <= rhs.mBitIdx) return true;
return false;
}
template<class T>
bool BitIterator<T>::operator>=(const BitIterator<T>& rhs) const
{
if (mWordIdx > rhs.mWordIdx) return true;
if (mWordIdx == rhs.mWordIdx && mBitIdx >= rhs.mBitIdx) return true;
return false;
}
template<class T>
bool BitIterator<T>::operator==(const BitIterator<T>& rhs) const
{
if (mWordIdx == rhs.mWordIdx && mBitIdx == rhs.mBitIdx) return true;
return false;
}
template<class T>
void BitIterator<T>::flipBit()
{
mNumber[mWordIdx] ^= mMask;
}
template<class T>
std::ostream& operator << (std::ostream& stream, const BitIterator<T>& bitIter)
{
BitIterator<T> scanner(bitIter);
HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
scanner.goToMSB();
while (scanner.isInRnage())
{
if (scanner == bitIter) SetConsoleTextAttribute(hConsole, 2);
stream << *scanner;
if (scanner == bitIter) SetConsoleTextAttribute(hConsole, 7);
scanner--;
}
stream << "'";
return stream;
} | [
"rindalp@onid.orst.edu"
] | rindalp@onid.orst.edu |
eead0f1ec3c3a1387aed3238292b0493232f27e4 | 99fb156ff7474d357d03b915ab1105767bb78475 | /Basic input output/Zoo's.cpp | c8138a624542d8d55aaaa95ed7f0c4af508622d0 | [] | no_license | shamaayilahmed/hackerearth-solved | 06c01a27c467241012670155ab1ac2321126e4fa | 3265457f1166672757324123c679a48be6ecf100 | refs/heads/master | 2021-05-19T17:59:08.694559 | 2020-05-09T11:48:56 | 2020-05-09T11:48:56 | 252,056,596 | 0 | 0 | null | 2020-04-25T09:18:55 | 2020-04-01T02:58:14 | null | UTF-8 | C++ | false | false | 272 | cpp | #include <stdio.h>
#include <string.h>
int main()
{
char s[20];
int cz=0,co=0,i;
scanf("%[^\n]%*c",s);
for (int i=0;i<strlen(s);i++){
if(s[i]=='z'){
cz=cz+1;
}
else{
co=co+1;
}
}
if((2*cz)==co){
printf("Yes");
}
else{
printf("No");
}
}
| [
"noreply@github.com"
] | noreply@github.com |
d3dedd3e3e8304384da609af20823b45958b48c3 | 05f6f704017406e4f0fb388472f607f494063cdc | /encoders/encoder.hpp | 80d73dcd295d4648cbccdb5cdf87ba0632a6c8e9 | [] | no_license | Catchip/raw2jpegTest | 86bb5d59ce0c65a35fb81df7d7b94707af85fa91 | 56162421c3c7d3185a2641cbfd7e215aeb4b0612 | refs/heads/main | 2023-04-19T17:31:59.892998 | 2021-04-30T06:49:40 | 2021-04-30T06:49:40 | 362,358,587 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 162 | hpp | #ifndef _ENCODER_H
#define _ENCODER_H
#include "jpeg_encoder.hpp"
#include "TurboEncoder.hpp"
#include "opencvEncoder.hpp"
#include "libjpegEncoder.hpp"
#endif
| [
"1850301858@qq.com"
] | 1850301858@qq.com |
34fa19a58a72689778d1e46f1e0e37cb5a37c776 | b197982a06f9275d3ab21e47a270cc4de83c916e | /generated/FSCTL_FILESYSTE.h | 595636f6af8f031419add71ad3586f507724a9e3 | [] | no_license | shashanksingh/Code-Generator-for-RDP | d0f88e8ad9b7f0da9a17210b9908e8f4b2f20820 | 3919b20672a68d99cea5b07d159a60fb200efe41 | refs/heads/master | 2021-03-12T19:35:39.373928 | 2012-01-22T15:51:11 | 2012-01-22T15:51:11 | 3,240,273 | 5 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 687 | h | /*
* =====================================================================================
*
* Filename: FSCTL_FILESYSTE.h
*
* Version: 1.0
* Created: 25/06/2011 06:54:53 PM
* Revision: none
* Compiler: gcc
*
* Author:
* Company: Devon IT
*
* =====================================================================================
*/
#ifndef FSCTL_FILESYSTE_H
#define FSCTL_FILESYSTE_H
class FSCTL_FILESYSTE
public:
GET_STATISTICS_Request get{();
void set{(GET_STATISTICS_Request value );
QByteArray getBytes();
void parse(const QByteArray & packet);
private:
GET_STATISTICS_Request m_{;
protected:
};
#endif | [
"shashank.personal@gmail.com"
] | shashank.personal@gmail.com |
c5e04f2db4ed409148f14d3d8fea0b3aa1fb9eed | bfeb1afba7869f717e568394bfba2c17f2e5bbdc | /test/framework/sql_query.cpp | 8e5f1a66f950c01225d33c108c8ead63d6c83285 | [
"Apache-2.0",
"CC-BY-4.0"
] | permissive | michaeldboyd/iroha | 872d95096ea481b37451a0fd7efc9f29ffdb2979 | 28b3b399849939ed85aabb2267b0859853c8fdbb | refs/heads/master | 2020-04-27T16:17:53.376687 | 2019-03-05T06:20:54 | 2019-03-05T06:20:54 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 11,649 | cpp | /**
* Copyright Soramitsu Co., Ltd. All Rights Reserved.
* SPDX-License-Identifier: Apache-2.0
*/
#include "framework/sql_query.hpp"
#include <soci/boost-tuple.h>
#include "ametsuchi/impl/soci_utils.hpp"
#include "backend/protobuf/permissions.hpp"
#include "common/bind.hpp"
#include "common/result.hpp"
namespace framework {
namespace ametsuchi {
using iroha::ametsuchi::flatMapValue;
using iroha::ametsuchi::flatMapValues;
using iroha::ametsuchi::mapValues;
using shared_model::interface::types::AccountDetailKeyType;
using shared_model::interface::types::AccountIdType;
using shared_model::interface::types::AssetIdType;
using shared_model::interface::types::DetailType;
using shared_model::interface::types::DomainIdType;
using shared_model::interface::types::JsonType;
using shared_model::interface::types::PrecisionType;
using shared_model::interface::types::QuorumType;
using shared_model::interface::types::RoleIdType;
template <typename T, typename F>
auto SqlQuery::execute(F &&f) -> boost::optional<soci::rowset<T>> {
try {
return soci::rowset<T>{std::forward<F>(f)()};
} catch (const std::exception &e) {
log_->error("Failed to execute query: {}", e.what());
return boost::none;
}
}
template <typename T>
boost::optional<std::shared_ptr<T>> SqlQuery::fromResult(
shared_model::interface::CommonObjectsFactory::FactoryResult<
std::unique_ptr<T>> &&result) {
return result.match(
[](iroha::expected::Value<std::unique_ptr<T>> &v) {
return boost::make_optional(std::shared_ptr<T>(std::move(v.value)));
},
[&](iroha::expected::Error<std::string> &e)
-> boost::optional<std::shared_ptr<T>> {
log_->error(e.error);
return boost::none;
});
}
SqlQuery::SqlQuery(
soci::session &sql,
std::shared_ptr<shared_model::interface::CommonObjectsFactory> factory,
logger::Logger log)
: sql_{sql}, factory_{std::move(factory)}, log_{std::move(log)} {}
bool SqlQuery::hasAccountGrantablePermission(
const AccountIdType &permitee_account_id,
const AccountIdType &account_id,
shared_model::interface::permissions::Grantable permission) {
const auto perm_str =
shared_model::interface::GrantablePermissionSet({permission})
.toBitstring();
using T = boost::tuple<int>;
auto result = execute<T>([&] {
return (sql_.prepare
<< "SELECT count(*) FROM "
"account_has_grantable_permissions WHERE "
"permittee_account_id = :permittee_account_id AND "
"account_id = "
":account_id "
" AND permission & :permission = :permission ",
soci::use(permitee_account_id, "permittee_account_id"),
soci::use(account_id, "account_id"),
soci::use(perm_str, "permission"));
});
return flatMapValue<boost::optional<bool>>(
result,
[](auto &count) { return boost::make_optional(count == 1); })
.value_or(false);
}
boost::optional<std::vector<RoleIdType>> SqlQuery::getAccountRoles(
const AccountIdType &account_id) {
using T = boost::tuple<RoleIdType>;
auto result = execute<T>([&] {
return (sql_.prepare << "SELECT role_id FROM account_has_roles WHERE "
"account_id = :account_id",
soci::use(account_id));
});
return mapValues<std::vector<RoleIdType>>(
result, [&](auto &role_id) { return role_id; });
}
boost::optional<shared_model::interface::RolePermissionSet>
SqlQuery::getRolePermissions(const RoleIdType &role_name) {
using iroha::operator|;
using T = boost::tuple<std::string>;
auto result = execute<T>([&] {
return (sql_.prepare
<< "SELECT permission FROM role_has_permissions WHERE "
"role_id = :role_name",
soci::use(role_name));
});
return result | [&](auto &&st)
-> boost::optional<
shared_model::interface::RolePermissionSet> {
auto range = boost::make_iterator_range(st);
if (range.empty()) {
return shared_model::interface::RolePermissionSet{};
}
return iroha::ametsuchi::apply(range.front(), [](auto &permission) {
return shared_model::interface::RolePermissionSet(permission);
});
};
}
boost::optional<std::vector<RoleIdType>> SqlQuery::getRoles() {
using T = boost::tuple<RoleIdType>;
auto result = execute<T>(
[&] { return (sql_.prepare << "SELECT role_id FROM role"); });
return mapValues<std::vector<RoleIdType>>(
result, [&](auto &role_id) { return role_id; });
}
boost::optional<std::shared_ptr<shared_model::interface::Account>>
SqlQuery::getAccount(const AccountIdType &account_id) {
using T = boost::tuple<DomainIdType, QuorumType, JsonType>;
auto result = execute<T>([&] {
return (sql_.prepare << "SELECT domain_id, quorum, data "
"FROM account WHERE account_id = "
":account_id",
soci::use(account_id, "account_id"));
});
return flatMapValue<
boost::optional<std::shared_ptr<shared_model::interface::Account>>>(
result, [&](auto &domain_id, auto quorum, auto &data) {
return this->fromResult(
factory_->createAccount(account_id, domain_id, quorum, data));
});
}
boost::optional<std::string> SqlQuery::getAccountDetail(
const std::string &account_id,
const AccountDetailKeyType &key,
const AccountIdType &writer) {
using T = boost::tuple<DetailType>;
boost::optional<soci::rowset<T>> result;
if (key.empty() and writer.empty()) {
// retrieve all values for a specified account
std::string empty_json = "{}";
result = execute<T>([&] {
return (sql_.prepare
<< "SELECT data#>>:empty_json FROM account WHERE "
"account_id = "
":account_id;",
soci::use(empty_json),
soci::use(account_id));
});
} else if (not key.empty() and not writer.empty()) {
// retrieve values for the account, under the key and added by the
// writer
std::string filled_json = "{\"" + writer + "\"" + ", \"" + key + "\"}";
result = execute<T>([&] {
return (sql_.prepare
<< "SELECT json_build_object(:writer::text, "
"json_build_object(:key::text, (SELECT data #>> "
":filled_json "
"FROM account WHERE account_id = :account_id)));",
soci::use(writer),
soci::use(key),
soci::use(filled_json),
soci::use(account_id));
});
} else if (not writer.empty()) {
// retrieve values added by the writer under all keys
result = execute<T>([&] {
return (
sql_.prepare
<< "SELECT json_build_object(:writer::text, (SELECT data -> "
":writer FROM account WHERE account_id = :account_id));",
soci::use(writer, "writer"),
soci::use(account_id, "account_id"));
});
} else {
// retrieve values from all writers under the key
result = execute<T>([&] {
return (
sql_.prepare
<< "SELECT json_object_agg(key, value) AS json FROM (SELECT "
"json_build_object(kv.key, json_build_object(:key::text, "
"kv.value -> :key)) FROM jsonb_each((SELECT data FROM "
"account "
"WHERE account_id = :account_id)) kv WHERE kv.value ? "
":key) "
"AS "
"jsons, json_each(json_build_object);",
soci::use(key, "key"),
soci::use(account_id, "account_id"));
});
}
return flatMapValue<boost::optional<std::string>>(
result, [&](auto &json) { return boost::make_optional(json); });
}
boost::optional<std::shared_ptr<shared_model::interface::Asset>>
SqlQuery::getAsset(const AssetIdType &asset_id) {
using T = boost::tuple<DomainIdType, PrecisionType>;
auto result = execute<T>([&] {
return (
sql_.prepare
<< "SELECT domain_id, precision FROM asset WHERE asset_id = "
":asset_id",
soci::use(asset_id));
});
return flatMapValue<
boost::optional<std::shared_ptr<shared_model::interface::Asset>>>(
result, [&](auto &domain_id, auto precision) {
return this->fromResult(
factory_->createAsset(asset_id, domain_id, precision));
});
}
boost::optional<
std::vector<std::shared_ptr<shared_model::interface::AccountAsset>>>
SqlQuery::getAccountAssets(const AccountIdType &account_id) {
using T = boost::tuple<AssetIdType, std::string>;
auto result = execute<T>([&] {
return (sql_.prepare
<< "SELECT asset_id, amount FROM account_has_asset "
"WHERE account_id = :account_id",
soci::use(account_id));
});
return flatMapValues<
std::vector<std::shared_ptr<shared_model::interface::AccountAsset>>>(
result, [&](auto &asset_id, auto &amount) {
return this->fromResult(factory_->createAccountAsset(
account_id, asset_id, shared_model::interface::Amount(amount)));
});
}
boost::optional<std::shared_ptr<shared_model::interface::AccountAsset>>
SqlQuery::getAccountAsset(const AccountIdType &account_id,
const AssetIdType &asset_id) {
using T = boost::tuple<std::string>;
auto result = execute<T>([&] {
return (
sql_.prepare
<< "SELECT amount FROM account_has_asset WHERE account_id = "
":account_id AND asset_id = :asset_id",
soci::use(account_id),
soci::use(asset_id));
});
return flatMapValue<boost::optional<
std::shared_ptr<shared_model::interface::AccountAsset>>>(
result, [&](auto &amount) {
return this->fromResult(factory_->createAccountAsset(
account_id, asset_id, shared_model::interface::Amount(amount)));
});
}
boost::optional<std::shared_ptr<shared_model::interface::Domain>>
SqlQuery::getDomain(const DomainIdType &domain_id) {
using T = boost::tuple<RoleIdType>;
auto result = execute<T>([&] {
return (sql_.prepare << "SELECT default_role FROM domain "
"WHERE domain_id = :id LIMIT 1",
soci::use(domain_id));
});
return flatMapValue<
boost::optional<std::shared_ptr<shared_model::interface::Domain>>>(
result, [&](auto &default_role) {
return this->fromResult(
factory_->createDomain(domain_id, default_role));
});
}
} // namespace ametsuchi
} // namespace framework
| [
"noreply@github.com"
] | noreply@github.com |
e669fc39a5f982f7001a018a521dc3e4bba25365 | 673bdf6a4d4963ec91d10e15dcd36b1cc0aad88a | /addon/multithreading/ex-mandelbrot/mandelbrot.h | 41bb7db95ca76eb30e264f93f173ea1b80499510 | [] | no_license | enricop/qt-training | f162f22b1874c7aee50e4bc39d3b6bbc64bc6df6 | 8de0adfee929236b380ada03769063c70aa1064f | refs/heads/master | 2020-03-20T19:22:57.591843 | 2018-06-17T07:07:06 | 2018-06-17T07:07:06 | 137,635,325 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 548 | h | #ifndef MANDELBROT_H
#define MANDELBROT_H
#include <QWidget>
class QImage;
class QThread;
class Renderer;
class Mandelbrot : public QWidget
{
Q_OBJECT
public:
Mandelbrot(QWidget *parent = 0);
public slots:
void scanLineRendered(QRgb *data, int row, int width);
void finished();
protected:
void paintEvent(QPaintEvent *event);
void mousePressEvent(QMouseEvent *event);
void closeEvent(QCloseEvent *event);
private:
QImage mImage;
QThread *mRenderThread;
Renderer *mRenderer;
};
#endif // MANDELBROT_H
| [
"djohnson@ics.com"
] | djohnson@ics.com |
70d6b9b952625aa003a29b763c8fcd252153197f | c0b353496618456e63eef9600c037cbf80e3006b | /tests/chaos/main.cpp | 4bfbb9b7e961afc6bf18533b267ae51c3e1f8a99 | [] | no_license | markgarcia/galena | 81369617cece0bdcbb62d629c52ac266cd052dca | 268c80c4ade28182eae9a8a188525c57b61b55d1 | refs/heads/master | 2021-08-23T18:29:16.669269 | 2016-08-07T06:55:06 | 2016-08-07T06:56:35 | 113,257,446 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,236 | cpp | #include <galena/shader/shader.h>
#include <galena/window_render_surface.h>
#include <galena/renderer.h>
#include <galena/window.h>
#include <galena/application.h>
#include <array>
namespace shaders {
galena::pixel_shader_position vertex_shader(galena::float4 pos);
galena::float4 pixel_shader(galena::pixel_shader_position);
}
int main() {
galena::application application;
galena::window window(640, 480, "galena chaos test application");
galena::renderer renderer(galena::renderer::renderer_type::dx11);
galena::window_render_surface window_render_surface(window, renderer);
renderer.render_on(window_render_surface);
auto vs_state = renderer.set_vertex_shader(shaders::vertex_shader);
vs_state.set_input<0>(std::array<galena::float4, 3> {
galena::float4 { 0.0f, 0.5f, 0.5f, 1.0f },
galena::float4 { 0.5f, -0.5f, 0.5f, 1.0f },
galena::float4 { -0.5f, -0.5f, 0.5f, 1.0f }
});
renderer.set_vertex_shader_state(vs_state);
renderer.set_pixel_shader(shaders::pixel_shader);
while(application.is_open()) {
application.process_events();
window_render_surface.clear();
renderer.draw(3);
window_render_surface.present();
}
}
| [
"markwynngarcia@outlook.com"
] | markwynngarcia@outlook.com |
d3df00d260d1a3d374a1a89bb40ca1db842f74ef | 0547be6949e3bbdb66e6542c9ac5ea3b22adb347 | /love.cpp | 1131c97b828634fb6be1529bc9bf7102323d778d | [] | no_license | potatoler/OI_Exercise | 361574e16578b306526e0d1e60d6d31994a35094 | 81cc2a562ba01f4361d73f09efc206a5411b7174 | refs/heads/master | 2023-02-02T12:27:34.805079 | 2020-12-15T14:30:12 | 2020-12-15T14:30:12 | 262,538,278 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,736 | cpp | #include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<stack>
#include<vector>
using namespace std;
const int maxn=10010;
vector<int> g[maxn];
stack<int> st;
int n,m,scc,ser;
int low[maxn],dfn[maxn],instack[maxn],fa[maxn];
int cnt[maxn];
void init(){
scc=ser=0;
while(!st.empty())st.pop();
for(int i=0;i<maxn;i++)g[i].clear();
memset(dfn,0,sizeof(dfn));
memset(instack,0,sizeof(instack));
memset(low,0,sizeof(low));
memset(cnt,0,sizeof(cnt));
}
void tarjan(int u){
dfn[u]=low[u]=++ser;
instack[u]=1;
st.push(u);
int v,size=g[u].size();
for(int i=0;i<size;i++){
v=g[u][i];
if(!dfn[v]){
tarjan(v);
low[u]=min(low[u],low[v]);
}
else if(instack[v])
low[u]=min(low[u],dfn[v]);
}
if(dfn[u]==low[u]){
scc++;
while(v!=u){
v=st.top();
st.pop();
fa[v]=scc;
instack[v]=0;
};
}
}
int main(){
scanf("%d%d",&n,&m);
init();
for(int i=0;i<m;i++){
int u,v;
scanf("%d%d",&u,&v);
g[u].push_back(v);
}
for(int i=1;i<=n;i++)
if(!dfn[i]) tarjan(i);
for(int i=1;i<=n;i++)
for(int j=0;j<g[i].size();j++){
int v=g[i][j];
if(fa[i]!=fa[v]) cnt[fa[i]]++;
}
int ans=0,u;
for(int i=1;i<=scc;i++)
if(!cnt[i]){
u=i;
ans++;
}
if(ans==1){
ans=0;
for(int i=1;i<=n;i++)
if(fa[i]==u) ans++;
printf("%d\n",ans);
}
else printf("0\n");
return 0;
} | [
"potatoler@icloud.com"
] | potatoler@icloud.com |
ce006c905be393b518f8bb0f3ef94738a8948362 | 6cc9349598ba3d55800638fb45f9720b20c33277 | /view/shaders/program_material.h | 99c81ca6ef0b17a805dd51b95e228153d51a2216 | [] | no_license | d-shulgin/GameCreator | 0447f480c52647209703c83a0022132c62d0a3b2 | 5f64dd67790df4b3c36db49e3f9b70f1e3eb9dc7 | refs/heads/master | 2023-05-07T17:43:14.119359 | 2021-04-28T12:46:02 | 2021-04-28T12:46:02 | 362,068,456 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,512 | h | #ifndef PROGRAM_MATERIAL_H
#define PROGRAM_MATERIAL_H
#include <QGLFunctions>
#include "../../parser/xml_meta_data.h"
#include "program_shader.h"
#include "../vector3.h"
class ProgramMaterial : public XMLObject
{
public:
static QString class_name() { return( QString("pMaterial") ); }
virtual QString xml_class_name() const
{
return( class_name() );
}
virtual bool isModify() const { return( _modify ); }
public:
ProgramMaterial();
virtual ~ProgramMaterial();
public:
ProgramMaterial( const ProgramMaterial& cpy )
: XMLObject( cpy )
{
unbind_fields();
bind_fields();
_modify = cpy._modify;
_ambientColor = cpy._ambientColor;
_ambientMap = cpy._ambientMap;
_useAmbientMap = cpy._useAmbientMap;
_diffuseColor = cpy._diffuseColor;
_diffuseMap = cpy._diffuseMap;
_useDiffuseMap = cpy._useDiffuseMap;
_specularColor = cpy._specularColor;
_specularExp = cpy._specularExp;
_specularMap = cpy._specularMap;
_useSpecularMap = cpy._useSpecularMap;
_dissolve = cpy._dissolve;
_halo = cpy._halo;
_dissolveMap = cpy._dissolveMap;
_useDissolveMap = cpy._useDissolveMap;
_normalMap = cpy._normalMap;
_useNormalMap = cpy._useNormalMap;
}
ProgramMaterial& operator = ( const ProgramMaterial& cpy )
{
if( this != &cpy )
{
XMLObject::operator = ( cpy );
unbind_fields();
bind_fields();
_modify = cpy._modify;
_ambientColor = cpy._ambientColor;
_ambientMap = cpy._ambientMap;
_useAmbientMap = cpy._useAmbientMap;
_diffuseColor = cpy._diffuseColor;
_diffuseMap = cpy._diffuseMap;
_useDiffuseMap = cpy._useDiffuseMap;
_specularColor = cpy._specularColor;
_specularExp = cpy._specularExp;
_specularMap = cpy._specularMap;
_useSpecularMap = cpy._useSpecularMap;
_dissolve = cpy._dissolve;
_halo = cpy._halo;
_dissolveMap = cpy._dissolveMap;
_useDissolveMap = cpy._useDissolveMap;
_normalMap = cpy._normalMap;
_useNormalMap = cpy._useNormalMap;
}
return( *this );
}
protected:
virtual void bind_fields()
{
XMLObject::bind_fields();
bind_field( "ambientColor", &_ambientColor );
bind_field( "ambientMap", &_ambientMap );
bind_field( "useAmbientMap", &_useAmbientMap );
bind_field( "diffuseColor", &_diffuseColor );
bind_field( "diffuseMap", &_diffuseMap );
bind_field( "useDiffuseMap", &_useDiffuseMap );
bind_field( "specularColor", &_specularColor );
bind_field( "specularExp", &_specularExp );
bind_field( "specularMap", &_specularMap );
bind_field( "useSpecularMap", &_useSpecularMap );
bind_field( "dissolve", &_dissolve );
bind_field( "halo", &_halo );
bind_field( "dissolveMap", &_dissolveMap );
bind_field( "useDissolveMap", &_useDissolveMap );
bind_field( "normalMap", &_normalMap );
bind_field( "useNormalMap", &_useNormalMap );
return;
}
protected:
virtual void event_Saved()
{
_modify = false;
return;
}
virtual void event_Loaded( bool success )
{
if( success )
_modify = false;
return;
}
public:
virtual XMLObject* create() const
{
return( new ProgramMaterial() );
}
virtual XMLObject* clone() const
{
ProgramMaterial* object = new ProgramMaterial();
(*object) = (*this);
return( object );
}
private:
bool _modify;
private: /// @section: uniform... material.ambientColor
QString _ambientColor;
public:
const QString& ambientColor() const;
void setAmbientColor( const QString& ambientColor );
private: /// @section: uniform... material.ambientMap
QString _ambientMap;
QString _useAmbientMap;
public:
const QString& ambientMap() const;
void setAmbientMap( const QString& ambientMap );
const QString& useAmbientMap() const;
void setUseAmbientMap( const QString& useAmbientMap );
private: /// @section: uniform... material.diffuseColor
QString _diffuseColor;
public:
const QString& diffuseColor() const;
void setDiffuseColor( const QString& diffuseColor );
private: /// @section: uniform... material.diffuseMap
QString _diffuseMap;
QString _useDiffuseMap;
public:
const QString& diffuseMap() const;
void setDiffuseMap( const QString& diffuseMap );
const QString& useDiffuseMap() const;
void setUseDiffuseMap( const QString& useDiffuseMap );
private: /// @section: uniform... material.specularColor
QString _specularColor;
public:
const QString& specularColor() const;
void setSpecularColor( const QString& specularColor );
private: /// @section: uniform... material.specExp
QString _specularExp;
public:
const QString& specularExp() const;
void setSpecularExp( const QString& specularExp );
private: /// @section: uniform... material.specularMap
QString _specularMap;
QString _useSpecularMap;
public:
const QString& specularMap() const;
void setSpecularMap( const QString& specularMap );
const QString& useSpecularMap() const;
void setUseSpecularMap( const QString& useSpecularMap );
private: /// @section: uniform... material.dissolve
QString _dissolve;
public:
const QString& dissolve() const;
void setDissolve( const QString& dissolve );
private: /// @section: uniform... material.halo
QString _halo;
public:
const QString& halo() const;
void setHalo( const QString& halo );
private: /// @section: uniform... material.dissolveMap
QString _dissolveMap;
QString _useDissolveMap;
public:
const QString& dissolveMap() const;
void setDissolveMap( const QString& dissolveMap );
const QString& useDissolveMap() const;
void setUseDissolveMap( const QString& useDissolveMap );
private: /// @section: uniform... material.normalMap
QString _normalMap;
QString _useNormalMap;
public:
const QString& normalMap() const;
void setNormalMap( const QString& normalMap );
const QString& useNormalMap() const;
void setUseNormalMap( const QString& useNormalMap );
public: /// @section: initialize
void initAmbientColor ( QGLFunctions*, ProgramShader*, const Vector3& ) const;
void initAmbientMap ( QGLFunctions*, ProgramShader*, int ) const;
void initDiffuseColor ( QGLFunctions*, ProgramShader*, const Vector3& ) const;
void initDiffuseMap ( QGLFunctions*, ProgramShader*, int ) const;
void initSpecularColor( QGLFunctions*, ProgramShader*, const Vector3& ) const;
void initSpecularExp ( QGLFunctions*, ProgramShader*, float ) const;
void initSpecularMap ( QGLFunctions*, ProgramShader*, int ) const;
void initDissolve ( QGLFunctions*, ProgramShader*, float ) const;
void initHalo ( QGLFunctions*, ProgramShader*, bool ) const;
void initDissolveMap ( QGLFunctions*, ProgramShader*, int ) const;
void initNormalMap ( QGLFunctions*, ProgramShader*, int ) const;
};
#endif // PROGRAM_MATERIAL_H
| [
"d-shulgin@inbox.ru"
] | d-shulgin@inbox.ru |
3d66eccb57f794126782d3e1f18df9a59c8c1355 | 98b63e3dc79c75048163512c3d1b71d4b6987493 | /tensorflow/lite/micro/kernels/xtensa_hifimini/svdf.cc | 28f8f1e1af05b68a231b10ee1e1204159d3787d0 | [
"Apache-2.0"
] | permissive | galeone/tensorflow | 11a4e4a3f42f4f61a65b432c429ace00401c9cc4 | 1b6f13331f4d8e7fccc66bfeb0b066e77a2b7206 | refs/heads/master | 2022-11-13T11:56:56.143276 | 2020-11-10T14:35:01 | 2020-11-10T14:35:01 | 310,642,488 | 21 | 12 | Apache-2.0 | 2020-11-06T16:01:03 | 2020-11-06T16:01:02 | null | UTF-8 | C++ | false | false | 16,675 | cc | /* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/
#include <math.h>
#include <xtensa/tie/xt_hifi2.h>
#include "tensorflow/lite/c/builtin_op_data.h"
#include "tensorflow/lite/c/common.h"
#include "tensorflow/lite/kernels/internal/common.h"
#include "tensorflow/lite/kernels/internal/quantization_util.h"
#include "tensorflow/lite/kernels/internal/tensor_ctypes.h"
#include "tensorflow/lite/kernels/kernel_util.h"
#include "tensorflow/lite/kernels/op_macros.h"
#include "tensorflow/lite/micro/kernels/activation_utils.h"
#include "tensorflow/lite/micro/kernels/kernel_util.h"
#include "tensorflow/lite/micro/kernels/xtensa_hifimini/fixedpoint_utils.h"
namespace tflite {
namespace {
struct OpData {
int32_t effective_scale_1_a;
int32_t effective_scale_2_a;
// b versions of each scale are kept at int since the numbers are just the
// shift value - typically between [-32, 32].
int effective_scale_1_b;
int effective_scale_2_b;
int scratch_tensor_index;
int scratch_output_tensor_index;
// Cached tensor zero point values for quantized operations.
int input_zero_point;
int output_zero_point;
};
// Input tensors.
constexpr int kInputTensor = 0;
constexpr int kWeightsFeatureTensor = 1;
constexpr int kWeightsTimeTensor = 2;
constexpr int kBiasTensor = 3;
// This is a variable tensor, and will be modified by this op.
constexpr int kInputActivationStateTensor = 4;
// Output tensor.
constexpr int kOutputTensor = 0;
/**
* This version of SVDF is specific to TFLite Micro. It contains only a full
* integer receipe with optimizations for the Xtensa HiFiMini platform.
*
* Note: passing OpData by value might seem like an oversight but it helps
* reduce the latency. See b/155656675 for more details.
*/
void EvalIntegerSVDF(TfLiteContext* context, TfLiteNode* node,
const TfLiteEvalTensor* input_tensor,
const TfLiteEvalTensor* weights_feature_tensor,
const TfLiteEvalTensor* weights_time_tensor,
const TfLiteEvalTensor* bias_tensor,
const TfLiteSVDFParams* params,
TfLiteEvalTensor* activation_state_tensor,
TfLiteEvalTensor* output_tensor, OpData data) {
const int n_rank = params->rank;
const int n_batch = input_tensor->dims->data[0];
const int n_input = input_tensor->dims->data[1];
const int n_filter = weights_feature_tensor->dims->data[0];
const int n_unit = n_filter / n_rank;
const int n_memory = weights_time_tensor->dims->data[1];
TFLITE_DCHECK(context != nullptr);
TFLITE_DCHECK(context->GetScratchBuffer != nullptr);
int32_t* scratch_tensor = static_cast<int32_t*>(
context->GetScratchBuffer(context, data.scratch_tensor_index));
TFLITE_DCHECK(scratch_tensor != nullptr);
int32_t* scratch_output_tensor = static_cast<int32_t*>(
context->GetScratchBuffer(context, data.scratch_output_tensor_index));
TFLITE_DCHECK(scratch_output_tensor != nullptr);
// Shift states.
int16_t* const state_ptr =
tflite::micro::GetTensorData<int16_t>(activation_state_tensor);
// Left shift the activation_state.
{
int16_t* new_state_start = state_ptr;
const int16_t* old_state_start = state_ptr + 1;
const int16_t* old_state_end = state_ptr + n_batch * n_filter * n_memory;
while (old_state_start != old_state_end) {
*new_state_start++ = *old_state_start++;
}
}
// Note: no need to clear the latest activation, matmul is not accumulative.
// Feature matmul.
{
const int8_t* input = tflite::micro::GetTensorData<int8_t>(input_tensor);
const int8_t* weight_feature =
tflite::micro::GetTensorData<int8_t>(weights_feature_tensor);
int16_t* result_in_batch = state_ptr + (n_memory - 1);
ae_q56s output_int16_max_56 = AE_CVTQ48A32S(INT16_MAX);
ae_q56s output_int16_min_56 = AE_CVTQ48A32S(INT16_MIN);
ae_p24x2s input_zp_24x2 = AE_MOVPA24(data.input_zero_point);
for (int b = 0; b < n_batch; b++) {
const int8_t* weight_feature_ptr = weight_feature - 2;
for (int r = 0; r < n_filter; r++) {
ae_q56s dot_prod_56 = AE_ZEROQ56();
const int8_t* input_batch_ptr = input + b * n_input;
const int8_t* offset_input_batch_ptr = input_batch_ptr - 2;
int num_iters = n_input / 2;
for (int c = 0; c < num_iters; c++) {
// Load 2 sets of values:
ae_p24x2s weight_feature_ptr_24x2;
ae_p24x2s input_batch_ptr_24x2;
AE_LP8X2F_IU(weight_feature_ptr_24x2, weight_feature_ptr, 2);
AE_LP8X2F_IU(input_batch_ptr_24x2, offset_input_batch_ptr, 2);
// Right shift the signed 8bit values to expand to signed 24bit
// values:
weight_feature_ptr_24x2 = AE_P24X2S_SRAI(weight_feature_ptr_24x2, 16);
input_batch_ptr_24x2 = AE_P24X2S_SRAI(input_batch_ptr_24x2, 16);
// First subtract input_zp from input_batch_ptr_24x2:
input_batch_ptr_24x2 =
AE_SUBSP24S(input_batch_ptr_24x2, input_zp_24x2);
// Multiply accum:
AE_MULAAP24S_HH_LL(dot_prod_56, weight_feature_ptr_24x2,
input_batch_ptr_24x2);
}
// Left shift 48bit value into 24bit space and place on the PR register:
dot_prod_56 = AE_Q56S_SLAI(dot_prod_56, 24);
ae_p24x2s dot_prod_24x2 = AE_TRUNCP24Q48(dot_prod_56);
dot_prod_56 = MultiplyByQuantizedMultiplier(
dot_prod_24x2, data.effective_scale_1_a, data.effective_scale_1_b);
// Cap min/max and convert to int32_t:
dot_prod_56 = AE_MAXQ56S(dot_prod_56, output_int16_min_56);
dot_prod_56 = AE_MINQ56S(dot_prod_56, output_int16_max_56);
// Truncate immediately since the QR register is already 32 bit aligned:
// This assumes state is symmetrically quantized. Otherwise last bit of
// state should be initialized to its zero point and accumulate the
// dot_prod.
// Equivalent as the following:
// result_in_batch = zero point, which happens to be zero.
// result_in_batch += dot_prod_56.
*result_in_batch = AE_TRUNCA32Q48(dot_prod_56);
result_in_batch += n_memory;
}
}
}
// Time.
{
for (int b = 0; b < n_batch; ++b) {
int32_t* scratch_ptr_batch = scratch_tensor + b * n_filter;
// Perform batched vector dot product:
const int16_t* vector1_ptr =
tflite::micro::GetTensorData<int16_t>(weights_time_tensor);
const int16_t* vector2_ptr = state_ptr + b * n_memory * n_filter;
const ae_p16x2s* offset_vector1 =
reinterpret_cast<const ae_p16x2s*>(vector1_ptr - 2);
const ae_p16x2s* offset_vector2 =
reinterpret_cast<const ae_p16x2s*>(vector2_ptr - 2);
for (int i = 0; i < n_filter; i++) {
*scratch_ptr_batch = 0;
ae_q56s sum_56 = AE_ZEROQ56();
int num_iters = n_memory / 2;
for (int j = 0; j < num_iters; j++) {
ae_p24x2s vector1_24x2;
ae_p24x2s vector2_24x2;
AE_LP16X2F_IU(vector1_24x2, offset_vector1, 4);
AE_LP16X2F_IU(vector2_24x2, offset_vector2, 4);
AE_MULAAP24S_HH_LL(sum_56, vector1_24x2, vector2_24x2);
}
// Truncate directly since values are already 32bit aligned:
*scratch_ptr_batch = AE_TRUNCA32Q48(sum_56);
scratch_ptr_batch++;
}
}
}
// Reduce, add bias, rescale, activation.
{
// Add bias.
if (bias_tensor) {
// Vector batch assign:
const int32_t* bias_data =
tflite::micro::GetTensorData<int32_t>(bias_tensor);
for (int i = 0; i < n_batch; ++i) {
int32_t* output_ptr = scratch_output_tensor + i * n_unit;
const int32_t* bias_ptr = bias_data;
for (int j = 0; j < n_unit; ++j) {
*output_ptr++ = *bias_ptr++;
}
}
} else {
int32_t* output_ptr = scratch_output_tensor;
for (int i = 0; i < n_batch * n_unit; ++i) {
*output_ptr++ = 0;
}
}
// Reduce.
for (int b = 0; b < n_batch; ++b) {
int32_t* output_temp_ptr = scratch_output_tensor + b * n_unit;
int32_t* scratch_ptr_batch = scratch_tensor + b * n_filter;
// Reduction sum vector
for (int i = 0; i < n_unit; ++i) {
for (int j = 0; j < n_rank; ++j) {
output_temp_ptr[i] += *scratch_ptr_batch++;
}
}
}
// Rescale.
ae_q56s output_int8_max_56 = AE_CVTQ48A32S(INT8_MAX);
ae_q56s output_int8_min_56 = AE_CVTQ48A32S(INT8_MIN);
ae_q56s output_zp_56 = AE_CVTQ48A32S(data.output_zero_point);
for (int i = 0; i < n_batch * n_unit; ++i) {
ae_q56s x_56 = MultiplyByQuantizedMultiplierResult48Bit(
scratch_output_tensor[i], data.effective_scale_2_a,
data.effective_scale_2_b);
// Add output adjustment:
x_56 = AE_ADDQ56(x_56, output_zp_56);
// Cap min/max and convert to int32_t (already aligned to 32bit):
x_56 = AE_MAXQ56S(x_56, output_int8_min_56);
x_56 = AE_MINQ56S(x_56, output_int8_max_56);
tflite::micro::GetTensorData<int8_t>(output_tensor)[i] =
static_cast<int8_t>(AE_TRUNCA32Q48(x_56));
}
}
}
void* Init(TfLiteContext* context, const char* buffer, size_t length) {
TFLITE_DCHECK(context != nullptr);
return context->AllocatePersistentBuffer(context, sizeof(OpData));
}
TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
TFLITE_DCHECK(node->builtin_data != nullptr);
const auto* params = static_cast<const TfLiteSVDFParams*>(node->builtin_data);
// Validate Tensor Inputs (dtype depends on quantization):
// [0] = Input, {2, batch_size, input_size}
// [1] = Weights Feature, {2, num_filters, input_size}
// [2] = Weights Time, {2, num_filters, memory_size}
// [3] = Bias (optional), {1, num_units}
// [4] = Activation State (variable),
// {2, batch_size, memory_size * num_filters}
const TfLiteTensor* input = GetInput(context, node, kInputTensor);
const TfLiteTensor* weights_feature =
GetInput(context, node, kWeightsFeatureTensor);
const TfLiteTensor* weights_time =
GetInput(context, node, kWeightsTimeTensor);
const TfLiteTensor* bias = GetOptionalInputTensor(context, node, kBiasTensor);
const TfLiteTensor* activation_state =
GetInput(context, node, kInputActivationStateTensor);
// Define input constants based on input tensor definition above:
const int rank = params->rank;
const int input_size = input->dims->data[1];
const int batch_size = input->dims->data[0];
// Ensure the input size is a multiple of two. This is necessary since
// optimized kernels access the memory in chunks of two, and all accesses
// must be aligned to 16 bits.
// TODO(b/153202598): Remove when padding is allowed in TFLite tensors.
TF_LITE_ENSURE_EQ(context, input_size % 2, 0);
const int num_filters = weights_feature->dims->data[0];
TF_LITE_ENSURE_EQ(context, num_filters % rank, 0);
const int num_units = num_filters / rank;
const int memory_size = weights_time->dims->data[1];
if (input->type != kTfLiteInt8) {
TF_LITE_KERNEL_LOG(context, "Type %s (%d) not supported.",
TfLiteTypeGetName(input->type), input->type);
return kTfLiteError;
}
// Validate Input Tensor:
TF_LITE_ENSURE(context, input->type == kTfLiteInt8);
TF_LITE_ENSURE_EQ(context, NumDimensions(input), 2);
// Validate Tensor Output:
// [0] = float/int8_t, {2, batch_size, num_units}
TF_LITE_ENSURE_EQ(context, node->outputs->size, 1);
TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
TF_LITE_ENSURE_EQ(context, NumDimensions(output), 2);
TF_LITE_ENSURE_EQ(context, output->dims->data[0], batch_size);
TF_LITE_ENSURE_EQ(context, output->dims->data[1], num_units);
// Validate Weights Feature Input Tensor:
TF_LITE_ENSURE_EQ(context, NumDimensions(weights_feature), 2);
TF_LITE_ENSURE_EQ(context, weights_feature->dims->data[1], input_size);
// Validate Weights Time Input Tensor:
TF_LITE_ENSURE_EQ(context, NumDimensions(weights_time), 2);
TF_LITE_ENSURE_EQ(context, weights_time->dims->data[0], num_filters);
TF_LITE_ENSURE_EQ(context, weights_time->dims->data[1], memory_size);
// Validate Optional Bias Input Tensor:
if (bias != nullptr) {
TF_LITE_ENSURE_EQ(context, bias->dims->data[0], num_units);
TF_LITE_ENSURE_EQ(context, bias->type, kTfLiteInt32);
}
// Validate Activation State Input Tensor:
TF_LITE_ENSURE_EQ(context, NumDimensions(activation_state), 2);
TF_LITE_ENSURE_EQ(context, activation_state->dims->data[0], batch_size);
TF_LITE_ENSURE_EQ(context, activation_state->dims->data[1],
memory_size * num_filters);
TF_LITE_ENSURE_EQ(context, node->inputs->size, 5);
TF_LITE_ENSURE_EQ(context, weights_feature->type, kTfLiteInt8);
TF_LITE_ENSURE_EQ(context, weights_time->type, kTfLiteInt16);
TF_LITE_ENSURE_EQ(context, activation_state->type, kTfLiteInt16);
// Validate output tensor:
TF_LITE_ENSURE_TYPES_EQ(context, output->type, kTfLiteInt8);
const double effective_scale_1 =
static_cast<double>(input->params.scale * weights_feature->params.scale /
activation_state->params.scale);
const double effective_scale_2 =
static_cast<double>(activation_state->params.scale *
weights_time->params.scale / output->params.scale);
TF_LITE_ENSURE_EQ(context, static_cast<double>(bias->params.scale),
static_cast<double>(activation_state->params.scale *
weights_time->params.scale));
TFLITE_DCHECK(node->user_data != nullptr);
OpData* data = static_cast<OpData*>(node->user_data);
QuantizeMultiplierForInt24(effective_scale_1, &data->effective_scale_1_a,
&data->effective_scale_1_b);
QuantizeMultiplierForInt24(effective_scale_2, &data->effective_scale_2_a,
&data->effective_scale_2_b);
data->input_zero_point = input->params.zero_point;
data->output_zero_point = output->params.zero_point;
const TfLiteStatus scratch_status = context->RequestScratchBufferInArena(
context, batch_size * num_filters * sizeof(int32_t),
&(data->scratch_tensor_index));
TF_LITE_ENSURE_OK(context, scratch_status);
const TfLiteStatus scratch_output_status =
context->RequestScratchBufferInArena(
context, batch_size * num_units * sizeof(int32_t),
&(data->scratch_output_tensor_index));
TF_LITE_ENSURE_OK(context, scratch_output_status);
return kTfLiteOk;
}
TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
auto* params = static_cast<TfLiteSVDFParams*>(node->builtin_data);
const TfLiteEvalTensor* input =
tflite::micro::GetEvalInput(context, node, kInputTensor);
const TfLiteEvalTensor* weights_feature =
tflite::micro::GetEvalInput(context, node, kWeightsFeatureTensor);
const TfLiteEvalTensor* weights_time =
tflite::micro::GetEvalInput(context, node, kWeightsTimeTensor);
const TfLiteEvalTensor* bias =
(NumInputs(node) == 5)
? tflite::micro::GetEvalInput(context, node, kBiasTensor)
: nullptr;
TfLiteEvalTensor* activation_state = tflite::micro::GetMutableEvalInput(
context, node, kInputActivationStateTensor);
TfLiteEvalTensor* output =
tflite::micro::GetEvalOutput(context, node, kOutputTensor);
TFLITE_DCHECK(node->user_data != nullptr);
const OpData& data = *(static_cast<const OpData*>(node->user_data));
EvalIntegerSVDF(context, node, input, weights_feature, weights_time, bias,
params, activation_state, output, data);
return kTfLiteOk;
}
} // namespace
TfLiteRegistration Register_SVDF() {
return {/*init=*/Init,
/*free=*/nullptr,
/*prepare=*/Prepare,
/*invoke=*/Eval,
/*profiling_string=*/nullptr,
/*builtin_code=*/0,
/*custom_name=*/nullptr,
/*version=*/0};
}
} // namespace tflite
| [
"gardener@tensorflow.org"
] | gardener@tensorflow.org |
09351dfda670ad523014983194658f2a583f87f3 | 01b61b4b576f05dbcdd3926fd27f08d8517fc545 | /vc/test/MFC/TestMFCWithActiveXAndAutomation/DlgProxy.h | 89416c70c2329731f4464c7b9e14eaf50739cdf5 | [] | no_license | Ex-Soft/test | 0877badde69ddcfc5e1ff78703a053ef2587a69e | 7c0d0e554ba91b203564da7e44f43838710ac59d | refs/heads/master | 2023-04-11T07:18:43.542556 | 2023-03-31T14:20:16 | 2023-03-31T14:20:16 | 73,572,547 | 5 | 5 | null | 2023-09-07T13:28:45 | 2016-11-12T19:06:44 | C# | UTF-8 | C++ | false | false | 906 | h |
// DlgProxy.h: header file
//
#pragma once
class CTestMFCWithActiveXAndAutomationDlg;
// CTestMFCWithActiveXAndAutomationDlgAutoProxy command target
class CTestMFCWithActiveXAndAutomationDlgAutoProxy : public CCmdTarget
{
DECLARE_DYNCREATE(CTestMFCWithActiveXAndAutomationDlgAutoProxy)
CTestMFCWithActiveXAndAutomationDlgAutoProxy(); // protected constructor used by dynamic creation
// Attributes
public:
CTestMFCWithActiveXAndAutomationDlg* m_pDialog;
// Operations
public:
// Overrides
public:
virtual void OnFinalRelease();
// Implementation
protected:
virtual ~CTestMFCWithActiveXAndAutomationDlgAutoProxy();
// Generated message map functions
DECLARE_MESSAGE_MAP()
DECLARE_OLECREATE(CTestMFCWithActiveXAndAutomationDlgAutoProxy)
// Generated OLE dispatch map functions
DECLARE_DISPATCH_MAP()
DECLARE_INTERFACE_MAP()
};
| [
"4others2@gmail.com"
] | 4others2@gmail.com |
982b601d7c2896fdd05601f958d62aef396e4eb2 | a6265407c94b7ee0327a32656641e5f7fcd5df1a | /util/cache.cc | 65a6544f18b4f6c93bd10f5fa78838d86b833632 | [
"BSD-3-Clause",
"LicenseRef-scancode-generic-cla"
] | permissive | wangziyuruc/leveldbtest | 331c257e67057735a73851c29bfb894de486cbe4 | 231b61d523421b19e5ff1a3796998c283c937cd4 | refs/heads/master | 2021-04-26T22:58:30.570623 | 2018-03-14T07:29:32 | 2018-03-14T07:29:32 | 123,907,068 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 13,834 | cc | // Copyright (c) 2011 The LevelDB Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file. See the AUTHORS file for names of contributors.
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include "leveldb/cache.h"
#include "port/port.h"
#include "util/hash.h"
#include "util/mutexlock.h"
namespace leveldb {
Cache::~Cache() {
}
namespace {
// LRU cache implementation
//
// Cache entries have an "in_cache" boolean indicating whether the cache has a
// reference on the entry. The only ways that this can become false without the
// entry being passed to its "deleter" are via Erase(), via Insert() when
// an element with a duplicate key is inserted, or on destruction of the cache.
//
// The cache keeps two linked lists of items in the cache. All items in the
// cache are in one list or the other, and never both. Items still referenced
// by clients but erased from the cache are in neither list. The lists are:
// - in-use: contains the items currently referenced by clients, in no
// particular order. (This list is used for invariant checking. If we
// removed the check, elements that would otherwise be on this list could be
// left as disconnected singleton lists.)
// - LRU: contains the items not currently referenced by clients, in LRU order
// Elements are moved between these lists by the Ref() and Unref() methods,
// when they detect an element in the cache acquiring or losing its only
// external reference.
// An entry is a variable length heap-allocated structure. Entries
// are kept in a circular doubly linked list ordered by access time.
struct LRUHandle {
void* value;
void (*deleter)(const Slice&, void* value);
LRUHandle* next_hash; // Hash 表指针，同样 Hash 值的 Handler 串接起来
LRUHandle* next; // LRU 双向链表指针
LRUHandle* prev; // LRU 双向链表指针
size_t charge; // TODO(opt): Only allow uint32_t? // 占用的空间
size_t key_length; // key 的长度
bool in_cache; // Whether entry is in the cache. // 该 Handle 是否在 cache 中
uint32_t refs; // References, including cache reference, if present. / 该 Handle 被引用到的次数，用于管理回收.
uint32_t hash; // Hash of key(); used for fast sharding and comparisons // Hash of key
char key_data[1]; // Beginning of key // key 数据
Slice key() const {
// For cheaper lookups, we allow a temporary Handle object
// to store a pointer to a key in "value".
if (next == this) {
return *(reinterpret_cast<Slice*>(value));
} else {
return Slice(key_data, key_length);
}
}
};
// We provide our own simple hash table since it removes a whole bunch
// of porting hacks and is also faster than some of the built-in hash
// table implementations in some of the compiler/runtime combinations
// we have tested. E.g., readrandom speeds up by ~5% over the g++
// 4.4.3's builtin hashtable.
class HandleTable {
public:
HandleTable() : length_(0), elems_(0), list_(NULL) { Resize(); }
~HandleTable() { delete[] list_; }
LRUHandle* Lookup(const Slice& key, uint32_t hash) {
return *FindPointer(key, hash);
}
LRUHandle* Insert(LRUHandle* h) {
LRUHandle** ptr = FindPointer(h->key(), h->hash); //调用 FindPointer 找到当前 key 和 hash 值所对应的那个 LRUHandle 的指针
LRUHandle* old = *ptr;
//判断返回的 ptr 是否是 NULL，如果是，表明表中没有当前的 key，那么直接插入到尾部，并调用 Resize()，
//否则从 Hash 表中删除原来的指针 ptr 指向的节点，也就是用新节点替换旧节点
h->next_hash = (old == NULL ? NULL : old->next_hash);
// 如果存在相同的key，那么删除old
*ptr = h; // 与 *ptr->next_hash = h 的区别
if (old == NULL) {
++elems_;
if (elems_ > length_) {
// Since each cache entry is fairly large, we aim for a small
// average linked list length (<= 1).
//Resize() 的作用是调整 Hash 表，使得每一个 slot 中的期望 Handle 的数量为1. 该函数首先将 LRUHandler** list_ 扩张成为 new_length，
//其中 new_length 是第一个大于 elem_ 的 2 的幂次，
//这主要是为了加速根据 hash 值选择 slot 的计算（因为 hash%new_length = hash & (new_length-1) ）。
Resize();
}
}
return old;
}
LRUHandle* Remove(const Slice& key, uint32_t hash) {
LRUHandle** ptr = FindPointer(key, hash);
LRUHandle* result = *ptr;
if (result != NULL) {
*ptr = result->next_hash;
--elems_;
}
return result;
}
private:
// The table consists of an array of buckets where each bucket is
// a linked list of cache entries that hash into the bucket.
uint32_t length_;
uint32_t elems_;
LRUHandle** list_;
// Return a pointer to slot that points to a cache entry that
// matches key/hash. If there is no such cache entry, return a
// pointer to the trailing slot in the corresponding linked list.
LRUHandle** FindPointer(const Slice& key, uint32_t hash) {
LRUHandle** ptr = &list_[hash & (length_ - 1)];
while (*ptr != NULL &&
((*ptr)->hash != hash || key != (*ptr)->key())) {
ptr = &(*ptr)->next_hash;
}
return ptr;
}
void Resize() {
uint32_t new_length = 4;
while (new_length < elems_) {
new_length *= 2;
}
LRUHandle** new_list = new LRUHandle*[new_length];
memset(new_list, 0, sizeof(new_list[0]) * new_length);
uint32_t count = 0;
for (uint32_t i = 0; i < length_; i++) {
LRUHandle* h = list_[i];
while (h != NULL) {
LRUHandle* next = h->next_hash;
uint32_t hash = h->hash;
LRUHandle** ptr = &new_list[hash & (new_length - 1)];
h->next_hash = *ptr;
*ptr = h;
h = next;
count++;
}
}
assert(elems_ == count);
delete[] list_;
list_ = new_list;
length_ = new_length;
}
};
// A single shard of sharded cache.
class LRUCache {
public:
LRUCache();
~LRUCache();
// Separate from constructor so caller can easily make an array of LRUCache
void SetCapacity(size_t capacity) { capacity_ = capacity; }
// Like Cache methods, but with an extra "hash" parameter.
Cache::Handle* Insert(const Slice& key, uint32_t hash,
void* value, size_t charge,
void (*deleter)(const Slice& key, void* value));
Cache::Handle* Lookup(const Slice& key, uint32_t hash);
void Release(Cache::Handle* handle);
void Erase(const Slice& key, uint32_t hash);
void Prune();
size_t TotalCharge() const {
MutexLock l(&mutex_);
return usage_;
}
private:
void LRU_Remove(LRUHandle* e);
void LRU_Append(LRUHandle*list, LRUHandle* e);
void Ref(LRUHandle* e);
void Unref(LRUHandle* e);
bool FinishErase(LRUHandle* e);
// Initialized before use.
size_t capacity_; //// lru 链表的容量
// mutex_ protects the following state.
mutable port::Mutex mutex_; // // 修改LRUCache时的并发保护
size_t usage_;
// Dummy head of LRU list.
// lru.prev is newest entry, lru.next is oldest entry.
// Entries have refs==1 and in_cache==true.
LRUHandle lru_; // // 双向循环链表，按照 LRU 原则组织
// Dummy head of in-use list.
// Entries are in use by clients, and have refs >= 2 and in_cache==true.
LRUHandle in_use_; // 双向循环链表，当前正在被使用的节点
HandleTable table_; // hash 表
};
LRUCache::LRUCache()
: usage_(0) {
// Make empty circular linked lists.
lru_.next = &lru_;
lru_.prev = &lru_;
in_use_.next = &in_use_;
in_use_.prev = &in_use_;
}
LRUCache::~LRUCache() {
assert(in_use_.next == &in_use_); // Error if caller has an unreleased handle
for (LRUHandle* e = lru_.next; e != &lru_; ) {
LRUHandle* next = e->next;
assert(e->in_cache);
e->in_cache = false;
assert(e->refs == 1); // Invariant of lru_ list.
Unref(e);
e = next;
}
}
void LRUCache::Ref(LRUHandle* e) {
if (e->refs == 1 && e->in_cache) { // If on lru_ list, move to in_use_ list.
LRU_Remove(e);
LRU_Append(&in_use_, e);
}
e->refs++;
}
void LRUCache::Unref(LRUHandle* e) {
assert(e->refs > 0);
e->refs--;
if (e->refs == 0) { // Deallocate.
assert(!e->in_cache);
(*e->deleter)(e->key(), e->value);
free(e);
} else if (e->in_cache && e->refs == 1) { // No longer in use; move to lru_ list.
LRU_Remove(e);
LRU_Append(&lru_, e);
}
}
void LRUCache::LRU_Remove(LRUHandle* e) {
e->next->prev = e->prev;
e->prev->next = e->next;
}
void LRUCache::LRU_Append(LRUHandle* list, LRUHandle* e) {
// Make "e" newest entry by inserting just before *list
e->next = list;
e->prev = list->prev;
e->prev->next = e;
e->next->prev = e;
}
Cache::Handle* LRUCache::Lookup(const Slice& key, uint32_t hash) {
MutexLock l(&mutex_);
LRUHandle* e = table_.Lookup(key, hash);
if (e != NULL) {
Ref(e);
}
return reinterpret_cast<Cache::Handle*>(e);
}
void LRUCache::Release(Cache::Handle* handle) {
MutexLock l(&mutex_);
Unref(reinterpret_cast<LRUHandle*>(handle));
}
Cache::Handle* LRUCache::Insert(
const Slice& key, uint32_t hash, void* value, size_t charge,
void (*deleter)(const Slice& key, void* value)) {
MutexLock l(&mutex_);
// 创建LRUHandle
LRUHandle* e = reinterpret_cast<LRUHandle*>(
malloc(sizeof(LRUHandle)-1 + key.size()));
e->value = value;
e->deleter = deleter;
e->charge = charge;
e->key_length = key.size();
e->hash = hash;
e->in_cache = false;
e->refs = 1; // for the returned handle.
memcpy(e->key_data, key.data(), key.size());
// 将Lruhandle链接到in_use表头 refs++
if (capacity_ > 0) {
e->refs++; // for the cache's reference.
e->in_cache = true;
LRU_Append(&in_use_, e);
usage_ += charge;
FinishErase(table_.Insert(e));
} // else don't cache. (Tests use capacity_==0 to turn off caching.)
//之后，该函数检测当前所有 cache 的条目所占的空间是否超过上限，
//如果超过上限，那么从 lru_ 链表中读取到最近未使用过的 Handle，并将其从 HashTable 和 lru_ 链表中删除来释放 LRUCache 的空间
while (usage_ > capacity_ && lru_.next != &lru_) {
LRUHandle* old = lru_.next;
assert(old->refs == 1);
bool erased = FinishErase(table_.Remove(old->key(), old->hash));
if (!erased) { // to avoid unused variable when compiled NDEBUG
assert(erased);
}
}
return reinterpret_cast<Cache::Handle*>(e);
}
// If e != NULL, finish removing *e from the cache; it has already been removed
// from the hash table. Return whether e != NULL. Requires mutex_ held.
bool LRUCache::FinishErase(LRUHandle* e) {
if (e != NULL) {
assert(e->in_cache);
LRU_Remove(e);
e->in_cache = false;
usage_ -= e->charge;
Unref(e);
}
return e != NULL;
}
void LRUCache::Erase(const Slice& key, uint32_t hash) {
MutexLock l(&mutex_);
FinishErase(table_.Remove(key, hash));
}
void LRUCache::Prune() {
MutexLock l(&mutex_);
while (lru_.next != &lru_) {
LRUHandle* e = lru_.next;
assert(e->refs == 1);
bool erased = FinishErase(table_.Remove(e->key(), e->hash));
if (!erased) { // to avoid unused variable when compiled NDEBUG
assert(erased);
}
}
}
static const int kNumShardBits = 4;
static const int kNumShards = 1 << kNumShardBits;
// /ShardedLRUCache 中定义了 16 个 LRUCache。每次进行插入或者查找时，
//首先使用 hash 值的最高 4 位来确定当前应该在哪个 LRUCache 中查找，
//然后在到对应的 LRUCache 中执行相关的操作。使用这种方式最重要的原因就是 LRUCache 的查找，
//插入和释放需要加锁，同时使用 16 个 LRUCache 能够提高对于 Cache 访问的并发，也就是从侧面降低了锁的粒度，提高访问效率。
class ShardedLRUCache : public Cache {
private:
LRUCache shard_[kNumShards];
port::Mutex id_mutex_;
uint64_t last_id_;
static inline uint32_t HashSlice(const Slice& s) {
return Hash(s.data(), s.size(), 0);
}
static uint32_t Shard(uint32_t hash) {
return hash >> (32 - kNumShardBits);
}
public:
explicit ShardedLRUCache(size_t capacity)
: last_id_(0) {
const size_t per_shard = (capacity + (kNumShards - 1)) / kNumShards;
for (int s = 0; s < kNumShards; s++) {
shard_[s].SetCapacity(per_shard);
}
}
virtual ~ShardedLRUCache() { }
virtual Handle* Insert(const Slice& key, void* value, size_t charge,
void (*deleter)(const Slice& key, void* value)) {
const uint32_t hash = HashSlice(key);
return shard_[Shard(hash)].Insert(key, hash, value, charge, deleter);
}
virtual Handle* Lookup(const Slice& key) {
const uint32_t hash = HashSlice(key);
return shard_[Shard(hash)].Lookup(key, hash);
}
virtual void Release(Handle* handle) {
LRUHandle* h = reinterpret_cast<LRUHandle*>(handle);
shard_[Shard(h->hash)].Release(handle);
}
virtual void Erase(const Slice& key) {
const uint32_t hash = HashSlice(key);
shard_[Shard(hash)].Erase(key, hash);
}
virtual void* Value(Handle* handle) {
return reinterpret_cast<LRUHandle*>(handle)->value;
}
virtual uint64_t NewId() {
MutexLock l(&id_mutex_);
return ++(last_id_);
}
virtual void Prune() {
for (int s = 0; s < kNumShards; s++) {
shard_[s].Prune();
}
}
virtual size_t TotalCharge() const {
size_t total = 0;
for (int s = 0; s < kNumShards; s++) {
total += shard_[s].TotalCharge();
}
return total;
}
};
} // end anonymous namespace
Cache* NewLRUCache(size_t capacity) {
return new ShardedLRUCache(capacity);
}
} // namespace leveldb
| [
"wangziyuruc@gmail.com"
] | wangziyuruc@gmail.com |
f6b57fd61ea6c676b1a37608a59e25449b7d2dca | 911399ddddbb2cb19141dca9445050c0cd4da2b7 | /t47.cpp | 2ec6580aac613aa58457ff7fd01449f83b41149a | [] | no_license | teja2609/DSA-LAB1 | f443397fbee841a662cc3304789f2efb67a78978 | 7a61a2dd70c7dcf557075f6e26fc849b90727b8d | refs/heads/master | 2020-08-27T11:31:19.404301 | 2019-10-29T12:54:34 | 2019-10-29T12:54:34 | 217,352,098 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 758 | cpp | #include<iostream>
#include<string>
using namespace std;
class employee {
public:
int emp_num;
char emp_name;
float basic,da,it,gsl,nsl;
void getinfo();
void getnetsal();
};
void employee::getinfo()
{
cout<<"\n enter employee id"<<endl;
cin>>emp_num;
cout<<"\n enter employee name"<<endl;
cin>>emp_name;
cout<<"\n enter employee basic"<<endl;
cin>>basic;
}
void employee::getnetsal()
{
da=0.52*basic;
gsl=basic+da;
it=0.3*gsl;
cout<<"net salary is"<< gsl-it<<endl;
}
int main() {
employee obj;
int i,n;
cout<<"enter number of employees";
cin>>n;
for(i=0;i<=n;i++)
{
obj.getinfo();
obj.getnetsal();
}
return 0;
}
| [
"noreply@github.com"
] | noreply@github.com |
d7b20bca4fa1e6dfd2c0833a1f0fccb087419d20 | 1147a3736b2319d908ce82cde5f5a0c7fbfdf819 | /Classes/ioCtrl/IoCtrlLayer.cpp | 9a30350f2067d8f6afa14d7038c1f6a2a1db2698 | [] | no_license | troubtimehero/cocos_PetCleaner | 2d3b6413ad0d314b3e938c96287d67714d929b43 | e23ab5f2824786443cea628ca8f12ee5655aa306 | refs/heads/master | 2021-05-20T19:30:59.850847 | 2020-04-02T07:59:48 | 2020-04-02T07:59:48 | 252,391,504 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 16,652 | cpp | #include "IoCtrlLayer.h"
#include "GameData.h"
#include "tool/MyTools.h"
#include "ComThread.h"
#include "menu/MenuScene.h"
#include "helloScene/HelloWorldScene.h"
#include "LeYaoYao.h"
#include "QRCode/QRSprite.h"
CComThread* g_pCom = nullptr;
io_lyy_Pet* g_pBox = nullptr;
LeYaoYao* g_pLeyaoyao = nullptr;
#if (VERSION_BUILD_NUMBER==2)
static bool bDebugIo = true;
#else
static bool bDebugIo = false;
#endif
extern bool g_bWorking;
void IoCtrlLayer::onPasswordOK(std::string password)
{
myCallMenu();
}
IoCtrlLayer::IoCtrlLayer()
{
//IO板
g_pCom = new CComThread(IO_USED_COUNT);
g_pCom->SetEnable(true, true);
//监控盒子
int port = MyIniGetInt("SETTING", USER_DEF_COM_BOX, 2);
g_pBox = new io_lyy_Pet(port);
c_iniLockOpeningTime = MyIniGetInt("SETTING", "MOTOR_TIME", 8);
if (c_iniLockOpeningTime <= 0)
c_iniLockOpeningTime = 10;
m_fLockOpeningTime = 0;
for (int i = 0; i < ARRAYSIZE(m_keyKeep); ++i)
{
m_keyDown[i] = false;
m_keyKeep[i] = false;
}
m_nTick = 0;
m_bLockError = false;
m_iMotorIndex = 0;
//音乐
m_music = new CGameMusic;
m_music->init();
m_fMusicDelay = 1;
//要放最后
init();
}
IoCtrlLayer::~IoCtrlLayer()
{
SAFE_DELETE_POINT(g_pCom);
SAFE_DELETE_POINT(g_pBox);
SAFE_DELETE_POINT(m_music);
}
bool IoCtrlLayer::init()
{
if (!Layer::init())
{
return false;
}
this->setCascadeColorEnabled(true);
this->setCascadeOpacityEnabled(true);
//键盘监测
auto listenerkeyPad = EventListenerKeyboard::create();
listenerkeyPad->onKeyReleased = CC_CALLBACK_2(IoCtrlLayer::onKeyReleased, this);
listenerkeyPad->onKeyPressed= CC_CALLBACK_2(IoCtrlLayer::onKeyPressed, this);
_eventDispatcher->addEventListenerWithSceneGraphPriority(listenerkeyPad, this);
//乐摇摇
g_pLeyaoyao = LeYaoYao::create();
this->addChild(g_pLeyaoyao);
//退扭蛋错误
#ifdef SINGLE_EGG_OUT
m_eggError = Sprite::create("image/tips/egg_over.png");
this->addChild(m_eggError);
m_eggError->setAnchorPoint(Point::ANCHOR_TOP_RIGHT);
m_eggError->setPosition(VisibleRect::rightTop() - Vec2(0, -100));
m_eggError->runAction(Sequence::createWithTwoActions(ScaleTo::create(0.1f, 0.5f), ScaleTo::create(1, 1)));
m_eggError->setVisible(false);
#endif // SINGLE_EGG_OUT
//退票错误
m_tickError = createFontTTF("fonts/dai meng wa wa ti.ttf", 80, 5, Color4B::YELLOW, Color4B::BLACK, Color4B(74, 0, 0, 255), true);
this->addChild(m_tickError);
m_tickError->setVisible(false);
m_tickError->setPosition(VisibleRect::rightTop() - Vec2(380, 40));
//正在退票数
m_tickNum = createFontTTF("fonts/dai meng wa wa ti.ttf", 80, 5, Color4B::YELLOW, Color4B::BLACK, Color4B(74, 0, 0, 255), true);
this->addChild(m_tickNum);
m_tickNum->setVisible(false);
m_tickNum->setPosition(VisibleRect::rightTop() - Vec2(120, 40));
//正在出货
m_boxOutting = LayerColor::create(Color4B(255, 255, 255, 128), GAME_WIDTH, GAME_HEIGHT/4);
this->addChild(m_boxOutting);
m_boxOutting->setZOrder(10);
m_boxOutting->setVisible(false);
Label* boxOuttingChar = createFontTTF("fonts/dai meng wa wa ti.ttf", 80, 5, Color4B::WHITE, Color4B::BLACK, Color4B::RED, true);
m_boxOutting->addChild(boxOuttingChar);
boxOuttingChar->setName("boxOuttingChar");
boxOuttingChar->setPosition(GAME_WIDTH / 2, GAME_HEIGHT / 8);
//控制板错误
m_errorMcu = Label::createWithTTF("Lost IO Control", "fonts/Marker Felt.ttf", 60);
//createWithSystemFont("Lost IO Control", "黑体", 40);
m_errorMcu->setPosition(VisibleRect::center());
m_errorMcu->setZOrder(12);
m_errorMcu->setVisible(false);
this->addChild(m_errorMcu);
m_lstKnobShakeRemain.clear();
return true;
}
void IoCtrlLayer::onEnter()
{
Layer::onEnter();
scheduleUpdate();
schedule(schedule_selector(IoCtrlLayer::timerBlinkInsertAndTick), 0.75f, CC_REPEAT_FOREVER, 0);
updateCoinShow();
m_tickError->setString(LanguageChoose("剩余彩票:", "Remain Ticket:"));
((Label*)m_boxOutting->getChildByName("boxOuttingChar"))->setString(LanguageChoose("正在出货", "Outting Goods"));
}
void IoCtrlLayer::onExit()
{
Layer::onExit();
}
void IoCtrlLayer::update(float delta)
{
Layer::update(delta);
g_pCom->Update();
static unsigned char errStaLast = 0;
unsigned char errSta = ioErrorStatus();
if (!bDebugIo) errSta = 0;
m_errorMcu->setVisible(errSta > 0);
if (errSta > 0)
{
if (errSta != errStaLast)
{
g_pBox->BoxReportStatus(io_LYY_Good::eBoxStatus::e_box_error);
}
if (IO_USED_COUNT > 1 && errSta != errStaLast)
{
#if 0
for (int i = 0; i < IO_USED_COUNT; ++i)
{
if (errSta & (1 << i))
{
if (!m_errorMcu->getChildByTag(i))
{
Label* l = Label::createWithTTF(StringUtils::format("COM %d: off line", i + 1), "fonts/Marker Felt.ttf", 60);
m_errorMcu->addChild(l);
m_errorMcu->setTag(i);
l->setPosition(150, -100 * (i + 1));
}
else
{
m_errorMcu->getChildByTag(i)->setVisible(true);
}
}
else
{
if (m_errorMcu->getChildByTag(i))
m_errorMcu->getChildByTag(i)->setVisible(false);
}
}
#else
string str = StringUtils::format("COM 1: %s, COM 2: %s", errSta & 0x01 ? "off" : "on", errSta & 0x02 ? "off" : "on");
m_errorMcu->setString(str);
#endif
}
//-------------------- 屏蔽下层触摸 -----------------------
if (!getChildByName("IoLost"))
{
float w = GAME_WIDTH;
float h = GAME_HEIGHT * 0.3f;
auto lLostCtrl = LayerColor::create(Color4B(255, 0, 0, 200), w, h);
lLostCtrl->setPosition(0, GAME_HEIGHT*0.35f);
DisableBelowTouch(lLostCtrl);
this->addChild(lLostCtrl, 0, "IoLost");
}
}
else
{
if (errSta != errStaLast)
{
g_pBox->BoxReportStatus(io_LYY_Good::eBoxStatus::e_box_free);
}
auto l = getChildByName("IoLost");
if (l)
l->removeFromParent();
}
errStaLast = errSta;
//投币状态
if (g_pCom->GetCoinIn() > 0)
{
myAddCent(g_pCom->GetCoinIn() * CENT_P_COIN);
}
if (dataIs_CoinChange())
{
dataIs_CoinChange() = false;
updateCoinShow();
}
//按键相应操作
if (g_pCom->CheckSpace(CComThread::e_addr_p2, CComThread::e_bit_POWER, 1))
{
if (!this->getChildByName("password"))
{
this->addChild(LayerPassword::MyCreate(this, "01010101"), 99999, "password");
}
}
else if (!g_bWorking && g_pBox->willEnterSetting())
{
this->removeChildByName("password");
myCallMenu();
g_pBox->clearEnterSettingSignal();
}
// if (g_pCom->CheckSpace(CComThread::e_addr_mgr, CComThread::e_bit_SCORE, 1))
// {
// g_pCom->ClearOuting();
// }
// if (g_pCom->CheckSpace(CComThread::e_addr_mgr, CComThread::e_bit_ADD, 1))
// {
// g_pCom->RetryOuting();
// }
//按键状态清除
for (int i = 0; i < ARRAYSIZE(m_keyDown); ++i)
{
m_keyDown[i] = false;
}
//振动旋钮自动停止
for (auto it = m_lstKnobShakeRemain.begin(); it != m_lstKnobShakeRemain.end(); )
{
it->time -= delta;
if (it->time <= 0)
{
g_pCom->SetDevOut(it->pid, 2, false);
it = m_lstKnobShakeRemain.erase(it);
}
else
{
it++;
}
}
m_bLockError = false;
//----------------------- 关锁、电机停止 ------------------------
static float sfCheckMotor = MyIniGetInt("SETTING", "MOTOR_CHECK", 3) * 0.1f;
if (m_fLockOpeningTime > 0)
{
m_fLockOpeningTime -= delta;
if (m_fLockOpeningTime <= 0) //超时错误，微动或电机故障
{
m_bLockError = true;
//出货失败，退款、退钱
g_pLeyaoyao->UpTrade(false);
//客服二维码，正在退款，请稍等，如果有问题请联系客服
LayerColor* showErrorHelp = LayerColor::create(Color4B::WHITE, GAME_WIDTH, GAME_HEIGHT);
this->addChild(showErrorHelp);
DisableBelowTouch(showErrorHelp);
showErrorHelp->setZOrder(11);
#ifdef _DEBUG
float fShowErrorTime = 2;
#else
float fShowErrorTime = 30;
#endif // _DEBUG
showErrorHelp->runAction(Sequence::createWithTwoActions(DelayTime::create(fShowErrorTime), RemoveSelf::create()));
Label* l = createFontTTF("fonts/dai meng wa wa ti.ttf", 60, 5, Color4B::YELLOW, Color4B::BLACK, Color4B::BLACK, true);
l->setString(LanguageChoose("出货失败\n正在退款", "Out Goods Failed\nNow Refund"));
l->setPosition(VisibleRect::center() + Vec2(0, 130));
showErrorHelp->addChild(l);
Label* l2 = createFontTTF("fonts/dai meng wa wa ti.ttf", 25, 2, Color4B::YELLOW, Color4B::BLACK, Color4B::BLACK, true);
l2->setString(LanguageChoose("如有疑问请扫码联系客服", "In case of doubt,\nplease scan the code to contact customer service"));
l2->setPosition(VisibleRect::bottom() + Vec2(0, 50));
showErrorHelp->addChild(l2);
DrawNode* qr = QRSprite::create(MyIniGetString("SETTING", "KE_FU", "http://weixin.qq.com/r/H0SWkvzE7zSTKbjxbxGb").c_str());
showErrorHelp->addChild(qr);
qr->setAnchorPoint(Point::ANCHOR_MIDDLE_BOTTOM);
qr->setPosition(VisibleRect::bottom() + Vec2(0, 120));
}
bool bFin = false;
#if (BOX_CONTAIN_GOODS == BOX_EACH_MUTL)
bFin = g_pCom->CheckUpDelay((CComThread::eBtnAddr)def_btnMotor[m_iMotorIndex].pid, (CComThread::eBtnBit)def_btnMotor[m_iMotorIndex].bit, sfCheckMotor); //微动检测转完一圈
if (bFin)
{
//出货成功
g_pLeyaoyao->UpTrade(true);
}
#endif
if (m_fLockOpeningTime <= 0 || bFin) //时间到自动关闭
{
m_fLockOpeningTime = 0;
g_pCom->CloseAllDev();
}
}
//正在出货
m_boxOutting->setVisible(m_fLockOpeningTime > 0);
//音乐
#ifndef _DEBUG
if (!m_music->isPlaying())
{
m_fMusicDelay -= delta;
if (m_fMusicDelay <= 0)
{
m_fMusicDelay = 0.5f;
m_music->play();
}
}
#endif // _DEBUG
}
void IoCtrlLayer::onKeyReleased(EventKeyboard::KeyCode keyCode, Event* event)
{
#if (VERSION_BUILD_NUMBER==2)
// system("shutdown -r -t 0");
#endif
#ifdef FORBID_KEYBOARD
// MessageBox(StringUtils::format("%d", keyCode).c_str(), "onKeyReleased");
return;
#endif // FORBID_KEYBOARD
switch (keyCode)
{
case EventKeyboard::KeyCode::KEY_ESCAPE:
Director::getInstance()->end();
break;
case EventKeyboard::KeyCode::KEY_Z:
if(this->getParent())
{
SceneMgr* scene = (SceneMgr*)this->getParent();
scene->captureScreen2();
}
break;
case EventKeyboard::KeyCode::KEY_SPACE:
if (Director::getInstance()->isPaused())
{
Director::getInstance()->resume();
}
else
{
Director::getInstance()->pause();
}
break;
case EventKeyboard::KeyCode::KEY_KP_PLUS:
myAddCent(1);
break;
case EventKeyboard::KeyCode::KEY_R:
g_pCom->RetryOuting();
case EventKeyboard::KeyCode::KEY_KP_MINUS:
myClearCoin();
break;
case EventKeyboard::KeyCode::KEY_S:
if (!this->getChildByName("password"))
{
this->addChild(LayerPassword::MyCreate(this, "111"), 99999, "password");
}
break;
case EventKeyboard::KeyCode::KEY_V:
g_pIoCtrlLayer->setVisible(!g_pIoCtrlLayer->isVisible());
break;
//------------- 旋钮 -------------
case EventKeyboard::KeyCode::KEY_ENTER:
m_keyDown[0] = true;
m_keyKeep[0] = false;
break;
case EventKeyboard::KeyCode::KEY_LEFT_ARROW:
m_keyDown[1] = true;
m_keyKeep[1] = false;
break;
case EventKeyboard::KeyCode::KEY_RIGHT_ARROW:
m_keyDown[2] = true;
m_keyKeep[2] = false;
break;
case EventKeyboard::KeyCode::KEY_L:
bDebugIo = !bDebugIo;
break;
#if 0
case EventKeyboard::KeyCode::KEY_1:
dataOutEgg(0, 1);
break;
case EventKeyboard::KeyCode::KEY_2:
dataOutEgg(1, 1);
break;
case EventKeyboard::KeyCode::KEY_3:
dataOutEgg(2, 1);
break;
case EventKeyboard::KeyCode::KEY_4:
dataOutEgg(3, 1);
break;
case EventKeyboard::KeyCode::KEY_5:
dataOutEgg(4, 1);
break;
case EventKeyboard::KeyCode::KEY_6:
dataOutEgg(5, 1);
break;
case EventKeyboard::KeyCode::KEY_7:
dataOutEgg(6, 1);
break;
case EventKeyboard::KeyCode::KEY_8:
dataOutEgg(7, 1);
break;
#endif
}
// g_pCom->SetKeyLogic(keyCode);
}
void IoCtrlLayer::onKeyPressed(EventKeyboard::KeyCode keyCode, Event* event)
{
#if (VERSION_BUILD_NUMBER==2)
// system("shutdown -r -t 0");
#endif
#ifdef FORBID_KEYBOARD
// MessageBox(StringUtils::format("%d", keyCode).c_str(), "onKeyReleased");
return;
#endif // FORBID_KEYBOARD
switch (keyCode)
{
//------------- 旋钮 -------------
case EventKeyboard::KeyCode::KEY_ENTER:
m_keyKeep[0] = true;
break;
case EventKeyboard::KeyCode::KEY_LEFT_ARROW:
m_keyKeep[1] = true;
break;
case EventKeyboard::KeyCode::KEY_RIGHT_ARROW:
m_keyKeep[2] = true;
break;
}
}
void IoCtrlLayer::updateCoinShow()
{
}
void IoCtrlLayer::myAddCent(int cent, bool bNet)
{
dataSet_AddCent(cent, bNet);
MySound::playEffect("sound/CoinIn.mp3");
}
void IoCtrlLayer::myClearCoin()
{
dataSet_ClearCent();
}
void IoCtrlLayer::myCallMenu()
{
if (getTag() == e_scene_game)
{
Director::getInstance()->replaceScene(TransitionJumpZoom::create(0.3f, HorizontalScreen(Scene_Menu::createScene())));
}
}
void IoCtrlLayer::myAddRemainCoin(int coin)
{//增加玩家币数，返还，不加记录
dataSet_AddCentByGame(coin);
MySound::playEffect("sound/CoinIn.mp3");
}
void IoCtrlLayer::useCoinByGame(int index)
{
dataUse_PlayGame(); //扣币
MySound::playEffect("sound/use_coin.mp3");
}
bool IoCtrlLayer::isKeyDown(eKeyTag key, float fSpace)
{
switch (key)
{
case IoCtrlLayer::e_key_fire:
if (fSpace > 0)
{
if (g_pCom->CheckSpace(CComThread::eBtnAddr::e_addr_p1, CComThread::e_bit_FIRE, fSpace))
return true;
}
else
{
if (g_pCom->CheckOnce(CComThread::eBtnAddr::e_addr_p1, CComThread::e_bit_FIRE))
return true;
}
break;
case IoCtrlLayer::e_key_left:
if (g_pCom->GetKnob(CComThread::e_knob_l) > 0)
return true;
break;
case IoCtrlLayer::e_key_right:
if (g_pCom->GetKnob(CComThread::e_knob_r) > 0)
return true;
break;
}
#ifdef _DEBUG
return m_keyDown[key];
#endif // _DEBUG
return false;
}
bool IoCtrlLayer::isKeyKeep(eKeyTag key)
{
switch (key)
{
case IoCtrlLayer::e_key_fire:
#if 1 //门检测开关，信号是相反的，关门时是断开
if (!g_pCom->Check(CComThread::e_addr_p1, CComThread::e_bit_FIRE))
#else
if (g_pCom->Check(CComThread::e_addr_p1, CComThread::e_bit_FIRE))
#endif
return true;
break;
#if 1
case IoCtrlLayer::e_key_left:
if (g_pCom->GetKnob(CComThread::e_knob_l) > 0)
return true;
break;
case IoCtrlLayer::e_key_right:
if (g_pCom->GetKnob(CComThread::e_knob_r) > 0)
return true;
break;
#else
case IoCtrlLayer::e_key_left:
if (g_pCom->Check(CComThread::e_bit_LEFT))
return true;
break;
case IoCtrlLayer::e_key_right:
if (g_pCom->Check(CComThread::e_bit_RIGHT))
return true;
break;
#endif
}
#ifdef _DEBUG
return m_keyKeep[key];
#endif // _DEBUG
return false;
}
void IoCtrlLayer::timerBlinkInsertAndTick(float delta)
{
#if (VERSION_BUY_TYPE == BUY_NONE)
//投币提示
if (getTag() == e_scene_other || dataGet_RemainCent() > 0 || EG_Base::isGamePlaying())
{
m_insert->setVisible(false);
}
else
{
m_insert->setVisible(!m_insert->isVisible());
}
//退票提示
{
if (m_nTick != g_pCom->GetTicketOut(0))
{
m_nTick = g_pCom->GetTicketOut(0);
m_tickNum->setString(GBKToUTF(StringUtils::format("%d", m_nTick)));
}
m_tickNum->setVisible(m_nTick > 0);
m_tickError->setVisible(g_pCom->IsTickOutError(0));
#ifdef SINGLE_EGG_OUT
m_eggError->setVisible(g_pCom->IsEggOutError(0));
#endif // SINGLE_EGG_OUT
}
#endif
}
void IoCtrlLayer::knobShake(int pid, float time)
{
#if ( VERSION_BUY_TYPE != BUY_EGG && VERSION_BUY_TYPE != BUY_GIFT)
g_pCom->SetDevOut(pid, 2, true);
m_lstKnobShakeRemain.push_back({ pid, time });
#endif
}
void IoCtrlLayer::lightFire(int pid, bool bOn)
{
#if ( VERSION_BUY_TYPE != BUY_EGG && VERSION_BUY_TYPE != BUY_GIFT)
g_pCom->SetDevOut(pid, 3, bOn);
#endif
}
void IoCtrlLayer::openLock(int v, int h, float openTime)
{
if (m_fLockOpeningTime > 0)
{
CCLOG("Error: 之前的锁还没关闭");
return;
}
#if (BOX_CONTAIN_GOODS == BOX_EACH_MUTL)
m_iMotorIndex = box_GetIndex(v, h);
ioOpenMotor(m_iMotorIndex);
m_fLockOpeningTime = c_iniLockOpeningTime; // cyhol 根据电机转动速度调节，用于防止微动坏 [11/22/2018 pc-ah]
#else
ioOpenLock(v, h);
m_fLockOpeningTime = 0.2f;
#endif
if (openTime > 0)
{
m_fLockOpeningTime = openTime;
}
}
bool IoCtrlLayer::isLockOpening()
{
return m_fLockOpeningTime > 0;
}
bool IoCtrlLayer::isLockError()
{
return m_bLockError;
}
/************************************************************************/
/* */
/************************************************************************/
#if 0
void SceneMgr::popScene(cocos2d::Scene* s, int tag)
{
Director::getInstance()->popScene();
Director::getInstance()->getRunningScene()->addChild(g_pIoCtrlLayer);
g_pIoCtrlLayer->setTag(tag);
g_pIoCtrlLayer->setZOrder(10001);
}
#endif
| [
"troubtimehero@126.com"
] | troubtimehero@126.com |
d1a8b86e84dd43723c892de9136babef2d77231b | 45a26f28a29ab6dd9d3bcf315117d814f50808b1 | /src/llvmCore/llvmCore-2358.3/lib/Target/PowerPC/PPCISelLowering.h | 1d05f3d4ea6982aa50e10eb81edb3059c133bb85 | [
"NCSA"
] | permissive | zeborrego/opensource.apple.com | 0eb9161029ce8440dbdc4b5157b3927a6e381f8d | 88cbaab4a42e97cbbfe6b660f2f0945536821be6 | refs/heads/master | 2021-07-06T17:16:28.241638 | 2017-10-02T11:58:56 | 2017-10-02T11:58:56 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 22,208 | h | //===-- PPCISelLowering.h - PPC32 DAG Lowering Interface --------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines the interfaces that PPC uses to lower LLVM code into a
// selection DAG.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_TARGET_POWERPC_PPC32ISELLOWERING_H
#define LLVM_TARGET_POWERPC_PPC32ISELLOWERING_H
#include "llvm/Target/TargetLowering.h"
#include "llvm/CodeGen/SelectionDAG.h"
#include "PPC.h"
#include "PPCSubtarget.h"
namespace llvm {
namespace PPCISD {
enum NodeType {
// Start the numbering where the builtin ops and target ops leave off.
FIRST_NUMBER = ISD::BUILTIN_OP_END,
/// FSEL - Traditional three-operand fsel node.
///
FSEL,
/// FCFID - The FCFID instruction, taking an f64 operand and producing
/// and f64 value containing the FP representation of the integer that
/// was temporarily in the f64 operand.
FCFID,
/// FCTI[D,W]Z - The FCTIDZ and FCTIWZ instructions, taking an f32 or f64
/// operand, producing an f64 value containing the integer representation
/// of that FP value.
FCTIDZ, FCTIWZ,
/// STFIWX - The STFIWX instruction. The first operand is an input token
/// chain, then an f64 value to store, then an address to store it to.
STFIWX,
// VMADDFP, VNMSUBFP - The VMADDFP and VNMSUBFP instructions, taking
// three v4f32 operands and producing a v4f32 result.
VMADDFP, VNMSUBFP,
/// VPERM - The PPC VPERM Instruction.
///
VPERM,
/// Hi/Lo - These represent the high and low 16-bit parts of a global
/// address respectively. These nodes have two operands, the first of
/// which must be a TargetGlobalAddress, and the second of which must be a
/// Constant. Selected naively, these turn into 'lis G+C' and 'li G+C',
/// though these are usually folded into other nodes.
Hi, Lo,
TOC_ENTRY,
/// The following three target-specific nodes are used for calls through
/// function pointers in the 64-bit SVR4 ABI.
/// Restore the TOC from the TOC save area of the current stack frame.
/// This is basically a hard coded load instruction which additionally
/// takes/produces a flag.
TOC_RESTORE,
/// Like a regular LOAD but additionally taking/producing a flag.
LOAD,
/// LOAD into r2 (also taking/producing a flag). Like TOC_RESTORE, this is
/// a hard coded load instruction.
LOAD_TOC,
/// OPRC, CHAIN = DYNALLOC(CHAIN, NEGSIZE, FRAME_INDEX)
/// This instruction is lowered in PPCRegisterInfo::eliminateFrameIndex to
/// compute an allocation on the stack.
DYNALLOC,
/// GlobalBaseReg - On Darwin, this node represents the result of the mflr
/// at function entry, used for PIC code.
GlobalBaseReg,
/// These nodes represent the 32-bit PPC shifts that operate on 6-bit
/// shift amounts. These nodes are generated by the multi-precision shift
/// code.
SRL, SRA, SHL,
/// EXTSW_32 - This is the EXTSW instruction for use with "32-bit"
/// registers.
EXTSW_32,
/// CALL - A direct function call.
CALL_Darwin, CALL_SVR4,
/// NOP - Special NOP which follows 64-bit SVR4 calls.
NOP,
/// CHAIN,FLAG = MTCTR(VAL, CHAIN[, INFLAG]) - Directly corresponds to a
/// MTCTR instruction.
MTCTR,
/// CHAIN,FLAG = BCTRL(CHAIN, INFLAG) - Directly corresponds to a
/// BCTRL instruction.
BCTRL_Darwin, BCTRL_SVR4,
/// Return with a flag operand, matched by 'blr'
RET_FLAG,
/// R32 = MFCR(CRREG, INFLAG) - Represents the MFCR/MFOCRF instructions.
/// This copies the bits corresponding to the specified CRREG into the
/// resultant GPR. Bits corresponding to other CR regs are undefined.
MFCR,
/// RESVEC = VCMP(LHS, RHS, OPC) - Represents one of the altivec VCMP*
/// instructions. For lack of better number, we use the opcode number
/// encoding for the OPC field to identify the compare. For example, 838
/// is VCMPGTSH.
VCMP,
/// RESVEC, OUTFLAG = VCMPo(LHS, RHS, OPC) - Represents one of the
/// altivec VCMP*o instructions. For lack of better number, we use the
/// opcode number encoding for the OPC field to identify the compare. For
/// example, 838 is VCMPGTSH.
VCMPo,
/// CHAIN = COND_BRANCH CHAIN, CRRC, OPC, DESTBB [, INFLAG] - This
/// corresponds to the COND_BRANCH pseudo instruction. CRRC is the
/// condition register to branch on, OPC is the branch opcode to use (e.g.
/// PPC::BLE), DESTBB is the destination block to branch to, and INFLAG is
/// an optional input flag argument.
COND_BRANCH,
// The following 5 instructions are used only as part of the
// long double-to-int conversion sequence.
/// OUTFLAG = MFFS F8RC - This moves the FPSCR (not modelled) into the
/// register.
MFFS,
/// OUTFLAG = MTFSB0 INFLAG - This clears a bit in the FPSCR.
MTFSB0,
/// OUTFLAG = MTFSB1 INFLAG - This sets a bit in the FPSCR.
MTFSB1,
/// F8RC, OUTFLAG = FADDRTZ F8RC, F8RC, INFLAG - This is an FADD done with
/// rounding towards zero. It has flags added so it won't move past the
/// FPSCR-setting instructions.
FADDRTZ,
/// MTFSF = F8RC, INFLAG - This moves the register into the FPSCR.
MTFSF,
/// LARX = This corresponds to PPC l{w|d}arx instrcution: load and
/// reserve indexed. This is used to implement atomic operations.
LARX,
/// STCX = This corresponds to PPC stcx. instrcution: store conditional
/// indexed. This is used to implement atomic operations.
STCX,
/// TC_RETURN - A tail call return.
/// operand #0 chain
/// operand #1 callee (register or absolute)
/// operand #2 stack adjustment
/// operand #3 optional in flag
TC_RETURN,
/// STD_32 - This is the STD instruction for use with "32-bit" registers.
STD_32 = ISD::FIRST_TARGET_MEMORY_OPCODE,
/// CHAIN = STBRX CHAIN, GPRC, Ptr, Type - This is a
/// byte-swapping store instruction. It byte-swaps the low "Type" bits of
/// the GPRC input, then stores it through Ptr. Type can be either i16 or
/// i32.
STBRX,
/// GPRC, CHAIN = LBRX CHAIN, Ptr, Type - This is a
/// byte-swapping load instruction. It loads "Type" bits, byte swaps it,
/// then puts it in the bottom bits of the GPRC. TYPE can be either i16
/// or i32.
LBRX
};
}
/// Define some predicates that are used for node matching.
namespace PPC {
/// isVPKUHUMShuffleMask - Return true if this is the shuffle mask for a
/// VPKUHUM instruction.
bool isVPKUHUMShuffleMask(ShuffleVectorSDNode *N, bool isUnary);
/// isVPKUWUMShuffleMask - Return true if this is the shuffle mask for a
/// VPKUWUM instruction.
bool isVPKUWUMShuffleMask(ShuffleVectorSDNode *N, bool isUnary);
/// isVMRGLShuffleMask - Return true if this is a shuffle mask suitable for
/// a VRGL* instruction with the specified unit size (1,2 or 4 bytes).
bool isVMRGLShuffleMask(ShuffleVectorSDNode *N, unsigned UnitSize,
bool isUnary);
/// isVMRGHShuffleMask - Return true if this is a shuffle mask suitable for
/// a VRGH* instruction with the specified unit size (1,2 or 4 bytes).
bool isVMRGHShuffleMask(ShuffleVectorSDNode *N, unsigned UnitSize,
bool isUnary);
/// isVSLDOIShuffleMask - If this is a vsldoi shuffle mask, return the shift
/// amount, otherwise return -1.
int isVSLDOIShuffleMask(SDNode *N, bool isUnary);
/// isSplatShuffleMask - Return true if the specified VECTOR_SHUFFLE operand
/// specifies a splat of a single element that is suitable for input to
/// VSPLTB/VSPLTH/VSPLTW.
bool isSplatShuffleMask(ShuffleVectorSDNode *N, unsigned EltSize);
/// isAllNegativeZeroVector - Returns true if all elements of build_vector
/// are -0.0.
bool isAllNegativeZeroVector(SDNode *N);
/// getVSPLTImmediate - Return the appropriate VSPLT* immediate to splat the
/// specified isSplatShuffleMask VECTOR_SHUFFLE mask.
unsigned getVSPLTImmediate(SDNode *N, unsigned EltSize);
/// get_VSPLTI_elt - If this is a build_vector of constants which can be
/// formed by using a vspltis[bhw] instruction of the specified element
/// size, return the constant being splatted. The ByteSize field indicates
/// the number of bytes of each element [124] -> [bhw].
SDValue get_VSPLTI_elt(SDNode *N, unsigned ByteSize, SelectionDAG &DAG);
}
class PPCTargetLowering : public TargetLowering {
const PPCSubtarget &PPCSubTarget;
public:
explicit PPCTargetLowering(PPCTargetMachine &TM);
/// getTargetNodeName() - This method returns the name of a target specific
/// DAG node.
virtual const char *getTargetNodeName(unsigned Opcode) const;
/// getSetCCResultType - Return the ISD::SETCC ValueType
virtual MVT::SimpleValueType getSetCCResultType(EVT VT) const;
/// getPreIndexedAddressParts - returns true by value, base pointer and
/// offset pointer and addressing mode by reference if the node's address
/// can be legally represented as pre-indexed load / store address.
virtual bool getPreIndexedAddressParts(SDNode *N, SDValue &Base,
SDValue &Offset,
ISD::MemIndexedMode &AM,
SelectionDAG &DAG) const;
/// SelectAddressRegReg - Given the specified addressed, check to see if it
/// can be represented as an indexed [r+r] operation. Returns false if it
/// can be more efficiently represented with [r+imm].
bool SelectAddressRegReg(SDValue N, SDValue &Base, SDValue &Index,
SelectionDAG &DAG) const;
/// SelectAddressRegImm - Returns true if the address N can be represented
/// by a base register plus a signed 16-bit displacement [r+imm], and if it
/// is not better represented as reg+reg.
bool SelectAddressRegImm(SDValue N, SDValue &Disp, SDValue &Base,
SelectionDAG &DAG) const;
/// SelectAddressRegRegOnly - Given the specified addressed, force it to be
/// represented as an indexed [r+r] operation.
bool SelectAddressRegRegOnly(SDValue N, SDValue &Base, SDValue &Index,
SelectionDAG &DAG) const;
/// SelectAddressRegImmShift - Returns true if the address N can be
/// represented by a base register plus a signed 14-bit displacement
/// [r+imm*4]. Suitable for use by STD and friends.
bool SelectAddressRegImmShift(SDValue N, SDValue &Disp, SDValue &Base,
SelectionDAG &DAG) const;
/// LowerOperation - Provide custom lowering hooks for some operations.
///
virtual SDValue LowerOperation(SDValue Op, SelectionDAG &DAG) const;
/// ReplaceNodeResults - Replace the results of node with an illegal result
/// type with new values built out of custom code.
///
virtual void ReplaceNodeResults(SDNode *N, SmallVectorImpl<SDValue>&Results,
SelectionDAG &DAG) const;
virtual SDValue PerformDAGCombine(SDNode *N, DAGCombinerInfo &DCI) const;
virtual void computeMaskedBitsForTargetNode(const SDValue Op,
const APInt &Mask,
APInt &KnownZero,
APInt &KnownOne,
const SelectionDAG &DAG,
unsigned Depth = 0) const;
virtual MachineBasicBlock *
EmitInstrWithCustomInserter(MachineInstr *MI,
MachineBasicBlock *MBB) const;
MachineBasicBlock *EmitAtomicBinary(MachineInstr *MI,
MachineBasicBlock *MBB, bool is64Bit,
unsigned BinOpcode) const;
MachineBasicBlock *EmitPartwordAtomicBinary(MachineInstr *MI,
MachineBasicBlock *MBB,
bool is8bit, unsigned Opcode) const;
ConstraintType getConstraintType(const std::string &Constraint) const;
std::pair<unsigned, const TargetRegisterClass*>
getRegForInlineAsmConstraint(const std::string &Constraint,
EVT VT) const;
/// getByValTypeAlignment - Return the desired alignment for ByVal aggregate
/// function arguments in the caller parameter area. This is the actual
/// alignment, not its logarithm.
unsigned getByValTypeAlignment(const Type *Ty) const;
/// LowerAsmOperandForConstraint - Lower the specified operand into the Ops
/// vector. If it is invalid, don't add anything to Ops. If hasMemory is
/// true it means one of the asm constraint of the inline asm instruction
/// being processed is 'm'.
virtual void LowerAsmOperandForConstraint(SDValue Op,
char ConstraintLetter,
bool hasMemory,
std::vector<SDValue> &Ops,
SelectionDAG &DAG) const;
/// isLegalAddressingMode - Return true if the addressing mode represented
/// by AM is legal for this target, for a load/store of the specified type.
virtual bool isLegalAddressingMode(const AddrMode &AM, const Type *Ty)const;
/// isLegalAddressImmediate - Return true if the integer value can be used
/// as the offset of the target addressing mode for load / store of the
/// given type.
virtual bool isLegalAddressImmediate(int64_t V, const Type *Ty) const;
/// isLegalAddressImmediate - Return true if the GlobalValue can be used as
/// the offset of the target addressing mode.
virtual bool isLegalAddressImmediate(GlobalValue *GV) const;
virtual bool isOffsetFoldingLegal(const GlobalAddressSDNode *GA) const;
/// getOptimalMemOpType - Returns the target specific optimal type for load
/// and store operations as a result of memset, memcpy, and memmove
/// lowering. If DstAlign is zero that means it's safe to destination
/// alignment can satisfy any constraint. Similarly if SrcAlign is zero it
/// means there isn't a need to check it against alignment requirement,
/// probably because the source does not need to be loaded. If
/// 'NonScalarIntSafe' is true, that means it's safe to return a
/// non-scalar-integer type, e.g. empty string source, constant, or loaded
/// from memory. 'MemcpyStrSrc' indicates whether the memcpy source is
/// constant so it does not need to be loaded.
/// It returns EVT::Other if the type should be determined using generic
/// target-independent logic.
virtual EVT
getOptimalMemOpType(uint64_t Size, unsigned DstAlign, unsigned SrcAlign,
bool NonScalarIntSafe, bool MemcpyStrSrc,
MachineFunction &MF) const;
/// getFunctionAlignment - Return the Log2 alignment of this function.
virtual unsigned getFunctionAlignment(const Function *F) const;
private:
SDValue getFramePointerFrameIndex(SelectionDAG & DAG) const;
SDValue getReturnAddrFrameIndex(SelectionDAG & DAG) const;
bool
IsEligibleForTailCallOptimization(SDValue Callee,
CallingConv::ID CalleeCC,
bool isVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins,
SelectionDAG& DAG) const;
SDValue EmitTailCallLoadFPAndRetAddr(SelectionDAG & DAG,
int SPDiff,
SDValue Chain,
SDValue &LROpOut,
SDValue &FPOpOut,
bool isDarwinABI,
DebugLoc dl) const;
SDValue LowerRETURNADDR(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerFRAMEADDR(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerConstantPool(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerBlockAddress(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerGlobalAddress(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerJumpTable(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerSETCC(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerTRAMPOLINE(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerVASTART(SDValue Op, SelectionDAG &DAG,
const PPCSubtarget &Subtarget) const;
SDValue LowerVAARG(SDValue Op, SelectionDAG &DAG,
const PPCSubtarget &Subtarget) const;
SDValue LowerSTACKRESTORE(SDValue Op, SelectionDAG &DAG,
const PPCSubtarget &Subtarget) const;
SDValue LowerDYNAMIC_STACKALLOC(SDValue Op, SelectionDAG &DAG,
const PPCSubtarget &Subtarget) const;
SDValue LowerSELECT_CC(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerFP_TO_INT(SDValue Op, SelectionDAG &DAG, DebugLoc dl) const;
SDValue LowerSINT_TO_FP(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerFLT_ROUNDS_(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerSHL_PARTS(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerSRL_PARTS(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerSRA_PARTS(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerBUILD_VECTOR(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerVECTOR_SHUFFLE(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerINTRINSIC_WO_CHAIN(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerSCALAR_TO_VECTOR(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerMUL(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerCallResult(SDValue Chain, SDValue InFlag,
CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const;
SDValue FinishCall(CallingConv::ID CallConv, DebugLoc dl, bool isTailCall,
bool isVarArg,
SelectionDAG &DAG,
SmallVector<std::pair<unsigned, SDValue>, 8>
&RegsToPass,
SDValue InFlag, SDValue Chain,
SDValue &Callee,
int SPDiff, unsigned NumBytes,
const SmallVectorImpl<ISD::InputArg> &Ins,
SmallVectorImpl<SDValue> &InVals) const;
virtual SDValue
LowerFormalArguments(SDValue Chain,
CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const;
virtual SDValue
LowerCall(SDValue Chain, SDValue Callee,
CallingConv::ID CallConv, bool isVarArg, bool &isTailCall,
const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const;
virtual SDValue
LowerReturn(SDValue Chain,
CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::OutputArg> &Outs,
DebugLoc dl, SelectionDAG &DAG) const;
SDValue
LowerFormalArguments_Darwin(SDValue Chain,
CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const;
SDValue
LowerFormalArguments_SVR4(SDValue Chain,
CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const;
SDValue
LowerCall_Darwin(SDValue Chain, SDValue Callee,
CallingConv::ID CallConv, bool isVarArg, bool isTailCall,
const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const;
SDValue
LowerCall_SVR4(SDValue Chain, SDValue Callee,
CallingConv::ID CallConv, bool isVarArg, bool isTailCall,
const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const;
};
}
#endif // LLVM_TARGET_POWERPC_PPC32ISELLOWERING_H
| [
"mattl@cnuk.org"
] | mattl@cnuk.org |
d633e17e26af88e2a7f7e687ed86cb2cb1f3d91b | 5fd7fcf4c893cb9b627675f1571beaec3db2a35c | /src/util/myString.cpp | b0f81f150a12a80e423dc8e9901a55c3f6ad50b5 | [] | no_license | paramoecium/EDA_project | f10fa44f3a2e163795cb9e9e6f5fd649a67e131b | 3e61d7f9ebbc680c9937c2cca9a93464eaef4381 | refs/heads/master | 2016-09-16T03:32:20.651522 | 2015-08-20T02:21:30 | 2015-08-20T02:21:30 | 35,333,017 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,747 | cpp | /****************************************************************************
FileName [ myString.cpp ]
PackageName [ util ]
Synopsis [ Customized string processing functions ]
Author [ Chung-Yang (Ric) Huang ]
Copyright [ Copyleft(c) 2007-2013 LaDs(III), GIEE, NTU, Taiwan ]
****************************************************************************/
#include <string>
#include <ctype.h>
#include <cstring>
#include <cassert>
using namespace std;
// 1. strlen(s1) must >= n
// 2. The first n characters of s2 are mandatory, they must be case-
// insensitively compared to s1. Return less or greater than 0 if unequal.
// 3. The rest of s2 are optional. Return 0 if EOF of s2 is encountered.
// Otherwise, perform case-insensitive comparison until non-equal result
// presents.
//
int
myStrNCmp(const string& s1, const string& s2, unsigned n)
{
assert(n > 0);
unsigned n2 = s2.size();
if (n2 == 0) return -1;
unsigned n1 = s1.size();
assert(n1 >= n);
for (unsigned i = 0; i < n1; ++i) {
if (i == n2)
return (i < n)? 1 : 0;
char ch1 = (isupper(s1[i]))? tolower(s1[i]) : s1[i];
char ch2 = (isupper(s2[i]))? tolower(s2[i]) : s2[i];
if (ch1 != ch2)
return (ch1 - ch2);
}
return (n1 - n2);
}
// Parse the string "str" for the token "tok", beginning at position "pos",
// with delimiter "del". The leading "del" will be skipped.
// Return "string::npos" if not found. Return the past to the end of "tok"
// (i.e. "del" or string::npos) if found.
//
size_t
myStrGetTok(const string& str, string& tok, size_t pos = 0,
const string del = " ")
{
size_t begin = str.find_first_not_of(del, pos);
if (begin == string::npos) { tok = ""; return begin; }
size_t end = str.find_first_of(del, begin);
tok = str.substr(begin, end - begin);
return end;
}
// Convert string "str" to integer "num". Return false if str does not appear
// to be a number
bool
myStr2Int(const string& str, int& num)
{
num = 0;
size_t i = 0;
int sign = 1;
if (str[0] == '-') { sign = -1; i = 1; }
bool valid = false;
for (; i < str.size(); ++i) {
if (isdigit(str[i])) {
num *= 10;
num += int(str[i] - '0');
valid = true;
}
else return false;
}
num *= sign;
return valid;
}
// Valid var name is ---
// 1. starts with [a-zA-Z_]
// 2. others, can only be [a-zA-Z0-9_]
// return false if not a var name
bool
isValidVarName(const string& str)
{
size_t n = str.size();
if (n == 0) return false;
if (!isalpha(str[0]) && str[0] != '_')
return false;
for (size_t i = 1; i < n; ++i)
if (!isalnum(str[i]) && str[i] != '_')
return false;
return true;
}
| [
"hank123456789321@yahoo.com.tw"
] | hank123456789321@yahoo.com.tw |
88f9035f87ecb88ffd5fd5a210a7f491fb946ee3 | b3094d2edcfc935f05b212b00e6ae98673c3e8d2 | /src/core/renderBase.cpp | 7343d711db8cf2ddb7b89790528ddca2ae449e60 | [] | no_license | tianxiejack/pro_stbenc_crcore2 | 6a5b1482250d955cf515e0cc01e81267dd04441a | 2a582b26441b6f629a3504cdd1e7bc0488609738 | refs/heads/master | 2021-08-16T18:04:52.736510 | 2020-08-18T00:33:24 | 2020-08-18T00:33:24 | 214,626,623 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,772 | cpp | /*
* renderBase.cpp
*
* Created on: Jul 5, 2019
* Author: ubuntu
*/
#include <opencv2/opencv.hpp>
#include "crCore.hpp"
#include "renderBase.hpp"
#include "crcoreRender.hpp"
#include "gluVideoWindow.hpp"
#include "osa_image_queue.h"
#include "glvideo.hpp"
#include "glvideoRender.hpp"
namespace cr_core
{
class CRenderBaseImpl : public RenderBase
{
public:
CRenderBaseImpl(int WinId, CCoreRenderBase *render, const cv::Scalar& clearColor = cv::Scalar(255, 0, 0, 0));
virtual ~CRenderBaseImpl();
void Draw();
int Draw(const cv::Rect& pos);
int Draw(const cv::Rect& pos, const cv::Mat& img);
int Draw(const cv::Rect& pos, const cv::Rect& roi);
int Draw(const cv::Rect& pos, int videoId, const cv::Rect& roi);
CGluVideoWindow *m_window;
CCoreRenderBase *m_render;
//private:
protected:
ICore_1001 *m_core;
cv::Size m_size;
int m_channels;
GLuint textureId;
GLMatx44f m_matrix;
cv::Scalar m_defaultColor;
};
CRenderBaseImpl::CRenderBaseImpl(int winId, CCoreRenderBase *render, const cv::Scalar& clearColor) :
m_size(cv::Size(0, 0)),m_channels(0),textureId(0), m_defaultColor(clearColor)
{
m_core = (ICore_1001*)ICore::Qury(COREID_1001);
OSA_assert(m_core);
if(winId <= 1)
m_window = (CGluVideoWindow*)ICore::QureyObj(1);
else
m_window = (CGluVideoWindow*)ICore::QureyObj(2);
OSA_assert(m_window != NULL);
m_render = render;
glGenTextures(1, &textureId);
glBindTexture(GL_TEXTURE_2D, textureId);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);//GL_NEAREST);//GL_NEAREST_MIPMAP_NEAREST);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);//GL_NEAREST);//GL_NEAREST_MIPMAP_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);//GL_CLAMP);//GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);//GL_CLAMP);//GL_CLAMP_TO_EDGE);
glBindTexture(GL_TEXTURE_2D, 0);
m_matrix = GLMatx44f::eye();
m_window->vRenders.push_back(this);
}
CRenderBaseImpl::~CRenderBaseImpl()
{
std::vector<RenderBase*>::iterator it;
for(it=m_window->vRenders.begin();it!=m_window->vRenders.end();++it){
if(this == (*it)){
m_window->vRenders.erase(it);
break;
}
}
ICore::Release(m_core);
glDeleteTextures(1, &textureId);
}
void CRenderBaseImpl::Draw()
{
m_render->OnRender();
}
int CRenderBaseImpl::Draw(const cv::Rect& pos)
{
if(pos.width <=0 || pos.height <= 0)
return 0;
static const GLfloat defaultVertices[8] = {
-1.f, -1.f,
1.f, -1.f,
-1.f, 1.f,
1.f, 1.f
};
static const GLfloat defaultTextureCoords[8] = {
0.0f, 1.0f,
1.0f, 1.0f,
0.0f, 0.0f,
1.0f, 0.0f
};
GLint glProg = CGLVideoRender::m_glProgram[1];
glUseProgram(glProg);
GLint Uniform_tex_in = glGetUniformLocation(glProg, "tex_in");
glUniform1i(Uniform_tex_in, 0);
GLint Uniform_mvp = glGetUniformLocation(glProg, "mvpMatrix");
GLMatx44f mTrans = m_matrix;
glUniformMatrix4fv(Uniform_mvp, 1, GL_FALSE, mTrans.val);
glEnable(GL_TEXTURE_2D);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, textureId);
glVertexAttribPointer(ATTRIB_VERTEX, 2, GL_FLOAT, GL_FALSE, 0, defaultVertices);
glVertexAttribPointer(ATTRIB_TEXTURE, 2, GL_FLOAT, GL_FALSE, 0, defaultTextureCoords);
glEnableVertexAttribArray(ATTRIB_VERTEX);
glEnableVertexAttribArray(ATTRIB_TEXTURE);
glViewport(pos.x, pos.y, pos.width, pos.height);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glBindTexture(GL_TEXTURE_2D, 0);
glDisable(GL_TEXTURE_2D);
glUseProgram(0);
}
int CRenderBaseImpl::Draw(const cv::Rect& pos, const cv::Mat& img)
{
int channels = img.channels();
int width = img.cols;
int height = img.rows;
glBindTexture(GL_TEXTURE_2D, textureId);
if(channels == 1)
glTexImage2D(GL_TEXTURE_2D, 0, channels, width, height, 0, GL_RED, GL_UNSIGNED_BYTE, img.data);
else
glTexImage2D(GL_TEXTURE_2D, 0, channels, width, height, 0, GL_BGR_EXT, GL_UNSIGNED_BYTE, img.data);
glBindTexture(GL_TEXTURE_2D, 0);
return Draw(pos);
}
int CRenderBaseImpl::Draw(const cv::Rect& pos, int videoId, const cv::Rect& roi)
{
bool bClear = false;
cv::Size curSize = cv::Size(roi.width, roi.height);
if(curSize.width == 0 || curSize.height == 0){
curSize = cv::Size(pos.width, pos.height);
bClear = true;
}
int nVideo = m_window->m_vvideos.size();
int channels = m_window->m_vvideos[videoId]->m_channels;
GLuint srcBufferId = m_window->m_vvideos[videoId]->m_curBufInfo.pbo;
cv::Size srcSize = m_window->m_vvideos[videoId]->m_size;
if(srcBufferId == 0)
m_window->m_vvideos[videoId]->m_pbo;
if(bClear)
{
m_size = curSize;
m_channels = channels;
//std::cout << __func__ << " Clear " << " pos = " << pos << " videoId = " << videoId << " roi " << roi << "m_size = " << m_size << std::endl;
glBindTexture(GL_TEXTURE_2D, textureId);
cv::Mat mFull = cv::Mat(m_size.height, m_size.width, CV_8UC3, m_defaultColor);
glTexImage2D(GL_TEXTURE_2D, 0, channels, m_size.width, m_size.height, 0, GL_BGR_EXT, GL_UNSIGNED_BYTE, mFull.data);
glBindTexture(GL_TEXTURE_2D, 0);
m_matrix = GLMatx44f::eye();
}
else if(m_size.width != curSize.width || m_size.height != curSize.height || m_channels != channels)
{
m_size = curSize;
m_channels = channels;
//std::cout << __func__ << " Init " << " pos = " << pos << " videoId = " << videoId << " roi " << roi << "m_size = " << m_size << std::endl;
}
if(!bClear){
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, srcBufferId);
glBindTexture(GL_TEXTURE_2D, textureId);
if(channels == 1)
glTexImage2D(GL_TEXTURE_2D, 0, channels, srcSize.width, srcSize.height, 0, GL_RED, GL_UNSIGNED_BYTE, NULL);
else
glTexImage2D(GL_TEXTURE_2D, 0, channels, srcSize.width, srcSize.height, 0, GL_BGR_EXT, GL_UNSIGNED_BYTE, NULL);
glBindTexture(GL_TEXTURE_2D, 0);
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
cv::Matx44f matricScale;
cv::Matx44f matricTranslate;
matricScale = cv::Matx44f::eye();
matricTranslate = cv::Matx44f::eye();
cv::Point2f center((float)(roi.x+(roi.width>>1))/(srcSize.width>>1)-1.0f, (float)(roi.y+(roi.height>>1))/(srcSize.height>>1)-1.0f);
matricTranslate.val[3] = -1.0f * center.x;
matricTranslate.val[7] = center.y;
matricScale.val[0] = (float)srcSize.width/roi.width;
matricScale.val[5] = (float)srcSize.height/roi.height;
m_matrix = (matricScale * matricTranslate).t();
}
return Draw(pos);
}
int CRenderBaseImpl::Draw(const cv::Rect& pos, const cv::Rect& roi)
{
return Draw(pos, m_core->m_stats.mainChId, roi);
}
}
CCoreRenderBase::CCoreRenderBase(int winId, const cv::Scalar& bgColor)
{
cr_core::CRenderBaseImpl *base = new cr_core::CRenderBaseImpl(winId, this, bgColor);
m_render = base;
OSA_assert(m_render);
}
CCoreRenderBase::~CCoreRenderBase()
{
if(m_render != NULL){
cr_core::CRenderBaseImpl *base = (cr_core::CRenderBaseImpl *)m_render;
delete base;
m_render = NULL;
}
}
int CCoreRenderBase::Draw(const cv::Rect& pos)
{
OSA_assert(m_render);
cr_core::CRenderBaseImpl *base = (cr_core::CRenderBaseImpl *)m_render;
return base->Draw(pos);
}
int CCoreRenderBase::Draw(const cv::Rect& pos, const cv::Mat& img)
{
OSA_assert(m_render);
cr_core::CRenderBaseImpl *base = (cr_core::CRenderBaseImpl *)m_render;
return base->Draw(pos, img);
}
int CCoreRenderBase::Draw(const cv::Rect& pos, const cv::Rect& roi)
{
OSA_assert(m_render);
cr_core::CRenderBaseImpl *base = (cr_core::CRenderBaseImpl *)m_render;
return base->Draw(pos, roi);
}
int CCoreRenderBase::Draw(const cv::Rect& pos, int videoId, const cv::Rect& roi)
{
OSA_assert(m_render);
cr_core::CRenderBaseImpl *base = (cr_core::CRenderBaseImpl *)m_render;
return base->Draw(pos, videoId, roi);
}
| [
"alex@qr.com"
] | alex@qr.com |
af1a59717f262a33fc128caeece2f155a1d9eb26 | 853e5baa52db7a587842f5d76d0107d1243b97c1 | /MySolutions/888. Fair Candy Swap/888.cpp | 48dcfabb0603205aca923452e2d9991d6a9cd4bb | [] | no_license | sanstwy777/Leetcode | 9f53723387bae6ed704589c509fd5c884dbde1af | 71f234f5f5308399b7e11b6fb85ed5b8aa06b3e9 | refs/heads/master | 2023-01-07T19:00:03.548755 | 2020-08-09T17:27:03 | 2020-11-01T04:19:21 | 286,284,350 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,311 | cpp | //============================================================================
// Name : Leetcode.888. Fair Candy Swap
// Author : sanstwy27
// Version : Version 1.0.0
// Copyright :
// Description : Any %
// Reference :
//============================================================================
#include <algorithm>
#include <iostream>
#include <set>
#include <string>
#include <vector>
using namespace std;
class Solution {
public:
vector<int> fairCandySwap(vector<int>& A, vector<int>& B) {
int sumA = 0;
set<int> setA;
for(int i = 0; i < A.size(); i++) {
sumA += A[i];
setA.insert(A[i]);
}
int sumB = 0;
set<int> setB;
for(int i = 0; i < B.size(); i++) {
sumB += B[i];
setB.insert(B[i]);
}
vector<int> ans;
int diff = sumB - sumA;
for(set<int>::iterator iter = setA.begin(); iter != setA.end(); iter++) {
int swapNum = (*iter) + (diff / 2);
if(setB.count(swapNum) != 0) {
ans.push_back(*iter);
ans.push_back(swapNum);
break;
}
}
return ans;
}
};
int main() {
// Test Case
vector<int> A{1,2}, B{2,3};
Solution t;
vector<int> ans = t.fairCandySwap(A, B);
for(int i = 0; i < ans.size(); i++) {
cout << ans[i] << endl;
}
return 0;
}
| [
"sanstwy777@outlook.com"
] | sanstwy777@outlook.com |
194f2b2edcf69549d4af0ba1674cfbfd579a52e8 | 69582830440f9d8de3ae83667741826fff09815d | /repositories/recipediskrepository.h | 19a022704a6173b47ecbd0972fb44734a814f6bc | [] | no_license | SimicDomagoj/Cookbook | f6094ce687d25b2510a9151066da3d06628f4c35 | 6a1464d26563457c07b72d9eaa854a1d97a78e5f | refs/heads/master | 2022-07-16T14:22:54.375407 | 2022-06-15T19:25:26 | 2022-06-15T19:25:26 | 182,816,934 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,254 | h | #include"repositories/reciperepository.h"
#include"filters/recipefilter.h"
#include"rcpreader.h"
#include<boost/filesystem.hpp>
class RecipeDiskRepository : public RecipeRepository
{
public:
RecipeDiskRepository();
virtual Recipe get(const uint32_t id) const override;
virtual std::vector<Recipe> get(const Filter<Recipe>& filter = RecipeFilter()) const override;
virtual Recipe getRandom(const Filter<Recipe>& filter = RecipeFilter()) const override;
virtual void insert(Recipe& recipe) override;
virtual void update(Recipe& recipe) override;
virtual void remove(uint32_t id) override;
virtual void remove(Recipe& recipe)override;
private:
uint32_t getNextId();
void applyFilter(std::vector<Recipe>& recipes, const Filter<Recipe>& filter) const;
std::string getFileName(const boost::filesystem::directory_entry& file) const;
uint32_t getIdFromFile(const boost::filesystem::directory_entry& file) const;
boost::filesystem::directory_entry getFileFromId(const uint32_t id) const;
bool startsWith(const std::string& s, const std::string& w) const;
std::string constructFileName(const Recipe& recipe) const;
uint32_t lastId;
boost::filesystem::path dataPath;
RcpReader rcpReader;
};
| [
"domagoj.simic0@gmail.com"
] | domagoj.simic0@gmail.com |
7bcded36473458ff23c2441361e7c63588330799 | b2aa4e5a6faef9d6b8fe08dd64149cd4e4896ccc | /libs/ofxPostProcessing/src/BloomPass.cpp | 7931cffd95d8252d86d23d416162b7587b7d6e82 | [
"MIT"
] | permissive | moebiussurfing/ofxSurfingFX | fa6bbfe0be2e2bf4a871fe34f7c9308bad856db6 | 5edfd77817ecc7137da6dddbc35a6b1094bfaaec | refs/heads/master | 2023-06-13T02:54:45.896907 | 2021-07-10T10:17:21 | 2021-07-10T10:17:21 | 336,920,679 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,384 | cpp | /*
* BloomPass.cpp
*
* Copyright (c) 2012, Neil Mendoza, http://www.neilmendoza.com
* 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 Neil Mendoza 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 "BloomPass.h"
#include "ofMain.h"
namespace itg
{
BloomPass::BloomPass(const ofVec2f& aspect, bool arb, const ofVec2f& xBlur, const ofVec2f& yBlur, unsigned resolution, bool aspectCorrect) : RenderPass(aspect, arb, "BLOOM")
{
currentReadFbo = 0;
if (resolution != ofNextPow2(resolution)) ofLogWarning() << "Resolution " << resolution << " is not a power of two, using " << ofNextPow2(resolution);
xConv = ConvolutionPass::Ptr(new ConvolutionPass(aspect, arb, xBlur));
yConv = ConvolutionPass::Ptr(new ConvolutionPass(aspect, arb, (aspectCorrect?aspect.x / aspect.y:1.f) * yBlur));
ofFbo::Settings s;
if (arb)
{
s.width = resolution;
s.height = resolution * aspect.y / aspect.x;
s.textureTarget = GL_TEXTURE_RECTANGLE_ARB;
}
else
{
s.width = ofNextPow2(resolution);
s.height = ofNextPow2(resolution);
s.textureTarget = GL_TEXTURE_2D;
}
s.useDepth = true;
for (int i = 0; i < 2; ++i) fbos[i].allocate(s);
}
void BloomPass::allocateSelectiveGlow(unsigned w, unsigned h)
{
this->w = w;
this->h = h;
ofFbo::Settings s;
s.textureTarget = GL_TEXTURE_2D;
s.width = ofNextPow2(w);
s.height = ofNextPow2(h);
s.useDepth = true;
selectiveGlow.allocate(s);
selectiveGlow.begin();
ofClear(0,0,0,255);
selectiveGlow.end();
}
void BloomPass::beginSelectiveGlow(bool clear)
{
selectiveGlow.begin();
glPushMatrix();
glScalef(1, -1, 1);
glTranslatef(0, -ofNextPow2(h), 0);
if (clear) ofClear(0,0,0, 255);
}
void BloomPass::endSelectiveGlow()
{
glPopMatrix();
selectiveGlow.end();
}
void BloomPass::debugDraw()
{
glPushMatrix();
glScalef(1, -1, 1);
selectiveGlow.draw(0, -selectiveGlow.getHeight());
glPopMatrix();
}
void BloomPass::render(ofFbo& readFbo, ofFbo& writeFbo)
{
if (selectiveGlow.isAllocated()) xConv->render(selectiveGlow, fbos[0]);
else xConv->render(readFbo, fbos[0]);
yConv->render(fbos[0], fbos[1]);
writeFbo.begin();
ofClear(0, 0, 0, 255);
ofSetColor(255, 255, 255);
readFbo.draw(0, 0);
ofEnableAlphaBlending();
glBlendFunc(GL_ONE, GL_ONE);
fbos[1].draw(0, 0, writeFbo.getWidth(), writeFbo.getHeight());
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
ofDisableAlphaBlending();
writeFbo.end();
}
} | [
"moebiussurfing@gmail.com"
] | moebiussurfing@gmail.com |
0c40385d23e78367b9cc28451217e55d29460faa | ecca4afeab636dcc4c2197b51cbb7e42b14361a3 | /opencv_imgproc/opencv_HoughCircles/ControlItem.cpp | 5a3addf3109f7164642ee2069ab29cf79b76cca4 | [] | no_license | ngzHappy/oct2 | f1140c2d930c7bd202b4494f1d4eab8e0d3fc4b2 | 5d4b17774e92ec149da68ec06c4543151e8885e1 | refs/heads/master | 2020-05-21T13:35:32.311475 | 2016-12-08T10:25:25 | 2016-12-08T10:25:25 | 55,474,235 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 667 | cpp | #include "ControlItem.hpp"
#include "ui_ControlItem.h"
ControlItem::ControlItem(OpenCVImageItem *arg_i, QWidget *parent) :
QWidget(parent),
ui(new Ui::ControlItem),
rootItem_(arg_i)
{
ui->setupUi(this);
}
ControlItem::~ControlItem()
{
delete ui;
}
void ControlItem::_p_init_pack(Pack* pack){
pack->dp=ui->dpDoubleSpinBox->value();
pack->maxRadius=ui->maxRadiusSpinBox->value();
pack->method=3/*HOUGH_GRADIENT*/;
pack->minDist=ui->minDistDoubleSpinBox->value();
pack->minRadius=ui->minRadiusSpinBox->value();
pack->param1=ui->param1DoubleSpinBox->value();
pack->param2=ui->param2DoubleSpinBox->value();
}
| [
"819869472@qq.com"
] | 819869472@qq.com |
a4eb327ce9fad412a5bbf71f646f5436c73e6103 | 4bb19998c4365d23b209597a326c551022cd72ee | /test_hls_server/test_hls_server.prj/solution1/sim/autowrap/testbench/test_hls_server.cpp_pre.cpp.line.cpp | 87cf2134aba220ac983ff4242587d6e84e2826ad | [] | no_license | JKHHai/xvc-hardware | f9c384b5a23f862d26e6990a03cac218be4029ae | 14470607123ff6207268d7aac40ab3b7afe71dd5 | refs/heads/master | 2022-12-13T23:48:26.203987 | 2020-09-05T09:40:06 | 2020-09-05T09:40:06 | 283,031,525 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 3,424,501 | cpp | #pragma line 1 "/home/justin/jhai/paulchowresearch2020/xvc/test_hls_server/test_hls_server.cpp"
#pragma line 1 "<built-in>"
#pragma line 1 "<command-line>"
#pragma line 1 "/usr/include/stdc-predef.h" 1 3 4
#pragma line 1 "<command-line>" 2
#pragma line 1 "/home/justin/jhai/paulchowresearch2020/xvc/test_hls_server/test_hls_server.cpp"
#pragma line 1 "/home/justin/jhai/paulchowresearch2020/xvc/test_hls_server/test_hls_server.h" 1
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_stream.h" 1
#pragma line 79 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_stream.h"
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/queue" 1 3
#pragma line 58 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/queue" 3
#pragma empty_line
#pragma line 59 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/queue" 3
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/deque" 1 3
#pragma line 58 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/deque" 3
#pragma empty_line
#pragma line 59 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/deque" 3
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 1 3
#pragma line 59 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 1 3
#pragma line 196 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 3
#pragma empty_line
#pragma line 196 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
#pragma empty_line
typedef decltype(nullptr) nullptr_t;
#pragma empty_line
}
#pragma line 218 "/home/justin/jhai/Xilinx/Vivado/2018.3/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"))) { }
}
#pragma line 495 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/os_defines.h" 1 3
#pragma line 39 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/os_defines.h" 3
#pragma line 1 "/usr/include/features.h" 1 3 4
#pragma line 461 "/usr/include/features.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 1 3 4
#pragma line 452 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
#pragma line 453 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 2 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/long-double.h" 1 3 4
#pragma line 454 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 2 3 4
#pragma line 462 "/usr/include/features.h" 2 3 4
#pragma line 485 "/usr/include/features.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 1 3 4
#pragma line 10 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/gnu/stubs-64.h" 1 3 4
#pragma line 11 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 2 3 4
#pragma line 486 "/usr/include/features.h" 2 3 4
#pragma line 40 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/os_defines.h" 2 3
#pragma line 496 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 2 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/cpu_defines.h" 1 3
#pragma line 499 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 2 3
#pragma line 60 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 2 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/functexcept.h" 1 3
#pragma line 40 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/functexcept.h" 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/exception_defines.h" 1 3
#pragma line 41 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/functexcept.h" 2 3
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
void
__throw_bad_exception(void) __attribute__((__noreturn__));
#pragma empty_line
#pragma empty_line
void
__throw_bad_alloc(void) __attribute__((__noreturn__));
#pragma empty_line
#pragma empty_line
void
__throw_bad_cast(void) __attribute__((__noreturn__));
#pragma empty_line
void
__throw_bad_typeid(void) __attribute__((__noreturn__));
#pragma empty_line
#pragma empty_line
void
__throw_logic_error(const char*) __attribute__((__noreturn__));
#pragma empty_line
void
__throw_domain_error(const char*) __attribute__((__noreturn__));
#pragma empty_line
void
__throw_invalid_argument(const char*) __attribute__((__noreturn__));
#pragma empty_line
void
__throw_length_error(const char*) __attribute__((__noreturn__));
#pragma empty_line
void
__throw_out_of_range(const char*) __attribute__((__noreturn__));
#pragma empty_line
void
__throw_out_of_range_fmt(const char*, ...) __attribute__((__noreturn__))
__attribute__((__format__(__gnu_printf__, 1, 2)));
#pragma empty_line
void
__throw_runtime_error(const char*) __attribute__((__noreturn__));
#pragma empty_line
void
__throw_range_error(const char*) __attribute__((__noreturn__));
#pragma empty_line
void
__throw_overflow_error(const char*) __attribute__((__noreturn__));
#pragma empty_line
void
__throw_underflow_error(const char*) __attribute__((__noreturn__));
#pragma empty_line
#pragma empty_line
void
__throw_ios_failure(const char*) __attribute__((__noreturn__));
#pragma empty_line
void
__throw_system_error(int) __attribute__((__noreturn__));
#pragma empty_line
void
__throw_future_error(int) __attribute__((__noreturn__));
#pragma empty_line
#pragma empty_line
void
__throw_bad_function_call() __attribute__((__noreturn__));
#pragma empty_line
#pragma empty_line
}
#pragma line 61 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 2 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/cpp_type_traits.h" 1 3
#pragma line 35 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/cpp_type_traits.h" 3
#pragma empty_line
#pragma line 36 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/cpp_type_traits.h" 3
#pragma line 67 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/cpp_type_traits.h" 3
extern "C++" {
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
struct __true_type { };
struct __false_type { };
#pragma empty_line
template<bool>
struct __truth_type
{ typedef __false_type __type; };
#pragma empty_line
template<>
struct __truth_type<true>
{ typedef __true_type __type; };
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<class _Sp, class _Tp>
struct __traitor
{
enum { __value = bool(_Sp::__value) || bool(_Tp::__value) };
typedef typename __truth_type<__value>::__type __type;
};
#pragma empty_line
#pragma empty_line
template<typename, typename>
struct __are_same
{
enum { __value = 0 };
typedef __false_type __type;
};
#pragma empty_line
template<typename _Tp>
struct __are_same<_Tp, _Tp>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct __is_void
{
enum { __value = 0 };
typedef __false_type __type;
};
#pragma empty_line
template<>
struct __is_void<void>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct __is_integer
{
enum { __value = 0 };
typedef __false_type __type;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<>
struct __is_integer<bool>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
template<>
struct __is_integer<char>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
template<>
struct __is_integer<signed char>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
template<>
struct __is_integer<unsigned char>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
#pragma empty_line
template<>
struct __is_integer<wchar_t>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<>
struct __is_integer<char16_t>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
template<>
struct __is_integer<char32_t>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
#pragma empty_line
template<>
struct __is_integer<short>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
template<>
struct __is_integer<unsigned short>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
template<>
struct __is_integer<int>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
template<>
struct __is_integer<unsigned int>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
template<>
struct __is_integer<long>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
template<>
struct __is_integer<unsigned long>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
template<>
struct __is_integer<long long>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
template<>
struct __is_integer<unsigned long long>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma line 261 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; };
#pragma line 278 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
};
#pragma empty_line
#pragma empty_line
template<>
struct __is_floating<float>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
template<>
struct __is_floating<double>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
template<>
struct __is_floating<long double>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct __is_pointer
{
enum { __value = 0 };
typedef __false_type __type;
};
#pragma empty_line
template<typename _Tp>
struct __is_pointer<_Tp*>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct __is_arithmetic
: public __traitor<__is_integer<_Tp>, __is_floating<_Tp> >
{ };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct __is_scalar
: public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> >
{ };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct __is_char
{
enum { __value = 0 };
typedef __false_type __type;
};
#pragma empty_line
template<>
struct __is_char<char>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
#pragma empty_line
template<>
struct __is_char<wchar_t>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct __is_byte
{
enum { __value = 0 };
typedef __false_type __type;
};
#pragma empty_line
template<>
struct __is_byte<char>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
template<>
struct __is_byte<signed char>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
template<>
struct __is_byte<unsigned char>
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct __is_move_iterator
{
enum { __value = 0 };
typedef __false_type __type;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Iterator>
inline _Iterator
__miter_base(_Iterator __it)
{ return __it; }
#pragma empty_line
#pragma empty_line
}
}
#pragma line 62 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 2 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/type_traits.h" 1 3
#pragma line 32 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/type_traits.h" 3
#pragma empty_line
#pragma line 33 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/type_traits.h" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern "C++" {
#pragma empty_line
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<bool, typename>
struct __enable_if
{ };
#pragma empty_line
template<typename _Tp>
struct __enable_if<true, _Tp>
{ typedef _Tp __type; };
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<bool _Cond, typename _Iftrue, typename _Iffalse>
struct __conditional_type
{ typedef _Iftrue __type; };
#pragma empty_line
template<typename _Iftrue, typename _Iffalse>
struct __conditional_type<false, _Iftrue, _Iffalse>
{ typedef _Iffalse __type; };
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct __add_unsigned
{
private:
typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;
#pragma empty_line
public:
typedef typename __if_type::__type __type;
};
#pragma empty_line
template<>
struct __add_unsigned<char>
{ typedef unsigned char __type; };
#pragma empty_line
template<>
struct __add_unsigned<signed char>
{ typedef unsigned char __type; };
#pragma empty_line
template<>
struct __add_unsigned<short>
{ typedef unsigned short __type; };
#pragma empty_line
template<>
struct __add_unsigned<int>
{ typedef unsigned int __type; };
#pragma empty_line
template<>
struct __add_unsigned<long>
{ typedef unsigned long __type; };
#pragma empty_line
template<>
struct __add_unsigned<long long>
{ typedef unsigned long long __type; };
#pragma empty_line
#pragma empty_line
template<>
struct __add_unsigned<bool>;
#pragma empty_line
template<>
struct __add_unsigned<wchar_t>;
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct __remove_unsigned
{
private:
typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;
#pragma empty_line
public:
typedef typename __if_type::__type __type;
};
#pragma empty_line
template<>
struct __remove_unsigned<char>
{ typedef signed char __type; };
#pragma empty_line
template<>
struct __remove_unsigned<unsigned char>
{ typedef signed char __type; };
#pragma empty_line
template<>
struct __remove_unsigned<unsigned short>
{ typedef short __type; };
#pragma empty_line
template<>
struct __remove_unsigned<unsigned int>
{ typedef int __type; };
#pragma empty_line
template<>
struct __remove_unsigned<unsigned long>
{ typedef long __type; };
#pragma empty_line
template<>
struct __remove_unsigned<unsigned long long>
{ typedef long long __type; };
#pragma empty_line
#pragma empty_line
template<>
struct __remove_unsigned<bool>;
#pragma empty_line
template<>
struct __remove_unsigned<wchar_t>;
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Type>
inline bool
__is_null_pointer(_Type* __ptr)
{ return __ptr == 0; }
#pragma empty_line
template<typename _Type>
inline bool
__is_null_pointer(_Type)
{ return false; }
#pragma empty_line
#pragma empty_line
inline bool
__is_null_pointer(std::nullptr_t)
{ return true; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp, bool = std::__is_integer<_Tp>::__value>
struct __promote
{ typedef double __type; };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct __promote<_Tp, false>
{ };
#pragma empty_line
template<>
struct __promote<long double>
{ typedef long double __type; };
#pragma empty_line
template<>
struct __promote<double>
{ typedef double __type; };
#pragma empty_line
template<>
struct __promote<float>
{ typedef float __type; };
#pragma empty_line
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;
};
#pragma empty_line
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;
};
#pragma empty_line
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;
};
#pragma empty_line
#pragma empty_line
}
}
#pragma line 63 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 2 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/numeric_traits.h" 1 3
#pragma line 32 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/numeric_traits.h" 3
#pragma empty_line
#pragma line 33 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/numeric_traits.h" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma line 54 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/numeric_traits.h" 3
template<typename _Value>
struct __numeric_traits_integer
{
#pragma empty_line
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);
#pragma empty_line
#pragma empty_line
#pragma empty_line
static const bool __is_signed = ((_Value)(-1) < 0);
static const int __digits = (sizeof(_Value) * 8 - ((_Value)(-1) < 0));
};
#pragma empty_line
template<typename _Value>
const _Value __numeric_traits_integer<_Value>::__min;
#pragma empty_line
template<typename _Value>
const _Value __numeric_traits_integer<_Value>::__max;
#pragma empty_line
template<typename _Value>
const bool __numeric_traits_integer<_Value>::__is_signed;
#pragma empty_line
template<typename _Value>
const int __numeric_traits_integer<_Value>::__digits;
#pragma line 99 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/numeric_traits.h" 3
template<typename _Value>
struct __numeric_traits_floating
{
#pragma empty_line
static const int __max_digits10 = (2 + (std::__are_same<_Value, float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 64) * 643L / 2136);
#pragma empty_line
#pragma empty_line
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);
};
#pragma empty_line
template<typename _Value>
const int __numeric_traits_floating<_Value>::__max_digits10;
#pragma empty_line
template<typename _Value>
const bool __numeric_traits_floating<_Value>::__is_signed;
#pragma empty_line
template<typename _Value>
const int __numeric_traits_floating<_Value>::__digits10;
#pragma empty_line
template<typename _Value>
const int __numeric_traits_floating<_Value>::__max_exponent10;
#pragma empty_line
template<typename _Value>
struct __numeric_traits
: public __conditional_type<std::__is_integer<_Value>::__value,
__numeric_traits_integer<_Value>,
__numeric_traits_floating<_Value> >::__type
{ };
#pragma empty_line
#pragma empty_line
}
#pragma line 64 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 2 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_pair.h" 1 3
#pragma line 59 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_pair.h" 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/move.h" 1 3
#pragma line 34 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/move.h" 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/concept_check.h" 1 3
#pragma line 33 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/concept_check.h" 3
#pragma empty_line
#pragma line 34 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/concept_check.h" 3
#pragma line 35 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/move.h" 2 3
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
inline _Tp*
__addressof(_Tp& __r) noexcept
{
return reinterpret_cast<_Tp*>
(&const_cast<char&>(reinterpret_cast<const volatile char&>(__r)));
}
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/type_traits" 1 3
#pragma line 32 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/type_traits" 3
#pragma empty_line
#pragma line 33 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/type_traits" 3
#pragma line 42 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma line 68 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
constexpr value_type operator()() const { return value; }
#pragma empty_line
};
#pragma empty_line
template<typename _Tp, _Tp __v>
constexpr _Tp integral_constant<_Tp, __v>::value;
#pragma empty_line
#pragma empty_line
typedef integral_constant<bool, true> true_type;
#pragma empty_line
#pragma empty_line
typedef integral_constant<bool, false> false_type;
#pragma empty_line
template<bool __v>
using __bool_constant = integral_constant<bool, __v>;
#pragma line 103 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/type_traits" 3
template<bool, typename, typename>
struct conditional;
#pragma empty_line
template<typename...>
struct __or_;
#pragma empty_line
template<>
struct __or_<>
: public false_type
{ };
#pragma empty_line
template<typename _B1>
struct __or_<_B1>
: public _B1
{ };
#pragma empty_line
template<typename _B1, typename _B2>
struct __or_<_B1, _B2>
: public conditional<_B1::value, _B1, _B2>::type
{ };
#pragma empty_line
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
{ };
#pragma empty_line
template<typename...>
struct __and_;
#pragma empty_line
template<>
struct __and_<>
: public true_type
{ };
#pragma empty_line
template<typename _B1>
struct __and_<_B1>
: public _B1
{ };
#pragma empty_line
template<typename _B1, typename _B2>
struct __and_<_B1, _B2>
: public conditional<_B1::value, _B2, _B1>::type
{ };
#pragma empty_line
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
{ };
#pragma empty_line
template<typename _Pp>
struct __not_
: public integral_constant<bool, !_Pp::value>
{ };
#pragma line 182 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/type_traits" 3
template<typename _Tp>
struct __success_type
{ typedef _Tp type; };
#pragma empty_line
struct __failure_type
{ };
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename>
struct remove_cv;
#pragma empty_line
template<typename>
struct __is_void_helper
: public false_type { };
#pragma empty_line
template<>
struct __is_void_helper<void>
: public true_type { };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_void
: public __is_void_helper<typename remove_cv<_Tp>::type>::type
{ };
#pragma empty_line
template<typename>
struct __is_integral_helper
: public false_type { };
#pragma empty_line
template<>
struct __is_integral_helper<bool>
: public true_type { };
#pragma empty_line
template<>
struct __is_integral_helper<char>
: public true_type { };
#pragma empty_line
template<>
struct __is_integral_helper<signed char>
: public true_type { };
#pragma empty_line
template<>
struct __is_integral_helper<unsigned char>
: public true_type { };
#pragma empty_line
#pragma empty_line
template<>
struct __is_integral_helper<wchar_t>
: public true_type { };
#pragma empty_line
#pragma empty_line
template<>
struct __is_integral_helper<char16_t>
: public true_type { };
#pragma empty_line
template<>
struct __is_integral_helper<char32_t>
: public true_type { };
#pragma empty_line
template<>
struct __is_integral_helper<short>
: public true_type { };
#pragma empty_line
template<>
struct __is_integral_helper<unsigned short>
: public true_type { };
#pragma empty_line
template<>
struct __is_integral_helper<int>
: public true_type { };
#pragma empty_line
template<>
struct __is_integral_helper<unsigned int>
: public true_type { };
#pragma empty_line
template<>
struct __is_integral_helper<long>
: public true_type { };
#pragma empty_line
template<>
struct __is_integral_helper<unsigned long>
: public true_type { };
#pragma empty_line
template<>
struct __is_integral_helper<long long>
: public true_type { };
#pragma empty_line
template<>
struct __is_integral_helper<unsigned long long>
: public true_type { };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<>
struct __is_integral_helper<__int128>
: public true_type { };
#pragma empty_line
template<>
struct __is_integral_helper<unsigned __int128>
: public true_type { };
#pragma line 314 "/home/justin/jhai/Xilinx/Vivado/2018.3/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
{ };
#pragma empty_line
template<typename>
struct __is_floating_point_helper
: public false_type { };
#pragma empty_line
template<>
struct __is_floating_point_helper<float>
: public true_type { };
#pragma empty_line
template<>
struct __is_floating_point_helper<double>
: public true_type { };
#pragma empty_line
template<>
struct __is_floating_point_helper<long double>
: public true_type { };
#pragma empty_line
#pragma empty_line
template<>
struct __is_floating_point_helper<__float128>
: public true_type { };
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_floating_point
: public __is_floating_point_helper<typename remove_cv<_Tp>::type>::type
{ };
#pragma empty_line
#pragma empty_line
template<typename>
struct is_array
: public false_type { };
#pragma empty_line
template<typename _Tp, std::size_t _Size>
struct is_array<_Tp[_Size]>
: public true_type { };
#pragma empty_line
template<typename _Tp>
struct is_array<_Tp[]>
: public true_type { };
#pragma empty_line
template<typename>
struct __is_pointer_helper
: public false_type { };
#pragma empty_line
template<typename _Tp>
struct __is_pointer_helper<_Tp*>
: public true_type { };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_pointer
: public __is_pointer_helper<typename remove_cv<_Tp>::type>::type
{ };
#pragma empty_line
#pragma empty_line
template<typename>
struct is_lvalue_reference
: public false_type { };
#pragma empty_line
template<typename _Tp>
struct is_lvalue_reference<_Tp&>
: public true_type { };
#pragma empty_line
#pragma empty_line
template<typename>
struct is_rvalue_reference
: public false_type { };
#pragma empty_line
template<typename _Tp>
struct is_rvalue_reference<_Tp&&>
: public true_type { };
#pragma empty_line
template<typename>
struct is_function;
#pragma empty_line
template<typename>
struct __is_member_object_pointer_helper
: public false_type { };
#pragma empty_line
template<typename _Tp, typename _Cp>
struct __is_member_object_pointer_helper<_Tp _Cp::*>
: public integral_constant<bool, !is_function<_Tp>::value> { };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_member_object_pointer
: public __is_member_object_pointer_helper<
typename remove_cv<_Tp>::type>::type
{ };
#pragma empty_line
template<typename>
struct __is_member_function_pointer_helper
: public false_type { };
#pragma empty_line
template<typename _Tp, typename _Cp>
struct __is_member_function_pointer_helper<_Tp _Cp::*>
: public integral_constant<bool, is_function<_Tp>::value> { };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_member_function_pointer
: public __is_member_function_pointer_helper<
typename remove_cv<_Tp>::type>::type
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_enum
: public integral_constant<bool, __is_enum(_Tp)>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_union
: public integral_constant<bool, __is_union(_Tp)>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_class
: public integral_constant<bool, __is_class(_Tp)>
{ };
#pragma empty_line
#pragma empty_line
template<typename>
struct is_function
: public false_type { };
#pragma empty_line
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...)>
: public true_type { };
#pragma empty_line
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) &>
: public true_type { };
#pragma empty_line
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) &&>
: public true_type { };
#pragma empty_line
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......)>
: public true_type { };
#pragma empty_line
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) &>
: public true_type { };
#pragma empty_line
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) &&>
: public true_type { };
#pragma empty_line
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) const>
: public true_type { };
#pragma empty_line
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) const &>
: public true_type { };
#pragma empty_line
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) const &&>
: public true_type { };
#pragma empty_line
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) const>
: public true_type { };
#pragma empty_line
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) const &>
: public true_type { };
#pragma empty_line
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) const &&>
: public true_type { };
#pragma empty_line
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) volatile>
: public true_type { };
#pragma empty_line
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) volatile &>
: public true_type { };
#pragma empty_line
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) volatile &&>
: public true_type { };
#pragma empty_line
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) volatile>
: public true_type { };
#pragma empty_line
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) volatile &>
: public true_type { };
#pragma empty_line
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) volatile &&>
: public true_type { };
#pragma empty_line
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) const volatile>
: public true_type { };
#pragma empty_line
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) const volatile &>
: public true_type { };
#pragma empty_line
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) const volatile &&>
: public true_type { };
#pragma empty_line
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) const volatile>
: public true_type { };
#pragma empty_line
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) const volatile &>
: public true_type { };
#pragma empty_line
template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) const volatile &&>
: public true_type { };
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename>
struct __is_null_pointer_helper
: public false_type { };
#pragma empty_line
template<>
struct __is_null_pointer_helper<std::nullptr_t>
: public true_type { };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_null_pointer
: public __is_null_pointer_helper<typename remove_cv<_Tp>::type>::type
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct __is_nullptr_t
: public is_null_pointer<_Tp>
{ };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_reference
: public __or_<is_lvalue_reference<_Tp>,
is_rvalue_reference<_Tp>>::type
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_arithmetic
: public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_fundamental
: public __or_<is_arithmetic<_Tp>, is_void<_Tp>,
is_null_pointer<_Tp>>::type
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_object
: public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
is_void<_Tp>>>::type
{ };
#pragma empty_line
template<typename>
struct is_member_pointer;
#pragma empty_line
#pragma empty_line
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
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_compound
: public integral_constant<bool, !is_fundamental<_Tp>::value> { };
#pragma empty_line
template<typename _Tp>
struct __is_member_pointer_helper
: public false_type { };
#pragma empty_line
template<typename _Tp, typename _Cp>
struct __is_member_pointer_helper<_Tp _Cp::*>
: public true_type { };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_member_pointer
: public __is_member_pointer_helper<typename remove_cv<_Tp>::type>::type
{ };
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct __is_referenceable
: public __or_<is_object<_Tp>, is_reference<_Tp>>::type
{ };
#pragma empty_line
template<typename _Res, typename... _Args>
struct __is_referenceable<_Res(_Args...)>
: public true_type
{ };
#pragma empty_line
template<typename _Res, typename... _Args>
struct __is_referenceable<_Res(_Args......)>
: public true_type
{ };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename>
struct is_const
: public false_type { };
#pragma empty_line
template<typename _Tp>
struct is_const<_Tp const>
: public true_type { };
#pragma empty_line
#pragma empty_line
template<typename>
struct is_volatile
: public false_type { };
#pragma empty_line
template<typename _Tp>
struct is_volatile<_Tp volatile>
: public true_type { };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_trivial
: public integral_constant<bool, __is_trivial(_Tp)>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_trivially_copyable
: public integral_constant<bool, __is_trivially_copyable(_Tp)>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_standard_layout
: public integral_constant<bool, __is_standard_layout(_Tp)>
{ };
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_pod
: public integral_constant<bool, __is_pod(_Tp)>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_literal_type
: public integral_constant<bool, __is_literal_type(_Tp)>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_empty
: public integral_constant<bool, __is_empty(_Tp)>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_polymorphic
: public integral_constant<bool, __is_polymorphic(_Tp)>
{ };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_final
: public integral_constant<bool, __is_final(_Tp)>
{ };
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_abstract
: public integral_constant<bool, __is_abstract(_Tp)>
{ };
#pragma empty_line
template<typename _Tp,
bool = is_arithmetic<_Tp>::value>
struct __is_signed_helper
: public false_type { };
#pragma empty_line
template<typename _Tp>
struct __is_signed_helper<_Tp, true>
: public integral_constant<bool, _Tp(-1) < _Tp(0)>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_signed
: public __is_signed_helper<_Tp>::type
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_unsigned
: public __and_<is_arithmetic<_Tp>, __not_<is_signed<_Tp>>>
{ };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename>
struct add_rvalue_reference;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
typename add_rvalue_reference<_Tp>::type declval() noexcept;
#pragma empty_line
template<typename, unsigned = 0>
struct extent;
#pragma empty_line
template<typename>
struct remove_all_extents;
#pragma empty_line
template<typename _Tp>
struct __is_array_known_bounds
: public integral_constant<bool, (extent<_Tp>::value > 0)>
{ };
#pragma empty_line
template<typename _Tp>
struct __is_array_unknown_bounds
: public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
{ };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
struct __do_is_destructible_impl
{
template<typename _Tp, typename = decltype(declval<_Tp&>().~_Tp())>
static true_type __test(int);
#pragma empty_line
template<typename>
static false_type __test(...);
};
#pragma empty_line
template<typename _Tp>
struct __is_destructible_impl
: public __do_is_destructible_impl
{
typedef decltype(__test<_Tp>(0)) type;
};
#pragma empty_line
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;
#pragma empty_line
template<typename _Tp>
struct __is_destructible_safe<_Tp, false, false>
: public __is_destructible_impl<typename
remove_all_extents<_Tp>::type>::type
{ };
#pragma empty_line
template<typename _Tp>
struct __is_destructible_safe<_Tp, true, false>
: public false_type { };
#pragma empty_line
template<typename _Tp>
struct __is_destructible_safe<_Tp, false, true>
: public true_type { };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_destructible
: public __is_destructible_safe<_Tp>::type
{ };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
struct __do_is_nt_destructible_impl
{
template<typename _Tp>
static integral_constant<bool, noexcept(declval<_Tp&>().~_Tp())>
__test(int);
#pragma empty_line
template<typename>
static false_type __test(...);
};
#pragma empty_line
template<typename _Tp>
struct __is_nt_destructible_impl
: public __do_is_nt_destructible_impl
{
typedef decltype(__test<_Tp>(0)) type;
};
#pragma empty_line
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;
#pragma empty_line
template<typename _Tp>
struct __is_nt_destructible_safe<_Tp, false, false>
: public __is_nt_destructible_impl<typename
remove_all_extents<_Tp>::type>::type
{ };
#pragma empty_line
template<typename _Tp>
struct __is_nt_destructible_safe<_Tp, true, false>
: public false_type { };
#pragma empty_line
template<typename _Tp>
struct __is_nt_destructible_safe<_Tp, false, true>
: public true_type { };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_nothrow_destructible
: public __is_nt_destructible_safe<_Tp>::type
{ };
#pragma empty_line
struct __do_is_default_constructible_impl
{
template<typename _Tp, typename = decltype(_Tp())>
static true_type __test(int);
#pragma empty_line
template<typename>
static false_type __test(...);
};
#pragma empty_line
template<typename _Tp>
struct __is_default_constructible_impl
: public __do_is_default_constructible_impl
{
typedef decltype(__test<_Tp>(0)) type;
};
#pragma empty_line
template<typename _Tp>
struct __is_default_constructible_atom
: public __and_<__not_<is_void<_Tp>>,
__is_default_constructible_impl<_Tp>>
{ };
#pragma empty_line
template<typename _Tp, bool = is_array<_Tp>::value>
struct __is_default_constructible_safe;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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>>
{ };
#pragma empty_line
template<typename _Tp>
struct __is_default_constructible_safe<_Tp, false>
: public __is_default_constructible_atom<_Tp>::type
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_default_constructible
: public __is_default_constructible_safe<_Tp>::type
{ };
#pragma line 926 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
#pragma empty_line
template<typename, typename>
static false_type __test(...);
};
#pragma empty_line
template<typename _From, typename _To>
struct __is_static_castable_impl
: public __do_is_static_castable_impl
{
typedef decltype(__test<_From, _To>(0)) type;
};
#pragma empty_line
template<typename _From, typename _To>
struct __is_static_castable_safe
: public __is_static_castable_impl<_From, _To>::type
{ };
#pragma empty_line
#pragma empty_line
template<typename _From, typename _To>
struct __is_static_castable
: public integral_constant<bool, (__is_static_castable_safe<
_From, _To>::value)>
{ };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
struct __do_is_direct_constructible_impl
{
template<typename _Tp, typename _Arg, typename
= decltype(::new _Tp(declval<_Arg>()))>
static true_type __test(int);
#pragma empty_line
template<typename, typename>
static false_type __test(...);
};
#pragma empty_line
template<typename _Tp, typename _Arg>
struct __is_direct_constructible_impl
: public __do_is_direct_constructible_impl
{
typedef decltype(__test<_Tp, _Arg>(0)) type;
};
#pragma empty_line
template<typename _Tp, typename _Arg>
struct __is_direct_constructible_new_safe
: public __and_<is_destructible<_Tp>,
__is_direct_constructible_impl<_Tp, _Arg>>
{ };
#pragma empty_line
template<typename, typename>
struct is_same;
#pragma empty_line
template<typename, typename>
struct is_base_of;
#pragma empty_line
template<typename>
struct remove_reference;
#pragma empty_line
template<typename _From, typename _To, bool
= __not_<__or_<is_void<_From>,
is_function<_From>>>::value>
struct __is_base_to_derived_ref;
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
};
#pragma empty_line
template<typename _From, typename _To>
struct __is_base_to_derived_ref<_From, _To, false>
: public false_type
{ };
#pragma empty_line
template<typename _From, typename _To, bool
= __and_<is_lvalue_reference<_From>,
is_rvalue_reference<_To>>::value>
struct __is_lvalue_to_rvalue_ref;
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
};
#pragma empty_line
template<typename _From, typename _To>
struct __is_lvalue_to_rvalue_ref<_From, _To, false>
: public false_type
{ };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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>
>>>
{ };
#pragma empty_line
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
{ };
#pragma empty_line
template<typename _Tp, typename _Arg>
struct __is_direct_constructible
: public __is_direct_constructible_new<_Tp, _Arg>::type
{ };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
struct __do_is_nary_constructible_impl
{
template<typename _Tp, typename... _Args, typename
= decltype(_Tp(declval<_Args>()...))>
static true_type __test(int);
#pragma empty_line
template<typename, typename...>
static false_type __test(...);
};
#pragma empty_line
template<typename _Tp, typename... _Args>
struct __is_nary_constructible_impl
: public __do_is_nary_constructible_impl
{
typedef decltype(__test<_Tp, _Args...>(0)) type;
};
#pragma empty_line
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");
};
#pragma empty_line
template<typename _Tp, typename... _Args>
struct __is_constructible_impl
: public __is_nary_constructible<_Tp, _Args...>
{ };
#pragma empty_line
template<typename _Tp, typename _Arg>
struct __is_constructible_impl<_Tp, _Arg>
: public __is_direct_constructible<_Tp, _Arg>
{ };
#pragma empty_line
template<typename _Tp>
struct __is_constructible_impl<_Tp>
: public is_default_constructible<_Tp>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename... _Args>
struct is_constructible
: public __is_constructible_impl<_Tp, _Args...>::type
{ };
#pragma empty_line
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_copy_constructible_impl;
#pragma empty_line
template<typename _Tp>
struct __is_copy_constructible_impl<_Tp, false>
: public false_type { };
#pragma empty_line
template<typename _Tp>
struct __is_copy_constructible_impl<_Tp, true>
: public is_constructible<_Tp, const _Tp&>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_copy_constructible
: public __is_copy_constructible_impl<_Tp>
{ };
#pragma empty_line
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_move_constructible_impl;
#pragma empty_line
template<typename _Tp>
struct __is_move_constructible_impl<_Tp, false>
: public false_type { };
#pragma empty_line
template<typename _Tp>
struct __is_move_constructible_impl<_Tp, true>
: public is_constructible<_Tp, _Tp&&>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_move_constructible
: public __is_move_constructible_impl<_Tp>
{ };
#pragma empty_line
template<typename _Tp>
struct __is_nt_default_constructible_atom
: public integral_constant<bool, noexcept(_Tp())>
{ };
#pragma empty_line
template<typename _Tp, bool = is_array<_Tp>::value>
struct __is_nt_default_constructible_impl;
#pragma empty_line
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>>
{ };
#pragma empty_line
template<typename _Tp>
struct __is_nt_default_constructible_impl<_Tp, false>
: public __is_nt_default_constructible_atom<_Tp>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_nothrow_default_constructible
: public __and_<is_default_constructible<_Tp>,
__is_nt_default_constructible_impl<_Tp>>
{ };
#pragma empty_line
template<typename _Tp, typename... _Args>
struct __is_nt_constructible_impl
: public integral_constant<bool, noexcept(_Tp(declval<_Args>()...))>
{ };
#pragma empty_line
template<typename _Tp, typename _Arg>
struct __is_nt_constructible_impl<_Tp, _Arg>
: public integral_constant<bool,
noexcept(static_cast<_Tp>(declval<_Arg>()))>
{ };
#pragma empty_line
template<typename _Tp>
struct __is_nt_constructible_impl<_Tp>
: public is_nothrow_default_constructible<_Tp>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename... _Args>
struct is_nothrow_constructible
: public __and_<is_constructible<_Tp, _Args...>,
__is_nt_constructible_impl<_Tp, _Args...>>
{ };
#pragma empty_line
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_nothrow_copy_constructible_impl;
#pragma empty_line
template<typename _Tp>
struct __is_nothrow_copy_constructible_impl<_Tp, false>
: public false_type { };
#pragma empty_line
template<typename _Tp>
struct __is_nothrow_copy_constructible_impl<_Tp, true>
: public is_nothrow_constructible<_Tp, const _Tp&>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_nothrow_copy_constructible
: public __is_nothrow_copy_constructible_impl<_Tp>
{ };
#pragma empty_line
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_nothrow_move_constructible_impl;
#pragma empty_line
template<typename _Tp>
struct __is_nothrow_move_constructible_impl<_Tp, false>
: public false_type { };
#pragma empty_line
template<typename _Tp>
struct __is_nothrow_move_constructible_impl<_Tp, true>
: public is_nothrow_constructible<_Tp, _Tp&&>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_nothrow_move_constructible
: public __is_nothrow_move_constructible_impl<_Tp>
{ };
#pragma empty_line
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);
#pragma empty_line
template<typename, typename>
static false_type
__test(...);
#pragma empty_line
public:
typedef decltype(__test<_Tp, _Up>(0)) type;
};
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename _Up>
struct is_assignable
: public __is_assignable_helper<_Tp, _Up>::type
{ };
#pragma empty_line
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_copy_assignable_impl;
#pragma empty_line
template<typename _Tp>
struct __is_copy_assignable_impl<_Tp, false>
: public false_type { };
#pragma empty_line
template<typename _Tp>
struct __is_copy_assignable_impl<_Tp, true>
: public is_assignable<_Tp&, const _Tp&>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_copy_assignable
: public __is_copy_assignable_impl<_Tp>
{ };
#pragma empty_line
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_move_assignable_impl;
#pragma empty_line
template<typename _Tp>
struct __is_move_assignable_impl<_Tp, false>
: public false_type { };
#pragma empty_line
template<typename _Tp>
struct __is_move_assignable_impl<_Tp, true>
: public is_assignable<_Tp&, _Tp&&>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_move_assignable
: public __is_move_assignable_impl<_Tp>
{ };
#pragma empty_line
template<typename _Tp, typename _Up>
struct __is_nt_assignable_impl
: public integral_constant<bool, noexcept(declval<_Tp>() = declval<_Up>())>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename _Up>
struct is_nothrow_assignable
: public __and_<is_assignable<_Tp, _Up>,
__is_nt_assignable_impl<_Tp, _Up>>
{ };
#pragma empty_line
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_nt_copy_assignable_impl;
#pragma empty_line
template<typename _Tp>
struct __is_nt_copy_assignable_impl<_Tp, false>
: public false_type { };
#pragma empty_line
template<typename _Tp>
struct __is_nt_copy_assignable_impl<_Tp, true>
: public is_nothrow_assignable<_Tp&, const _Tp&>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_nothrow_copy_assignable
: public __is_nt_copy_assignable_impl<_Tp>
{ };
#pragma empty_line
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_nt_move_assignable_impl;
#pragma empty_line
template<typename _Tp>
struct __is_nt_move_assignable_impl<_Tp, false>
: public false_type { };
#pragma empty_line
template<typename _Tp>
struct __is_nt_move_assignable_impl<_Tp, true>
: public is_nothrow_assignable<_Tp&, _Tp&&>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_nothrow_move_assignable
: public __is_nt_move_assignable_impl<_Tp>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename... _Args>
struct is_trivially_constructible
: public __and_<is_constructible<_Tp, _Args...>, integral_constant<bool,
__is_trivially_constructible(_Tp, _Args...)>>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_trivially_default_constructible
: public is_trivially_constructible<_Tp>::type
{ };
#pragma empty_line
struct __do_is_implicitly_default_constructible_impl
{
template <typename _Tp>
static void __helper(const _Tp&);
#pragma empty_line
template <typename _Tp>
static true_type __test(const _Tp&,
decltype(__helper<const _Tp&>({}))* = 0);
#pragma empty_line
static false_type __test(...);
};
#pragma empty_line
template<typename _Tp>
struct __is_implicitly_default_constructible_impl
: public __do_is_implicitly_default_constructible_impl
{
typedef decltype(__test(declval<_Tp>())) type;
};
#pragma empty_line
template<typename _Tp>
struct __is_implicitly_default_constructible_safe
: public __is_implicitly_default_constructible_impl<_Tp>::type
{ };
#pragma empty_line
template <typename _Tp>
struct __is_implicitly_default_constructible
: public __and_<is_default_constructible<_Tp>,
__is_implicitly_default_constructible_safe<_Tp>>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_trivially_copy_constructible
: public __and_<is_copy_constructible<_Tp>,
integral_constant<bool,
__is_trivially_constructible(_Tp, const _Tp&)>>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_trivially_move_constructible
: public __and_<is_move_constructible<_Tp>,
integral_constant<bool,
__is_trivially_constructible(_Tp, _Tp&&)>>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename _Up>
struct is_trivially_assignable
: public __and_<is_assignable<_Tp, _Up>,
integral_constant<bool,
__is_trivially_assignable(_Tp, _Up)>>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_trivially_copy_assignable
: public __and_<is_copy_assignable<_Tp>,
integral_constant<bool,
__is_trivially_assignable(_Tp&, const _Tp&)>>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_trivially_move_assignable
: public __and_<is_move_assignable<_Tp>,
integral_constant<bool,
__is_trivially_assignable(_Tp&, _Tp&&)>>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_trivially_destructible
: public __and_<is_destructible<_Tp>, integral_constant<bool,
__has_trivial_destructor(_Tp)>>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct has_trivial_default_constructor
: public integral_constant<bool, __has_trivial_constructor(_Tp)>
{ } __attribute__ ((__deprecated__));
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct has_trivial_copy_constructor
: public integral_constant<bool, __has_trivial_copy(_Tp)>
{ } __attribute__ ((__deprecated__));
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct has_trivial_copy_assign
: public integral_constant<bool, __has_trivial_assign(_Tp)>
{ } __attribute__ ((__deprecated__));
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct has_virtual_destructor
: public integral_constant<bool, __has_virtual_destructor(_Tp)>
{ };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct alignment_of
: public integral_constant<std::size_t, __alignof__(_Tp)> { };
#pragma empty_line
#pragma empty_line
template<typename>
struct rank
: public integral_constant<std::size_t, 0> { };
#pragma empty_line
template<typename _Tp, std::size_t _Size>
struct rank<_Tp[_Size]>
: public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
#pragma empty_line
template<typename _Tp>
struct rank<_Tp[]>
: public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
#pragma empty_line
#pragma empty_line
template<typename, unsigned _Uint>
struct extent
: public integral_constant<std::size_t, 0> { };
#pragma empty_line
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>
{ };
#pragma empty_line
template<typename _Tp, unsigned _Uint>
struct extent<_Tp[], _Uint>
: public integral_constant<std::size_t,
_Uint == 0 ? 0 : extent<_Tp,
_Uint - 1>::value>
{ };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename, typename>
struct is_same
: public false_type { };
#pragma empty_line
template<typename _Tp>
struct is_same<_Tp, _Tp>
: public true_type { };
#pragma empty_line
#pragma empty_line
template<typename _Base, typename _Derived>
struct is_base_of
: public integral_constant<bool, __is_base_of(_Base, _Derived)>
{ };
#pragma empty_line
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; };
#pragma empty_line
template<typename _From, typename _To>
class __is_convertible_helper<_From, _To, false>
{
template<typename _To1>
static void __test_aux(_To1);
#pragma empty_line
template<typename _From1, typename _To1,
typename = decltype(__test_aux<_To1>(std::declval<_From1>()))>
static true_type
__test(int);
#pragma empty_line
template<typename, typename>
static false_type
__test(...);
#pragma empty_line
public:
typedef decltype(__test<_From, _To>(0)) type;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _From, typename _To>
struct is_convertible
: public __is_convertible_helper<_From, _To>::type
{ };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct remove_const
{ typedef _Tp type; };
#pragma empty_line
template<typename _Tp>
struct remove_const<_Tp const>
{ typedef _Tp type; };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct remove_volatile
{ typedef _Tp type; };
#pragma empty_line
template<typename _Tp>
struct remove_volatile<_Tp volatile>
{ typedef _Tp type; };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct remove_cv
{
typedef typename
remove_const<typename remove_volatile<_Tp>::type>::type type;
};
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct add_const
{ typedef _Tp const type; };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct add_volatile
{ typedef _Tp volatile type; };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct add_cv
{
typedef typename
add_const<typename add_volatile<_Tp>::type>::type type;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
using remove_const_t = typename remove_const<_Tp>::type;
#pragma empty_line
#pragma empty_line
template<typename _Tp>
using remove_volatile_t = typename remove_volatile<_Tp>::type;
#pragma empty_line
#pragma empty_line
template<typename _Tp>
using remove_cv_t = typename remove_cv<_Tp>::type;
#pragma empty_line
#pragma empty_line
template<typename _Tp>
using add_const_t = typename add_const<_Tp>::type;
#pragma empty_line
#pragma empty_line
template<typename _Tp>
using add_volatile_t = typename add_volatile<_Tp>::type;
#pragma empty_line
#pragma empty_line
template<typename _Tp>
using add_cv_t = typename add_cv<_Tp>::type;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct remove_reference
{ typedef _Tp type; };
#pragma empty_line
template<typename _Tp>
struct remove_reference<_Tp&>
{ typedef _Tp type; };
#pragma empty_line
template<typename _Tp>
struct remove_reference<_Tp&&>
{ typedef _Tp type; };
#pragma empty_line
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __add_lvalue_reference_helper
{ typedef _Tp type; };
#pragma empty_line
template<typename _Tp>
struct __add_lvalue_reference_helper<_Tp, true>
{ typedef _Tp& type; };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct add_lvalue_reference
: public __add_lvalue_reference_helper<_Tp>
{ };
#pragma empty_line
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __add_rvalue_reference_helper
{ typedef _Tp type; };
#pragma empty_line
template<typename _Tp>
struct __add_rvalue_reference_helper<_Tp, true>
{ typedef _Tp&& type; };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct add_rvalue_reference
: public __add_rvalue_reference_helper<_Tp>
{ };
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
using remove_reference_t = typename remove_reference<_Tp>::type;
#pragma empty_line
#pragma empty_line
template<typename _Tp>
using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type;
#pragma empty_line
#pragma empty_line
template<typename _Tp>
using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Unqualified, bool _IsConst, bool _IsVol>
struct __cv_selector;
#pragma empty_line
template<typename _Unqualified>
struct __cv_selector<_Unqualified, false, false>
{ typedef _Unqualified __type; };
#pragma empty_line
template<typename _Unqualified>
struct __cv_selector<_Unqualified, false, true>
{ typedef volatile _Unqualified __type; };
#pragma empty_line
template<typename _Unqualified>
struct __cv_selector<_Unqualified, true, false>
{ typedef const _Unqualified __type; };
#pragma empty_line
template<typename _Unqualified>
struct __cv_selector<_Unqualified, true, true>
{ typedef const volatile _Unqualified __type; };
#pragma empty_line
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;
#pragma empty_line
public:
typedef typename __match::__type __type;
};
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct __make_unsigned
{ typedef _Tp __type; };
#pragma empty_line
template<>
struct __make_unsigned<char>
{ typedef unsigned char __type; };
#pragma empty_line
template<>
struct __make_unsigned<signed char>
{ typedef unsigned char __type; };
#pragma empty_line
template<>
struct __make_unsigned<short>
{ typedef unsigned short __type; };
#pragma empty_line
template<>
struct __make_unsigned<int>
{ typedef unsigned int __type; };
#pragma empty_line
template<>
struct __make_unsigned<long>
{ typedef unsigned long __type; };
#pragma empty_line
template<>
struct __make_unsigned<long long>
{ typedef unsigned long long __type; };
#pragma empty_line
#pragma empty_line
template<>
struct __make_unsigned<wchar_t> : __make_unsigned<int>
{ };
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<>
struct __make_unsigned<__int128>
{ typedef unsigned __int128 __type; };
#pragma line 1774 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
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;
#pragma empty_line
public:
typedef typename __cv_unsigned::__type __type;
};
#pragma empty_line
template<typename _Tp>
class __make_unsigned_selector<_Tp, false, true>
{
#pragma empty_line
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;
#pragma empty_line
typedef typename conditional<__b0, __smallest, __cond1_type>::type
__unsigned_type;
typedef __match_cv_qualifiers<_Tp, __unsigned_type> __cv_unsigned;
#pragma empty_line
public:
typedef typename __cv_unsigned::__type __type;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct make_unsigned
{ typedef typename __make_unsigned_selector<_Tp>::__type type; };
#pragma empty_line
#pragma empty_line
template<>
struct make_unsigned<bool>;
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct __make_signed
{ typedef _Tp __type; };
#pragma empty_line
template<>
struct __make_signed<char>
{ typedef signed char __type; };
#pragma empty_line
template<>
struct __make_signed<unsigned char>
{ typedef signed char __type; };
#pragma empty_line
template<>
struct __make_signed<unsigned short>
{ typedef signed short __type; };
#pragma empty_line
template<>
struct __make_signed<unsigned int>
{ typedef signed int __type; };
#pragma empty_line
template<>
struct __make_signed<unsigned long>
{ typedef signed long __type; };
#pragma empty_line
template<>
struct __make_signed<unsigned long long>
{ typedef signed long long __type; };
#pragma line 1863 "/home/justin/jhai/Xilinx/Vivado/2018.3/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>
{ };
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<>
struct __make_signed<unsigned __int128>
{ typedef __int128 __type; };
#pragma line 1893 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
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;
#pragma empty_line
public:
typedef typename __cv_signed::__type __type;
};
#pragma empty_line
template<typename _Tp>
class __make_signed_selector<_Tp, false, true>
{
typedef typename __make_unsigned_selector<_Tp>::__type __unsigned_type;
#pragma empty_line
public:
typedef typename __make_signed_selector<__unsigned_type>::__type __type;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct make_signed
{ typedef typename __make_signed_selector<_Tp>::__type type; };
#pragma empty_line
#pragma empty_line
template<>
struct make_signed<bool>;
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
using make_signed_t = typename make_signed<_Tp>::type;
#pragma empty_line
#pragma empty_line
template<typename _Tp>
using make_unsigned_t = typename make_unsigned<_Tp>::type;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct remove_extent
{ typedef _Tp type; };
#pragma empty_line
template<typename _Tp, std::size_t _Size>
struct remove_extent<_Tp[_Size]>
{ typedef _Tp type; };
#pragma empty_line
template<typename _Tp>
struct remove_extent<_Tp[]>
{ typedef _Tp type; };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct remove_all_extents
{ typedef _Tp type; };
#pragma empty_line
template<typename _Tp, std::size_t _Size>
struct remove_all_extents<_Tp[_Size]>
{ typedef typename remove_all_extents<_Tp>::type type; };
#pragma empty_line
template<typename _Tp>
struct remove_all_extents<_Tp[]>
{ typedef typename remove_all_extents<_Tp>::type type; };
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
using remove_extent_t = typename remove_extent<_Tp>::type;
#pragma empty_line
#pragma empty_line
template<typename _Tp>
using remove_all_extents_t = typename remove_all_extents<_Tp>::type;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename>
struct __remove_pointer_helper
{ typedef _Tp type; };
#pragma empty_line
template<typename _Tp, typename _Up>
struct __remove_pointer_helper<_Tp, _Up*>
{ typedef _Up type; };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct remove_pointer
: public __remove_pointer_helper<_Tp, typename remove_cv<_Tp>::type>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp, bool = __or_<__is_referenceable<_Tp>,
is_void<_Tp>>::value>
struct __add_pointer_helper
{ typedef _Tp type; };
#pragma empty_line
template<typename _Tp>
struct __add_pointer_helper<_Tp, true>
{ typedef typename remove_reference<_Tp>::type* type; };
#pragma empty_line
template<typename _Tp>
struct add_pointer
: public __add_pointer_helper<_Tp>
{ };
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
using remove_pointer_t = typename remove_pointer<_Tp>::type;
#pragma empty_line
#pragma empty_line
template<typename _Tp>
using add_pointer_t = typename add_pointer<_Tp>::type;
#pragma empty_line
#pragma empty_line
template<std::size_t _Len>
struct __aligned_storage_msa
{
union __type
{
unsigned char __data[_Len];
struct __attribute__((__aligned__)) { } __align;
};
};
#pragma line 2039 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
};
};
#pragma empty_line
template <typename... _Types>
struct __strictest_alignment
{
static const size_t _S_alignment = 0;
static const size_t _S_size = 0;
};
#pragma empty_line
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;
};
#pragma line 2078 "/home/justin/jhai/Xilinx/Vivado/2018.3/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");
#pragma empty_line
using __strictest = __strictest_alignment<_Types...>;
static const size_t _S_len = _Len > __strictest::_S_size
? _Len : __strictest::_S_size;
public:
#pragma empty_line
static const size_t alignment_value = __strictest::_S_alignment;
#pragma empty_line
typedef typename aligned_storage<_S_len, alignment_value>::type type;
};
#pragma empty_line
template <size_t _Len, typename... _Types>
const size_t aligned_union<_Len, _Types...>::alignment_value;
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Up,
bool _IsArray = is_array<_Up>::value,
bool _IsFunction = is_function<_Up>::value>
struct __decay_selector;
#pragma empty_line
#pragma empty_line
template<typename _Up>
struct __decay_selector<_Up, false, false>
{ typedef typename remove_cv<_Up>::type __type; };
#pragma empty_line
template<typename _Up>
struct __decay_selector<_Up, true, false>
{ typedef typename remove_extent<_Up>::type* __type; };
#pragma empty_line
template<typename _Up>
struct __decay_selector<_Up, false, true>
{ typedef typename add_pointer<_Up>::type __type; };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
class decay
{
typedef typename remove_reference<_Tp>::type __remove_type;
#pragma empty_line
public:
typedef typename __decay_selector<__remove_type>::__type type;
};
#pragma empty_line
template<typename _Tp>
class reference_wrapper;
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct __strip_reference_wrapper
{
typedef _Tp __type;
};
#pragma empty_line
template<typename _Tp>
struct __strip_reference_wrapper<reference_wrapper<_Tp> >
{
typedef _Tp& __type;
};
#pragma empty_line
template<typename _Tp>
struct __decay_and_strip
{
typedef typename __strip_reference_wrapper<
typename decay<_Tp>::type>::__type __type;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<bool, typename _Tp = void>
struct enable_if
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct enable_if<true, _Tp>
{ typedef _Tp type; };
#pragma empty_line
template<typename... _Cond>
using _Require = typename enable_if<__and_<_Cond...>::value>::type;
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<bool _Cond, typename _Iftrue, typename _Iffalse>
struct conditional
{ typedef _Iftrue type; };
#pragma empty_line
#pragma empty_line
template<typename _Iftrue, typename _Iffalse>
struct conditional<false, _Iftrue, _Iffalse>
{ typedef _Iffalse type; };
#pragma empty_line
#pragma empty_line
template<typename... _Tp>
struct common_type;
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
#pragma empty_line
template<typename, typename>
static __failure_type _S_test(...);
};
#pragma empty_line
template<typename _Tp, typename _Up>
struct __common_type_impl
: private __do_common_type_impl
{
typedef decltype(_S_test<_Tp, _Up>(0)) type;
};
#pragma empty_line
struct __do_member_type_wrapper
{
template<typename _Tp>
static __success_type<typename _Tp::type> _S_test(int);
#pragma empty_line
template<typename>
static __failure_type _S_test(...);
};
#pragma empty_line
template<typename _Tp>
struct __member_type_wrapper
: private __do_member_type_wrapper
{
typedef decltype(_S_test<_Tp>(0)) type;
};
#pragma empty_line
template<typename _CTp, typename... _Args>
struct __expanded_common_type_wrapper
{
typedef common_type<typename _CTp::type, _Args...> type;
};
#pragma empty_line
template<typename... _Args>
struct __expanded_common_type_wrapper<__failure_type, _Args...>
{ typedef __failure_type type; };
#pragma empty_line
template<typename _Tp>
struct common_type<_Tp>
{ typedef typename decay<_Tp>::type type; };
#pragma empty_line
template<typename _Tp, typename _Up>
struct common_type<_Tp, _Up>
: public __common_type_impl<_Tp, _Up>::type
{ };
#pragma empty_line
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
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct underlying_type
{
typedef __underlying_type(_Tp) type;
};
#pragma empty_line
template<typename _Tp>
struct __declval_protector
{
static const bool __stop = false;
static typename add_rvalue_reference<_Tp>::type __delegate();
};
#pragma empty_line
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();
}
#pragma empty_line
#pragma empty_line
template<typename _Signature>
class result_of;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
struct __invoke_memfun_ref { };
struct __invoke_memfun_deref { };
struct __invoke_memobj_ref { };
struct __invoke_memobj_deref { };
struct __invoke_other { };
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename _Tag>
struct __result_of_success : __success_type<_Tp>
{ using __invoke_type = _Tag; };
#pragma empty_line
#pragma empty_line
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);
#pragma empty_line
template<typename...>
static __failure_type _S_test(...);
};
#pragma empty_line
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;
};
#pragma empty_line
#pragma empty_line
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);
#pragma empty_line
template<typename...>
static __failure_type _S_test(...);
};
#pragma empty_line
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;
};
#pragma empty_line
#pragma empty_line
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);
#pragma empty_line
template<typename, typename>
static __failure_type _S_test(...);
};
#pragma empty_line
template<typename _MemPtr, typename _Arg>
struct __result_of_memobj_ref
: private __result_of_memobj_ref_impl
{
typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
};
#pragma empty_line
#pragma empty_line
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);
#pragma empty_line
template<typename, typename>
static __failure_type _S_test(...);
};
#pragma empty_line
template<typename _MemPtr, typename _Arg>
struct __result_of_memobj_deref
: private __result_of_memobj_deref_impl
{
typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
};
#pragma empty_line
template<typename _MemPtr, typename _Arg>
struct __result_of_memobj;
#pragma empty_line
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;
};
#pragma empty_line
template<typename _MemPtr, typename _Arg, typename... _Args>
struct __result_of_memfun;
#pragma empty_line
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;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Res, typename _Class, typename _Arg>
struct __result_of_memobj<_Res _Class::*, reference_wrapper<_Arg>>
: __result_of_memobj_ref<_Res _Class::*, _Arg&>
{ };
#pragma empty_line
template<typename _Res, typename _Class, typename _Arg>
struct __result_of_memobj<_Res _Class::*, reference_wrapper<_Arg>&>
: __result_of_memobj_ref<_Res _Class::*, _Arg&>
{ };
#pragma empty_line
template<typename _Res, typename _Class, typename _Arg>
struct __result_of_memobj<_Res _Class::*, const reference_wrapper<_Arg>&>
: __result_of_memobj_ref<_Res _Class::*, _Arg&>
{ };
#pragma empty_line
template<typename _Res, typename _Class, typename _Arg>
struct __result_of_memobj<_Res _Class::*, reference_wrapper<_Arg>&&>
: __result_of_memobj_ref<_Res _Class::*, _Arg&>
{ };
#pragma empty_line
template<typename _Res, typename _Class, typename _Arg>
struct __result_of_memobj<_Res _Class::*, const reference_wrapper<_Arg>&&>
: __result_of_memobj_ref<_Res _Class::*, _Arg&>
{ };
#pragma empty_line
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...>
{ };
#pragma empty_line
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...>
{ };
#pragma empty_line
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...>
{ };
#pragma empty_line
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...>
{ };
#pragma empty_line
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...>
{ };
#pragma empty_line
template<bool, bool, typename _Functor, typename... _ArgTypes>
struct __result_of_impl
{
typedef __failure_type type;
};
#pragma empty_line
template<typename _MemPtr, typename _Arg>
struct __result_of_impl<true, false, _MemPtr, _Arg>
: public __result_of_memobj<typename decay<_MemPtr>::type, _Arg>
{ };
#pragma empty_line
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...>
{ };
#pragma empty_line
#pragma empty_line
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);
#pragma empty_line
template<typename...>
static __failure_type _S_test(...);
};
#pragma empty_line
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;
};
#pragma empty_line
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
{ };
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<size_t _Len, size_t _Align =
__alignof__(typename __aligned_storage_msa<_Len>::__type)>
using aligned_storage_t = typename aligned_storage<_Len, _Align>::type;
#pragma empty_line
template <size_t _Len, typename... _Types>
using aligned_union_t = typename aligned_union<_Len, _Types...>::type;
#pragma empty_line
#pragma empty_line
template<typename _Tp>
using decay_t = typename decay<_Tp>::type;
#pragma empty_line
#pragma empty_line
template<bool _Cond, typename _Tp = void>
using enable_if_t = typename enable_if<_Cond, _Tp>::type;
#pragma empty_line
#pragma empty_line
template<bool _Cond, typename _Iftrue, typename _Iffalse>
using conditional_t = typename conditional<_Cond, _Iftrue, _Iffalse>::type;
#pragma empty_line
#pragma empty_line
template<typename... _Tp>
using common_type_t = typename common_type<_Tp...>::type;
#pragma empty_line
#pragma empty_line
template<typename _Tp>
using underlying_type_t = typename underlying_type<_Tp>::type;
#pragma empty_line
#pragma empty_line
template<typename _Tp>
using result_of_t = typename result_of<_Tp>::type;
#pragma empty_line
#pragma empty_line
template<typename...> using __void_t = void;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename...> using void_t = void;
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Default, typename _AlwaysVoid,
template<typename...> class _Op, typename... _Args>
struct __detector
{
using value_t = false_type;
using type = _Default;
};
#pragma empty_line
#pragma empty_line
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...>;
};
#pragma empty_line
#pragma empty_line
template<typename _Default, template<typename...> class _Op,
typename... _Args>
using __detected_or = __detector<_Default, void, _Op, _Args...>;
#pragma empty_line
#pragma empty_line
template<typename _Default, template<typename...> class _Op,
typename... _Args>
using __detected_or_t
= typename __detected_or<_Default, _Op, _Args...>::type;
#pragma empty_line
#pragma empty_line
template<template<typename...> class _Default,
template<typename...> class _Op, typename... _Args>
using __detected_or_t_ =
__detected_or_t<_Default<_Args...>, _Op, _Args...>;
#pragma line 2590 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/type_traits" 3
template <typename _Tp>
struct __is_swappable;
#pragma empty_line
template <typename _Tp>
struct __is_nothrow_swappable;
#pragma empty_line
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);
#pragma empty_line
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);
#pragma empty_line
namespace __swappable_details {
using std::swap;
#pragma empty_line
struct __do_is_swappable_impl
{
template<typename _Tp, typename
= decltype(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))>
static true_type __test(int);
#pragma empty_line
template<typename>
static false_type __test(...);
};
#pragma empty_line
struct __do_is_nothrow_swappable_impl
{
template<typename _Tp>
static __bool_constant<
noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))
> __test(int);
#pragma empty_line
template<typename>
static false_type __test(...);
};
#pragma empty_line
}
#pragma empty_line
template<typename _Tp>
struct __is_swappable_impl
: public __swappable_details::__do_is_swappable_impl
{
typedef decltype(__test<_Tp>(0)) type;
};
#pragma empty_line
template<typename _Tp>
struct __is_nothrow_swappable_impl
: public __swappable_details::__do_is_nothrow_swappable_impl
{
typedef decltype(__test<_Tp>(0)) type;
};
#pragma empty_line
template<typename _Tp>
struct __is_swappable
: public __is_swappable_impl<_Tp>::type
{ };
#pragma empty_line
template<typename _Tp>
struct __is_nothrow_swappable
: public __is_nothrow_swappable_impl<_Tp>::type
{ };
#pragma empty_line
#pragma empty_line
}
#pragma line 58 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/move.h" 2 3
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma line 74 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
constexpr typename std::remove_reference<_Tp>::type&&
move(_Tp&& __t) noexcept
{ return static_cast<typename std::remove_reference<_Tp>::type&&>(__t); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct __move_if_noexcept_cond
: public __and_<__not_<is_nothrow_move_constructible<_Tp>>,
is_copy_constructible<_Tp>>::type { };
#pragma line 118 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 133 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 159 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/move.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma line 174 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/move.h" 3
template<typename _Tp>
inline
#pragma empty_line
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)
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
_Tp __tmp = std::move(__a);
__a = std::move(__b);
__b = std::move(__tmp);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp, size_t _Nm>
inline
#pragma empty_line
typename enable_if<__is_swappable<_Tp>::value>::type
swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
noexcept(__is_nothrow_swappable<_Tp>::value)
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
{
for (size_t __n = 0; __n < _Nm; ++__n)
swap(__a[__n], __b[__n]);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 60 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_pair.h" 2 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma line 76 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; };
#pragma empty_line
#pragma empty_line
constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
#pragma empty_line
#pragma empty_line
template<typename...>
class tuple;
#pragma empty_line
template<std::size_t...>
struct _Index_tuple;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma line 146 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
_T1 first;
_T2 second;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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>
#pragma empty_line
constexpr pair()
: first(), second() { }
#pragma empty_line
#pragma empty_line
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() { }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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) { }
#pragma empty_line
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) { }
#pragma line 210 "/home/justin/jhai/Xilinx/Vivado/2018.3/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) { }
#pragma empty_line
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) { }
#pragma empty_line
constexpr pair(const pair&) = default;
constexpr pair(pair&&) = default;
#pragma empty_line
#pragma empty_line
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) { }
#pragma empty_line
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) { }
#pragma empty_line
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)) { }
#pragma empty_line
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)) { }
#pragma empty_line
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)) { }
#pragma empty_line
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)) { }
#pragma empty_line
#pragma empty_line
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)) { }
#pragma empty_line
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)) { }
#pragma empty_line
template<typename... _Args1, typename... _Args2>
pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>);
#pragma empty_line
pair&
operator=(const pair& __p)
{
first = __p.first;
second = __p.second;
return *this;
}
#pragma empty_line
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;
}
#pragma empty_line
template<typename _U1, typename _U2>
pair&
operator=(const pair<_U1, _U2>& __p)
{
first = __p.first;
second = __p.second;
return *this;
}
#pragma empty_line
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;
}
#pragma empty_line
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);
}
#pragma empty_line
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...>);
#pragma empty_line
};
#pragma empty_line
#pragma empty_line
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; }
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
template<typename _T1, typename _T2>
inline constexpr bool
operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return !(__x == __y); }
#pragma empty_line
#pragma empty_line
template<typename _T1, typename _T2>
inline constexpr bool
operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return __y < __x; }
#pragma empty_line
#pragma empty_line
template<typename _T1, typename _T2>
inline constexpr bool
operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return !(__y < __x); }
#pragma empty_line
#pragma empty_line
template<typename _T1, typename _T2>
inline constexpr bool
operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return !(__x < __y); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _T1, typename _T2>
inline void
swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
noexcept(noexcept(__x.swap(__y)))
{ __x.swap(__y); }
#pragma line 422 "/home/justin/jhai/Xilinx/Vivado/2018.3/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));
}
#pragma line 441 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_pair.h" 3
#pragma empty_line
}
#pragma line 65 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 2 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator_base_types.h" 1 3
#pragma line 62 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator_base_types.h" 3
#pragma empty_line
#pragma line 63 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator_base_types.h" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma line 89 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator_base_types.h" 3
struct input_iterator_tag { };
#pragma empty_line
#pragma empty_line
struct output_iterator_tag { };
#pragma empty_line
#pragma empty_line
struct forward_iterator_tag : public input_iterator_tag { };
#pragma empty_line
#pragma empty_line
#pragma empty_line
struct bidirectional_iterator_tag : public forward_iterator_tag { };
#pragma empty_line
#pragma empty_line
#pragma empty_line
struct random_access_iterator_tag : public bidirectional_iterator_tag { };
#pragma line 116 "/home/justin/jhai/Xilinx/Vivado/2018.3/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
{
#pragma empty_line
typedef _Category iterator_category;
#pragma empty_line
typedef _Tp value_type;
#pragma empty_line
typedef _Distance difference_type;
#pragma empty_line
typedef _Pointer pointer;
#pragma empty_line
typedef _Reference reference;
};
#pragma line 143 "/home/justin/jhai/Xilinx/Vivado/2018.3/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 { };
#pragma empty_line
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;
};
#pragma empty_line
template<typename _Iterator>
struct iterator_traits
: public __iterator_traits<_Iterator> { };
#pragma line 177 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
};
#pragma empty_line
#pragma empty_line
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;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Iter>
inline typename iterator_traits<_Iter>::iterator_category
__iterator_category(const _Iter&)
{ return typename iterator_traits<_Iter>::iterator_category(); }
#pragma line 230 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 66 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 2 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator_base_funcs.h" 1 3
#pragma line 62 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator_base_funcs.h" 3
#pragma empty_line
#pragma line 63 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator_base_funcs.h" 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/debug/assertions.h" 1 3
#pragma line 66 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator_base_funcs.h" 2 3
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
template <typename> struct _List_iterator;
template <typename> struct _List_const_iterator;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _InputIterator>
inline typename iterator_traits<_InputIterator>::difference_type
__distance(_InputIterator __first, _InputIterator __last,
input_iterator_tag)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
typename iterator_traits<_InputIterator>::difference_type __n = 0;
while (__first != __last)
{
++__first;
++__n;
}
return __n;
}
#pragma empty_line
template<typename _RandomAccessIterator>
inline typename iterator_traits<_RandomAccessIterator>::difference_type
__distance(_RandomAccessIterator __first, _RandomAccessIterator __last,
random_access_iterator_tag)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
return __last - __first;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
ptrdiff_t
__distance(std::_List_iterator<_Tp>,
std::_List_iterator<_Tp>,
input_iterator_tag);
#pragma empty_line
template<typename _Tp>
ptrdiff_t
__distance(std::_List_const_iterator<_Tp>,
std::_List_const_iterator<_Tp>,
input_iterator_tag);
#pragma line 133 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
return std::__distance(__first, __last,
std::__iterator_category(__first));
}
#pragma empty_line
template<typename _InputIterator, typename _Distance>
inline void
__advance(_InputIterator& __i, _Distance __n, input_iterator_tag)
{
#pragma empty_line
#pragma empty_line
;
while (__n--)
++__i;
}
#pragma empty_line
template<typename _BidirectionalIterator, typename _Distance>
inline void
__advance(_BidirectionalIterator& __i, _Distance __n,
bidirectional_iterator_tag)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
if (__n > 0)
while (__n--)
++__i;
else
while (__n++)
--__i;
}
#pragma empty_line
template<typename _RandomAccessIterator, typename _Distance>
inline void
__advance(_RandomAccessIterator& __i, _Distance __n,
random_access_iterator_tag)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
__i += __n;
}
#pragma line 192 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
typename iterator_traits<_InputIterator>::difference_type __d = __n;
std::__advance(__i, __d, std::__iterator_category(__i));
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _ForwardIterator>
inline _ForwardIterator
next(_ForwardIterator __x, typename
iterator_traits<_ForwardIterator>::difference_type __n = 1)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
std::advance(__x, __n);
return __x;
}
#pragma empty_line
template<typename _BidirectionalIterator>
inline _BidirectionalIterator
prev(_BidirectionalIterator __x, typename
iterator_traits<_BidirectionalIterator>::difference_type __n = 1)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
std::advance(__x, -__n);
return __x;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 67 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 2 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator.h" 1 3
#pragma line 66 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator.h" 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ptr_traits.h" 1 3
#pragma line 37 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ptr_traits.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
class __undefined;
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct __get_first_arg
{ using type = __undefined; };
#pragma empty_line
template<template<typename, typename...> class _Template, typename _Tp,
typename... _Types>
struct __get_first_arg<_Template<_Tp, _Types...>>
{ using type = _Tp; };
#pragma empty_line
template<typename _Tp>
using __get_first_arg_t = typename __get_first_arg<_Tp>::type;
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename _Up>
struct __replace_first_arg
{ using type = __undefined; };
#pragma empty_line
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...>; };
#pragma empty_line
template<typename _Tp, typename _Up>
using __replace_first_arg_t = typename __replace_first_arg<_Tp, _Up>::type;
#pragma empty_line
template<typename _Tp>
using __make_not_void
= typename conditional<is_void<_Tp>::value, __undefined, _Tp>::type;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Ptr>
struct pointer_traits
{
private:
template<typename _Tp>
using __element_type = typename _Tp::element_type;
#pragma empty_line
template<typename _Tp>
using __difference_type = typename _Tp::difference_type;
#pragma empty_line
template<typename _Tp, typename _Up>
using __rebind = typename _Tp::template rebind<_Up>;
#pragma empty_line
public:
#pragma empty_line
using pointer = _Ptr;
#pragma empty_line
#pragma empty_line
using element_type
= __detected_or_t_<__get_first_arg_t, __element_type, _Ptr>;
#pragma empty_line
#pragma empty_line
using difference_type
= __detected_or_t<ptrdiff_t, __difference_type, _Ptr>;
#pragma empty_line
#pragma empty_line
template<typename _Up>
using rebind
= __detected_or_t_<__replace_first_arg_t, __rebind, _Ptr, _Up>;
#pragma empty_line
static _Ptr
pointer_to(__make_not_void<element_type>& __e)
{ return _Ptr::pointer_to(__e); }
#pragma empty_line
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>");
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct pointer_traits<_Tp*>
{
#pragma empty_line
typedef _Tp* pointer;
#pragma empty_line
typedef _Tp element_type;
#pragma empty_line
typedef ptrdiff_t difference_type;
#pragma empty_line
template<typename _Up>
using rebind = _Up*;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static pointer
pointer_to(__make_not_void<element_type>& __r) noexcept
{ return std::addressof(__r); }
};
#pragma empty_line
#pragma empty_line
template<typename _Ptr, typename _Tp>
using __ptr_rebind = typename pointer_traits<_Ptr>::template rebind<_Tp>;
#pragma empty_line
#pragma empty_line
}
#pragma line 67 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator.h" 2 3
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma line 96 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
typedef iterator_traits<_Iterator> __traits_type;
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
reverse_iterator() : current() { }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
explicit
reverse_iterator(iterator_type __x) : current(__x) { }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
reverse_iterator(const reverse_iterator& __x)
: current(__x.current) { }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Iter>
reverse_iterator(const reverse_iterator<_Iter>& __x)
: current(__x.base()) { }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
iterator_type
base() const
{ return current; }
#pragma line 160 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_iterator.h" 3
reference
operator*() const
{
_Iterator __tmp = current;
return *--__tmp;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
pointer
operator->() const
{ return &(operator*()); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
reverse_iterator&
operator++()
{
--current;
return *this;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
reverse_iterator
operator++(int)
{
reverse_iterator __tmp = *this;
--current;
return __tmp;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
reverse_iterator&
operator--()
{
++current;
return *this;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
reverse_iterator
operator--(int)
{
reverse_iterator __tmp = *this;
++current;
return __tmp;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
reverse_iterator
operator+(difference_type __n) const
{ return reverse_iterator(current - __n); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
reverse_iterator&
operator+=(difference_type __n)
{
current -= __n;
return *this;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
reverse_iterator
operator-(difference_type __n) const
{ return reverse_iterator(current + __n); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
reverse_iterator&
operator-=(difference_type __n)
{
current += __n;
return *this;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
reference
operator[](difference_type __n) const
{ return *(*this + __n); }
};
#pragma line 290 "/home/justin/jhai/Xilinx/Vivado/2018.3/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(); }
#pragma empty_line
template<typename _Iterator>
inline bool
operator<(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
{ return __y.base() < __x.base(); }
#pragma empty_line
template<typename _Iterator>
inline bool
operator!=(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
{ return !(__x == __y); }
#pragma empty_line
template<typename _Iterator>
inline bool
operator>(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
{ return __y < __x; }
#pragma empty_line
template<typename _Iterator>
inline bool
operator<=(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
{ return !(__y < __x); }
#pragma empty_line
template<typename _Iterator>
inline bool
operator>=(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
{ return !(__x < __y); }
#pragma empty_line
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(); }
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _IteratorL, typename _IteratorR>
inline bool
operator==(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
{ return __x.base() == __y.base(); }
#pragma empty_line
template<typename _IteratorL, typename _IteratorR>
inline bool
operator<(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
{ return __y.base() < __x.base(); }
#pragma empty_line
template<typename _IteratorL, typename _IteratorR>
inline bool
operator!=(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
{ return !(__x == __y); }
#pragma empty_line
template<typename _IteratorL, typename _IteratorR>
inline bool
operator>(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
{ return __y < __x; }
#pragma empty_line
template<typename _IteratorL, typename _IteratorR>
inline bool
operator<=(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
{ return !(__y < __x); }
#pragma empty_line
template<typename _IteratorL, typename _IteratorR>
inline bool
operator>=(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
{ return !(__x < __y); }
#pragma empty_line
template<typename _IteratorL, typename _IteratorR>
#pragma empty_line
#pragma empty_line
inline auto
operator-(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
-> decltype(__y.base() - __x.base())
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
{ return __y.base() - __x.base(); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Iterator>
inline reverse_iterator<_Iterator>
__make_reverse_iterator(_Iterator __i)
{ return reverse_iterator<_Iterator>(__i); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Iterator>
inline reverse_iterator<_Iterator>
make_reverse_iterator(_Iterator __i)
{ return reverse_iterator<_Iterator>(__i); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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())); }
#pragma empty_line
template<typename _Iterator>
struct __is_move_iterator<reverse_iterator<_Iterator> >
: __is_move_iterator<_Iterator>
{ };
#pragma empty_line
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())); }
#pragma line 441 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
public:
#pragma empty_line
typedef _Container container_type;
#pragma empty_line
#pragma empty_line
explicit
back_insert_iterator(_Container& __x)
: container(std::__addressof(__x)) { }
#pragma line 476 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma empty_line
back_insert_iterator&
operator=(typename _Container::value_type&& __value)
{
container->push_back(std::move(__value));
return *this;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
back_insert_iterator&
operator*()
{ return *this; }
#pragma empty_line
#pragma empty_line
back_insert_iterator&
operator++()
{ return *this; }
#pragma empty_line
#pragma empty_line
back_insert_iterator
operator++(int)
{ return *this; }
};
#pragma line 518 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 533 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
public:
#pragma empty_line
typedef _Container container_type;
#pragma empty_line
#pragma empty_line
explicit front_insert_iterator(_Container& __x)
: container(std::__addressof(__x)) { }
#pragma line 567 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma empty_line
front_insert_iterator&
operator=(typename _Container::value_type&& __value)
{
container->push_front(std::move(__value));
return *this;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
front_insert_iterator&
operator*()
{ return *this; }
#pragma empty_line
#pragma empty_line
front_insert_iterator&
operator++()
{ return *this; }
#pragma empty_line
#pragma empty_line
front_insert_iterator
operator++(int)
{ return *this; }
};
#pragma line 609 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 628 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
public:
#pragma empty_line
typedef _Container container_type;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
insert_iterator(_Container& __x, typename _Container::iterator __i)
: container(std::__addressof(__x)), iter(__i) {}
#pragma line 679 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma empty_line
insert_iterator&
operator=(typename _Container::value_type&& __value)
{
iter = container->insert(iter, std::move(__value));
++iter;
return *this;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
insert_iterator&
operator*()
{ return *this; }
#pragma empty_line
#pragma empty_line
insert_iterator&
operator++()
{ return *this; }
#pragma empty_line
#pragma empty_line
insert_iterator&
operator++(int)
{ return *this; }
};
#pragma line 723 "/home/justin/jhai/Xilinx/Vivado/2018.3/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));
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma line 747 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
typedef iterator_traits<_Iterator> __traits_type;
#pragma empty_line
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;
#pragma empty_line
constexpr __normal_iterator() noexcept
: _M_current(_Iterator()) { }
#pragma empty_line
explicit
__normal_iterator(const _Iterator& __i) noexcept
: _M_current(__i) { }
#pragma empty_line
#pragma empty_line
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()) { }
#pragma empty_line
#pragma empty_line
reference
operator*() const noexcept
{ return *_M_current; }
#pragma empty_line
pointer
operator->() const noexcept
{ return _M_current; }
#pragma empty_line
__normal_iterator&
operator++() noexcept
{
++_M_current;
return *this;
}
#pragma empty_line
__normal_iterator
operator++(int) noexcept
{ return __normal_iterator(_M_current++); }
#pragma empty_line
#pragma empty_line
__normal_iterator&
operator--() noexcept
{
--_M_current;
return *this;
}
#pragma empty_line
__normal_iterator
operator--(int) noexcept
{ return __normal_iterator(_M_current--); }
#pragma empty_line
#pragma empty_line
reference
operator[](difference_type __n) const noexcept
{ return _M_current[__n]; }
#pragma empty_line
__normal_iterator&
operator+=(difference_type __n) noexcept
{ _M_current += __n; return *this; }
#pragma empty_line
__normal_iterator
operator+(difference_type __n) const noexcept
{ return __normal_iterator(_M_current + __n); }
#pragma empty_line
__normal_iterator&
operator-=(difference_type __n) noexcept
{ _M_current -= __n; return *this; }
#pragma empty_line
__normal_iterator
operator-(difference_type __n) const noexcept
{ return __normal_iterator(_M_current - __n); }
#pragma empty_line
const _Iterator&
base() const noexcept
{ return _M_current; }
};
#pragma line 847 "/home/justin/jhai/Xilinx/Vivado/2018.3/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(); }
#pragma empty_line
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(); }
#pragma empty_line
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(); }
#pragma empty_line
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(); }
#pragma empty_line
#pragma empty_line
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(); }
#pragma empty_line
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(); }
#pragma empty_line
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(); }
#pragma empty_line
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(); }
#pragma empty_line
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(); }
#pragma empty_line
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(); }
#pragma empty_line
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(); }
#pragma empty_line
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(); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _IteratorL, typename _IteratorR, typename _Container>
#pragma empty_line
#pragma empty_line
inline auto
operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept
-> decltype(__lhs.base() - __rhs.base())
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
{ return __lhs.base() - __rhs.base(); }
#pragma empty_line
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(); }
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
template<typename _Iterator, typename _Container>
_Iterator
__niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it)
{ return __it.base(); }
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma line 999 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
typedef iterator_traits<_Iterator> __traits_type;
typedef typename __traits_type::reference __base_ref;
#pragma empty_line
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;
#pragma empty_line
typedef _Iterator pointer;
#pragma empty_line
#pragma empty_line
typedef typename conditional<is_reference<__base_ref>::value,
typename remove_reference<__base_ref>::type&&,
__base_ref>::type reference;
#pragma empty_line
move_iterator()
: _M_current() { }
#pragma empty_line
explicit
move_iterator(iterator_type __i)
: _M_current(__i) { }
#pragma empty_line
template<typename _Iter>
move_iterator(const move_iterator<_Iter>& __i)
: _M_current(__i.base()) { }
#pragma empty_line
iterator_type
base() const
{ return _M_current; }
#pragma empty_line
reference
operator*() const
{ return static_cast<reference>(*_M_current); }
#pragma empty_line
pointer
operator->() const
{ return _M_current; }
#pragma empty_line
move_iterator&
operator++()
{
++_M_current;
return *this;
}
#pragma empty_line
move_iterator
operator++(int)
{
move_iterator __tmp = *this;
++_M_current;
return __tmp;
}
#pragma empty_line
move_iterator&
operator--()
{
--_M_current;
return *this;
}
#pragma empty_line
move_iterator
operator--(int)
{
move_iterator __tmp = *this;
--_M_current;
return __tmp;
}
#pragma empty_line
move_iterator
operator+(difference_type __n) const
{ return move_iterator(_M_current + __n); }
#pragma empty_line
move_iterator&
operator+=(difference_type __n)
{
_M_current += __n;
return *this;
}
#pragma empty_line
move_iterator
operator-(difference_type __n) const
{ return move_iterator(_M_current - __n); }
#pragma empty_line
move_iterator&
operator-=(difference_type __n)
{
_M_current -= __n;
return *this;
}
#pragma empty_line
reference
operator[](difference_type __n) const
{ return std::move(_M_current[__n]); }
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _IteratorL, typename _IteratorR>
inline bool
operator==(const move_iterator<_IteratorL>& __x,
const move_iterator<_IteratorR>& __y)
{ return __x.base() == __y.base(); }
#pragma empty_line
template<typename _Iterator>
inline bool
operator==(const move_iterator<_Iterator>& __x,
const move_iterator<_Iterator>& __y)
{ return __x.base() == __y.base(); }
#pragma empty_line
template<typename _IteratorL, typename _IteratorR>
inline bool
operator!=(const move_iterator<_IteratorL>& __x,
const move_iterator<_IteratorR>& __y)
{ return !(__x == __y); }
#pragma empty_line
template<typename _Iterator>
inline bool
operator!=(const move_iterator<_Iterator>& __x,
const move_iterator<_Iterator>& __y)
{ return !(__x == __y); }
#pragma empty_line
template<typename _IteratorL, typename _IteratorR>
inline bool
operator<(const move_iterator<_IteratorL>& __x,
const move_iterator<_IteratorR>& __y)
{ return __x.base() < __y.base(); }
#pragma empty_line
template<typename _Iterator>
inline bool
operator<(const move_iterator<_Iterator>& __x,
const move_iterator<_Iterator>& __y)
{ return __x.base() < __y.base(); }
#pragma empty_line
template<typename _IteratorL, typename _IteratorR>
inline bool
operator<=(const move_iterator<_IteratorL>& __x,
const move_iterator<_IteratorR>& __y)
{ return !(__y < __x); }
#pragma empty_line
template<typename _Iterator>
inline bool
operator<=(const move_iterator<_Iterator>& __x,
const move_iterator<_Iterator>& __y)
{ return !(__y < __x); }
#pragma empty_line
template<typename _IteratorL, typename _IteratorR>
inline bool
operator>(const move_iterator<_IteratorL>& __x,
const move_iterator<_IteratorR>& __y)
{ return __y < __x; }
#pragma empty_line
template<typename _Iterator>
inline bool
operator>(const move_iterator<_Iterator>& __x,
const move_iterator<_Iterator>& __y)
{ return __y < __x; }
#pragma empty_line
template<typename _IteratorL, typename _IteratorR>
inline bool
operator>=(const move_iterator<_IteratorL>& __x,
const move_iterator<_IteratorR>& __y)
{ return !(__x < __y); }
#pragma empty_line
template<typename _Iterator>
inline bool
operator>=(const move_iterator<_Iterator>& __x,
const move_iterator<_Iterator>& __y)
{ return !(__x < __y); }
#pragma empty_line
#pragma empty_line
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(); }
#pragma empty_line
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(); }
#pragma empty_line
template<typename _Iterator>
inline move_iterator<_Iterator>
operator+(typename move_iterator<_Iterator>::difference_type __n,
const move_iterator<_Iterator>& __x)
{ return __x + __n; }
#pragma empty_line
template<typename _Iterator>
inline move_iterator<_Iterator>
make_move_iterator(_Iterator __i)
{ return move_iterator<_Iterator>(__i); }
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
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())); }
#pragma empty_line
template<typename _Iterator>
struct __is_move_iterator<move_iterator<_Iterator> >
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
template<typename _Iterator>
auto
__miter_base(move_iterator<_Iterator> __it)
-> decltype(__miter_base(__it.base()))
{ return __miter_base(__it.base()); }
#pragma empty_line
#pragma empty_line
}
#pragma line 68 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 2 3
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/debug/debug.h" 1 3
#pragma line 48 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/debug/debug.h" 3
namespace std
{
namespace __debug { }
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace __gnu_debug
{
using namespace std::__debug;
}
#pragma line 70 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 2 3
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/predefined_ops.h" 1 3
#pragma line 33 "/home/justin/jhai/Xilinx/Vivado/2018.3/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(); }
#pragma empty_line
struct _Iter_less_val
{
template<typename _Iterator, typename _Value>
bool
operator()(_Iterator __it, _Value& __val) const
{ return *__it < __val; }
};
#pragma empty_line
inline _Iter_less_val
__iter_less_val()
{ return _Iter_less_val(); }
#pragma empty_line
inline _Iter_less_val
__iter_comp_val(_Iter_less_iter)
{ return _Iter_less_val(); }
#pragma empty_line
struct _Val_less_iter
{
template<typename _Value, typename _Iterator>
bool
operator()(_Value& __val, _Iterator __it) const
{ return __val < *__it; }
};
#pragma empty_line
inline _Val_less_iter
__val_less_iter()
{ return _Val_less_iter(); }
#pragma empty_line
inline _Val_less_iter
__val_comp_iter(_Iter_less_iter)
{ return _Val_less_iter(); }
#pragma empty_line
struct _Iter_equal_to_iter
{
template<typename _Iterator1, typename _Iterator2>
bool
operator()(_Iterator1 __it1, _Iterator2 __it2) const
{ return *__it1 == *__it2; }
};
#pragma empty_line
inline _Iter_equal_to_iter
__iter_equal_to_iter()
{ return _Iter_equal_to_iter(); }
#pragma empty_line
struct _Iter_equal_to_val
{
template<typename _Iterator, typename _Value>
bool
operator()(_Iterator __it, _Value& __val) const
{ return *__it == __val; }
};
#pragma empty_line
inline _Iter_equal_to_val
__iter_equal_to_val()
{ return _Iter_equal_to_val(); }
#pragma empty_line
inline _Iter_equal_to_val
__iter_comp_val(_Iter_equal_to_iter)
{ return _Iter_equal_to_val(); }
#pragma empty_line
template<typename _Compare>
struct _Iter_comp_iter
{
_Compare _M_comp;
constexpr
_Iter_comp_iter(_Compare __comp)
: _M_comp(__comp)
{ }
#pragma empty_line
template<typename _Iterator1, typename _Iterator2>
constexpr
bool
operator()(_Iterator1 __it1, _Iterator2 __it2)
{ return bool(_M_comp(*__it1, *__it2)); }
};
#pragma empty_line
template<typename _Compare>
constexpr
inline _Iter_comp_iter<_Compare>
__iter_comp_iter(_Compare __comp)
{ return _Iter_comp_iter<_Compare>(__comp); }
#pragma empty_line
template<typename _Compare>
struct _Iter_comp_val
{
_Compare _M_comp;
#pragma empty_line
_Iter_comp_val(_Compare __comp)
: _M_comp(__comp)
{ }
#pragma empty_line
template<typename _Iterator, typename _Value>
bool
operator()(_Iterator __it, _Value& __val)
{ return bool(_M_comp(*__it, __val)); }
};
#pragma empty_line
template<typename _Compare>
inline _Iter_comp_val<_Compare>
__iter_comp_val(_Compare __comp)
{ return _Iter_comp_val<_Compare>(__comp); }
#pragma empty_line
template<typename _Compare>
inline _Iter_comp_val<_Compare>
__iter_comp_val(_Iter_comp_iter<_Compare> __comp)
{ return _Iter_comp_val<_Compare>(__comp._M_comp); }
#pragma empty_line
template<typename _Compare>
struct _Val_comp_iter
{
_Compare _M_comp;
#pragma empty_line
_Val_comp_iter(_Compare __comp)
: _M_comp(__comp)
{ }
#pragma empty_line
template<typename _Value, typename _Iterator>
bool
operator()(_Value& __val, _Iterator __it)
{ return bool(_M_comp(__val, *__it)); }
};
#pragma empty_line
template<typename _Compare>
inline _Val_comp_iter<_Compare>
__val_comp_iter(_Compare __comp)
{ return _Val_comp_iter<_Compare>(__comp); }
#pragma empty_line
template<typename _Compare>
inline _Val_comp_iter<_Compare>
__val_comp_iter(_Iter_comp_iter<_Compare> __comp)
{ return _Val_comp_iter<_Compare>(__comp._M_comp); }
#pragma empty_line
template<typename _Value>
struct _Iter_equals_val
{
_Value& _M_value;
#pragma empty_line
_Iter_equals_val(_Value& __value)
: _M_value(__value)
{ }
#pragma empty_line
template<typename _Iterator>
bool
operator()(_Iterator __it)
{ return *__it == _M_value; }
};
#pragma empty_line
template<typename _Value>
inline _Iter_equals_val<_Value>
__iter_equals_val(_Value& __val)
{ return _Iter_equals_val<_Value>(__val); }
#pragma empty_line
template<typename _Iterator1>
struct _Iter_equals_iter
{
typename std::iterator_traits<_Iterator1>::reference _M_ref;
#pragma empty_line
_Iter_equals_iter(_Iterator1 __it1)
: _M_ref(*__it1)
{ }
#pragma empty_line
template<typename _Iterator2>
bool
operator()(_Iterator2 __it2)
{ return *__it2 == _M_ref; }
};
#pragma empty_line
template<typename _Iterator>
inline _Iter_equals_iter<_Iterator>
__iter_comp_iter(_Iter_equal_to_iter, _Iterator __it)
{ return _Iter_equals_iter<_Iterator>(__it); }
#pragma empty_line
template<typename _Predicate>
struct _Iter_pred
{
_Predicate _M_pred;
#pragma empty_line
_Iter_pred(_Predicate __pred)
: _M_pred(__pred)
{ }
#pragma empty_line
template<typename _Iterator>
bool
operator()(_Iterator __it)
{ return bool(_M_pred(*__it)); }
};
#pragma empty_line
template<typename _Predicate>
inline _Iter_pred<_Predicate>
__pred_iter(_Predicate __pred)
{ return _Iter_pred<_Predicate>(__pred); }
#pragma empty_line
template<typename _Compare, typename _Value>
struct _Iter_comp_to_val
{
_Compare _M_comp;
_Value& _M_value;
#pragma empty_line
_Iter_comp_to_val(_Compare __comp, _Value& __value)
: _M_comp(__comp), _M_value(__value)
{ }
#pragma empty_line
template<typename _Iterator>
bool
operator()(_Iterator __it)
{ return bool(_M_comp(*__it, _M_value)); }
};
#pragma empty_line
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); }
#pragma empty_line
template<typename _Compare, typename _Iterator1>
struct _Iter_comp_to_iter
{
_Compare _M_comp;
typename std::iterator_traits<_Iterator1>::reference _M_ref;
#pragma empty_line
_Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1)
: _M_comp(__comp), _M_ref(*__it1)
{ }
#pragma empty_line
template<typename _Iterator2>
bool
operator()(_Iterator2 __it2)
{ return bool(_M_comp(*__it2, _M_ref)); }
};
#pragma empty_line
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); }
#pragma empty_line
template<typename _Predicate>
struct _Iter_negate
{
_Predicate _M_pred;
#pragma empty_line
_Iter_negate(_Predicate __pred)
: _M_pred(__pred)
{ }
#pragma empty_line
template<typename _Iterator>
bool
operator()(_Iterator __it)
{ return !bool(_M_pred(*__it)); }
};
#pragma empty_line
template<typename _Predicate>
inline _Iter_negate<_Predicate>
__negate(_Iter_pred<_Predicate> __pred)
{ return _Iter_negate<_Predicate>(__pred._M_pred); }
#pragma empty_line
}
}
#pragma line 72 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 2 3
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma line 118 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 148 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algobase.h" 3
swap(*__a, *__b);
#pragma empty_line
}
#pragma line 164 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
for (; __first1 != __last1; ++__first1, (void)++__first2)
std::iter_swap(__first1, __first2);
return __first2;
}
#pragma line 192 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
if (__b < __a)
return __b;
return __a;
}
#pragma line 216 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
if (__a < __b)
return __b;
return __a;
}
#pragma line 240 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
if (__comp(__b, __a))
return __b;
return __a;
}
#pragma line 262 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
if (__comp(__a, __b))
return __b;
return __a;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Iterator>
inline _Iterator
__niter_base(_Iterator __it)
{ return __it; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
};
#pragma empty_line
#pragma empty_line
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;
}
};
#pragma empty_line
#pragma empty_line
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;
}
};
#pragma empty_line
#pragma empty_line
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;
}
};
#pragma empty_line
#pragma empty_line
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)
{
#pragma empty_line
using __assignable = conditional<_IsMove,
is_move_assignable<_Tp>,
is_copy_assignable<_Tp>>;
#pragma empty_line
static_assert( __assignable::type::value, "type is not assignable" );
#pragma empty_line
const ptrdiff_t _Num = __last - __first;
if (_Num)
__builtin_memmove(__result, __first, sizeof(_Tp) * _Num);
return __result + _Num;
}
};
#pragma empty_line
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);
#pragma empty_line
return std::__copy_move<_IsMove, __simple,
_Category>::__copy_m(__first, __last, __result);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _CharT>
struct char_traits;
#pragma empty_line
template<typename _CharT, typename _Traits>
class istreambuf_iterator;
#pragma empty_line
template<typename _CharT, typename _Traits>
class ostreambuf_iterator;
#pragma empty_line
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> >);
#pragma empty_line
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> >);
#pragma empty_line
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*);
#pragma empty_line
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)));
}
#pragma line 444 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
return (std::__copy_move_a2<__is_move_iterator<_II>::__value>
(std::__miter_base(__first), std::__miter_base(__last),
__result));
}
#pragma line 477 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
return std::__copy_move_a2<true>(std::__miter_base(__first),
std::__miter_base(__last), __result);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
};
#pragma empty_line
#pragma empty_line
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;
}
};
#pragma empty_line
#pragma empty_line
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;
}
};
#pragma empty_line
#pragma empty_line
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;
}
};
#pragma empty_line
#pragma empty_line
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)
{
#pragma empty_line
using __assignable = conditional<_IsMove,
is_move_assignable<_Tp>,
is_copy_assignable<_Tp>>;
#pragma empty_line
static_assert( __assignable::type::value, "type is not assignable" );
#pragma empty_line
const ptrdiff_t _Num = __last - __first;
if (_Num)
__builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num);
return __result - _Num;
}
};
#pragma empty_line
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);
#pragma empty_line
return std::__copy_move_backward<_IsMove, __simple,
_Category>::__copy_move_b(__first,
__last,
__result);
}
#pragma empty_line
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)));
}
#pragma line 620 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
return (std::__copy_move_backward_a2<__is_move_iterator<_BI1>::__value>
(std::__miter_base(__first), std::__miter_base(__last),
__result));
}
#pragma line 656 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
return std::__copy_move_backward_a2<true>(std::__miter_base(__first),
std::__miter_base(__last),
__result);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
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);
}
#pragma line 722 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
std::__fill_a(std::__niter_base(__first), std::__niter_base(__last),
__value);
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma line 782 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
return _OI(std::__fill_n_a(std::__niter_base(__first), __n, __value));
}
#pragma empty_line
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;
}
};
#pragma empty_line
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;
}
};
#pragma empty_line
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);
#pragma empty_line
return std::__equal<__simple>::equal(__first1, __last1, __first2);
}
#pragma empty_line
template<typename, typename>
struct __lc_rai
{
template<typename _II1, typename _II2>
static _II1
__newlast1(_II1, _II1 __last1, _II2, _II2)
{ return __last1; }
#pragma empty_line
template<typename _II>
static bool
__cnd2(_II __first, _II __last)
{ return __first != __last; }
};
#pragma empty_line
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;
}
#pragma empty_line
template<typename _RAI>
static bool
__cnd2(_RAI, _RAI)
{ return true; }
};
#pragma empty_line
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;
#pragma empty_line
__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;
}
#pragma empty_line
template<bool _BoolType>
struct __lexicographical_compare
{
template<typename _II1, typename _II2>
static bool __lc(_II1, _II1, _II2, _II2);
};
#pragma empty_line
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());
}
#pragma empty_line
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;
}
};
#pragma empty_line
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);
#pragma empty_line
return std::__lexicographical_compare<__simple>::__lc(__first1, __last1,
__first2, __last2);
}
#pragma empty_line
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;
#pragma empty_line
_DistanceType __len = std::distance(__first, __last);
#pragma empty_line
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;
}
#pragma line 982 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
return std::__lower_bound(__first, __last, __val,
__gnu_cxx::__ops::__iter_less_val());
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline constexpr int
__lg(int __n)
{ return sizeof(int) * 8 - 1 - __builtin_clz(__n); }
#pragma empty_line
inline constexpr unsigned
__lg(unsigned __n)
{ return sizeof(int) * 8 - 1 - __builtin_clz(__n); }
#pragma empty_line
inline constexpr long
__lg(long __n)
{ return sizeof(long) * 8 - 1 - __builtin_clzl(__n); }
#pragma empty_line
inline constexpr unsigned long
__lg(unsigned long __n)
{ return sizeof(long) * 8 - 1 - __builtin_clzl(__n); }
#pragma empty_line
inline constexpr long long
__lg(long long __n)
{ return sizeof(long long) * 8 - 1 - __builtin_clzll(__n); }
#pragma empty_line
inline constexpr unsigned long long
__lg(unsigned long long __n)
{ return sizeof(long long) * 8 - 1 - __builtin_clzll(__n); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1039 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
return std::__equal_aux(std::__niter_base(__first1),
std::__niter_base(__last1),
std::__niter_base(__first2));
}
#pragma line 1071 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
for (; __first1 != __last1; ++__first1, (void)++__first2)
if (!bool(__binary_pred(*__first1, *__first2)))
return false;
return true;
}
#pragma line 1104 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
#pragma empty_line
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);
}
#pragma empty_line
for (; __first1 != __last1 && __first2 != __last2;
++__first1, (void)++__first2)
if (!(*__first1 == *__first2))
return false;
return __first1 == __last1 && __first2 == __last2;
}
#pragma line 1153 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
#pragma empty_line
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);
}
#pragma empty_line
for (; __first1 != __last1 && __first2 != __last2;
++__first1, (void)++__first2)
if (!bool(__binary_pred(*__first1, *__first2)))
return false;
return __first1 == __last1 && __first2 == __last2;
}
#pragma line 1201 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
#pragma empty_line
return std::__lexicographical_compare_aux(std::__niter_base(__first1),
std::__niter_base(__last1),
std::__niter_base(__first2),
std::__niter_base(__last2));
}
#pragma line 1237 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
#pragma empty_line
return std::__lexicographical_compare_impl
(__first1, __last1, __first2, __last2,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
#pragma empty_line
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);
}
#pragma line 1280 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
return std::__mismatch(__first1, __last1, __first2,
__gnu_cxx::__ops::__iter_equal_to_iter());
}
#pragma line 1313 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
return std::__mismatch(__first1, __last1, __first2,
__gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
}
#pragma line 1360 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
#pragma empty_line
return std::__mismatch(__first1, __last1, __first2, __last2,
__gnu_cxx::__ops::__iter_equal_to_iter());
}
#pragma line 1395 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
#pragma empty_line
return std::__mismatch(__first1, __last1, __first2, __last2,
__gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 61 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/deque" 2 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/allocator.h" 1 3
#pragma line 46 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/allocator.h" 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/c++allocator.h" 1 3
#pragma line 33 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/c++allocator.h" 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/new_allocator.h" 1 3
#pragma line 33 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/new_allocator.h" 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/new" 1 3
#pragma line 37 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/new" 3
#pragma empty_line
#pragma line 38 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/new" 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/exception" 1 3
#pragma line 33 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/exception" 3
#pragma empty_line
#pragma line 34 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/exception" 3
#pragma empty_line
#pragma GCC visibility push(default)
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/atomic_lockfree_defines.h" 1 3
#pragma line 33 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/atomic_lockfree_defines.h" 3
#pragma empty_line
#pragma line 34 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/atomic_lockfree_defines.h" 3
#pragma line 39 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/exception" 2 3
#pragma empty_line
extern "C++" {
#pragma empty_line
namespace std
{
#pragma line 60 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/exception" 3
class exception
{
public:
exception() noexcept { }
virtual ~exception() noexcept;
#pragma empty_line
#pragma empty_line
#pragma empty_line
virtual const char*
what() const noexcept;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
class bad_exception : public exception
{
public:
bad_exception() noexcept { }
#pragma empty_line
#pragma empty_line
#pragma empty_line
virtual ~bad_exception() noexcept;
#pragma empty_line
#pragma empty_line
virtual const char*
what() const noexcept;
};
#pragma empty_line
#pragma empty_line
typedef void (*terminate_handler) ();
#pragma empty_line
#pragma empty_line
typedef void (*unexpected_handler) ();
#pragma empty_line
#pragma empty_line
terminate_handler set_terminate(terminate_handler) noexcept;
#pragma empty_line
#pragma empty_line
#pragma empty_line
terminate_handler get_terminate() noexcept;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
void terminate() noexcept __attribute__ ((__noreturn__));
#pragma empty_line
#pragma empty_line
unexpected_handler set_unexpected(unexpected_handler) noexcept;
#pragma empty_line
#pragma empty_line
#pragma empty_line
unexpected_handler get_unexpected() noexcept;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
void unexpected() __attribute__ ((__noreturn__));
#pragma line 129 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/exception" 3
bool uncaught_exception() noexcept __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
int uncaught_exceptions() noexcept __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
namespace __gnu_cxx
{
#pragma empty_line
#pragma line 160 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/exception" 3
void __verbose_terminate_handler();
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
}
#pragma empty_line
#pragma GCC visibility pop
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/exception_ptr.h" 1 3
#pragma line 34 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/exception_ptr.h" 3
#pragma GCC visibility push(default)
#pragma line 43 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/exception_ptr.h" 3
extern "C++" {
#pragma empty_line
namespace std
{
class type_info;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace __exception_ptr
{
class exception_ptr;
}
#pragma empty_line
using __exception_ptr::exception_ptr;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
exception_ptr current_exception() noexcept;
#pragma empty_line
#pragma empty_line
void rethrow_exception(exception_ptr) __attribute__ ((__noreturn__));
#pragma empty_line
namespace __exception_ptr
{
using std::rethrow_exception;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
class exception_ptr
{
void* _M_exception_object;
#pragma empty_line
explicit exception_ptr(void* __e) noexcept;
#pragma empty_line
void _M_addref() noexcept;
void _M_release() noexcept;
#pragma empty_line
void *_M_get() const noexcept __attribute__ ((__pure__));
#pragma empty_line
friend exception_ptr std::current_exception() noexcept;
friend void std::rethrow_exception(exception_ptr);
#pragma empty_line
public:
exception_ptr() noexcept;
#pragma empty_line
exception_ptr(const exception_ptr&) noexcept;
#pragma empty_line
#pragma empty_line
exception_ptr(nullptr_t) noexcept
: _M_exception_object(0)
{ }
#pragma empty_line
exception_ptr(exception_ptr&& __o) noexcept
: _M_exception_object(__o._M_exception_object)
{ __o._M_exception_object = 0; }
#pragma line 113 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/exception_ptr.h" 3
exception_ptr&
operator=(const exception_ptr&) noexcept;
#pragma empty_line
#pragma empty_line
exception_ptr&
operator=(exception_ptr&& __o) noexcept
{
exception_ptr(static_cast<exception_ptr&&>(__o)).swap(*this);
return *this;
}
#pragma empty_line
#pragma empty_line
~exception_ptr() noexcept;
#pragma empty_line
void
swap(exception_ptr&) noexcept;
#pragma line 140 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/exception_ptr.h" 3
explicit operator bool() const
{ return _M_exception_object; }
#pragma empty_line
#pragma empty_line
friend bool
operator==(const exception_ptr&, const exception_ptr&)
noexcept __attribute__ ((__pure__));
#pragma empty_line
const class std::type_info*
__cxa_exception_type() const noexcept
__attribute__ ((__pure__));
};
#pragma empty_line
bool
operator==(const exception_ptr&, const exception_ptr&)
noexcept __attribute__ ((__pure__));
#pragma empty_line
bool
operator!=(const exception_ptr&, const exception_ptr&)
noexcept __attribute__ ((__pure__));
#pragma empty_line
inline void
swap(exception_ptr& __lhs, exception_ptr& __rhs)
{ __lhs.swap(__rhs); }
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Ex>
exception_ptr
make_exception_ptr(_Ex __ex) noexcept
{
#pragma empty_line
try
{
throw __ex;
}
catch(...)
{
return current_exception();
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Ex>
exception_ptr
copy_exception(_Ex __ex) noexcept __attribute__ ((__deprecated__));
#pragma empty_line
template<typename _Ex>
exception_ptr
copy_exception(_Ex __ex) noexcept
{ return std::make_exception_ptr<_Ex>(__ex); }
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
}
#pragma empty_line
#pragma GCC visibility pop
#pragma line 171 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/exception" 2 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/nested_exception.h" 1 3
#pragma line 33 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/nested_exception.h" 3
#pragma GCC visibility push(default)
#pragma line 46 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/nested_exception.h" 3
extern "C++" {
#pragma empty_line
namespace std
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
class nested_exception
{
exception_ptr _M_ptr;
#pragma empty_line
public:
nested_exception() noexcept : _M_ptr(current_exception()) { }
#pragma empty_line
nested_exception(const nested_exception&) noexcept = default;
#pragma empty_line
nested_exception& operator=(const nested_exception&) noexcept = default;
#pragma empty_line
virtual ~nested_exception() noexcept;
#pragma empty_line
[[noreturn]]
void
rethrow_nested() const
{
if (_M_ptr)
rethrow_exception(_M_ptr);
std::terminate();
}
#pragma empty_line
exception_ptr
nested_ptr() const noexcept
{ return _M_ptr; }
};
#pragma empty_line
template<typename _Except>
struct _Nested_exception : public _Except, public nested_exception
{
explicit _Nested_exception(const _Except& __ex)
: _Except(__ex)
{ }
#pragma empty_line
explicit _Nested_exception(_Except&& __ex)
: _Except(static_cast<_Except&&>(__ex))
{ }
};
#pragma empty_line
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)}; }
};
#pragma empty_line
template<typename _Tp>
struct _Throw_with_nested_impl<_Tp, false>
{
template<typename _Up>
static void _S_throw(_Up&& __t)
{ throw static_cast<_Up&&>(__t); }
};
#pragma empty_line
template<typename _Tp, bool = __is_class(_Tp) && !__is_final(_Tp)>
struct _Throw_with_nested_helper : _Throw_with_nested_impl<_Tp>
{ };
#pragma empty_line
template<typename _Tp>
struct _Throw_with_nested_helper<_Tp, false>
: _Throw_with_nested_impl<_Tp, false>
{ };
#pragma empty_line
template<typename _Tp>
struct _Throw_with_nested_helper<_Tp&, false>
: _Throw_with_nested_helper<_Tp>
{ };
#pragma empty_line
template<typename _Tp>
struct _Throw_with_nested_helper<_Tp&&, false>
: _Throw_with_nested_helper<_Tp>
{ };
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
[[noreturn]]
inline void
throw_with_nested(_Tp&& __t)
{
_Throw_with_nested_helper<_Tp>::_S_throw(static_cast<_Tp&&>(__t));
}
#pragma empty_line
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();
}
};
#pragma empty_line
template<typename _Tp>
struct _Rethrow_if_nested_impl<_Tp, false>
{
static void _S_rethrow(const _Tp&) { }
};
#pragma empty_line
#pragma empty_line
template<typename _Ex>
inline void
rethrow_if_nested(const _Ex& __ex)
{
_Rethrow_if_nested_impl<_Ex>::_S_rethrow(__ex);
}
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma GCC visibility pop
#pragma line 172 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/exception" 2 3
#pragma line 41 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/new" 2 3
#pragma empty_line
#pragma GCC visibility push(default)
#pragma empty_line
extern "C++" {
#pragma empty_line
namespace std
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
class bad_alloc : public exception
{
public:
bad_alloc() throw() { }
#pragma empty_line
#pragma empty_line
#pragma empty_line
virtual ~bad_alloc() throw();
#pragma empty_line
#pragma empty_line
virtual const char* what() const throw();
};
#pragma empty_line
#pragma empty_line
class bad_array_new_length : public bad_alloc
{
public:
bad_array_new_length() throw() { };
#pragma empty_line
#pragma empty_line
#pragma empty_line
virtual ~bad_array_new_length() throw();
#pragma empty_line
#pragma empty_line
virtual const char* what() const throw();
};
#pragma empty_line
#pragma empty_line
struct nothrow_t
{
#pragma empty_line
explicit nothrow_t() = default;
#pragma empty_line
};
#pragma empty_line
extern const nothrow_t nothrow;
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef void (*new_handler)();
#pragma empty_line
#pragma empty_line
#pragma empty_line
new_handler set_new_handler(new_handler) throw();
#pragma empty_line
#pragma empty_line
#pragma empty_line
new_handler get_new_handler() noexcept;
#pragma empty_line
}
#pragma line 116 "/home/justin/jhai/Xilinx/Vivado/2018.3/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__));
#pragma empty_line
void operator delete(void*, std::size_t) noexcept
__attribute__((__externally_visible__));
void operator delete[](void*, std::size_t) noexcept
__attribute__((__externally_visible__));
#pragma empty_line
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__));
#pragma empty_line
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__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline void* operator new(std::size_t, void* __p) noexcept
{ return __p; }
inline void* operator new[](std::size_t, void* __p) noexcept
{ return __p; }
#pragma empty_line
#pragma empty_line
inline void operator delete (void*, void*) noexcept { }
inline void operator delete[](void*, void*) noexcept { }
#pragma empty_line
}
#pragma empty_line
#pragma GCC visibility pop
#pragma line 34 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/new_allocator.h" 2 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
using std::size_t;
using std::ptrdiff_t;
#pragma line 57 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
template<typename _Tp1>
struct rebind
{ typedef new_allocator<_Tp1> other; };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef std::true_type propagate_on_container_move_assignment;
#pragma empty_line
#pragma empty_line
new_allocator() noexcept { }
#pragma empty_line
new_allocator(const new_allocator&) noexcept { }
#pragma empty_line
template<typename _Tp1>
new_allocator(const new_allocator<_Tp1>&) noexcept { }
#pragma empty_line
~new_allocator() noexcept { }
#pragma empty_line
pointer
address(reference __x) const noexcept
{ return std::__addressof(__x); }
#pragma empty_line
const_pointer
address(const_reference __x) const noexcept
{ return std::__addressof(__x); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
pointer
allocate(size_type __n, const void* = 0)
{
if (__n > this->max_size())
std::__throw_bad_alloc();
#pragma empty_line
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
}
#pragma empty_line
#pragma empty_line
void
deallocate(pointer __p, size_type)
{ ::operator delete(__p); }
#pragma empty_line
size_type
max_size() const noexcept
{ return size_t(-1) / sizeof(_Tp); }
#pragma empty_line
#pragma empty_line
template<typename _Up, typename... _Args>
void
construct(_Up* __p, _Args&&... __args)
{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
#pragma empty_line
template<typename _Up>
void
destroy(_Up* __p) { __p->~_Up(); }
#pragma line 135 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/new_allocator.h" 3
};
#pragma empty_line
template<typename _Tp>
inline bool
operator==(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
{ return true; }
#pragma empty_line
template<typename _Tp>
inline bool
operator!=(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
{ return false; }
#pragma empty_line
#pragma empty_line
}
#pragma line 34 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/c++allocator.h" 2 3
#pragma empty_line
#pragma empty_line
namespace std
{
#pragma line 47 "/home/justin/jhai/Xilinx/Vivado/2018.3/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>;
}
#pragma line 47 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/allocator.h" 2 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/memoryfwd.h" 1 3
#pragma line 46 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/memoryfwd.h" 3
#pragma empty_line
#pragma line 47 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/memoryfwd.h" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma line 63 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/memoryfwd.h" 3
template<typename>
class allocator;
#pragma empty_line
template<>
class allocator<void>;
#pragma empty_line
#pragma empty_line
template<typename, typename>
struct uses_allocator;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 48 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/allocator.h" 2 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
template<typename _Tp1>
struct rebind
{ typedef allocator<_Tp1> other; };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef true_type propagate_on_container_move_assignment;
#pragma empty_line
#pragma empty_line
typedef true_type is_always_equal;
#pragma empty_line
};
#pragma line 96 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
template<typename _Tp1>
struct rebind
{ typedef allocator<_Tp1> other; };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef true_type propagate_on_container_move_assignment;
#pragma empty_line
#pragma empty_line
allocator() throw() { }
#pragma empty_line
allocator(const allocator& __a) throw()
: __allocator_base<_Tp>(__a) { }
#pragma empty_line
template<typename _Tp1>
allocator(const allocator<_Tp1>&) throw() { }
#pragma empty_line
~allocator() throw() { }
#pragma empty_line
#pragma empty_line
};
#pragma empty_line
template<typename _T1, typename _T2>
inline bool
operator==(const allocator<_T1>&, const allocator<_T2>&)
noexcept
{ return true; }
#pragma empty_line
template<typename _Tp>
inline bool
operator==(const allocator<_Tp>&, const allocator<_Tp>&)
noexcept
{ return true; }
#pragma empty_line
template<typename _T1, typename _T2>
inline bool
operator!=(const allocator<_T1>&, const allocator<_T2>&)
noexcept
{ return false; }
#pragma empty_line
template<typename _Tp>
inline bool
operator!=(const allocator<_Tp>&, const allocator<_Tp>&)
noexcept
{ return false; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern template class allocator<char>;
extern template class allocator<wchar_t>;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Alloc, bool = __is_empty(_Alloc)>
struct __alloc_swap
{ static void _S_do_it(_Alloc&, _Alloc&) noexcept { } };
#pragma empty_line
template<typename _Alloc>
struct __alloc_swap<_Alloc, false>
{
static void
_S_do_it(_Alloc& __one, _Alloc& __two) noexcept
{
#pragma empty_line
if (__one != __two)
swap(__one, __two);
}
};
#pragma empty_line
#pragma empty_line
template<typename _Alloc, bool = __is_empty(_Alloc)>
struct __alloc_neq
{
static bool
_S_do_it(const _Alloc&, const _Alloc&)
{ return false; }
};
#pragma empty_line
template<typename _Alloc>
struct __alloc_neq<_Alloc, false>
{
static bool
_S_do_it(const _Alloc& __one, const _Alloc& __two)
{ return __one != __two; }
};
#pragma empty_line
#pragma empty_line
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; } };
#pragma empty_line
template<typename _Tp>
struct __shrink_to_fit_aux<_Tp, true>
{
static bool
_S_do_it(_Tp& __c) noexcept
{
#pragma empty_line
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; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 62 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/deque" 2 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_construct.h" 1 3
#pragma line 61 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_construct.h" 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/alloc_traits.h" 1 3
#pragma line 32 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/alloc_traits.h" 3
#pragma empty_line
#pragma line 33 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/alloc_traits.h" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/alloc_traits.h" 1 3
#pragma line 41 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/alloc_traits.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
struct __allocator_traits_base
{
template<typename _Alloc, typename _Up>
using __rebind = typename _Alloc::template rebind<_Up>::other;
#pragma empty_line
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;
};
#pragma empty_line
template<typename _Alloc, typename _Up>
using __alloc_rebind = __detected_or_t_<__replace_first_arg_t,
__allocator_traits_base::__rebind,
_Alloc, _Up>;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Alloc>
struct allocator_traits : __allocator_traits_base
{
#pragma empty_line
typedef _Alloc allocator_type;
#pragma empty_line
typedef typename _Alloc::value_type value_type;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
using pointer = __detected_or_t<value_type*, __pointer, _Alloc>;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
using const_pointer
= __detected_or_t<__ptr_rebind<pointer, const value_type>,
__c_pointer, _Alloc>;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
using void_pointer
= __detected_or_t<__ptr_rebind<pointer, void>, __v_pointer, _Alloc>;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
using const_void_pointer
= __detected_or_t<__ptr_rebind<pointer, const void>, __cv_pointer,
_Alloc>;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
using difference_type
= __detected_or_t<typename pointer_traits<pointer>::difference_type,
__diff_type, _Alloc>;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
using size_type
= __detected_or_t<typename make_unsigned<difference_type>::type,
__size_type, _Alloc>;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
using propagate_on_container_copy_assignment
= __detected_or_t<false_type, __pocca, _Alloc>;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
using propagate_on_container_move_assignment
= __detected_or_t<false_type, __pocma, _Alloc>;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
using propagate_on_container_swap
= __detected_or_t<false_type, __pocs, _Alloc>;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
using is_always_equal
= __detected_or_t<typename is_empty<_Alloc>::type, __equal, _Alloc>;
#pragma empty_line
template<typename _Tp>
using rebind_alloc = __alloc_rebind<_Alloc, _Tp>;
template<typename _Tp>
using rebind_traits = allocator_traits<rebind_alloc<_Tp>>;
#pragma empty_line
static_assert(!is_same<rebind_alloc<value_type>, __undefined>::value,
"allocator defines rebind or is like Alloc<T, Args>");
#pragma empty_line
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); }
#pragma empty_line
template<typename _Alloc2>
static pointer
_S_allocate(_Alloc2& __a, size_type __n, const_void_pointer, ...)
{ return __a.allocate(__n); }
#pragma empty_line
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);
#pragma empty_line
template<typename>
static false_type __test(...);
#pragma empty_line
using type = decltype(__test<_Alloc>(0));
};
#pragma empty_line
template<typename _Tp, typename... _Args>
using __has_construct
= typename __construct_helper<_Tp, _Args...>::type;
#pragma empty_line
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)...); }
#pragma empty_line
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)...); }
#pragma empty_line
template<typename _Alloc2, typename _Tp>
static auto
_S_destroy(_Alloc2& __a, _Tp* __p, int)
-> decltype(__a.destroy(__p))
{ __a.destroy(__p); }
#pragma empty_line
template<typename _Alloc2, typename _Tp>
static void
_S_destroy(_Alloc2&, _Tp* __p, ...)
{ __p->~_Tp(); }
#pragma empty_line
template<typename _Alloc2>
static auto
_S_max_size(_Alloc2& __a, int)
-> decltype(__a.max_size())
{ return __a.max_size(); }
#pragma empty_line
template<typename _Alloc2>
static size_type
_S_max_size(_Alloc2&, ...)
{
#pragma empty_line
#pragma empty_line
return __gnu_cxx::__numeric_traits<size_type>::__max
/ sizeof(value_type);
}
#pragma empty_line
template<typename _Alloc2>
static auto
_S_select(_Alloc2& __a, int)
-> decltype(__a.select_on_container_copy_construction())
{ return __a.select_on_container_copy_construction(); }
#pragma empty_line
template<typename _Alloc2>
static _Alloc2
_S_select(_Alloc2& __a, ...)
{ return __a; }
#pragma empty_line
public:
#pragma line 279 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 294 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 306 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 321 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)...); }
#pragma line 334 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 346 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 357 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
};
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct allocator_traits<allocator<_Tp>>
{
#pragma empty_line
using allocator_type = allocator<_Tp>;
#pragma empty_line
using value_type = _Tp;
#pragma empty_line
#pragma empty_line
using pointer = _Tp*;
#pragma empty_line
#pragma empty_line
using const_pointer = const _Tp*;
#pragma empty_line
#pragma empty_line
using void_pointer = void*;
#pragma empty_line
#pragma empty_line
using const_void_pointer = const void*;
#pragma empty_line
#pragma empty_line
using difference_type = std::ptrdiff_t;
#pragma empty_line
#pragma empty_line
using size_type = std::size_t;
#pragma empty_line
#pragma empty_line
using propagate_on_container_copy_assignment = false_type;
#pragma empty_line
#pragma empty_line
using propagate_on_container_move_assignment = true_type;
#pragma empty_line
#pragma empty_line
using propagate_on_container_swap = false_type;
#pragma empty_line
#pragma empty_line
using is_always_equal = true_type;
#pragma empty_line
template<typename _Up>
using rebind_alloc = allocator<_Up>;
#pragma empty_line
template<typename _Up>
using rebind_traits = allocator_traits<allocator<_Up>>;
#pragma line 414 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 428 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 440 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 452 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)...); }
#pragma line 464 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static size_type
max_size(const allocator_type& __a) noexcept
{ return __a.max_size(); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static allocator_type
select_on_container_copy_construction(const allocator_type& __rhs)
{ return __rhs; }
};
#pragma empty_line
#pragma empty_line
template<typename _Alloc>
inline void
__do_alloc_on_copy(_Alloc& __one, const _Alloc& __two, true_type)
{ __one = __two; }
#pragma empty_line
template<typename _Alloc>
inline void
__do_alloc_on_copy(_Alloc&, const _Alloc&, false_type)
{ }
#pragma empty_line
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());
}
#pragma empty_line
template<typename _Alloc>
inline _Alloc __alloc_on_copy(const _Alloc& __a)
{
typedef allocator_traits<_Alloc> __traits;
return __traits::select_on_container_copy_construction(__a);
}
#pragma empty_line
template<typename _Alloc>
inline void __do_alloc_on_move(_Alloc& __one, _Alloc& __two, true_type)
{ __one = std::move(__two); }
#pragma empty_line
template<typename _Alloc>
inline void __do_alloc_on_move(_Alloc&, _Alloc&, false_type)
{ }
#pragma empty_line
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());
}
#pragma empty_line
template<typename _Alloc>
inline void __do_alloc_on_swap(_Alloc& __one, _Alloc& __two, true_type)
{
using std::swap;
swap(__one, __two);
}
#pragma empty_line
template<typename _Alloc>
inline void __do_alloc_on_swap(_Alloc&, _Alloc&, false_type)
{ }
#pragma empty_line
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());
}
#pragma empty_line
template<typename _Alloc>
class __is_copy_insertable_impl
{
typedef allocator_traits<_Alloc> _Traits;
#pragma empty_line
template<typename _Up, typename
= decltype(_Traits::construct(std::declval<_Alloc&>(),
std::declval<_Up*>(),
std::declval<const _Up&>()))>
static true_type
_M_select(int);
#pragma empty_line
template<typename _Up>
static false_type
_M_select(...);
#pragma empty_line
public:
typedef decltype(_M_select<typename _Alloc::value_type>(0)) type;
};
#pragma empty_line
#pragma empty_line
template<typename _Alloc>
struct __is_copy_insertable
: __is_copy_insertable_impl<_Alloc>::type
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct __is_copy_insertable<allocator<_Tp>>
: is_copy_constructible<_Tp>
{ };
#pragma empty_line
#pragma empty_line
}
#pragma line 37 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/alloc_traits.h" 2 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Alloc>
struct __alloc_traits
#pragma empty_line
: std::allocator_traits<_Alloc>
#pragma empty_line
{
typedef _Alloc allocator_type;
#pragma empty_line
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;
#pragma empty_line
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;
#pragma empty_line
private:
template<typename _Ptr>
using __is_custom_pointer
= std::__and_<std::is_same<pointer, _Ptr>,
std::__not_<std::is_pointer<_Ptr>>>;
#pragma empty_line
public:
#pragma empty_line
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)...);
}
#pragma empty_line
#pragma empty_line
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)); }
#pragma empty_line
static _Alloc _S_select_on_copy(const _Alloc& __a)
{ return _Base_type::select_on_container_copy_construction(__a); }
#pragma empty_line
static void _S_on_swap(_Alloc& __a, _Alloc& __b)
{ std::__alloc_on_swap(__a, __b); }
#pragma empty_line
static constexpr bool _S_propagate_on_copy_assign()
{ return _Base_type::propagate_on_container_copy_assignment::value; }
#pragma empty_line
static constexpr bool _S_propagate_on_move_assign()
{ return _Base_type::propagate_on_container_move_assignment::value; }
#pragma empty_line
static constexpr bool _S_propagate_on_swap()
{ return _Base_type::propagate_on_container_swap::value; }
#pragma empty_line
static constexpr bool _S_always_equal()
{ return _Base_type::is_always_equal::value; }
#pragma empty_line
static constexpr bool _S_nothrow_move()
{ return _S_propagate_on_move_assign() || _S_always_equal(); }
#pragma empty_line
template<typename _Tp>
struct rebind
{ typedef typename _Base_type::template rebind_alloc<_Tp> other; };
#pragma line 158 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/alloc_traits.h" 3
};
#pragma empty_line
#pragma empty_line
}
#pragma line 62 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_construct.h" 2 3
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _T1, typename... _Args>
inline void
_Construct(_T1* __p, _Args&&... __args)
{ ::new(static_cast<void*>(__p)) _T1(std::forward<_Args>(__args)...); }
#pragma line 90 "/home/justin/jhai/Xilinx/Vivado/2018.3/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(); }
#pragma empty_line
template<bool>
struct _Destroy_aux
{
template<typename _ForwardIterator>
static void
__destroy(_ForwardIterator __first, _ForwardIterator __last)
{
for (; __first != __last; ++__first)
std::_Destroy(std::__addressof(*__first));
}
};
#pragma empty_line
template<>
struct _Destroy_aux<true>
{
template<typename _ForwardIterator>
static void
__destroy(_ForwardIterator, _ForwardIterator) { }
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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));
}
#pragma empty_line
template<typename _ForwardIterator, typename _Tp>
inline void
_Destroy(_ForwardIterator __first, _ForwardIterator __last,
allocator<_Tp>&)
{
_Destroy(__first, __last);
}
#pragma empty_line
#pragma empty_line
}
#pragma line 63 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/deque" 2 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_uninitialized.h" 1 3
#pragma line 59 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_uninitialized.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
template<bool _TrivialValueTypes>
struct __uninitialized_copy
{
template<typename _InputIterator, typename _ForwardIterator>
static _ForwardIterator
__uninit_copy(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result)
{
_ForwardIterator __cur = __result;
try
{
for (; __first != __last; ++__first, (void)++__cur)
std::_Construct(std::__addressof(*__cur), *__first);
return __cur;
}
catch(...)
{
std::_Destroy(__result, __cur);
throw;
}
}
};
#pragma empty_line
template<>
struct __uninitialized_copy<true>
{
template<typename _InputIterator, typename _ForwardIterator>
static _ForwardIterator
__uninit_copy(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result)
{ return std::copy(__first, __last, __result); }
};
#pragma line 105 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_uninitialized.h" 3
template<typename _InputIterator, typename _ForwardIterator>
inline _ForwardIterator
uninitialized_copy(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result)
{
typedef typename iterator_traits<_InputIterator>::value_type
_ValueType1;
typedef typename iterator_traits<_ForwardIterator>::value_type
_ValueType2;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef typename iterator_traits<_InputIterator>::reference _RefType1;
typedef typename iterator_traits<_ForwardIterator>::reference _RefType2;
const bool __assignable = is_assignable<_RefType2, _RefType1>::value;
#pragma empty_line
#pragma empty_line
return std::__uninitialized_copy<__is_trivial(_ValueType1)
&& __is_trivial(_ValueType2)
&& __assignable>::
__uninit_copy(__first, __last, __result);
}
#pragma empty_line
#pragma empty_line
template<bool _TrivialValueType>
struct __uninitialized_fill
{
template<typename _ForwardIterator, typename _Tp>
static void
__uninit_fill(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __x)
{
_ForwardIterator __cur = __first;
try
{
for (; __cur != __last; ++__cur)
std::_Construct(std::__addressof(*__cur), __x);
}
catch(...)
{
std::_Destroy(__first, __cur);
throw;
}
}
};
#pragma empty_line
template<>
struct __uninitialized_fill<true>
{
template<typename _ForwardIterator, typename _Tp>
static void
__uninit_fill(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __x)
{ std::fill(__first, __last, __x); }
};
#pragma line 171 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_uninitialized.h" 3
template<typename _ForwardIterator, typename _Tp>
inline void
uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __x)
{
typedef typename iterator_traits<_ForwardIterator>::value_type
_ValueType;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
const bool __assignable = is_copy_assignable<_ValueType>::value;
#pragma empty_line
#pragma empty_line
std::__uninitialized_fill<__is_trivial(_ValueType) && __assignable>::
__uninit_fill(__first, __last, __x);
}
#pragma empty_line
#pragma empty_line
template<bool _TrivialValueType>
struct __uninitialized_fill_n
{
template<typename _ForwardIterator, typename _Size, typename _Tp>
static _ForwardIterator
__uninit_fill_n(_ForwardIterator __first, _Size __n,
const _Tp& __x)
{
_ForwardIterator __cur = __first;
try
{
for (; __n > 0; --__n, ++__cur)
std::_Construct(std::__addressof(*__cur), __x);
return __cur;
}
catch(...)
{
std::_Destroy(__first, __cur);
throw;
}
}
};
#pragma empty_line
template<>
struct __uninitialized_fill_n<true>
{
template<typename _ForwardIterator, typename _Size, typename _Tp>
static _ForwardIterator
__uninit_fill_n(_ForwardIterator __first, _Size __n,
const _Tp& __x)
{ return std::fill_n(__first, __n, __x); }
};
#pragma line 234 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_uninitialized.h" 3
template<typename _ForwardIterator, typename _Size, typename _Tp>
inline _ForwardIterator
uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x)
{
typedef typename iterator_traits<_ForwardIterator>::value_type
_ValueType;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
const bool __assignable = is_copy_assignable<_ValueType>::value;
#pragma empty_line
return __uninitialized_fill_n<__is_trivial(_ValueType) && __assignable>::
__uninit_fill_n(__first, __n, __x);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _InputIterator, typename _ForwardIterator,
typename _Allocator>
_ForwardIterator
__uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result, _Allocator& __alloc)
{
_ForwardIterator __cur = __result;
try
{
typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
for (; __first != __last; ++__first, (void)++__cur)
__traits::construct(__alloc, std::__addressof(*__cur), *__first);
return __cur;
}
catch(...)
{
std::_Destroy(__result, __cur, __alloc);
throw;
}
}
#pragma empty_line
template<typename _InputIterator, typename _ForwardIterator, typename _Tp>
inline _ForwardIterator
__uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result, allocator<_Tp>&)
{ return std::uninitialized_copy(__first, __last, __result); }
#pragma empty_line
template<typename _InputIterator, typename _ForwardIterator,
typename _Allocator>
inline _ForwardIterator
__uninitialized_move_a(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result, _Allocator& __alloc)
{
return std::__uninitialized_copy_a(std::make_move_iterator(__first),
std::make_move_iterator(__last),
__result, __alloc);
}
#pragma empty_line
template<typename _InputIterator, typename _ForwardIterator,
typename _Allocator>
inline _ForwardIterator
__uninitialized_move_if_noexcept_a(_InputIterator __first,
_InputIterator __last,
_ForwardIterator __result,
_Allocator& __alloc)
{
return std::__uninitialized_copy_a
(std::__make_move_if_noexcept_iterator(__first),
std::__make_move_if_noexcept_iterator(__last), __result, __alloc);
}
#pragma empty_line
template<typename _ForwardIterator, typename _Tp, typename _Allocator>
void
__uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __x, _Allocator& __alloc)
{
_ForwardIterator __cur = __first;
try
{
typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
for (; __cur != __last; ++__cur)
__traits::construct(__alloc, std::__addressof(*__cur), __x);
}
catch(...)
{
std::_Destroy(__first, __cur, __alloc);
throw;
}
}
#pragma empty_line
template<typename _ForwardIterator, typename _Tp, typename _Tp2>
inline void
__uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __x, allocator<_Tp2>&)
{ std::uninitialized_fill(__first, __last, __x); }
#pragma empty_line
template<typename _ForwardIterator, typename _Size, typename _Tp,
typename _Allocator>
_ForwardIterator
__uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
const _Tp& __x, _Allocator& __alloc)
{
_ForwardIterator __cur = __first;
try
{
typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
for (; __n > 0; --__n, ++__cur)
__traits::construct(__alloc, std::__addressof(*__cur), __x);
return __cur;
}
catch(...)
{
std::_Destroy(__first, __cur, __alloc);
throw;
}
}
#pragma empty_line
template<typename _ForwardIterator, typename _Size, typename _Tp,
typename _Tp2>
inline _ForwardIterator
__uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
const _Tp& __x, allocator<_Tp2>&)
{ return std::uninitialized_fill_n(__first, __n, __x); }
#pragma line 370 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_uninitialized.h" 3
template<typename _InputIterator1, typename _InputIterator2,
typename _ForwardIterator, typename _Allocator>
inline _ForwardIterator
__uninitialized_copy_move(_InputIterator1 __first1,
_InputIterator1 __last1,
_InputIterator2 __first2,
_InputIterator2 __last2,
_ForwardIterator __result,
_Allocator& __alloc)
{
_ForwardIterator __mid = std::__uninitialized_copy_a(__first1, __last1,
__result,
__alloc);
try
{
return std::__uninitialized_move_a(__first2, __last2, __mid, __alloc);
}
catch(...)
{
std::_Destroy(__result, __mid, __alloc);
throw;
}
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _InputIterator1, typename _InputIterator2,
typename _ForwardIterator, typename _Allocator>
inline _ForwardIterator
__uninitialized_move_copy(_InputIterator1 __first1,
_InputIterator1 __last1,
_InputIterator2 __first2,
_InputIterator2 __last2,
_ForwardIterator __result,
_Allocator& __alloc)
{
_ForwardIterator __mid = std::__uninitialized_move_a(__first1, __last1,
__result,
__alloc);
try
{
return std::__uninitialized_copy_a(__first2, __last2, __mid, __alloc);
}
catch(...)
{
std::_Destroy(__result, __mid, __alloc);
throw;
}
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _ForwardIterator, typename _Tp, typename _InputIterator,
typename _Allocator>
inline _ForwardIterator
__uninitialized_fill_move(_ForwardIterator __result, _ForwardIterator __mid,
const _Tp& __x, _InputIterator __first,
_InputIterator __last, _Allocator& __alloc)
{
std::__uninitialized_fill_a(__result, __mid, __x, __alloc);
try
{
return std::__uninitialized_move_a(__first, __last, __mid, __alloc);
}
catch(...)
{
std::_Destroy(__result, __mid, __alloc);
throw;
}
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _InputIterator, typename _ForwardIterator, typename _Tp,
typename _Allocator>
inline void
__uninitialized_move_fill(_InputIterator __first1, _InputIterator __last1,
_ForwardIterator __first2,
_ForwardIterator __last2, const _Tp& __x,
_Allocator& __alloc)
{
_ForwardIterator __mid2 = std::__uninitialized_move_a(__first1, __last1,
__first2,
__alloc);
try
{
std::__uninitialized_fill_a(__mid2, __last2, __x, __alloc);
}
catch(...)
{
std::_Destroy(__first2, __mid2, __alloc);
throw;
}
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<bool _TrivialValueType>
struct __uninitialized_default_1
{
template<typename _ForwardIterator>
static void
__uninit_default(_ForwardIterator __first, _ForwardIterator __last)
{
_ForwardIterator __cur = __first;
try
{
for (; __cur != __last; ++__cur)
std::_Construct(std::__addressof(*__cur));
}
catch(...)
{
std::_Destroy(__first, __cur);
throw;
}
}
};
#pragma empty_line
template<>
struct __uninitialized_default_1<true>
{
template<typename _ForwardIterator>
static void
__uninit_default(_ForwardIterator __first, _ForwardIterator __last)
{
typedef typename iterator_traits<_ForwardIterator>::value_type
_ValueType;
#pragma empty_line
std::fill(__first, __last, _ValueType());
}
};
#pragma empty_line
template<bool _TrivialValueType>
struct __uninitialized_default_n_1
{
template<typename _ForwardIterator, typename _Size>
static _ForwardIterator
__uninit_default_n(_ForwardIterator __first, _Size __n)
{
_ForwardIterator __cur = __first;
try
{
for (; __n > 0; --__n, ++__cur)
std::_Construct(std::__addressof(*__cur));
return __cur;
}
catch(...)
{
std::_Destroy(__first, __cur);
throw;
}
}
};
#pragma empty_line
template<>
struct __uninitialized_default_n_1<true>
{
template<typename _ForwardIterator, typename _Size>
static _ForwardIterator
__uninit_default_n(_ForwardIterator __first, _Size __n)
{
typedef typename iterator_traits<_ForwardIterator>::value_type
_ValueType;
#pragma empty_line
return std::fill_n(__first, __n, _ValueType());
}
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _ForwardIterator>
inline void
__uninitialized_default(_ForwardIterator __first,
_ForwardIterator __last)
{
typedef typename iterator_traits<_ForwardIterator>::value_type
_ValueType;
#pragma empty_line
const bool __assignable = is_copy_assignable<_ValueType>::value;
#pragma empty_line
std::__uninitialized_default_1<__is_trivial(_ValueType)
&& __assignable>::
__uninit_default(__first, __last);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _ForwardIterator, typename _Size>
inline _ForwardIterator
__uninitialized_default_n(_ForwardIterator __first, _Size __n)
{
typedef typename iterator_traits<_ForwardIterator>::value_type
_ValueType;
#pragma empty_line
const bool __assignable = is_copy_assignable<_ValueType>::value;
#pragma empty_line
return __uninitialized_default_n_1<__is_trivial(_ValueType)
&& __assignable>::
__uninit_default_n(__first, __n);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _ForwardIterator, typename _Allocator>
void
__uninitialized_default_a(_ForwardIterator __first,
_ForwardIterator __last,
_Allocator& __alloc)
{
_ForwardIterator __cur = __first;
try
{
typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
for (; __cur != __last; ++__cur)
__traits::construct(__alloc, std::__addressof(*__cur));
}
catch(...)
{
std::_Destroy(__first, __cur, __alloc);
throw;
}
}
#pragma empty_line
template<typename _ForwardIterator, typename _Tp>
inline void
__uninitialized_default_a(_ForwardIterator __first,
_ForwardIterator __last,
allocator<_Tp>&)
{ std::__uninitialized_default(__first, __last); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _ForwardIterator, typename _Size, typename _Allocator>
_ForwardIterator
__uninitialized_default_n_a(_ForwardIterator __first, _Size __n,
_Allocator& __alloc)
{
_ForwardIterator __cur = __first;
try
{
typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
for (; __n > 0; --__n, ++__cur)
__traits::construct(__alloc, std::__addressof(*__cur));
return __cur;
}
catch(...)
{
std::_Destroy(__first, __cur, __alloc);
throw;
}
}
#pragma empty_line
template<typename _ForwardIterator, typename _Size, typename _Tp>
inline _ForwardIterator
__uninitialized_default_n_a(_ForwardIterator __first, _Size __n,
allocator<_Tp>&)
{ return std::__uninitialized_default_n(__first, __n); }
#pragma empty_line
#pragma empty_line
template<typename _InputIterator, typename _Size,
typename _ForwardIterator>
_ForwardIterator
__uninitialized_copy_n(_InputIterator __first, _Size __n,
_ForwardIterator __result, input_iterator_tag)
{
_ForwardIterator __cur = __result;
try
{
for (; __n > 0; --__n, ++__first, ++__cur)
std::_Construct(std::__addressof(*__cur), *__first);
return __cur;
}
catch(...)
{
std::_Destroy(__result, __cur);
throw;
}
}
#pragma empty_line
template<typename _RandomAccessIterator, typename _Size,
typename _ForwardIterator>
inline _ForwardIterator
__uninitialized_copy_n(_RandomAccessIterator __first, _Size __n,
_ForwardIterator __result,
random_access_iterator_tag)
{ return std::uninitialized_copy(__first, __first + __n, __result); }
#pragma line 677 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_uninitialized.h" 3
template<typename _InputIterator, typename _Size, typename _ForwardIterator>
inline _ForwardIterator
uninitialized_copy_n(_InputIterator __first, _Size __n,
_ForwardIterator __result)
{ return std::__uninitialized_copy_n(__first, __n, __result,
std::__iterator_category(__first)); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 64 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/deque" 2 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 1 3
#pragma line 63 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/initializer_list" 1 3
#pragma line 33 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/initializer_list" 3
#pragma empty_line
#pragma line 34 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/initializer_list" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma GCC visibility push(default)
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std
{
#pragma empty_line
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;
#pragma empty_line
private:
iterator _M_array;
size_type _M_len;
#pragma empty_line
#pragma empty_line
constexpr initializer_list(const_iterator __a, size_type __l)
: _M_array(__a), _M_len(__l) { }
#pragma empty_line
public:
constexpr initializer_list() noexcept
: _M_array(0), _M_len(0) { }
#pragma empty_line
#pragma empty_line
constexpr size_type
size() const noexcept { return _M_len; }
#pragma empty_line
#pragma empty_line
constexpr const_iterator
begin() const noexcept { return _M_array; }
#pragma empty_line
#pragma empty_line
constexpr const_iterator
end() const noexcept { return begin() + size(); }
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<class _Tp>
constexpr const _Tp*
begin(initializer_list<_Tp> __ils) noexcept
{ return __ils.begin(); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<class _Tp>
constexpr const _Tp*
end(initializer_list<_Tp> __ils) noexcept
{ return __ils.end(); }
}
#pragma empty_line
#pragma GCC visibility pop
#pragma line 64 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 2 3
#pragma empty_line
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma line 88 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
constexpr inline size_t
__deque_buf_size(size_t __size)
{ return (__size < 512
? size_t(512 / __size) : size_t(1)); }
#pragma line 105 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
template<typename _Tp, typename _Ref, typename _Ptr>
struct _Deque_iterator
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
private:
template<typename _Up>
using __ptr_to = typename pointer_traits<_Ptr>::template rebind<_Up>;
template<typename _CvTp>
using __iter = _Deque_iterator<_Tp, _CvTp&, __ptr_to<_CvTp>>;
public:
typedef __iter<_Tp> iterator;
typedef __iter<const _Tp> const_iterator;
typedef __ptr_to<_Tp> _Elt_pointer;
typedef __ptr_to<_Elt_pointer> _Map_pointer;
#pragma empty_line
#pragma empty_line
static size_t _S_buffer_size() noexcept
{ return __deque_buf_size(sizeof(_Tp)); }
#pragma empty_line
typedef std::random_access_iterator_tag iterator_category;
typedef _Tp value_type;
typedef _Ptr pointer;
typedef _Ref reference;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef _Deque_iterator _Self;
#pragma empty_line
_Elt_pointer _M_cur;
_Elt_pointer _M_first;
_Elt_pointer _M_last;
_Map_pointer _M_node;
#pragma empty_line
_Deque_iterator(_Elt_pointer __x, _Map_pointer __y) noexcept
: _M_cur(__x), _M_first(*__y),
_M_last(*__y + _S_buffer_size()), _M_node(__y) { }
#pragma empty_line
_Deque_iterator() noexcept
: _M_cur(), _M_first(), _M_last(), _M_node() { }
#pragma empty_line
_Deque_iterator(const iterator& __x) noexcept
: _M_cur(__x._M_cur), _M_first(__x._M_first),
_M_last(__x._M_last), _M_node(__x._M_node) { }
#pragma empty_line
iterator
_M_const_cast() const noexcept
{ return iterator(_M_cur, _M_node); }
#pragma empty_line
reference
operator*() const noexcept
{ return *_M_cur; }
#pragma empty_line
pointer
operator->() const noexcept
{ return _M_cur; }
#pragma empty_line
_Self&
operator++() noexcept
{
++_M_cur;
if (_M_cur == _M_last)
{
_M_set_node(_M_node + 1);
_M_cur = _M_first;
}
return *this;
}
#pragma empty_line
_Self
operator++(int) noexcept
{
_Self __tmp = *this;
++*this;
return __tmp;
}
#pragma empty_line
_Self&
operator--() noexcept
{
if (_M_cur == _M_first)
{
_M_set_node(_M_node - 1);
_M_cur = _M_last;
}
--_M_cur;
return *this;
}
#pragma empty_line
_Self
operator--(int) noexcept
{
_Self __tmp = *this;
--*this;
return __tmp;
}
#pragma empty_line
_Self&
operator+=(difference_type __n) noexcept
{
const difference_type __offset = __n + (_M_cur - _M_first);
if (__offset >= 0 && __offset < difference_type(_S_buffer_size()))
_M_cur += __n;
else
{
const difference_type __node_offset =
__offset > 0 ? __offset / difference_type(_S_buffer_size())
: -difference_type((-__offset - 1)
/ _S_buffer_size()) - 1;
_M_set_node(_M_node + __node_offset);
_M_cur = _M_first + (__offset - __node_offset
* difference_type(_S_buffer_size()));
}
return *this;
}
#pragma empty_line
_Self
operator+(difference_type __n) const noexcept
{
_Self __tmp = *this;
return __tmp += __n;
}
#pragma empty_line
_Self&
operator-=(difference_type __n) noexcept
{ return *this += -__n; }
#pragma empty_line
_Self
operator-(difference_type __n) const noexcept
{
_Self __tmp = *this;
return __tmp -= __n;
}
#pragma empty_line
reference
operator[](difference_type __n) const noexcept
{ return *(*this + __n); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
void
_M_set_node(_Map_pointer __new_node) noexcept
{
_M_node = __new_node;
_M_first = *__new_node;
_M_last = _M_first + difference_type(_S_buffer_size());
}
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename _Ref, typename _Ptr>
inline bool
operator==(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) noexcept
{ return __x._M_cur == __y._M_cur; }
#pragma empty_line
template<typename _Tp, typename _RefL, typename _PtrL,
typename _RefR, typename _PtrR>
inline bool
operator==(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) noexcept
{ return __x._M_cur == __y._M_cur; }
#pragma empty_line
template<typename _Tp, typename _Ref, typename _Ptr>
inline bool
operator!=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) noexcept
{ return !(__x == __y); }
#pragma empty_line
template<typename _Tp, typename _RefL, typename _PtrL,
typename _RefR, typename _PtrR>
inline bool
operator!=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) noexcept
{ return !(__x == __y); }
#pragma empty_line
template<typename _Tp, typename _Ref, typename _Ptr>
inline bool
operator<(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) noexcept
{ return (__x._M_node == __y._M_node) ? (__x._M_cur < __y._M_cur)
: (__x._M_node < __y._M_node); }
#pragma empty_line
template<typename _Tp, typename _RefL, typename _PtrL,
typename _RefR, typename _PtrR>
inline bool
operator<(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) noexcept
{ return (__x._M_node == __y._M_node) ? (__x._M_cur < __y._M_cur)
: (__x._M_node < __y._M_node); }
#pragma empty_line
template<typename _Tp, typename _Ref, typename _Ptr>
inline bool
operator>(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) noexcept
{ return __y < __x; }
#pragma empty_line
template<typename _Tp, typename _RefL, typename _PtrL,
typename _RefR, typename _PtrR>
inline bool
operator>(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) noexcept
{ return __y < __x; }
#pragma empty_line
template<typename _Tp, typename _Ref, typename _Ptr>
inline bool
operator<=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) noexcept
{ return !(__y < __x); }
#pragma empty_line
template<typename _Tp, typename _RefL, typename _PtrL,
typename _RefR, typename _PtrR>
inline bool
operator<=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) noexcept
{ return !(__y < __x); }
#pragma empty_line
template<typename _Tp, typename _Ref, typename _Ptr>
inline bool
operator>=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) noexcept
{ return !(__x < __y); }
#pragma empty_line
template<typename _Tp, typename _RefL, typename _PtrL,
typename _RefR, typename _PtrR>
inline bool
operator>=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) noexcept
{ return !(__x < __y); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename _Ref, typename _Ptr>
inline typename _Deque_iterator<_Tp, _Ref, _Ptr>::difference_type
operator-(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) noexcept
{
return typename _Deque_iterator<_Tp, _Ref, _Ptr>::difference_type
(_Deque_iterator<_Tp, _Ref, _Ptr>::_S_buffer_size())
* (__x._M_node - __y._M_node - 1) + (__x._M_cur - __x._M_first)
+ (__y._M_last - __y._M_cur);
}
#pragma empty_line
template<typename _Tp, typename _RefL, typename _PtrL,
typename _RefR, typename _PtrR>
inline typename _Deque_iterator<_Tp, _RefL, _PtrL>::difference_type
operator-(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) noexcept
{
return typename _Deque_iterator<_Tp, _RefL, _PtrL>::difference_type
(_Deque_iterator<_Tp, _RefL, _PtrL>::_S_buffer_size())
* (__x._M_node - __y._M_node - 1) + (__x._M_cur - __x._M_first)
+ (__y._M_last - __y._M_cur);
}
#pragma empty_line
template<typename _Tp, typename _Ref, typename _Ptr>
inline _Deque_iterator<_Tp, _Ref, _Ptr>
operator+(ptrdiff_t __n, const _Deque_iterator<_Tp, _Ref, _Ptr>& __x)
noexcept
{ return __x + __n; }
#pragma empty_line
template<typename _Tp>
void
fill(const _Deque_iterator<_Tp, _Tp&, _Tp*>&,
const _Deque_iterator<_Tp, _Tp&, _Tp*>&, const _Tp&);
#pragma empty_line
template<typename _Tp>
_Deque_iterator<_Tp, _Tp&, _Tp*>
copy(_Deque_iterator<_Tp, const _Tp&, const _Tp*>,
_Deque_iterator<_Tp, const _Tp&, const _Tp*>,
_Deque_iterator<_Tp, _Tp&, _Tp*>);
#pragma empty_line
template<typename _Tp>
inline _Deque_iterator<_Tp, _Tp&, _Tp*>
copy(_Deque_iterator<_Tp, _Tp&, _Tp*> __first,
_Deque_iterator<_Tp, _Tp&, _Tp*> __last,
_Deque_iterator<_Tp, _Tp&, _Tp*> __result)
{ return std::copy(_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__first),
_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__last),
__result); }
#pragma empty_line
template<typename _Tp>
_Deque_iterator<_Tp, _Tp&, _Tp*>
copy_backward(_Deque_iterator<_Tp, const _Tp&, const _Tp*>,
_Deque_iterator<_Tp, const _Tp&, const _Tp*>,
_Deque_iterator<_Tp, _Tp&, _Tp*>);
#pragma empty_line
template<typename _Tp>
inline _Deque_iterator<_Tp, _Tp&, _Tp*>
copy_backward(_Deque_iterator<_Tp, _Tp&, _Tp*> __first,
_Deque_iterator<_Tp, _Tp&, _Tp*> __last,
_Deque_iterator<_Tp, _Tp&, _Tp*> __result)
{ return std::copy_backward(_Deque_iterator<_Tp,
const _Tp&, const _Tp*>(__first),
_Deque_iterator<_Tp,
const _Tp&, const _Tp*>(__last),
__result); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
_Deque_iterator<_Tp, _Tp&, _Tp*>
move(_Deque_iterator<_Tp, const _Tp&, const _Tp*>,
_Deque_iterator<_Tp, const _Tp&, const _Tp*>,
_Deque_iterator<_Tp, _Tp&, _Tp*>);
#pragma empty_line
template<typename _Tp>
inline _Deque_iterator<_Tp, _Tp&, _Tp*>
move(_Deque_iterator<_Tp, _Tp&, _Tp*> __first,
_Deque_iterator<_Tp, _Tp&, _Tp*> __last,
_Deque_iterator<_Tp, _Tp&, _Tp*> __result)
{ return std::move(_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__first),
_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__last),
__result); }
#pragma empty_line
template<typename _Tp>
_Deque_iterator<_Tp, _Tp&, _Tp*>
move_backward(_Deque_iterator<_Tp, const _Tp&, const _Tp*>,
_Deque_iterator<_Tp, const _Tp&, const _Tp*>,
_Deque_iterator<_Tp, _Tp&, _Tp*>);
#pragma empty_line
template<typename _Tp>
inline _Deque_iterator<_Tp, _Tp&, _Tp*>
move_backward(_Deque_iterator<_Tp, _Tp&, _Tp*> __first,
_Deque_iterator<_Tp, _Tp&, _Tp*> __last,
_Deque_iterator<_Tp, _Tp&, _Tp*> __result)
{ return std::move_backward(_Deque_iterator<_Tp,
const _Tp&, const _Tp*>(__first),
_Deque_iterator<_Tp,
const _Tp&, const _Tp*>(__last),
__result); }
#pragma line 457 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
template<typename _Tp, typename _Alloc>
class _Deque_base
{
protected:
typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
rebind<_Tp>::other _Tp_alloc_type;
typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Alloc_traits;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef typename _Alloc_traits::pointer _Ptr;
typedef typename _Alloc_traits::const_pointer _Ptr_const;
#pragma empty_line
#pragma empty_line
typedef typename _Alloc_traits::template rebind<_Ptr>::other
_Map_alloc_type;
typedef __gnu_cxx::__alloc_traits<_Map_alloc_type> _Map_alloc_traits;
#pragma empty_line
public:
typedef _Alloc allocator_type;
typedef typename _Alloc_traits::size_type size_type;
#pragma empty_line
allocator_type
get_allocator() const noexcept
{ return allocator_type(_M_get_Tp_allocator()); }
#pragma empty_line
typedef _Deque_iterator<_Tp, _Tp&, _Ptr> iterator;
typedef _Deque_iterator<_Tp, const _Tp&, _Ptr_const> const_iterator;
#pragma empty_line
_Deque_base()
: _M_impl()
{ _M_initialize_map(0); }
#pragma empty_line
_Deque_base(size_t __num_elements)
: _M_impl()
{ _M_initialize_map(__num_elements); }
#pragma empty_line
_Deque_base(const allocator_type& __a, size_t __num_elements)
: _M_impl(__a)
{ _M_initialize_map(__num_elements); }
#pragma empty_line
_Deque_base(const allocator_type& __a)
: _M_impl(__a)
{ }
#pragma empty_line
#pragma empty_line
_Deque_base(_Deque_base&& __x, false_type)
: _M_impl(__x._M_move_impl())
{ }
#pragma empty_line
_Deque_base(_Deque_base&& __x, true_type)
: _M_impl(std::move(__x._M_get_Tp_allocator()))
{
_M_initialize_map(0);
if (__x._M_impl._M_map)
this->_M_impl._M_swap_data(__x._M_impl);
}
#pragma empty_line
_Deque_base(_Deque_base&& __x)
: _Deque_base(std::move(__x), typename _Alloc_traits::is_always_equal{})
{ }
#pragma empty_line
_Deque_base(_Deque_base&& __x, const allocator_type& __a, size_type __n)
: _M_impl(__a)
{
if (__x.get_allocator() == __a)
{
if (__x._M_impl._M_map)
{
_M_initialize_map(0);
this->_M_impl._M_swap_data(__x._M_impl);
}
}
else
{
_M_initialize_map(__n);
}
}
#pragma empty_line
#pragma empty_line
~_Deque_base() noexcept;
#pragma empty_line
protected:
typedef typename iterator::_Map_pointer _Map_pointer;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
struct _Deque_impl
: public _Tp_alloc_type
{
_Map_pointer _M_map;
size_t _M_map_size;
iterator _M_start;
iterator _M_finish;
#pragma empty_line
_Deque_impl()
: _Tp_alloc_type(), _M_map(), _M_map_size(0),
_M_start(), _M_finish()
{ }
#pragma empty_line
_Deque_impl(const _Tp_alloc_type& __a) noexcept
: _Tp_alloc_type(__a), _M_map(), _M_map_size(0),
_M_start(), _M_finish()
{ }
#pragma empty_line
#pragma empty_line
_Deque_impl(_Deque_impl&&) = default;
#pragma empty_line
_Deque_impl(_Tp_alloc_type&& __a) noexcept
: _Tp_alloc_type(std::move(__a)), _M_map(), _M_map_size(0),
_M_start(), _M_finish()
{ }
#pragma empty_line
#pragma empty_line
void _M_swap_data(_Deque_impl& __x) noexcept
{
using std::swap;
swap(this->_M_start, __x._M_start);
swap(this->_M_finish, __x._M_finish);
swap(this->_M_map, __x._M_map);
swap(this->_M_map_size, __x._M_map_size);
}
};
#pragma empty_line
_Tp_alloc_type&
_M_get_Tp_allocator() noexcept
{ return *static_cast<_Tp_alloc_type*>(&this->_M_impl); }
#pragma empty_line
const _Tp_alloc_type&
_M_get_Tp_allocator() const noexcept
{ return *static_cast<const _Tp_alloc_type*>(&this->_M_impl); }
#pragma empty_line
_Map_alloc_type
_M_get_map_allocator() const noexcept
{ return _Map_alloc_type(_M_get_Tp_allocator()); }
#pragma empty_line
_Ptr
_M_allocate_node()
{
typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Traits;
return _Traits::allocate(_M_impl, __deque_buf_size(sizeof(_Tp)));
}
#pragma empty_line
void
_M_deallocate_node(_Ptr __p) noexcept
{
typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Traits;
_Traits::deallocate(_M_impl, __p, __deque_buf_size(sizeof(_Tp)));
}
#pragma empty_line
_Map_pointer
_M_allocate_map(size_t __n)
{
_Map_alloc_type __map_alloc = _M_get_map_allocator();
return _Map_alloc_traits::allocate(__map_alloc, __n);
}
#pragma empty_line
void
_M_deallocate_map(_Map_pointer __p, size_t __n) noexcept
{
_Map_alloc_type __map_alloc = _M_get_map_allocator();
_Map_alloc_traits::deallocate(__map_alloc, __p, __n);
}
#pragma empty_line
protected:
void _M_initialize_map(size_t);
void _M_create_nodes(_Map_pointer __nstart, _Map_pointer __nfinish);
void _M_destroy_nodes(_Map_pointer __nstart,
_Map_pointer __nfinish) noexcept;
enum { _S_initial_map_size = 8 };
#pragma empty_line
_Deque_impl _M_impl;
#pragma empty_line
#pragma empty_line
private:
_Deque_impl
_M_move_impl()
{
if (!_M_impl._M_map)
return std::move(_M_impl);
#pragma empty_line
#pragma empty_line
_Tp_alloc_type __alloc{_M_get_Tp_allocator()};
#pragma empty_line
_Tp_alloc_type __sink __attribute((__unused__)) {std::move(__alloc)};
#pragma empty_line
_Deque_base __empty{__alloc};
__empty._M_initialize_map(0);
#pragma empty_line
_Deque_impl __ret{std::move(_M_get_Tp_allocator())};
_M_impl._M_swap_data(__ret);
_M_impl._M_swap_data(__empty._M_impl);
return __ret;
}
#pragma empty_line
};
#pragma empty_line
template<typename _Tp, typename _Alloc>
_Deque_base<_Tp, _Alloc>::
~_Deque_base() noexcept
{
if (this->_M_impl._M_map)
{
_M_destroy_nodes(this->_M_impl._M_start._M_node,
this->_M_impl._M_finish._M_node + 1);
_M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
}
}
#pragma line 677 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
template<typename _Tp, typename _Alloc>
void
_Deque_base<_Tp, _Alloc>::
_M_initialize_map(size_t __num_elements)
{
const size_t __num_nodes = (__num_elements/ __deque_buf_size(sizeof(_Tp))
+ 1);
#pragma empty_line
this->_M_impl._M_map_size = std::max((size_t) _S_initial_map_size,
size_t(__num_nodes + 2));
this->_M_impl._M_map = _M_allocate_map(this->_M_impl._M_map_size);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
_Map_pointer __nstart = (this->_M_impl._M_map
+ (this->_M_impl._M_map_size - __num_nodes) / 2);
_Map_pointer __nfinish = __nstart + __num_nodes;
#pragma empty_line
try
{ _M_create_nodes(__nstart, __nfinish); }
catch(...)
{
_M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
this->_M_impl._M_map = _Map_pointer();
this->_M_impl._M_map_size = 0;
throw;
}
#pragma empty_line
this->_M_impl._M_start._M_set_node(__nstart);
this->_M_impl._M_finish._M_set_node(__nfinish - 1);
this->_M_impl._M_start._M_cur = _M_impl._M_start._M_first;
this->_M_impl._M_finish._M_cur = (this->_M_impl._M_finish._M_first
+ __num_elements
% __deque_buf_size(sizeof(_Tp)));
}
#pragma empty_line
template<typename _Tp, typename _Alloc>
void
_Deque_base<_Tp, _Alloc>::
_M_create_nodes(_Map_pointer __nstart, _Map_pointer __nfinish)
{
_Map_pointer __cur;
try
{
for (__cur = __nstart; __cur < __nfinish; ++__cur)
*__cur = this->_M_allocate_node();
}
catch(...)
{
_M_destroy_nodes(__nstart, __cur);
throw;
}
}
#pragma empty_line
template<typename _Tp, typename _Alloc>
void
_Deque_base<_Tp, _Alloc>::
_M_destroy_nodes(_Map_pointer __nstart,
_Map_pointer __nfinish) noexcept
{
for (_Map_pointer __n = __nstart; __n < __nfinish; ++__n)
_M_deallocate_node(*__n);
}
#pragma line 828 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
class deque : protected _Deque_base<_Tp, _Alloc>
{
#pragma empty_line
typedef typename _Alloc::value_type _Alloc_value_type;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef _Deque_base<_Tp, _Alloc> _Base;
typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
typedef typename _Base::_Alloc_traits _Alloc_traits;
typedef typename _Base::_Map_pointer _Map_pointer;
#pragma empty_line
public:
typedef _Tp value_type;
typedef typename _Alloc_traits::pointer pointer;
typedef typename _Alloc_traits::const_pointer const_pointer;
typedef typename _Alloc_traits::reference reference;
typedef typename _Alloc_traits::const_reference const_reference;
typedef typename _Base::iterator iterator;
typedef typename _Base::const_iterator const_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef _Alloc allocator_type;
#pragma empty_line
protected:
static size_t _S_buffer_size() noexcept
{ return __deque_buf_size(sizeof(_Tp)); }
#pragma empty_line
#pragma empty_line
using _Base::_M_initialize_map;
using _Base::_M_create_nodes;
using _Base::_M_destroy_nodes;
using _Base::_M_allocate_node;
using _Base::_M_deallocate_node;
using _Base::_M_allocate_map;
using _Base::_M_deallocate_map;
using _Base::_M_get_Tp_allocator;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
using _Base::_M_impl;
#pragma empty_line
public:
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
deque() : _Base() { }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
explicit
deque(const allocator_type& __a)
: _Base(__a, 0) { }
#pragma line 903 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
explicit
deque(size_type __n, const allocator_type& __a = allocator_type())
: _Base(__a, __n)
{ _M_default_initialize(); }
#pragma line 916 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
deque(size_type __n, const value_type& __value,
const allocator_type& __a = allocator_type())
: _Base(__a, __n)
{ _M_fill_initialize(__value); }
#pragma line 943 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
deque(const deque& __x)
: _Base(_Alloc_traits::_S_select_on_copy(__x._M_get_Tp_allocator()),
__x.size())
{ std::__uninitialized_copy_a(__x.begin(), __x.end(),
this->_M_impl._M_start,
_M_get_Tp_allocator()); }
#pragma line 958 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
deque(deque&& __x)
: _Base(std::move(__x)) { }
#pragma empty_line
#pragma empty_line
deque(const deque& __x, const allocator_type& __a)
: _Base(__a, __x.size())
{ std::__uninitialized_copy_a(__x.begin(), __x.end(),
this->_M_impl._M_start,
_M_get_Tp_allocator()); }
#pragma empty_line
#pragma empty_line
deque(deque&& __x, const allocator_type& __a)
: _Base(std::move(__x), __a, __x.size())
{
if (__x.get_allocator() != __a)
{
std::__uninitialized_move_a(__x.begin(), __x.end(),
this->_M_impl._M_start,
_M_get_Tp_allocator());
__x.clear();
}
}
#pragma line 992 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
deque(initializer_list<value_type> __l,
const allocator_type& __a = allocator_type())
: _Base(__a)
{
_M_range_initialize(__l.begin(), __l.end(),
random_access_iterator_tag());
}
#pragma line 1017 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
template<typename _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
deque(_InputIterator __first, _InputIterator __last,
const allocator_type& __a = allocator_type())
: _Base(__a)
{ _M_initialize_dispatch(__first, __last, __false_type()); }
#pragma line 1040 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
~deque()
{ _M_destroy_data(begin(), end(), _M_get_Tp_allocator()); }
#pragma line 1050 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
deque&
operator=(const deque& __x);
#pragma line 1062 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
deque&
operator=(deque&& __x) noexcept(_Alloc_traits::_S_always_equal())
{
using __always_equal = typename _Alloc_traits::is_always_equal;
_M_move_assign1(std::move(__x), __always_equal{});
return *this;
}
#pragma line 1081 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
deque&
operator=(initializer_list<value_type> __l)
{
this->assign(__l.begin(), __l.end());
return *this;
}
#pragma line 1099 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
void
assign(size_type __n, const value_type& __val)
{ _M_fill_assign(__n, __val); }
#pragma line 1116 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
template<typename _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
void
assign(_InputIterator __first, _InputIterator __last)
{ _M_assign_dispatch(__first, __last, __false_type()); }
#pragma line 1143 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
void
assign(initializer_list<value_type> __l)
{ this->assign(__l.begin(), __l.end()); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
allocator_type
get_allocator() const noexcept
{ return _Base::get_allocator(); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
iterator
begin() noexcept
{ return this->_M_impl._M_start; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
const_iterator
begin() const noexcept
{ return this->_M_impl._M_start; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
iterator
end() noexcept
{ return this->_M_impl._M_finish; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
const_iterator
end() const noexcept
{ return this->_M_impl._M_finish; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
reverse_iterator
rbegin() noexcept
{ return reverse_iterator(this->_M_impl._M_finish); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
const_reverse_iterator
rbegin() const noexcept
{ return const_reverse_iterator(this->_M_impl._M_finish); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
reverse_iterator
rend() noexcept
{ return reverse_iterator(this->_M_impl._M_start); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
const_reverse_iterator
rend() const noexcept
{ return const_reverse_iterator(this->_M_impl._M_start); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
const_iterator
cbegin() const noexcept
{ return this->_M_impl._M_start; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
const_iterator
cend() const noexcept
{ return this->_M_impl._M_finish; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
const_reverse_iterator
crbegin() const noexcept
{ return const_reverse_iterator(this->_M_impl._M_finish); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
const_reverse_iterator
crend() const noexcept
{ return const_reverse_iterator(this->_M_impl._M_start); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
size_type
size() const noexcept
{ return this->_M_impl._M_finish - this->_M_impl._M_start; }
#pragma empty_line
#pragma empty_line
size_type
max_size() const noexcept
{ return _Alloc_traits::max_size(_M_get_Tp_allocator()); }
#pragma line 1282 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
void
resize(size_type __new_size)
{
const size_type __len = size();
if (__new_size > __len)
_M_default_append(__new_size - __len);
else if (__new_size < __len)
_M_erase_at_end(this->_M_impl._M_start
+ difference_type(__new_size));
}
#pragma line 1304 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
void
resize(size_type __new_size, const value_type& __x)
{
const size_type __len = size();
if (__new_size > __len)
insert(this->_M_impl._M_finish, __new_size - __len, __x);
else if (__new_size < __len)
_M_erase_at_end(this->_M_impl._M_start
+ difference_type(__new_size));
}
#pragma line 1340 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
void
shrink_to_fit() noexcept
{ _M_shrink_to_fit(); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
bool
empty() const noexcept
{ return this->_M_impl._M_finish == this->_M_impl._M_start; }
#pragma line 1365 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
reference
operator[](size_type __n) noexcept
{ return this->_M_impl._M_start[difference_type(__n)]; }
#pragma line 1380 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
const_reference
operator[](size_type __n) const noexcept
{ return this->_M_impl._M_start[difference_type(__n)]; }
#pragma empty_line
protected:
#pragma empty_line
void
_M_range_check(size_type __n) const
{
if (__n >= this->size())
__throw_out_of_range_fmt(("deque::_M_range_check: __n " "(which is %zu)>= this->size() " "(which is %zu)")
#pragma empty_line
,
__n, this->size());
}
#pragma empty_line
public:
#pragma line 1408 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
reference
at(size_type __n)
{
_M_range_check(__n);
return (*this)[__n];
}
#pragma line 1426 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
const_reference
at(size_type __n) const
{
_M_range_check(__n);
return (*this)[__n];
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
reference
front() noexcept
{ return *begin(); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
const_reference
front() const noexcept
{ return *begin(); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
reference
back() noexcept
{
iterator __tmp = end();
--__tmp;
return *__tmp;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
const_reference
back() const noexcept
{
const_iterator __tmp = end();
--__tmp;
return *__tmp;
}
#pragma line 1483 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
void
push_front(const value_type& __x)
{
if (this->_M_impl._M_start._M_cur != this->_M_impl._M_start._M_first)
{
_Alloc_traits::construct(this->_M_impl,
this->_M_impl._M_start._M_cur - 1,
__x);
--this->_M_impl._M_start._M_cur;
}
else
_M_push_front_aux(__x);
}
#pragma empty_line
#pragma empty_line
void
push_front(value_type&& __x)
{ emplace_front(std::move(__x)); }
#pragma empty_line
template<typename... _Args>
void
emplace_front(_Args&&... __args);
#pragma line 1516 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
void
push_back(const value_type& __x)
{
if (this->_M_impl._M_finish._M_cur
!= this->_M_impl._M_finish._M_last - 1)
{
_Alloc_traits::construct(this->_M_impl,
this->_M_impl._M_finish._M_cur, __x);
++this->_M_impl._M_finish._M_cur;
}
else
_M_push_back_aux(__x);
}
#pragma empty_line
#pragma empty_line
void
push_back(value_type&& __x)
{ emplace_back(std::move(__x)); }
#pragma empty_line
template<typename... _Args>
void
emplace_back(_Args&&... __args);
#pragma line 1548 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
void
pop_front() noexcept
{
if (this->_M_impl._M_start._M_cur
!= this->_M_impl._M_start._M_last - 1)
{
_Alloc_traits::destroy(this->_M_impl,
this->_M_impl._M_start._M_cur);
++this->_M_impl._M_start._M_cur;
}
else
_M_pop_front_aux();
}
#pragma line 1570 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
void
pop_back() noexcept
{
if (this->_M_impl._M_finish._M_cur
!= this->_M_impl._M_finish._M_first)
{
--this->_M_impl._M_finish._M_cur;
_Alloc_traits::destroy(this->_M_impl,
this->_M_impl._M_finish._M_cur);
}
else
_M_pop_back_aux();
}
#pragma line 1594 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
template<typename... _Args>
iterator
emplace(const_iterator __position, _Args&&... __args);
#pragma line 1607 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
iterator
insert(const_iterator __position, const value_type& __x);
#pragma line 1633 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
iterator
insert(const_iterator __position, value_type&& __x)
{ return emplace(__position, std::move(__x)); }
#pragma line 1646 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
iterator
insert(const_iterator __p, initializer_list<value_type> __l)
{ return this->insert(__p, __l.begin(), __l.end()); }
#pragma line 1662 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
iterator
insert(const_iterator __position, size_type __n, const value_type& __x)
{
difference_type __offset = __position - cbegin();
_M_fill_insert(__position._M_const_cast(), __n, __x);
return begin() + __offset;
}
#pragma line 1696 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
template<typename _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
iterator
insert(const_iterator __position, _InputIterator __first,
_InputIterator __last)
{
difference_type __offset = __position - cbegin();
_M_insert_dispatch(__position._M_const_cast(),
__first, __last, __false_type());
return begin() + __offset;
}
#pragma line 1742 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
iterator
#pragma empty_line
erase(const_iterator __position)
#pragma empty_line
#pragma empty_line
#pragma empty_line
{ return _M_erase(__position._M_const_cast()); }
#pragma line 1766 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
iterator
#pragma empty_line
erase(const_iterator __first, const_iterator __last)
#pragma empty_line
#pragma empty_line
#pragma empty_line
{ return _M_erase(__first._M_const_cast(), __last._M_const_cast()); }
#pragma line 1783 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
void
swap(deque& __x) noexcept
{
_M_impl._M_swap_data(__x._M_impl);
_Alloc_traits::_S_on_swap(_M_get_Tp_allocator(),
__x._M_get_Tp_allocator());
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
void
clear() noexcept
{ _M_erase_at_end(begin()); }
#pragma empty_line
protected:
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Integer>
void
_M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
{
_M_initialize_map(static_cast<size_type>(__n));
_M_fill_initialize(__x);
}
#pragma empty_line
#pragma empty_line
template<typename _InputIterator>
void
_M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
__false_type)
{
typedef typename std::iterator_traits<_InputIterator>::
iterator_category _IterCategory;
_M_range_initialize(__first, __last, _IterCategory());
}
#pragma line 1839 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
template<typename _InputIterator>
void
_M_range_initialize(_InputIterator __first, _InputIterator __last,
std::input_iterator_tag);
#pragma empty_line
#pragma empty_line
template<typename _ForwardIterator>
void
_M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
std::forward_iterator_tag);
#pragma line 1861 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
void
_M_fill_initialize(const value_type& __value);
#pragma empty_line
#pragma empty_line
#pragma empty_line
void
_M_default_initialize();
#pragma line 1877 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
template<typename _Integer>
void
_M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
{ _M_fill_assign(__n, __val); }
#pragma empty_line
#pragma empty_line
template<typename _InputIterator>
void
_M_assign_dispatch(_InputIterator __first, _InputIterator __last,
__false_type)
{
typedef typename std::iterator_traits<_InputIterator>::
iterator_category _IterCategory;
_M_assign_aux(__first, __last, _IterCategory());
}
#pragma empty_line
#pragma empty_line
template<typename _InputIterator>
void
_M_assign_aux(_InputIterator __first, _InputIterator __last,
std::input_iterator_tag);
#pragma empty_line
#pragma empty_line
template<typename _ForwardIterator>
void
_M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
std::forward_iterator_tag)
{
const size_type __len = std::distance(__first, __last);
if (__len > size())
{
_ForwardIterator __mid = __first;
std::advance(__mid, size());
std::copy(__first, __mid, begin());
insert(end(), __mid, __last);
}
else
_M_erase_at_end(std::copy(__first, __last, begin()));
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
void
_M_fill_assign(size_type __n, const value_type& __val)
{
if (__n > size())
{
std::fill(begin(), end(), __val);
insert(end(), __n - size(), __val);
}
else
{
_M_erase_at_end(begin() + difference_type(__n));
std::fill(begin(), end(), __val);
}
}
#pragma line 1941 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
template<typename... _Args>
void _M_push_back_aux(_Args&&... __args);
#pragma empty_line
template<typename... _Args>
void _M_push_front_aux(_Args&&... __args);
#pragma empty_line
#pragma empty_line
void _M_pop_back_aux();
#pragma empty_line
void _M_pop_front_aux();
#pragma line 1960 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
template<typename _Integer>
void
_M_insert_dispatch(iterator __pos,
_Integer __n, _Integer __x, __true_type)
{ _M_fill_insert(__pos, __n, __x); }
#pragma empty_line
#pragma empty_line
template<typename _InputIterator>
void
_M_insert_dispatch(iterator __pos,
_InputIterator __first, _InputIterator __last,
__false_type)
{
typedef typename std::iterator_traits<_InputIterator>::
iterator_category _IterCategory;
_M_range_insert_aux(__pos, __first, __last, _IterCategory());
}
#pragma empty_line
#pragma empty_line
template<typename _InputIterator>
void
_M_range_insert_aux(iterator __pos, _InputIterator __first,
_InputIterator __last, std::input_iterator_tag);
#pragma empty_line
#pragma empty_line
template<typename _ForwardIterator>
void
_M_range_insert_aux(iterator __pos, _ForwardIterator __first,
_ForwardIterator __last, std::forward_iterator_tag);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
void
_M_fill_insert(iterator __pos, size_type __n, const value_type& __x);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename... _Args>
iterator
_M_insert_aux(iterator __pos, _Args&&... __args);
#pragma empty_line
#pragma empty_line
#pragma empty_line
void
_M_insert_aux(iterator __pos, size_type __n, const value_type& __x);
#pragma empty_line
#pragma empty_line
template<typename _ForwardIterator>
void
_M_insert_aux(iterator __pos,
_ForwardIterator __first, _ForwardIterator __last,
size_type __n);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
void
_M_destroy_data_aux(iterator __first, iterator __last);
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Alloc1>
void
_M_destroy_data(iterator __first, iterator __last, const _Alloc1&)
{ _M_destroy_data_aux(__first, __last); }
#pragma empty_line
void
_M_destroy_data(iterator __first, iterator __last,
const std::allocator<_Tp>&)
{
if (!__has_trivial_destructor(value_type))
_M_destroy_data_aux(__first, __last);
}
#pragma empty_line
#pragma empty_line
void
_M_erase_at_begin(iterator __pos)
{
_M_destroy_data(begin(), __pos, _M_get_Tp_allocator());
_M_destroy_nodes(this->_M_impl._M_start._M_node, __pos._M_node);
this->_M_impl._M_start = __pos;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
void
_M_erase_at_end(iterator __pos)
{
_M_destroy_data(__pos, end(), _M_get_Tp_allocator());
_M_destroy_nodes(__pos._M_node + 1,
this->_M_impl._M_finish._M_node + 1);
this->_M_impl._M_finish = __pos;
}
#pragma empty_line
iterator
_M_erase(iterator __pos);
#pragma empty_line
iterator
_M_erase(iterator __first, iterator __last);
#pragma empty_line
#pragma empty_line
#pragma empty_line
void
_M_default_append(size_type __n);
#pragma empty_line
bool
_M_shrink_to_fit();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
iterator
_M_reserve_elements_at_front(size_type __n)
{
const size_type __vacancies = this->_M_impl._M_start._M_cur
- this->_M_impl._M_start._M_first;
if (__n > __vacancies)
_M_new_elements_at_front(__n - __vacancies);
return this->_M_impl._M_start - difference_type(__n);
}
#pragma empty_line
iterator
_M_reserve_elements_at_back(size_type __n)
{
const size_type __vacancies = (this->_M_impl._M_finish._M_last
- this->_M_impl._M_finish._M_cur) - 1;
if (__n > __vacancies)
_M_new_elements_at_back(__n - __vacancies);
return this->_M_impl._M_finish + difference_type(__n);
}
#pragma empty_line
void
_M_new_elements_at_front(size_type __new_elements);
#pragma empty_line
void
_M_new_elements_at_back(size_type __new_elements);
#pragma line 2111 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
void
_M_reserve_map_at_back(size_type __nodes_to_add = 1)
{
if (__nodes_to_add + 1 > this->_M_impl._M_map_size
- (this->_M_impl._M_finish._M_node - this->_M_impl._M_map))
_M_reallocate_map(__nodes_to_add, false);
}
#pragma empty_line
void
_M_reserve_map_at_front(size_type __nodes_to_add = 1)
{
if (__nodes_to_add > size_type(this->_M_impl._M_start._M_node
- this->_M_impl._M_map))
_M_reallocate_map(__nodes_to_add, true);
}
#pragma empty_line
void
_M_reallocate_map(size_type __nodes_to_add, bool __add_at_front);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
void
_M_move_assign1(deque&& __x, true_type) noexcept
{
this->_M_impl._M_swap_data(__x._M_impl);
__x.clear();
std::__alloc_on_move(_M_get_Tp_allocator(), __x._M_get_Tp_allocator());
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
void
_M_move_assign1(deque&& __x, false_type)
{
constexpr bool __move_storage =
_Alloc_traits::_S_propagate_on_move_assign();
_M_move_assign2(std::move(__x), __bool_constant<__move_storage>());
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename... _Args>
void
_M_replace_map(_Args&&... __args)
{
#pragma empty_line
deque __newobj(std::forward<_Args>(__args)...);
#pragma empty_line
clear();
_M_deallocate_node(*begin()._M_node);
_M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
this->_M_impl._M_map = nullptr;
this->_M_impl._M_map_size = 0;
#pragma empty_line
this->_M_impl._M_swap_data(__newobj._M_impl);
}
#pragma empty_line
#pragma empty_line
void
_M_move_assign2(deque&& __x, true_type)
{
#pragma empty_line
auto __alloc = __x._M_get_Tp_allocator();
#pragma empty_line
#pragma empty_line
_M_replace_map(std::move(__x));
#pragma empty_line
_M_get_Tp_allocator() = std::move(__alloc);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
void
_M_move_assign2(deque&& __x, false_type)
{
if (__x._M_get_Tp_allocator() == this->_M_get_Tp_allocator())
{
#pragma empty_line
#pragma empty_line
_M_replace_map(std::move(__x), __x.get_allocator());
}
else
{
#pragma empty_line
#pragma empty_line
this->assign(std::__make_move_if_noexcept_iterator(__x.begin()),
std::__make_move_if_noexcept_iterator(__x.end()));
__x.clear();
}
}
#pragma empty_line
};
#pragma line 2218 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
template<typename _Tp, typename _Alloc>
inline bool
operator==(const deque<_Tp, _Alloc>& __x,
const deque<_Tp, _Alloc>& __y)
{ return __x.size() == __y.size()
&& std::equal(__x.begin(), __x.end(), __y.begin()); }
#pragma line 2236 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_deque.h" 3
template<typename _Tp, typename _Alloc>
inline bool
operator<(const deque<_Tp, _Alloc>& __x,
const deque<_Tp, _Alloc>& __y)
{ return std::lexicographical_compare(__x.begin(), __x.end(),
__y.begin(), __y.end()); }
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename _Alloc>
inline bool
operator!=(const deque<_Tp, _Alloc>& __x,
const deque<_Tp, _Alloc>& __y)
{ return !(__x == __y); }
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename _Alloc>
inline bool
operator>(const deque<_Tp, _Alloc>& __x,
const deque<_Tp, _Alloc>& __y)
{ return __y < __x; }
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename _Alloc>
inline bool
operator<=(const deque<_Tp, _Alloc>& __x,
const deque<_Tp, _Alloc>& __y)
{ return !(__y < __x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename _Alloc>
inline bool
operator>=(const deque<_Tp, _Alloc>& __x,
const deque<_Tp, _Alloc>& __y)
{ return !(__x < __y); }
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename _Alloc>
inline void
swap(deque<_Tp,_Alloc>& __x, deque<_Tp,_Alloc>& __y)
noexcept(noexcept(__x.swap(__y)))
{ __x.swap(__y); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 65 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/deque" 2 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/range_access.h" 1 3
#pragma line 33 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/range_access.h" 3
#pragma empty_line
#pragma line 34 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/range_access.h" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Container>
inline auto
begin(_Container& __cont) -> decltype(__cont.begin())
{ return __cont.begin(); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Container>
inline auto
begin(const _Container& __cont) -> decltype(__cont.begin())
{ return __cont.begin(); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Container>
inline auto
end(_Container& __cont) -> decltype(__cont.end())
{ return __cont.end(); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Container>
inline auto
end(const _Container& __cont) -> decltype(__cont.end())
{ return __cont.end(); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp, size_t _Nm>
inline constexpr _Tp*
begin(_Tp (&__arr)[_Nm])
{ return __arr; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp, size_t _Nm>
inline constexpr _Tp*
end(_Tp (&__arr)[_Nm])
{ return __arr + _Nm; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp> class valarray;
#pragma empty_line
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>&);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Container>
inline constexpr auto
cbegin(const _Container& __cont) noexcept(noexcept(std::begin(__cont)))
-> decltype(std::begin(__cont))
{ return std::begin(__cont); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Container>
inline constexpr auto
cend(const _Container& __cont) noexcept(noexcept(std::end(__cont)))
-> decltype(std::end(__cont))
{ return std::end(__cont); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Container>
inline auto
rbegin(_Container& __cont) -> decltype(__cont.rbegin())
{ return __cont.rbegin(); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Container>
inline auto
rbegin(const _Container& __cont) -> decltype(__cont.rbegin())
{ return __cont.rbegin(); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Container>
inline auto
rend(_Container& __cont) -> decltype(__cont.rend())
{ return __cont.rend(); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Container>
inline auto
rend(const _Container& __cont) -> decltype(__cont.rend())
{ return __cont.rend(); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp, size_t _Nm>
inline reverse_iterator<_Tp*>
rbegin(_Tp (&__arr)[_Nm])
{ return reverse_iterator<_Tp*>(__arr + _Nm); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp, size_t _Nm>
inline reverse_iterator<_Tp*>
rend(_Tp (&__arr)[_Nm])
{ return reverse_iterator<_Tp*>(__arr); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
inline reverse_iterator<const _Tp*>
rbegin(initializer_list<_Tp> __il)
{ return reverse_iterator<const _Tp*>(__il.end()); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
inline reverse_iterator<const _Tp*>
rend(initializer_list<_Tp> __il)
{ return reverse_iterator<const _Tp*>(__il.begin()); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Container>
inline auto
crbegin(const _Container& __cont) -> decltype(std::rbegin(__cont))
{ return std::rbegin(__cont); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Container>
inline auto
crend(const _Container& __cont) -> decltype(std::rend(__cont))
{ return std::rend(__cont); }
#pragma line 319 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/range_access.h" 3
#pragma empty_line
}
#pragma line 66 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/deque" 2 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/deque.tcc" 1 3
#pragma line 59 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/deque.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
template <typename _Tp, typename _Alloc>
void
deque<_Tp, _Alloc>::
_M_default_initialize()
{
_Map_pointer __cur;
try
{
for (__cur = this->_M_impl._M_start._M_node;
__cur < this->_M_impl._M_finish._M_node;
++__cur)
std::__uninitialized_default_a(*__cur, *__cur + _S_buffer_size(),
_M_get_Tp_allocator());
std::__uninitialized_default_a(this->_M_impl._M_finish._M_first,
this->_M_impl._M_finish._M_cur,
_M_get_Tp_allocator());
}
catch(...)
{
std::_Destroy(this->_M_impl._M_start, iterator(*__cur, __cur),
_M_get_Tp_allocator());
throw;
}
}
#pragma empty_line
#pragma empty_line
template <typename _Tp, typename _Alloc>
deque<_Tp, _Alloc>&
deque<_Tp, _Alloc>::
operator=(const deque& __x)
{
if (&__x != this)
{
#pragma empty_line
if (_Alloc_traits::_S_propagate_on_copy_assign())
{
if (!_Alloc_traits::_S_always_equal()
&& _M_get_Tp_allocator() != __x._M_get_Tp_allocator())
{
#pragma empty_line
#pragma empty_line
_M_replace_map(__x, __x.get_allocator());
std::__alloc_on_copy(_M_get_Tp_allocator(),
__x._M_get_Tp_allocator());
return *this;
}
std::__alloc_on_copy(_M_get_Tp_allocator(),
__x._M_get_Tp_allocator());
}
#pragma empty_line
const size_type __len = size();
if (__len >= __x.size())
_M_erase_at_end(std::copy(__x.begin(), __x.end(),
this->_M_impl._M_start));
else
{
const_iterator __mid = __x.begin() + difference_type(__len);
std::copy(__x.begin(), __mid, this->_M_impl._M_start);
insert(this->_M_impl._M_finish, __mid, __x.end());
}
}
return *this;
}
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename _Alloc>
template<typename... _Args>
void
deque<_Tp, _Alloc>::
emplace_front(_Args&&... __args)
{
if (this->_M_impl._M_start._M_cur != this->_M_impl._M_start._M_first)
{
_Alloc_traits::construct(this->_M_impl,
this->_M_impl._M_start._M_cur - 1,
std::forward<_Args>(__args)...);
--this->_M_impl._M_start._M_cur;
}
else
_M_push_front_aux(std::forward<_Args>(__args)...);
}
#pragma empty_line
template<typename _Tp, typename _Alloc>
template<typename... _Args>
void
deque<_Tp, _Alloc>::
emplace_back(_Args&&... __args)
{
if (this->_M_impl._M_finish._M_cur
!= this->_M_impl._M_finish._M_last - 1)
{
_Alloc_traits::construct(this->_M_impl,
this->_M_impl._M_finish._M_cur,
std::forward<_Args>(__args)...);
++this->_M_impl._M_finish._M_cur;
}
else
_M_push_back_aux(std::forward<_Args>(__args)...);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename _Alloc>
template<typename... _Args>
typename deque<_Tp, _Alloc>::iterator
deque<_Tp, _Alloc>::
emplace(const_iterator __position, _Args&&... __args)
{
if (__position._M_cur == this->_M_impl._M_start._M_cur)
{
emplace_front(std::forward<_Args>(__args)...);
return this->_M_impl._M_start;
}
else if (__position._M_cur == this->_M_impl._M_finish._M_cur)
{
emplace_back(std::forward<_Args>(__args)...);
iterator __tmp = this->_M_impl._M_finish;
--__tmp;
return __tmp;
}
else
return _M_insert_aux(__position._M_const_cast(),
std::forward<_Args>(__args)...);
}
#pragma empty_line
#pragma empty_line
template <typename _Tp, typename _Alloc>
typename deque<_Tp, _Alloc>::iterator
deque<_Tp, _Alloc>::
#pragma empty_line
insert(const_iterator __position, const value_type& __x)
#pragma empty_line
#pragma empty_line
#pragma empty_line
{
if (__position._M_cur == this->_M_impl._M_start._M_cur)
{
push_front(__x);
return this->_M_impl._M_start;
}
else if (__position._M_cur == this->_M_impl._M_finish._M_cur)
{
push_back(__x);
iterator __tmp = this->_M_impl._M_finish;
--__tmp;
return __tmp;
}
else
return _M_insert_aux(__position._M_const_cast(), __x);
}
#pragma empty_line
template <typename _Tp, typename _Alloc>
typename deque<_Tp, _Alloc>::iterator
deque<_Tp, _Alloc>::
_M_erase(iterator __position)
{
iterator __next = __position;
++__next;
const difference_type __index = __position - begin();
if (static_cast<size_type>(__index) < (size() >> 1))
{
if (__position != begin())
std::move_backward(begin(), __position, __next);
pop_front();
}
else
{
if (__next != end())
std::move(__next, end(), __position);
pop_back();
}
return begin() + __index;
}
#pragma empty_line
template <typename _Tp, typename _Alloc>
typename deque<_Tp, _Alloc>::iterator
deque<_Tp, _Alloc>::
_M_erase(iterator __first, iterator __last)
{
if (__first == __last)
return __first;
else if (__first == begin() && __last == end())
{
clear();
return end();
}
else
{
const difference_type __n = __last - __first;
const difference_type __elems_before = __first - begin();
if (static_cast<size_type>(__elems_before) <= (size() - __n) / 2)
{
if (__first != begin())
std::move_backward(begin(), __first, __last);
_M_erase_at_begin(begin() + __n);
}
else
{
if (__last != end())
std::move(__last, end(), __first);
_M_erase_at_end(end() - __n);
}
return begin() + __elems_before;
}
}
#pragma empty_line
template <typename _Tp, class _Alloc>
template <typename _InputIterator>
void
deque<_Tp, _Alloc>::
_M_assign_aux(_InputIterator __first, _InputIterator __last,
std::input_iterator_tag)
{
iterator __cur = begin();
for (; __first != __last && __cur != end(); ++__cur, ++__first)
*__cur = *__first;
if (__first == __last)
_M_erase_at_end(__cur);
else
insert(end(), __first, __last);
}
#pragma empty_line
template <typename _Tp, typename _Alloc>
void
deque<_Tp, _Alloc>::
_M_fill_insert(iterator __pos, size_type __n, const value_type& __x)
{
if (__pos._M_cur == this->_M_impl._M_start._M_cur)
{
iterator __new_start = _M_reserve_elements_at_front(__n);
try
{
std::__uninitialized_fill_a(__new_start, this->_M_impl._M_start,
__x, _M_get_Tp_allocator());
this->_M_impl._M_start = __new_start;
}
catch(...)
{
_M_destroy_nodes(__new_start._M_node,
this->_M_impl._M_start._M_node);
throw;
}
}
else if (__pos._M_cur == this->_M_impl._M_finish._M_cur)
{
iterator __new_finish = _M_reserve_elements_at_back(__n);
try
{
std::__uninitialized_fill_a(this->_M_impl._M_finish,
__new_finish, __x,
_M_get_Tp_allocator());
this->_M_impl._M_finish = __new_finish;
}
catch(...)
{
_M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
__new_finish._M_node + 1);
throw;
}
}
else
_M_insert_aux(__pos, __n, __x);
}
#pragma empty_line
#pragma empty_line
template <typename _Tp, typename _Alloc>
void
deque<_Tp, _Alloc>::
_M_default_append(size_type __n)
{
if (__n)
{
iterator __new_finish = _M_reserve_elements_at_back(__n);
try
{
std::__uninitialized_default_a(this->_M_impl._M_finish,
__new_finish,
_M_get_Tp_allocator());
this->_M_impl._M_finish = __new_finish;
}
catch(...)
{
_M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
__new_finish._M_node + 1);
throw;
}
}
}
#pragma empty_line
template <typename _Tp, typename _Alloc>
bool
deque<_Tp, _Alloc>::
_M_shrink_to_fit()
{
const difference_type __front_capacity
= (this->_M_impl._M_start._M_cur - this->_M_impl._M_start._M_first);
if (__front_capacity == 0)
return false;
#pragma empty_line
const difference_type __back_capacity
= (this->_M_impl._M_finish._M_last - this->_M_impl._M_finish._M_cur);
if (__front_capacity + __back_capacity < _S_buffer_size())
return false;
#pragma empty_line
return std::__shrink_to_fit_aux<deque>::_S_do_it(*this);
}
#pragma empty_line
#pragma empty_line
template <typename _Tp, typename _Alloc>
void
deque<_Tp, _Alloc>::
_M_fill_initialize(const value_type& __value)
{
_Map_pointer __cur;
try
{
for (__cur = this->_M_impl._M_start._M_node;
__cur < this->_M_impl._M_finish._M_node;
++__cur)
std::__uninitialized_fill_a(*__cur, *__cur + _S_buffer_size(),
__value, _M_get_Tp_allocator());
std::__uninitialized_fill_a(this->_M_impl._M_finish._M_first,
this->_M_impl._M_finish._M_cur,
__value, _M_get_Tp_allocator());
}
catch(...)
{
std::_Destroy(this->_M_impl._M_start, iterator(*__cur, __cur),
_M_get_Tp_allocator());
throw;
}
}
#pragma empty_line
template <typename _Tp, typename _Alloc>
template <typename _InputIterator>
void
deque<_Tp, _Alloc>::
_M_range_initialize(_InputIterator __first, _InputIterator __last,
std::input_iterator_tag)
{
this->_M_initialize_map(0);
try
{
for (; __first != __last; ++__first)
#pragma empty_line
emplace_back(*__first);
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
catch(...)
{
clear();
throw;
}
}
#pragma empty_line
template <typename _Tp, typename _Alloc>
template <typename _ForwardIterator>
void
deque<_Tp, _Alloc>::
_M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
std::forward_iterator_tag)
{
const size_type __n = std::distance(__first, __last);
this->_M_initialize_map(__n);
#pragma empty_line
_Map_pointer __cur_node;
try
{
for (__cur_node = this->_M_impl._M_start._M_node;
__cur_node < this->_M_impl._M_finish._M_node;
++__cur_node)
{
_ForwardIterator __mid = __first;
std::advance(__mid, _S_buffer_size());
std::__uninitialized_copy_a(__first, __mid, *__cur_node,
_M_get_Tp_allocator());
__first = __mid;
}
std::__uninitialized_copy_a(__first, __last,
this->_M_impl._M_finish._M_first,
_M_get_Tp_allocator());
}
catch(...)
{
std::_Destroy(this->_M_impl._M_start,
iterator(*__cur_node, __cur_node),
_M_get_Tp_allocator());
throw;
}
}
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename _Alloc>
#pragma empty_line
template<typename... _Args>
void
deque<_Tp, _Alloc>::
_M_push_back_aux(_Args&&... __args)
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
{
_M_reserve_map_at_back();
*(this->_M_impl._M_finish._M_node + 1) = this->_M_allocate_node();
try
{
#pragma empty_line
_Alloc_traits::construct(this->_M_impl,
this->_M_impl._M_finish._M_cur,
std::forward<_Args>(__args)...);
#pragma empty_line
#pragma empty_line
#pragma empty_line
this->_M_impl._M_finish._M_set_node(this->_M_impl._M_finish._M_node
+ 1);
this->_M_impl._M_finish._M_cur = this->_M_impl._M_finish._M_first;
}
catch(...)
{
_M_deallocate_node(*(this->_M_impl._M_finish._M_node + 1));
throw;
}
}
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename _Alloc>
#pragma empty_line
template<typename... _Args>
void
deque<_Tp, _Alloc>::
_M_push_front_aux(_Args&&... __args)
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
{
_M_reserve_map_at_front();
*(this->_M_impl._M_start._M_node - 1) = this->_M_allocate_node();
try
{
this->_M_impl._M_start._M_set_node(this->_M_impl._M_start._M_node
- 1);
this->_M_impl._M_start._M_cur = this->_M_impl._M_start._M_last - 1;
#pragma empty_line
_Alloc_traits::construct(this->_M_impl,
this->_M_impl._M_start._M_cur,
std::forward<_Args>(__args)...);
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
catch(...)
{
++this->_M_impl._M_start;
_M_deallocate_node(*(this->_M_impl._M_start._M_node - 1));
throw;
}
}
#pragma empty_line
#pragma empty_line
template <typename _Tp, typename _Alloc>
void deque<_Tp, _Alloc>::
_M_pop_back_aux()
{
_M_deallocate_node(this->_M_impl._M_finish._M_first);
this->_M_impl._M_finish._M_set_node(this->_M_impl._M_finish._M_node - 1);
this->_M_impl._M_finish._M_cur = this->_M_impl._M_finish._M_last - 1;
_Alloc_traits::destroy(_M_get_Tp_allocator(),
this->_M_impl._M_finish._M_cur);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template <typename _Tp, typename _Alloc>
void deque<_Tp, _Alloc>::
_M_pop_front_aux()
{
_Alloc_traits::destroy(_M_get_Tp_allocator(),
this->_M_impl._M_start._M_cur);
_M_deallocate_node(this->_M_impl._M_start._M_first);
this->_M_impl._M_start._M_set_node(this->_M_impl._M_start._M_node + 1);
this->_M_impl._M_start._M_cur = this->_M_impl._M_start._M_first;
}
#pragma empty_line
template <typename _Tp, typename _Alloc>
template <typename _InputIterator>
void
deque<_Tp, _Alloc>::
_M_range_insert_aux(iterator __pos,
_InputIterator __first, _InputIterator __last,
std::input_iterator_tag)
{ std::copy(__first, __last, std::inserter(*this, __pos)); }
#pragma empty_line
template <typename _Tp, typename _Alloc>
template <typename _ForwardIterator>
void
deque<_Tp, _Alloc>::
_M_range_insert_aux(iterator __pos,
_ForwardIterator __first, _ForwardIterator __last,
std::forward_iterator_tag)
{
const size_type __n = std::distance(__first, __last);
if (__pos._M_cur == this->_M_impl._M_start._M_cur)
{
iterator __new_start = _M_reserve_elements_at_front(__n);
try
{
std::__uninitialized_copy_a(__first, __last, __new_start,
_M_get_Tp_allocator());
this->_M_impl._M_start = __new_start;
}
catch(...)
{
_M_destroy_nodes(__new_start._M_node,
this->_M_impl._M_start._M_node);
throw;
}
}
else if (__pos._M_cur == this->_M_impl._M_finish._M_cur)
{
iterator __new_finish = _M_reserve_elements_at_back(__n);
try
{
std::__uninitialized_copy_a(__first, __last,
this->_M_impl._M_finish,
_M_get_Tp_allocator());
this->_M_impl._M_finish = __new_finish;
}
catch(...)
{
_M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
__new_finish._M_node + 1);
throw;
}
}
else
_M_insert_aux(__pos, __first, __last, __n);
}
#pragma empty_line
template<typename _Tp, typename _Alloc>
#pragma empty_line
template<typename... _Args>
typename deque<_Tp, _Alloc>::iterator
deque<_Tp, _Alloc>::
_M_insert_aux(iterator __pos, _Args&&... __args)
{
value_type __x_copy(std::forward<_Args>(__args)...);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
difference_type __index = __pos - this->_M_impl._M_start;
if (static_cast<size_type>(__index) < size() / 2)
{
push_front(std::move(front()));
iterator __front1 = this->_M_impl._M_start;
++__front1;
iterator __front2 = __front1;
++__front2;
__pos = this->_M_impl._M_start + __index;
iterator __pos1 = __pos;
++__pos1;
std::move(__front2, __pos1, __front1);
}
else
{
push_back(std::move(back()));
iterator __back1 = this->_M_impl._M_finish;
--__back1;
iterator __back2 = __back1;
--__back2;
__pos = this->_M_impl._M_start + __index;
std::move_backward(__pos, __back2, __back1);
}
*__pos = std::move(__x_copy);
return __pos;
}
#pragma empty_line
template <typename _Tp, typename _Alloc>
void
deque<_Tp, _Alloc>::
_M_insert_aux(iterator __pos, size_type __n, const value_type& __x)
{
const difference_type __elems_before = __pos - this->_M_impl._M_start;
const size_type __length = this->size();
value_type __x_copy = __x;
if (__elems_before < difference_type(__length / 2))
{
iterator __new_start = _M_reserve_elements_at_front(__n);
iterator __old_start = this->_M_impl._M_start;
__pos = this->_M_impl._M_start + __elems_before;
try
{
if (__elems_before >= difference_type(__n))
{
iterator __start_n = (this->_M_impl._M_start
+ difference_type(__n));
std::__uninitialized_move_a(this->_M_impl._M_start,
__start_n, __new_start,
_M_get_Tp_allocator());
this->_M_impl._M_start = __new_start;
std::move(__start_n, __pos, __old_start);
std::fill(__pos - difference_type(__n), __pos, __x_copy);
}
else
{
std::__uninitialized_move_fill(this->_M_impl._M_start,
__pos, __new_start,
this->_M_impl._M_start,
__x_copy,
_M_get_Tp_allocator());
this->_M_impl._M_start = __new_start;
std::fill(__old_start, __pos, __x_copy);
}
}
catch(...)
{
_M_destroy_nodes(__new_start._M_node,
this->_M_impl._M_start._M_node);
throw;
}
}
else
{
iterator __new_finish = _M_reserve_elements_at_back(__n);
iterator __old_finish = this->_M_impl._M_finish;
const difference_type __elems_after =
difference_type(__length) - __elems_before;
__pos = this->_M_impl._M_finish - __elems_after;
try
{
if (__elems_after > difference_type(__n))
{
iterator __finish_n = (this->_M_impl._M_finish
- difference_type(__n));
std::__uninitialized_move_a(__finish_n,
this->_M_impl._M_finish,
this->_M_impl._M_finish,
_M_get_Tp_allocator());
this->_M_impl._M_finish = __new_finish;
std::move_backward(__pos, __finish_n, __old_finish);
std::fill(__pos, __pos + difference_type(__n), __x_copy);
}
else
{
std::__uninitialized_fill_move(this->_M_impl._M_finish,
__pos + difference_type(__n),
__x_copy, __pos,
this->_M_impl._M_finish,
_M_get_Tp_allocator());
this->_M_impl._M_finish = __new_finish;
std::fill(__pos, __old_finish, __x_copy);
}
}
catch(...)
{
_M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
__new_finish._M_node + 1);
throw;
}
}
}
#pragma empty_line
template <typename _Tp, typename _Alloc>
template <typename _ForwardIterator>
void
deque<_Tp, _Alloc>::
_M_insert_aux(iterator __pos,
_ForwardIterator __first, _ForwardIterator __last,
size_type __n)
{
const difference_type __elemsbefore = __pos - this->_M_impl._M_start;
const size_type __length = size();
if (static_cast<size_type>(__elemsbefore) < __length / 2)
{
iterator __new_start = _M_reserve_elements_at_front(__n);
iterator __old_start = this->_M_impl._M_start;
__pos = this->_M_impl._M_start + __elemsbefore;
try
{
if (__elemsbefore >= difference_type(__n))
{
iterator __start_n = (this->_M_impl._M_start
+ difference_type(__n));
std::__uninitialized_move_a(this->_M_impl._M_start,
__start_n, __new_start,
_M_get_Tp_allocator());
this->_M_impl._M_start = __new_start;
std::move(__start_n, __pos, __old_start);
std::copy(__first, __last, __pos - difference_type(__n));
}
else
{
_ForwardIterator __mid = __first;
std::advance(__mid, difference_type(__n) - __elemsbefore);
std::__uninitialized_move_copy(this->_M_impl._M_start,
__pos, __first, __mid,
__new_start,
_M_get_Tp_allocator());
this->_M_impl._M_start = __new_start;
std::copy(__mid, __last, __old_start);
}
}
catch(...)
{
_M_destroy_nodes(__new_start._M_node,
this->_M_impl._M_start._M_node);
throw;
}
}
else
{
iterator __new_finish = _M_reserve_elements_at_back(__n);
iterator __old_finish = this->_M_impl._M_finish;
const difference_type __elemsafter =
difference_type(__length) - __elemsbefore;
__pos = this->_M_impl._M_finish - __elemsafter;
try
{
if (__elemsafter > difference_type(__n))
{
iterator __finish_n = (this->_M_impl._M_finish
- difference_type(__n));
std::__uninitialized_move_a(__finish_n,
this->_M_impl._M_finish,
this->_M_impl._M_finish,
_M_get_Tp_allocator());
this->_M_impl._M_finish = __new_finish;
std::move_backward(__pos, __finish_n, __old_finish);
std::copy(__first, __last, __pos);
}
else
{
_ForwardIterator __mid = __first;
std::advance(__mid, __elemsafter);
std::__uninitialized_copy_move(__mid, __last, __pos,
this->_M_impl._M_finish,
this->_M_impl._M_finish,
_M_get_Tp_allocator());
this->_M_impl._M_finish = __new_finish;
std::copy(__first, __mid, __pos);
}
}
catch(...)
{
_M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
__new_finish._M_node + 1);
throw;
}
}
}
#pragma empty_line
template<typename _Tp, typename _Alloc>
void
deque<_Tp, _Alloc>::
_M_destroy_data_aux(iterator __first, iterator __last)
{
for (_Map_pointer __node = __first._M_node + 1;
__node < __last._M_node; ++__node)
std::_Destroy(*__node, *__node + _S_buffer_size(),
_M_get_Tp_allocator());
#pragma empty_line
if (__first._M_node != __last._M_node)
{
std::_Destroy(__first._M_cur, __first._M_last,
_M_get_Tp_allocator());
std::_Destroy(__last._M_first, __last._M_cur,
_M_get_Tp_allocator());
}
else
std::_Destroy(__first._M_cur, __last._M_cur,
_M_get_Tp_allocator());
}
#pragma empty_line
template <typename _Tp, typename _Alloc>
void
deque<_Tp, _Alloc>::
_M_new_elements_at_front(size_type __new_elems)
{
if (this->max_size() - this->size() < __new_elems)
__throw_length_error(("deque::_M_new_elements_at_front"));
#pragma empty_line
const size_type __new_nodes = ((__new_elems + _S_buffer_size() - 1)
/ _S_buffer_size());
_M_reserve_map_at_front(__new_nodes);
size_type __i;
try
{
for (__i = 1; __i <= __new_nodes; ++__i)
*(this->_M_impl._M_start._M_node - __i) = this->_M_allocate_node();
}
catch(...)
{
for (size_type __j = 1; __j < __i; ++__j)
_M_deallocate_node(*(this->_M_impl._M_start._M_node - __j));
throw;
}
}
#pragma empty_line
template <typename _Tp, typename _Alloc>
void
deque<_Tp, _Alloc>::
_M_new_elements_at_back(size_type __new_elems)
{
if (this->max_size() - this->size() < __new_elems)
__throw_length_error(("deque::_M_new_elements_at_back"));
#pragma empty_line
const size_type __new_nodes = ((__new_elems + _S_buffer_size() - 1)
/ _S_buffer_size());
_M_reserve_map_at_back(__new_nodes);
size_type __i;
try
{
for (__i = 1; __i <= __new_nodes; ++__i)
*(this->_M_impl._M_finish._M_node + __i) = this->_M_allocate_node();
}
catch(...)
{
for (size_type __j = 1; __j < __i; ++__j)
_M_deallocate_node(*(this->_M_impl._M_finish._M_node + __j));
throw;
}
}
#pragma empty_line
template <typename _Tp, typename _Alloc>
void
deque<_Tp, _Alloc>::
_M_reallocate_map(size_type __nodes_to_add, bool __add_at_front)
{
const size_type __old_num_nodes
= this->_M_impl._M_finish._M_node - this->_M_impl._M_start._M_node + 1;
const size_type __new_num_nodes = __old_num_nodes + __nodes_to_add;
#pragma empty_line
_Map_pointer __new_nstart;
if (this->_M_impl._M_map_size > 2 * __new_num_nodes)
{
__new_nstart = this->_M_impl._M_map + (this->_M_impl._M_map_size
- __new_num_nodes) / 2
+ (__add_at_front ? __nodes_to_add : 0);
if (__new_nstart < this->_M_impl._M_start._M_node)
std::copy(this->_M_impl._M_start._M_node,
this->_M_impl._M_finish._M_node + 1,
__new_nstart);
else
std::copy_backward(this->_M_impl._M_start._M_node,
this->_M_impl._M_finish._M_node + 1,
__new_nstart + __old_num_nodes);
}
else
{
size_type __new_map_size = this->_M_impl._M_map_size
+ std::max(this->_M_impl._M_map_size,
__nodes_to_add) + 2;
#pragma empty_line
_Map_pointer __new_map = this->_M_allocate_map(__new_map_size);
__new_nstart = __new_map + (__new_map_size - __new_num_nodes) / 2
+ (__add_at_front ? __nodes_to_add : 0);
std::copy(this->_M_impl._M_start._M_node,
this->_M_impl._M_finish._M_node + 1,
__new_nstart);
_M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
#pragma empty_line
this->_M_impl._M_map = __new_map;
this->_M_impl._M_map_size = __new_map_size;
}
#pragma empty_line
this->_M_impl._M_start._M_set_node(__new_nstart);
this->_M_impl._M_finish._M_set_node(__new_nstart + __old_num_nodes - 1);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
void
fill(const _Deque_iterator<_Tp, _Tp&, _Tp*>& __first,
const _Deque_iterator<_Tp, _Tp&, _Tp*>& __last, const _Tp& __value)
{
typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self;
#pragma empty_line
for (typename _Self::_Map_pointer __node = __first._M_node + 1;
__node < __last._M_node; ++__node)
std::fill(*__node, *__node + _Self::_S_buffer_size(), __value);
#pragma empty_line
if (__first._M_node != __last._M_node)
{
std::fill(__first._M_cur, __first._M_last, __value);
std::fill(__last._M_first, __last._M_cur, __value);
}
else
std::fill(__first._M_cur, __last._M_cur, __value);
}
#pragma empty_line
template<typename _Tp>
_Deque_iterator<_Tp, _Tp&, _Tp*>
copy(_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first,
_Deque_iterator<_Tp, const _Tp&, const _Tp*> __last,
_Deque_iterator<_Tp, _Tp&, _Tp*> __result)
{
typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self;
typedef typename _Self::difference_type difference_type;
#pragma empty_line
difference_type __len = __last - __first;
while (__len > 0)
{
const difference_type __clen
= std::min(__len, std::min(__first._M_last - __first._M_cur,
__result._M_last - __result._M_cur));
std::copy(__first._M_cur, __first._M_cur + __clen, __result._M_cur);
__first += __clen;
__result += __clen;
__len -= __clen;
}
return __result;
}
#pragma empty_line
template<typename _Tp>
_Deque_iterator<_Tp, _Tp&, _Tp*>
copy_backward(_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first,
_Deque_iterator<_Tp, const _Tp&, const _Tp*> __last,
_Deque_iterator<_Tp, _Tp&, _Tp*> __result)
{
typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self;
typedef typename _Self::difference_type difference_type;
#pragma empty_line
difference_type __len = __last - __first;
while (__len > 0)
{
difference_type __llen = __last._M_cur - __last._M_first;
_Tp* __lend = __last._M_cur;
#pragma empty_line
difference_type __rlen = __result._M_cur - __result._M_first;
_Tp* __rend = __result._M_cur;
#pragma empty_line
if (!__llen)
{
__llen = _Self::_S_buffer_size();
__lend = *(__last._M_node - 1) + __llen;
}
if (!__rlen)
{
__rlen = _Self::_S_buffer_size();
__rend = *(__result._M_node - 1) + __rlen;
}
#pragma empty_line
const difference_type __clen = std::min(__len,
std::min(__llen, __rlen));
std::copy_backward(__lend - __clen, __lend, __rend);
__last -= __clen;
__result -= __clen;
__len -= __clen;
}
return __result;
}
#pragma empty_line
#pragma empty_line
template<typename _Tp>
_Deque_iterator<_Tp, _Tp&, _Tp*>
move(_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first,
_Deque_iterator<_Tp, const _Tp&, const _Tp*> __last,
_Deque_iterator<_Tp, _Tp&, _Tp*> __result)
{
typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self;
typedef typename _Self::difference_type difference_type;
#pragma empty_line
difference_type __len = __last - __first;
while (__len > 0)
{
const difference_type __clen
= std::min(__len, std::min(__first._M_last - __first._M_cur,
__result._M_last - __result._M_cur));
std::move(__first._M_cur, __first._M_cur + __clen, __result._M_cur);
__first += __clen;
__result += __clen;
__len -= __clen;
}
return __result;
}
#pragma empty_line
template<typename _Tp>
_Deque_iterator<_Tp, _Tp&, _Tp*>
move_backward(_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first,
_Deque_iterator<_Tp, const _Tp&, const _Tp*> __last,
_Deque_iterator<_Tp, _Tp&, _Tp*> __result)
{
typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self;
typedef typename _Self::difference_type difference_type;
#pragma empty_line
difference_type __len = __last - __first;
while (__len > 0)
{
difference_type __llen = __last._M_cur - __last._M_first;
_Tp* __lend = __last._M_cur;
#pragma empty_line
difference_type __rlen = __result._M_cur - __result._M_first;
_Tp* __rend = __result._M_cur;
#pragma empty_line
if (!__llen)
{
__llen = _Self::_S_buffer_size();
__lend = *(__last._M_node - 1) + __llen;
}
if (!__rlen)
{
__rlen = _Self::_S_buffer_size();
__rend = *(__result._M_node - 1) + __rlen;
}
#pragma empty_line
const difference_type __clen = std::min(__len,
std::min(__llen, __rlen));
std::move_backward(__lend - __clen, __lend, __rend);
__last -= __clen;
__result -= __clen;
__len -= __clen;
}
return __result;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 67 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/deque" 2 3
#pragma line 61 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/queue" 2 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/vector" 1 3
#pragma line 58 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/vector" 3
#pragma empty_line
#pragma line 59 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/vector" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_vector.h" 1 3
#pragma line 66 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_vector.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename _Alloc>
struct _Vector_base
{
typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
rebind<_Tp>::other _Tp_alloc_type;
typedef typename __gnu_cxx::__alloc_traits<_Tp_alloc_type>::pointer
pointer;
#pragma empty_line
struct _Vector_impl
: public _Tp_alloc_type
{
pointer _M_start;
pointer _M_finish;
pointer _M_end_of_storage;
#pragma empty_line
_Vector_impl()
: _Tp_alloc_type(), _M_start(), _M_finish(), _M_end_of_storage()
{ }
#pragma empty_line
_Vector_impl(_Tp_alloc_type const& __a) noexcept
: _Tp_alloc_type(__a), _M_start(), _M_finish(), _M_end_of_storage()
{ }
#pragma empty_line
#pragma empty_line
_Vector_impl(_Tp_alloc_type&& __a) noexcept
: _Tp_alloc_type(std::move(__a)),
_M_start(), _M_finish(), _M_end_of_storage()
{ }
#pragma empty_line
#pragma empty_line
void _M_swap_data(_Vector_impl& __x) noexcept
{
std::swap(_M_start, __x._M_start);
std::swap(_M_finish, __x._M_finish);
std::swap(_M_end_of_storage, __x._M_end_of_storage);
}
};
#pragma empty_line
public:
typedef _Alloc allocator_type;
#pragma empty_line
_Tp_alloc_type&
_M_get_Tp_allocator() noexcept
{ return *static_cast<_Tp_alloc_type*>(&this->_M_impl); }
#pragma empty_line
const _Tp_alloc_type&
_M_get_Tp_allocator() const noexcept
{ return *static_cast<const _Tp_alloc_type*>(&this->_M_impl); }
#pragma empty_line
allocator_type
get_allocator() const noexcept
{ return allocator_type(_M_get_Tp_allocator()); }
#pragma empty_line
_Vector_base()
: _M_impl() { }
#pragma empty_line
_Vector_base(const allocator_type& __a) noexcept
: _M_impl(__a) { }
#pragma empty_line
_Vector_base(size_t __n)
: _M_impl()
{ _M_create_storage(__n); }
#pragma empty_line
_Vector_base(size_t __n, const allocator_type& __a)
: _M_impl(__a)
{ _M_create_storage(__n); }
#pragma empty_line
#pragma empty_line
_Vector_base(_Tp_alloc_type&& __a) noexcept
: _M_impl(std::move(__a)) { }
#pragma empty_line
_Vector_base(_Vector_base&& __x) noexcept
: _M_impl(std::move(__x._M_get_Tp_allocator()))
{ this->_M_impl._M_swap_data(__x._M_impl); }
#pragma empty_line
_Vector_base(_Vector_base&& __x, const allocator_type& __a)
: _M_impl(__a)
{
if (__x.get_allocator() == __a)
this->_M_impl._M_swap_data(__x._M_impl);
else
{
size_t __n = __x._M_impl._M_finish - __x._M_impl._M_start;
_M_create_storage(__n);
}
}
#pragma empty_line
#pragma empty_line
~_Vector_base() noexcept
{ _M_deallocate(this->_M_impl._M_start, this->_M_impl._M_end_of_storage
- this->_M_impl._M_start); }
#pragma empty_line
public:
_Vector_impl _M_impl;
#pragma empty_line
pointer
_M_allocate(size_t __n)
{
typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
return __n != 0 ? _Tr::allocate(_M_impl, __n) : pointer();
}
#pragma empty_line
void
_M_deallocate(pointer __p, size_t __n)
{
typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
if (__p)
_Tr::deallocate(_M_impl, __p, __n);
}
#pragma empty_line
private:
void
_M_create_storage(size_t __n)
{
this->_M_impl._M_start = this->_M_allocate(__n);
this->_M_impl._M_finish = this->_M_impl._M_start;
this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
}
};
#pragma line 213 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_vector.h" 3
template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
class vector : protected _Vector_base<_Tp, _Alloc>
{
#pragma empty_line
typedef typename _Alloc::value_type _Alloc_value_type;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef _Vector_base<_Tp, _Alloc> _Base;
typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Alloc_traits;
#pragma empty_line
public:
typedef _Tp value_type;
typedef typename _Base::pointer pointer;
typedef typename _Alloc_traits::const_pointer const_pointer;
typedef typename _Alloc_traits::reference reference;
typedef typename _Alloc_traits::const_reference const_reference;
typedef __gnu_cxx::__normal_iterator<pointer, vector> iterator;
typedef __gnu_cxx::__normal_iterator<const_pointer, vector>
const_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef _Alloc allocator_type;
#pragma empty_line
protected:
using _Base::_M_allocate;
using _Base::_M_deallocate;
using _Base::_M_impl;
using _Base::_M_get_Tp_allocator;
#pragma empty_line
public:
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
vector()
#pragma empty_line
noexcept(is_nothrow_default_constructible<_Alloc>::value)
#pragma empty_line
: _Base() { }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
explicit
vector(const allocator_type& __a) noexcept
: _Base(__a) { }
#pragma line 278 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_vector.h" 3
explicit
vector(size_type __n, const allocator_type& __a = allocator_type())
: _Base(__n, __a)
{ _M_default_initialize(__n); }
#pragma line 291 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_vector.h" 3
vector(size_type __n, const value_type& __value,
const allocator_type& __a = allocator_type())
: _Base(__n, __a)
{ _M_fill_initialize(__n, __value); }
#pragma line 320 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_vector.h" 3
vector(const vector& __x)
: _Base(__x.size(),
_Alloc_traits::_S_select_on_copy(__x._M_get_Tp_allocator()))
{ this->_M_impl._M_finish =
std::__uninitialized_copy_a(__x.begin(), __x.end(),
this->_M_impl._M_start,
_M_get_Tp_allocator());
}
#pragma line 337 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_vector.h" 3
vector(vector&& __x) noexcept
: _Base(std::move(__x)) { }
#pragma empty_line
#pragma empty_line
vector(const vector& __x, const allocator_type& __a)
: _Base(__x.size(), __a)
{ this->_M_impl._M_finish =
std::__uninitialized_copy_a(__x.begin(), __x.end(),
this->_M_impl._M_start,
_M_get_Tp_allocator());
}
#pragma empty_line
#pragma empty_line
vector(vector&& __rv, const allocator_type& __m)
noexcept(_Alloc_traits::_S_always_equal())
: _Base(std::move(__rv), __m)
{
if (__rv.get_allocator() != __m)
{
this->_M_impl._M_finish =
std::__uninitialized_move_a(__rv.begin(), __rv.end(),
this->_M_impl._M_start,
_M_get_Tp_allocator());
__rv.clear();
}
}
#pragma line 375 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_vector.h" 3
vector(initializer_list<value_type> __l,
const allocator_type& __a = allocator_type())
: _Base(__a)
{
_M_range_initialize(__l.begin(), __l.end(),
random_access_iterator_tag());
}
#pragma line 401 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_vector.h" 3
template<typename _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
vector(_InputIterator __first, _InputIterator __last,
const allocator_type& __a = allocator_type())
: _Base(__a)
{ _M_initialize_dispatch(__first, __last, __false_type()); }
#pragma line 425 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_vector.h" 3
~vector() noexcept
{ std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
_M_get_Tp_allocator()); }
#pragma line 437 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_vector.h" 3
vector&
operator=(const vector& __x);
#pragma line 449 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_vector.h" 3
vector&
operator=(vector&& __x) noexcept(_Alloc_traits::_S_nothrow_move())
{
constexpr bool __move_storage =
_Alloc_traits::_S_propagate_on_move_assign()
|| _Alloc_traits::_S_always_equal();
_M_move_assign(std::move(__x), __bool_constant<__move_storage>());
return *this;
}
#pragma line 470 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_vector.h" 3
vector&
operator=(initializer_list<value_type> __l)
{
this->assign(__l.begin(), __l.end());
return *this;
}
#pragma line 488 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_vector.h" 3
void
assign(size_type __n, const value_type& __val)
{ _M_fill_assign(__n, __val); }
#pragma line 505 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_vector.h" 3
template<typename _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
void
assign(_InputIterator __first, _InputIterator __last)
{ _M_assign_dispatch(__first, __last, __false_type()); }
#pragma line 533 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_vector.h" 3
void
assign(initializer_list<value_type> __l)
{ this->assign(__l.begin(), __l.end()); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
using _Base::get_allocator;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
iterator
begin() noexcept
{ return iterator(this->_M_impl._M_start); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
const_iterator
begin() const noexcept
{ return const_iterator(this->_M_impl._M_start); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
iterator
end() noexcept
{ return iterator(this->_M_impl._M_finish); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
const_iterator
end() const noexcept
{ return const_iterator(this->_M_impl._M_finish); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
reverse_iterator
rbegin() noexcept
{ return reverse_iterator(end()); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
const_reverse_iterator
rbegin() const noexcept
{ return const_reverse_iterator(end()); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
reverse_iterator
rend() noexcept
{ return reverse_iterator(begin()); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
const_reverse_iterator
rend() const noexcept
{ return const_reverse_iterator(begin()); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
const_iterator
cbegin() const noexcept
{ return const_iterator(this->_M_impl._M_start); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
const_iterator
cend() const noexcept
{ return const_iterator(this->_M_impl._M_finish); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
const_reverse_iterator
crbegin() const noexcept
{ return const_reverse_iterator(end()); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
const_reverse_iterator
crend() const noexcept
{ return const_reverse_iterator(begin()); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
size_type
size() const noexcept
{ return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); }
#pragma empty_line
#pragma empty_line
size_type
max_size() const noexcept
{ return _Alloc_traits::max_size(_M_get_Tp_allocator()); }
#pragma line 673 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_vector.h" 3
void
resize(size_type __new_size)
{
if (__new_size > size())
_M_default_append(__new_size - size());
else if (__new_size < size())
_M_erase_at_end(this->_M_impl._M_start + __new_size);
}
#pragma line 693 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_vector.h" 3
void
resize(size_type __new_size, const value_type& __x)
{
if (__new_size > size())
insert(end(), __new_size - size(), __x);
else if (__new_size < size())
_M_erase_at_end(this->_M_impl._M_start + __new_size);
}
#pragma line 725 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_vector.h" 3
void
shrink_to_fit()
{ _M_shrink_to_fit(); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
size_type
capacity() const noexcept
{ return size_type(this->_M_impl._M_end_of_storage
- this->_M_impl._M_start); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
bool
empty() const noexcept
{ return begin() == end(); }
#pragma line 764 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_vector.h" 3
void
reserve(size_type __n);
#pragma line 779 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_vector.h" 3
reference
operator[](size_type __n) noexcept
{ return *(this->_M_impl._M_start + __n); }
#pragma line 794 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_vector.h" 3
const_reference
operator[](size_type __n) const noexcept
{ return *(this->_M_impl._M_start + __n); }
#pragma empty_line
protected:
#pragma empty_line
void
_M_range_check(size_type __n) const
{
if (__n >= this->size())
__throw_out_of_range_fmt(("vector::_M_range_check: __n " "(which is %zu) >= this->size() " "(which is %zu)")
#pragma empty_line
,
__n, this->size());
}
#pragma empty_line
public:
#pragma line 822 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_vector.h" 3
reference
at(size_type __n)
{
_M_range_check(__n);
return (*this)[__n];
}
#pragma line 840 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_vector.h" 3
const_reference
at(size_type __n) const
{
_M_range_check(__n);
return (*this)[__n];
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
reference
front() noexcept
{ return *begin(); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
const_reference
front() const noexcept
{ return *begin(); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
reference
back() noexcept
{ return *(end() - 1); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
const_reference
back() const noexcept
{ return *(end() - 1); }
#pragma line 887 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_vector.h" 3
_Tp*
#pragma empty_line
#pragma empty_line
#pragma empty_line
data() noexcept
{ return _M_data_ptr(this->_M_impl._M_start); }
#pragma empty_line
#pragma empty_line
const _Tp*
#pragma empty_line
#pragma empty_line
#pragma empty_line
data() const noexcept
{ return _M_data_ptr(this->_M_impl._M_start); }
#pragma line 913 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_vector.h" 3
void
push_back(const value_type& __x)
{
if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
{
_Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
__x);
++this->_M_impl._M_finish;
}
else
#pragma empty_line
_M_emplace_back_aux(__x);
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
void
push_back(value_type&& __x)
{ emplace_back(std::move(__x)); }
#pragma empty_line
template<typename... _Args>
void
emplace_back(_Args&&... __args);
#pragma line 949 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_vector.h" 3
void
pop_back() noexcept
{
--this->_M_impl._M_finish;
_Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish);
}
#pragma line 969 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_vector.h" 3
template<typename... _Args>
iterator
emplace(const_iterator __position, _Args&&... __args);
#pragma line 984 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_vector.h" 3
iterator
insert(const_iterator __position, const value_type& __x);
#pragma line 1014 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_vector.h" 3
iterator
insert(const_iterator __position, value_type&& __x)
{ return emplace(__position, std::move(__x)); }
#pragma line 1031 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_vector.h" 3
iterator
insert(const_iterator __position, initializer_list<value_type> __l)
{ return this->insert(__position, __l.begin(), __l.end()); }
#pragma line 1051 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_vector.h" 3
iterator
insert(const_iterator __position, size_type __n, const value_type& __x)
{
difference_type __offset = __position - cbegin();
_M_fill_insert(begin() + __offset, __n, __x);
return begin() + __offset;
}
#pragma line 1093 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_vector.h" 3
template<typename _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
iterator
insert(const_iterator __position, _InputIterator __first,
_InputIterator __last)
{
difference_type __offset = __position - cbegin();
_M_insert_dispatch(begin() + __offset,
__first, __last, __false_type());
return begin() + __offset;
}
#pragma line 1145 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_vector.h" 3
iterator
#pragma empty_line
erase(const_iterator __position)
{ return _M_erase(begin() + (__position - cbegin())); }
#pragma line 1172 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_vector.h" 3
iterator
#pragma empty_line
erase(const_iterator __first, const_iterator __last)
{
const auto __beg = begin();
const auto __cbeg = cbegin();
return _M_erase(__beg + (__first - __cbeg), __beg + (__last - __cbeg));
}
#pragma line 1194 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_vector.h" 3
void
swap(vector& __x) noexcept
{
this->_M_impl._M_swap_data(__x._M_impl);
_Alloc_traits::_S_on_swap(_M_get_Tp_allocator(),
__x._M_get_Tp_allocator());
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
void
clear() noexcept
{ _M_erase_at_end(this->_M_impl._M_start); }
#pragma empty_line
protected:
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _ForwardIterator>
pointer
_M_allocate_and_copy(size_type __n,
_ForwardIterator __first, _ForwardIterator __last)
{
pointer __result = this->_M_allocate(__n);
try
{
std::__uninitialized_copy_a(__first, __last, __result,
_M_get_Tp_allocator());
return __result;
}
catch(...)
{
_M_deallocate(__result, __n);
throw;
}
}
#pragma line 1243 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_vector.h" 3
template<typename _Integer>
void
_M_initialize_dispatch(_Integer __n, _Integer __value, __true_type)
{
this->_M_impl._M_start = _M_allocate(static_cast<size_type>(__n));
this->_M_impl._M_end_of_storage =
this->_M_impl._M_start + static_cast<size_type>(__n);
_M_fill_initialize(static_cast<size_type>(__n), __value);
}
#pragma empty_line
#pragma empty_line
template<typename _InputIterator>
void
_M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
__false_type)
{
typedef typename std::iterator_traits<_InputIterator>::
iterator_category _IterCategory;
_M_range_initialize(__first, __last, _IterCategory());
}
#pragma empty_line
#pragma empty_line
template<typename _InputIterator>
void
_M_range_initialize(_InputIterator __first,
_InputIterator __last, std::input_iterator_tag)
{
for (; __first != __last; ++__first)
#pragma empty_line
emplace_back(*__first);
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
template<typename _ForwardIterator>
void
_M_range_initialize(_ForwardIterator __first,
_ForwardIterator __last, std::forward_iterator_tag)
{
const size_type __n = std::distance(__first, __last);
this->_M_impl._M_start = this->_M_allocate(__n);
this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
this->_M_impl._M_finish =
std::__uninitialized_copy_a(__first, __last,
this->_M_impl._M_start,
_M_get_Tp_allocator());
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
void
_M_fill_initialize(size_type __n, const value_type& __value)
{
this->_M_impl._M_finish =
std::__uninitialized_fill_n_a(this->_M_impl._M_start, __n, __value,
_M_get_Tp_allocator());
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
void
_M_default_initialize(size_type __n)
{
this->_M_impl._M_finish =
std::__uninitialized_default_n_a(this->_M_impl._M_start, __n,
_M_get_Tp_allocator());
}
#pragma line 1321 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_vector.h" 3
template<typename _Integer>
void
_M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
{ _M_fill_assign(__n, __val); }
#pragma empty_line
#pragma empty_line
template<typename _InputIterator>
void
_M_assign_dispatch(_InputIterator __first, _InputIterator __last,
__false_type)
{
typedef typename std::iterator_traits<_InputIterator>::
iterator_category _IterCategory;
_M_assign_aux(__first, __last, _IterCategory());
}
#pragma empty_line
#pragma empty_line
template<typename _InputIterator>
void
_M_assign_aux(_InputIterator __first, _InputIterator __last,
std::input_iterator_tag);
#pragma empty_line
#pragma empty_line
template<typename _ForwardIterator>
void
_M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
std::forward_iterator_tag);
#pragma empty_line
#pragma empty_line
#pragma empty_line
void
_M_fill_assign(size_type __n, const value_type& __val);
#pragma line 1361 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_vector.h" 3
template<typename _Integer>
void
_M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
__true_type)
{ _M_fill_insert(__pos, __n, __val); }
#pragma empty_line
#pragma empty_line
template<typename _InputIterator>
void
_M_insert_dispatch(iterator __pos, _InputIterator __first,
_InputIterator __last, __false_type)
{
typedef typename std::iterator_traits<_InputIterator>::
iterator_category _IterCategory;
_M_range_insert(__pos, __first, __last, _IterCategory());
}
#pragma empty_line
#pragma empty_line
template<typename _InputIterator>
void
_M_range_insert(iterator __pos, _InputIterator __first,
_InputIterator __last, std::input_iterator_tag);
#pragma empty_line
#pragma empty_line
template<typename _ForwardIterator>
void
_M_range_insert(iterator __pos, _ForwardIterator __first,
_ForwardIterator __last, std::forward_iterator_tag);
#pragma empty_line
#pragma empty_line
#pragma empty_line
void
_M_fill_insert(iterator __pos, size_type __n, const value_type& __x);
#pragma empty_line
#pragma empty_line
#pragma empty_line
void
_M_default_append(size_type __n);
#pragma empty_line
bool
_M_shrink_to_fit();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename... _Args>
void
_M_insert_aux(iterator __position, _Args&&... __args);
#pragma empty_line
template<typename... _Args>
void
_M_emplace_back_aux(_Args&&... __args);
#pragma empty_line
#pragma empty_line
#pragma empty_line
size_type
_M_check_len(size_type __n, const char* __s) const
{
if (max_size() - size() < __n)
__throw_length_error((__s));
#pragma empty_line
const size_type __len = size() + std::max(size(), __n);
return (__len < size() || __len > max_size()) ? max_size() : __len;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
void
_M_erase_at_end(pointer __pos) noexcept
{
std::_Destroy(__pos, this->_M_impl._M_finish, _M_get_Tp_allocator());
this->_M_impl._M_finish = __pos;
}
#pragma empty_line
iterator
_M_erase(iterator __position);
#pragma empty_line
iterator
_M_erase(iterator __first, iterator __last);
#pragma empty_line
#pragma empty_line
private:
#pragma empty_line
#pragma empty_line
#pragma empty_line
void
_M_move_assign(vector&& __x, std::true_type) noexcept
{
vector __tmp(get_allocator());
this->_M_impl._M_swap_data(__tmp._M_impl);
this->_M_impl._M_swap_data(__x._M_impl);
std::__alloc_on_move(_M_get_Tp_allocator(), __x._M_get_Tp_allocator());
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
void
_M_move_assign(vector&& __x, std::false_type)
{
if (__x._M_get_Tp_allocator() == this->_M_get_Tp_allocator())
_M_move_assign(std::move(__x), std::true_type());
else
{
#pragma empty_line
#pragma empty_line
this->assign(std::__make_move_if_noexcept_iterator(__x.begin()),
std::__make_move_if_noexcept_iterator(__x.end()));
__x.clear();
}
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Up>
_Up*
_M_data_ptr(_Up* __ptr) const
{ return __ptr; }
#pragma empty_line
template<typename _Ptr>
typename std::pointer_traits<_Ptr>::element_type*
_M_data_ptr(_Ptr __ptr) const
{ return empty() ? nullptr : std::__addressof(*__ptr); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
};
#pragma line 1507 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_vector.h" 3
template<typename _Tp, typename _Alloc>
inline bool
operator==(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
{ return (__x.size() == __y.size()
&& std::equal(__x.begin(), __x.end(), __y.begin())); }
#pragma line 1524 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_vector.h" 3
template<typename _Tp, typename _Alloc>
inline bool
operator<(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
{ return std::lexicographical_compare(__x.begin(), __x.end(),
__y.begin(), __y.end()); }
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename _Alloc>
inline bool
operator!=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
{ return !(__x == __y); }
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename _Alloc>
inline bool
operator>(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
{ return __y < __x; }
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename _Alloc>
inline bool
operator<=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
{ return !(__y < __x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename _Alloc>
inline bool
operator>=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
{ return !(__x < __y); }
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename _Alloc>
inline void
swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y)
noexcept(noexcept(__x.swap(__y)))
{ __x.swap(__y); }
#pragma empty_line
#pragma empty_line
}
#pragma line 65 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/vector" 2 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_bvector.h" 1 3
#pragma line 63 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_bvector.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
typedef unsigned long _Bit_type;
enum { _S_word_bit = int(8 * sizeof(_Bit_type)) };
#pragma empty_line
struct _Bit_reference
{
_Bit_type * _M_p;
_Bit_type _M_mask;
#pragma empty_line
_Bit_reference(_Bit_type * __x, _Bit_type __y)
: _M_p(__x), _M_mask(__y) { }
#pragma empty_line
_Bit_reference() noexcept : _M_p(0), _M_mask(0) { }
#pragma empty_line
operator bool() const noexcept
{ return !!(*_M_p & _M_mask); }
#pragma empty_line
_Bit_reference&
operator=(bool __x) noexcept
{
if (__x)
*_M_p |= _M_mask;
else
*_M_p &= ~_M_mask;
return *this;
}
#pragma empty_line
_Bit_reference&
operator=(const _Bit_reference& __x) noexcept
{ return *this = bool(__x); }
#pragma empty_line
bool
operator==(const _Bit_reference& __x) const
{ return bool(*this) == bool(__x); }
#pragma empty_line
bool
operator<(const _Bit_reference& __x) const
{ return !bool(*this) && bool(__x); }
#pragma empty_line
void
flip() noexcept
{ *_M_p ^= _M_mask; }
};
#pragma empty_line
#pragma empty_line
inline void
swap(_Bit_reference __x, _Bit_reference __y) noexcept
{
bool __tmp = __x;
__x = __y;
__y = __tmp;
}
#pragma empty_line
inline void
swap(_Bit_reference __x, bool& __y) noexcept
{
bool __tmp = __x;
__x = __y;
__y = __tmp;
}
#pragma empty_line
inline void
swap(bool& __x, _Bit_reference __y) noexcept
{
bool __tmp = __x;
__x = __y;
__y = __tmp;
}
#pragma empty_line
#pragma empty_line
struct _Bit_iterator_base
: public std::iterator<std::random_access_iterator_tag, bool>
{
_Bit_type * _M_p;
unsigned int _M_offset;
#pragma empty_line
_Bit_iterator_base(_Bit_type * __x, unsigned int __y)
: _M_p(__x), _M_offset(__y) { }
#pragma empty_line
void
_M_bump_up()
{
if (_M_offset++ == int(_S_word_bit) - 1)
{
_M_offset = 0;
++_M_p;
}
}
#pragma empty_line
void
_M_bump_down()
{
if (_M_offset-- == 0)
{
_M_offset = int(_S_word_bit) - 1;
--_M_p;
}
}
#pragma empty_line
void
_M_incr(ptrdiff_t __i)
{
difference_type __n = __i + _M_offset;
_M_p += __n / int(_S_word_bit);
__n = __n % int(_S_word_bit);
if (__n < 0)
{
__n += int(_S_word_bit);
--_M_p;
}
_M_offset = static_cast<unsigned int>(__n);
}
#pragma empty_line
bool
operator==(const _Bit_iterator_base& __i) const
{ return _M_p == __i._M_p && _M_offset == __i._M_offset; }
#pragma empty_line
bool
operator<(const _Bit_iterator_base& __i) const
{
return _M_p < __i._M_p
|| (_M_p == __i._M_p && _M_offset < __i._M_offset);
}
#pragma empty_line
bool
operator!=(const _Bit_iterator_base& __i) const
{ return !(*this == __i); }
#pragma empty_line
bool
operator>(const _Bit_iterator_base& __i) const
{ return __i < *this; }
#pragma empty_line
bool
operator<=(const _Bit_iterator_base& __i) const
{ return !(__i < *this); }
#pragma empty_line
bool
operator>=(const _Bit_iterator_base& __i) const
{ return !(*this < __i); }
};
#pragma empty_line
inline ptrdiff_t
operator-(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
{
return (int(_S_word_bit) * (__x._M_p - __y._M_p)
+ __x._M_offset - __y._M_offset);
}
#pragma empty_line
struct _Bit_iterator : public _Bit_iterator_base
{
typedef _Bit_reference reference;
typedef _Bit_reference* pointer;
typedef _Bit_iterator iterator;
#pragma empty_line
_Bit_iterator() : _Bit_iterator_base(0, 0) { }
#pragma empty_line
_Bit_iterator(_Bit_type * __x, unsigned int __y)
: _Bit_iterator_base(__x, __y) { }
#pragma empty_line
iterator
_M_const_cast() const
{ return *this; }
#pragma empty_line
reference
operator*() const
{ return reference(_M_p, 1UL << _M_offset); }
#pragma empty_line
iterator&
operator++()
{
_M_bump_up();
return *this;
}
#pragma empty_line
iterator
operator++(int)
{
iterator __tmp = *this;
_M_bump_up();
return __tmp;
}
#pragma empty_line
iterator&
operator--()
{
_M_bump_down();
return *this;
}
#pragma empty_line
iterator
operator--(int)
{
iterator __tmp = *this;
_M_bump_down();
return __tmp;
}
#pragma empty_line
iterator&
operator+=(difference_type __i)
{
_M_incr(__i);
return *this;
}
#pragma empty_line
iterator&
operator-=(difference_type __i)
{
*this += -__i;
return *this;
}
#pragma empty_line
iterator
operator+(difference_type __i) const
{
iterator __tmp = *this;
return __tmp += __i;
}
#pragma empty_line
iterator
operator-(difference_type __i) const
{
iterator __tmp = *this;
return __tmp -= __i;
}
#pragma empty_line
reference
operator[](difference_type __i) const
{ return *(*this + __i); }
};
#pragma empty_line
inline _Bit_iterator
operator+(ptrdiff_t __n, const _Bit_iterator& __x)
{ return __x + __n; }
#pragma empty_line
struct _Bit_const_iterator : public _Bit_iterator_base
{
typedef bool reference;
typedef bool const_reference;
typedef const bool* pointer;
typedef _Bit_const_iterator const_iterator;
#pragma empty_line
_Bit_const_iterator() : _Bit_iterator_base(0, 0) { }
#pragma empty_line
_Bit_const_iterator(_Bit_type * __x, unsigned int __y)
: _Bit_iterator_base(__x, __y) { }
#pragma empty_line
_Bit_const_iterator(const _Bit_iterator& __x)
: _Bit_iterator_base(__x._M_p, __x._M_offset) { }
#pragma empty_line
_Bit_iterator
_M_const_cast() const
{ return _Bit_iterator(_M_p, _M_offset); }
#pragma empty_line
const_reference
operator*() const
{ return _Bit_reference(_M_p, 1UL << _M_offset); }
#pragma empty_line
const_iterator&
operator++()
{
_M_bump_up();
return *this;
}
#pragma empty_line
const_iterator
operator++(int)
{
const_iterator __tmp = *this;
_M_bump_up();
return __tmp;
}
#pragma empty_line
const_iterator&
operator--()
{
_M_bump_down();
return *this;
}
#pragma empty_line
const_iterator
operator--(int)
{
const_iterator __tmp = *this;
_M_bump_down();
return __tmp;
}
#pragma empty_line
const_iterator&
operator+=(difference_type __i)
{
_M_incr(__i);
return *this;
}
#pragma empty_line
const_iterator&
operator-=(difference_type __i)
{
*this += -__i;
return *this;
}
#pragma empty_line
const_iterator
operator+(difference_type __i) const
{
const_iterator __tmp = *this;
return __tmp += __i;
}
#pragma empty_line
const_iterator
operator-(difference_type __i) const
{
const_iterator __tmp = *this;
return __tmp -= __i;
}
#pragma empty_line
const_reference
operator[](difference_type __i) const
{ return *(*this + __i); }
};
#pragma empty_line
inline _Bit_const_iterator
operator+(ptrdiff_t __n, const _Bit_const_iterator& __x)
{ return __x + __n; }
#pragma empty_line
inline void
__fill_bvector(_Bit_iterator __first, _Bit_iterator __last, bool __x)
{
for (; __first != __last; ++__first)
*__first = __x;
}
#pragma empty_line
inline void
fill(_Bit_iterator __first, _Bit_iterator __last, const bool& __x)
{
if (__first._M_p != __last._M_p)
{
std::fill(__first._M_p + 1, __last._M_p, __x ? ~0 : 0);
__fill_bvector(__first, _Bit_iterator(__first._M_p + 1, 0), __x);
__fill_bvector(_Bit_iterator(__last._M_p, 0), __last, __x);
}
else
__fill_bvector(__first, __last, __x);
}
#pragma empty_line
template<typename _Alloc>
struct _Bvector_base
{
typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
rebind<_Bit_type>::other _Bit_alloc_type;
typedef typename __gnu_cxx::__alloc_traits<_Bit_alloc_type>
_Bit_alloc_traits;
typedef typename _Bit_alloc_traits::pointer _Bit_pointer;
#pragma empty_line
struct _Bvector_impl
: public _Bit_alloc_type
{
_Bit_iterator _M_start;
_Bit_iterator _M_finish;
_Bit_pointer _M_end_of_storage;
#pragma empty_line
_Bvector_impl()
: _Bit_alloc_type(), _M_start(), _M_finish(), _M_end_of_storage()
{ }
#pragma empty_line
_Bvector_impl(const _Bit_alloc_type& __a)
: _Bit_alloc_type(__a), _M_start(), _M_finish(), _M_end_of_storage()
{ }
#pragma empty_line
#pragma empty_line
_Bvector_impl(_Bit_alloc_type&& __a)
: _Bit_alloc_type(std::move(__a)), _M_start(), _M_finish(),
_M_end_of_storage()
{ }
#pragma empty_line
#pragma empty_line
_Bit_type*
_M_end_addr() const noexcept
{
if (_M_end_of_storage)
return std::__addressof(_M_end_of_storage[-1]) + 1;
return 0;
}
};
#pragma empty_line
public:
typedef _Alloc allocator_type;
#pragma empty_line
_Bit_alloc_type&
_M_get_Bit_allocator() noexcept
{ return *static_cast<_Bit_alloc_type*>(&this->_M_impl); }
#pragma empty_line
const _Bit_alloc_type&
_M_get_Bit_allocator() const noexcept
{ return *static_cast<const _Bit_alloc_type*>(&this->_M_impl); }
#pragma empty_line
allocator_type
get_allocator() const noexcept
{ return allocator_type(_M_get_Bit_allocator()); }
#pragma empty_line
_Bvector_base()
: _M_impl() { }
#pragma empty_line
_Bvector_base(const allocator_type& __a)
: _M_impl(__a) { }
#pragma empty_line
#pragma empty_line
_Bvector_base(_Bvector_base&& __x) noexcept
: _M_impl(std::move(__x._M_get_Bit_allocator()))
{
this->_M_impl._M_start = __x._M_impl._M_start;
this->_M_impl._M_finish = __x._M_impl._M_finish;
this->_M_impl._M_end_of_storage = __x._M_impl._M_end_of_storage;
__x._M_impl._M_start = _Bit_iterator();
__x._M_impl._M_finish = _Bit_iterator();
__x._M_impl._M_end_of_storage = nullptr;
}
#pragma empty_line
#pragma empty_line
~_Bvector_base()
{ this->_M_deallocate(); }
#pragma empty_line
protected:
_Bvector_impl _M_impl;
#pragma empty_line
_Bit_pointer
_M_allocate(size_t __n)
{ return _Bit_alloc_traits::allocate(_M_impl, _S_nword(__n)); }
#pragma empty_line
void
_M_deallocate()
{
if (_M_impl._M_start._M_p)
{
const size_t __n = _M_impl._M_end_addr() - _M_impl._M_start._M_p;
_Bit_alloc_traits::deallocate(_M_impl,
_M_impl._M_end_of_storage - __n,
__n);
}
}
#pragma empty_line
static size_t
_S_nword(size_t __n)
{ return (__n + int(_S_word_bit) - 1) / int(_S_word_bit); }
};
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma line 540 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_bvector.h" 3
template<typename _Alloc>
class vector<bool, _Alloc> : protected _Bvector_base<_Alloc>
{
typedef _Bvector_base<_Alloc> _Base;
typedef typename _Base::_Bit_pointer _Bit_pointer;
typedef typename _Base::_Bit_alloc_traits _Bit_alloc_traits;
#pragma empty_line
#pragma empty_line
template<typename> friend struct hash;
#pragma empty_line
#pragma empty_line
public:
typedef bool value_type;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef _Bit_reference reference;
typedef bool const_reference;
typedef _Bit_reference* pointer;
typedef const bool* const_pointer;
typedef _Bit_iterator iterator;
typedef _Bit_const_iterator const_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef _Alloc allocator_type;
#pragma empty_line
allocator_type get_allocator() const
{ return _Base::get_allocator(); }
#pragma empty_line
protected:
using _Base::_M_allocate;
using _Base::_M_deallocate;
using _Base::_S_nword;
using _Base::_M_get_Bit_allocator;
#pragma empty_line
public:
vector()
#pragma empty_line
noexcept(is_nothrow_default_constructible<allocator_type>::value)
#pragma empty_line
: _Base() { }
#pragma empty_line
explicit
vector(const allocator_type& __a)
: _Base(__a) { }
#pragma empty_line
#pragma empty_line
explicit
vector(size_type __n, const allocator_type& __a = allocator_type())
: vector(__n, false, __a)
{ }
#pragma empty_line
vector(size_type __n, const bool& __value,
const allocator_type& __a = allocator_type())
: _Base(__a)
{
_M_initialize(__n);
std::fill(this->_M_impl._M_start._M_p, this->_M_impl._M_end_addr(),
__value ? ~0 : 0);
}
#pragma line 611 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_bvector.h" 3
vector(const vector& __x)
: _Base(_Bit_alloc_traits::_S_select_on_copy(__x._M_get_Bit_allocator()))
{
_M_initialize(__x.size());
_M_copy_aligned(__x.begin(), __x.end(), this->_M_impl._M_start);
}
#pragma empty_line
#pragma empty_line
vector(vector&& __x) noexcept
: _Base(std::move(__x)) { }
#pragma empty_line
vector(vector&& __x, const allocator_type& __a)
noexcept(_Bit_alloc_traits::_S_always_equal())
: _Base(__a)
{
if (__x.get_allocator() == __a)
{
this->_M_impl._M_start = __x._M_impl._M_start;
this->_M_impl._M_finish = __x._M_impl._M_finish;
this->_M_impl._M_end_of_storage = __x._M_impl._M_end_of_storage;
__x._M_impl._M_start = _Bit_iterator();
__x._M_impl._M_finish = _Bit_iterator();
__x._M_impl._M_end_of_storage = nullptr;
}
else
{
_M_initialize(__x.size());
_M_copy_aligned(__x.begin(), __x.end(), begin());
__x.clear();
}
}
#pragma empty_line
vector(const vector& __x, const allocator_type& __a)
: _Base(__a)
{
_M_initialize(__x.size());
_M_copy_aligned(__x.begin(), __x.end(), this->_M_impl._M_start);
}
#pragma empty_line
vector(initializer_list<bool> __l,
const allocator_type& __a = allocator_type())
: _Base(__a)
{
_M_initialize_range(__l.begin(), __l.end(),
random_access_iterator_tag());
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
vector(_InputIterator __first, _InputIterator __last,
const allocator_type& __a = allocator_type())
: _Base(__a)
{ _M_initialize_dispatch(__first, __last, __false_type()); }
#pragma line 677 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_bvector.h" 3
~vector() noexcept { }
#pragma empty_line
vector&
operator=(const vector& __x)
{
if (&__x == this)
return *this;
#pragma empty_line
if (_Bit_alloc_traits::_S_propagate_on_copy_assign())
{
if (this->_M_get_Bit_allocator() != __x._M_get_Bit_allocator())
{
this->_M_deallocate();
std::__alloc_on_copy(_M_get_Bit_allocator(),
__x._M_get_Bit_allocator());
_M_initialize(__x.size());
}
else
std::__alloc_on_copy(_M_get_Bit_allocator(),
__x._M_get_Bit_allocator());
}
#pragma empty_line
if (__x.size() > capacity())
{
this->_M_deallocate();
_M_initialize(__x.size());
}
this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(),
begin());
return *this;
}
#pragma empty_line
#pragma empty_line
vector&
operator=(vector&& __x) noexcept(_Bit_alloc_traits::_S_nothrow_move())
{
if (_Bit_alloc_traits::_S_propagate_on_move_assign()
|| this->_M_get_Bit_allocator() == __x._M_get_Bit_allocator())
{
this->_M_deallocate();
this->_M_impl._M_start = __x._M_impl._M_start;
this->_M_impl._M_finish = __x._M_impl._M_finish;
this->_M_impl._M_end_of_storage = __x._M_impl._M_end_of_storage;
__x._M_impl._M_start = _Bit_iterator();
__x._M_impl._M_finish = _Bit_iterator();
__x._M_impl._M_end_of_storage = nullptr;
std::__alloc_on_move(_M_get_Bit_allocator(),
__x._M_get_Bit_allocator());
}
else
{
if (__x.size() > capacity())
{
this->_M_deallocate();
_M_initialize(__x.size());
}
this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(),
begin());
__x.clear();
}
return *this;
}
#pragma empty_line
vector&
operator=(initializer_list<bool> __l)
{
this->assign (__l.begin(), __l.end());
return *this;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
void
assign(size_type __n, const bool& __x)
{ _M_fill_assign(__n, __x); }
#pragma empty_line
#pragma empty_line
template<typename _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
void
assign(_InputIterator __first, _InputIterator __last)
{ _M_assign_dispatch(__first, __last, __false_type()); }
#pragma line 773 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_bvector.h" 3
void
assign(initializer_list<bool> __l)
{ this->assign(__l.begin(), __l.end()); }
#pragma empty_line
#pragma empty_line
iterator
begin() noexcept
{ return this->_M_impl._M_start; }
#pragma empty_line
const_iterator
begin() const noexcept
{ return this->_M_impl._M_start; }
#pragma empty_line
iterator
end() noexcept
{ return this->_M_impl._M_finish; }
#pragma empty_line
const_iterator
end() const noexcept
{ return this->_M_impl._M_finish; }
#pragma empty_line
reverse_iterator
rbegin() noexcept
{ return reverse_iterator(end()); }
#pragma empty_line
const_reverse_iterator
rbegin() const noexcept
{ return const_reverse_iterator(end()); }
#pragma empty_line
reverse_iterator
rend() noexcept
{ return reverse_iterator(begin()); }
#pragma empty_line
const_reverse_iterator
rend() const noexcept
{ return const_reverse_iterator(begin()); }
#pragma empty_line
#pragma empty_line
const_iterator
cbegin() const noexcept
{ return this->_M_impl._M_start; }
#pragma empty_line
const_iterator
cend() const noexcept
{ return this->_M_impl._M_finish; }
#pragma empty_line
const_reverse_iterator
crbegin() const noexcept
{ return const_reverse_iterator(end()); }
#pragma empty_line
const_reverse_iterator
crend() const noexcept
{ return const_reverse_iterator(begin()); }
#pragma empty_line
#pragma empty_line
size_type
size() const noexcept
{ return size_type(end() - begin()); }
#pragma empty_line
size_type
max_size() const noexcept
{
const size_type __isize =
__gnu_cxx::__numeric_traits<difference_type>::__max
- int(_S_word_bit) + 1;
const size_type __asize
= _Bit_alloc_traits::max_size(_M_get_Bit_allocator());
return (__asize <= __isize / int(_S_word_bit)
? __asize * int(_S_word_bit) : __isize);
}
#pragma empty_line
size_type
capacity() const noexcept
{ return size_type(const_iterator(this->_M_impl._M_end_addr(), 0)
- begin()); }
#pragma empty_line
bool
empty() const noexcept
{ return begin() == end(); }
#pragma empty_line
reference
operator[](size_type __n)
{
return *iterator(this->_M_impl._M_start._M_p
+ __n / int(_S_word_bit), __n % int(_S_word_bit));
}
#pragma empty_line
const_reference
operator[](size_type __n) const
{
return *const_iterator(this->_M_impl._M_start._M_p
+ __n / int(_S_word_bit), __n % int(_S_word_bit));
}
#pragma empty_line
protected:
void
_M_range_check(size_type __n) const
{
if (__n >= this->size())
__throw_out_of_range_fmt(("vector<bool>::_M_range_check: __n " "(which is %zu) >= this->size() " "(which is %zu)")
#pragma empty_line
,
__n, this->size());
}
#pragma empty_line
public:
reference
at(size_type __n)
{ _M_range_check(__n); return (*this)[__n]; }
#pragma empty_line
const_reference
at(size_type __n) const
{ _M_range_check(__n); return (*this)[__n]; }
#pragma empty_line
void
reserve(size_type __n)
{
if (__n > max_size())
__throw_length_error(("vector::reserve"));
if (capacity() < __n)
_M_reallocate(__n);
}
#pragma empty_line
reference
front()
{ return *begin(); }
#pragma empty_line
const_reference
front() const
{ return *begin(); }
#pragma empty_line
reference
back()
{ return *(end() - 1); }
#pragma empty_line
const_reference
back() const
{ return *(end() - 1); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
void
data() noexcept { }
#pragma empty_line
void
push_back(bool __x)
{
if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr())
*this->_M_impl._M_finish++ = __x;
else
_M_insert_aux(end(), __x);
}
#pragma empty_line
void
swap(vector& __x) noexcept
{
std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
std::swap(this->_M_impl._M_end_of_storage,
__x._M_impl._M_end_of_storage);
_Bit_alloc_traits::_S_on_swap(_M_get_Bit_allocator(),
__x._M_get_Bit_allocator());
}
#pragma empty_line
#pragma empty_line
static void
swap(reference __x, reference __y) noexcept
{
bool __tmp = __x;
__x = __y;
__y = __tmp;
}
#pragma empty_line
iterator
#pragma empty_line
insert(const_iterator __position, const bool& __x = bool())
#pragma empty_line
#pragma empty_line
#pragma empty_line
{
const difference_type __n = __position - begin();
if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr()
&& __position == end())
*this->_M_impl._M_finish++ = __x;
else
_M_insert_aux(__position._M_const_cast(), __x);
return begin() + __n;
}
#pragma empty_line
#pragma empty_line
template<typename _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
iterator
insert(const_iterator __position,
_InputIterator __first, _InputIterator __last)
{
difference_type __offset = __position - cbegin();
_M_insert_dispatch(__position._M_const_cast(),
__first, __last, __false_type());
return begin() + __offset;
}
#pragma line 989 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_bvector.h" 3
iterator
insert(const_iterator __position, size_type __n, const bool& __x)
{
difference_type __offset = __position - cbegin();
_M_fill_insert(__position._M_const_cast(), __n, __x);
return begin() + __offset;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
iterator
insert(const_iterator __p, initializer_list<bool> __l)
{ return this->insert(__p, __l.begin(), __l.end()); }
#pragma empty_line
#pragma empty_line
void
pop_back()
{ --this->_M_impl._M_finish; }
#pragma empty_line
iterator
#pragma empty_line
erase(const_iterator __position)
#pragma empty_line
#pragma empty_line
#pragma empty_line
{ return _M_erase(__position._M_const_cast()); }
#pragma empty_line
iterator
#pragma empty_line
erase(const_iterator __first, const_iterator __last)
#pragma empty_line
#pragma empty_line
#pragma empty_line
{ return _M_erase(__first._M_const_cast(), __last._M_const_cast()); }
#pragma empty_line
void
resize(size_type __new_size, bool __x = bool())
{
if (__new_size < size())
_M_erase_at_end(begin() + difference_type(__new_size));
else
insert(end(), __new_size - size(), __x);
}
#pragma empty_line
#pragma empty_line
void
shrink_to_fit()
{ _M_shrink_to_fit(); }
#pragma empty_line
#pragma empty_line
void
flip() noexcept
{
_Bit_type * const __end = this->_M_impl._M_end_addr();
for (_Bit_type * __p = this->_M_impl._M_start._M_p; __p != __end; ++__p)
*__p = ~*__p;
}
#pragma empty_line
void
clear() noexcept
{ _M_erase_at_end(begin()); }
#pragma empty_line
#pragma empty_line
template<typename... _Args>
void
emplace_back(_Args&&... __args)
{ push_back(bool(__args...)); }
#pragma empty_line
template<typename... _Args>
iterator
emplace(const_iterator __pos, _Args&&... __args)
{ return insert(__pos, bool(__args...)); }
#pragma empty_line
#pragma empty_line
protected:
#pragma empty_line
iterator
_M_copy_aligned(const_iterator __first, const_iterator __last,
iterator __result)
{
_Bit_type* __q = std::copy(__first._M_p, __last._M_p, __result._M_p);
return std::copy(const_iterator(__last._M_p, 0), __last,
iterator(__q, 0));
}
#pragma empty_line
void
_M_initialize(size_type __n)
{
_Bit_pointer __q = this->_M_allocate(__n);
this->_M_impl._M_end_of_storage = __q + _S_nword(__n);
this->_M_impl._M_start = iterator(std::__addressof(*__q), 0);
this->_M_impl._M_finish = this->_M_impl._M_start + difference_type(__n);
}
#pragma empty_line
void
_M_reallocate(size_type __n);
#pragma empty_line
#pragma empty_line
bool
_M_shrink_to_fit();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Integer>
void
_M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
{
_M_initialize(static_cast<size_type>(__n));
std::fill(this->_M_impl._M_start._M_p,
this->_M_impl._M_end_addr(), __x ? ~0 : 0);
}
#pragma empty_line
template<typename _InputIterator>
void
_M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
__false_type)
{ _M_initialize_range(__first, __last,
std::__iterator_category(__first)); }
#pragma empty_line
template<typename _InputIterator>
void
_M_initialize_range(_InputIterator __first, _InputIterator __last,
std::input_iterator_tag)
{
for (; __first != __last; ++__first)
push_back(*__first);
}
#pragma empty_line
template<typename _ForwardIterator>
void
_M_initialize_range(_ForwardIterator __first, _ForwardIterator __last,
std::forward_iterator_tag)
{
const size_type __n = std::distance(__first, __last);
_M_initialize(__n);
std::copy(__first, __last, this->_M_impl._M_start);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Integer>
void
_M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
{ _M_fill_assign(__n, __val); }
#pragma empty_line
template<class _InputIterator>
void
_M_assign_dispatch(_InputIterator __first, _InputIterator __last,
__false_type)
{ _M_assign_aux(__first, __last, std::__iterator_category(__first)); }
#pragma empty_line
void
_M_fill_assign(size_t __n, bool __x)
{
if (__n > size())
{
std::fill(this->_M_impl._M_start._M_p,
this->_M_impl._M_end_addr(), __x ? ~0 : 0);
insert(end(), __n - size(), __x);
}
else
{
_M_erase_at_end(begin() + __n);
std::fill(this->_M_impl._M_start._M_p,
this->_M_impl._M_end_addr(), __x ? ~0 : 0);
}
}
#pragma empty_line
template<typename _InputIterator>
void
_M_assign_aux(_InputIterator __first, _InputIterator __last,
std::input_iterator_tag)
{
iterator __cur = begin();
for (; __first != __last && __cur != end(); ++__cur, ++__first)
*__cur = *__first;
if (__first == __last)
_M_erase_at_end(__cur);
else
insert(end(), __first, __last);
}
#pragma empty_line
template<typename _ForwardIterator>
void
_M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
std::forward_iterator_tag)
{
const size_type __len = std::distance(__first, __last);
if (__len < size())
_M_erase_at_end(std::copy(__first, __last, begin()));
else
{
_ForwardIterator __mid = __first;
std::advance(__mid, size());
std::copy(__first, __mid, begin());
insert(end(), __mid, __last);
}
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Integer>
void
_M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
__true_type)
{ _M_fill_insert(__pos, __n, __x); }
#pragma empty_line
template<typename _InputIterator>
void
_M_insert_dispatch(iterator __pos,
_InputIterator __first, _InputIterator __last,
__false_type)
{ _M_insert_range(__pos, __first, __last,
std::__iterator_category(__first)); }
#pragma empty_line
void
_M_fill_insert(iterator __position, size_type __n, bool __x);
#pragma empty_line
template<typename _InputIterator>
void
_M_insert_range(iterator __pos, _InputIterator __first,
_InputIterator __last, std::input_iterator_tag)
{
for (; __first != __last; ++__first)
{
__pos = insert(__pos, *__first);
++__pos;
}
}
#pragma empty_line
template<typename _ForwardIterator>
void
_M_insert_range(iterator __position, _ForwardIterator __first,
_ForwardIterator __last, std::forward_iterator_tag);
#pragma empty_line
void
_M_insert_aux(iterator __position, bool __x);
#pragma empty_line
size_type
_M_check_len(size_type __n, const char* __s) const
{
if (max_size() - size() < __n)
__throw_length_error((__s));
#pragma empty_line
const size_type __len = size() + std::max(size(), __n);
return (__len < size() || __len > max_size()) ? max_size() : __len;
}
#pragma empty_line
void
_M_erase_at_end(iterator __pos)
{ this->_M_impl._M_finish = __pos; }
#pragma empty_line
iterator
_M_erase(iterator __pos);
#pragma empty_line
iterator
_M_erase(iterator __first, iterator __last);
};
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/functional_hash.h" 1 3
#pragma line 33 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/functional_hash.h" 3
#pragma empty_line
#pragma line 34 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/functional_hash.h" 3
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/hash_bytes.h" 1 3
#pragma line 33 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/hash_bytes.h" 3
#pragma empty_line
#pragma line 34 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/hash_bytes.h" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
size_t
_Hash_bytes(const void* __ptr, size_t __len, size_t __seed);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
size_t
_Fnv_hash_bytes(const void* __ptr, size_t __len, size_t __seed);
#pragma empty_line
#pragma empty_line
}
#pragma line 36 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/functional_hash.h" 2 3
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma line 49 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
};
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct hash;
#pragma empty_line
#pragma empty_line
template<typename _Tp, bool = is_enum<_Tp>::value>
struct __hash_enum
{
private:
#pragma empty_line
__hash_enum(__hash_enum&&);
~__hash_enum();
};
#pragma empty_line
#pragma empty_line
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));
}
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct hash : __hash_enum<_Tp>
{ };
#pragma empty_line
#pragma empty_line
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); }
};
#pragma line 108 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); } };
#pragma empty_line
#pragma empty_line
template<> struct hash<char> : public __hash_base<size_t, char> { size_t operator()(char __val) const noexcept { return static_cast<size_t>(__val); } };
#pragma empty_line
#pragma empty_line
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); } };
#pragma empty_line
#pragma empty_line
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); } };
#pragma empty_line
#pragma empty_line
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); } };
#pragma empty_line
#pragma empty_line
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); } };
#pragma empty_line
#pragma empty_line
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); } };
#pragma empty_line
#pragma empty_line
template<> struct hash<short> : public __hash_base<size_t, short> { size_t operator()(short __val) const noexcept { return static_cast<size_t>(__val); } };
#pragma empty_line
#pragma empty_line
template<> struct hash<int> : public __hash_base<size_t, int> { size_t operator()(int __val) const noexcept { return static_cast<size_t>(__val); } };
#pragma empty_line
#pragma empty_line
template<> struct hash<long> : public __hash_base<size_t, long> { size_t operator()(long __val) const noexcept { return static_cast<size_t>(__val); } };
#pragma empty_line
#pragma empty_line
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); } };
#pragma empty_line
#pragma empty_line
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); } };
#pragma empty_line
#pragma empty_line
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); } };
#pragma empty_line
#pragma empty_line
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); } };
#pragma empty_line
#pragma empty_line
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); } };
#pragma empty_line
#pragma empty_line
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); } };
#pragma line 171 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
template<typename _Tp>
static size_t
hash(const _Tp& __val)
{ return hash(&__val, sizeof(__val)); }
#pragma empty_line
template<typename _Tp>
static size_t
__hash_combine(const _Tp& __val, size_t __hash)
{ return hash(&__val, sizeof(__val), __hash); }
};
#pragma empty_line
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); }
#pragma empty_line
template<typename _Tp>
static size_t
hash(const _Tp& __val)
{ return hash(&__val, sizeof(__val)); }
#pragma empty_line
template<typename _Tp>
static size_t
__hash_combine(const _Tp& __val, size_t __hash)
{ return hash(&__val, sizeof(__val), __hash); }
};
#pragma empty_line
#pragma empty_line
template<>
struct hash<float> : public __hash_base<size_t, float>
{
size_t
operator()(float __val) const noexcept
{
#pragma empty_line
return __val != 0.0f ? std::_Hash_impl::hash(__val) : 0;
}
};
#pragma empty_line
#pragma empty_line
template<>
struct hash<double> : public __hash_base<size_t, double>
{
size_t
operator()(double __val) const noexcept
{
#pragma empty_line
return __val != 0.0 ? std::_Hash_impl::hash(__val) : 0;
}
};
#pragma empty_line
#pragma empty_line
template<>
struct hash<long double>
: public __hash_base<size_t, long double>
{
__attribute__ ((__pure__)) size_t
operator()(long double __val) const noexcept;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Hash>
struct __is_fast_hash : public std::true_type
{ };
#pragma empty_line
template<>
struct __is_fast_hash<hash<long double>> : public std::false_type
{ };
#pragma empty_line
#pragma empty_line
}
#pragma line 1263 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_bvector.h" 2 3
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Alloc>
struct hash<std::vector<bool, _Alloc>>
: public __hash_base<size_t, std::vector<bool, _Alloc>>
{
size_t
operator()(const std::vector<bool, _Alloc>&) const noexcept;
};
#pragma empty_line
#pragma empty_line
}
#pragma line 66 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/vector" 2 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/vector.tcc" 1 3
#pragma line 59 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/vector.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename _Alloc>
void
vector<_Tp, _Alloc>::
reserve(size_type __n)
{
if (__n > this->max_size())
__throw_length_error(("vector::reserve"));
if (this->capacity() < __n)
{
const size_type __old_size = size();
pointer __tmp = _M_allocate_and_copy(__n,
std::__make_move_if_noexcept_iterator(this->_M_impl._M_start),
std::__make_move_if_noexcept_iterator(this->_M_impl._M_finish));
std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
_M_get_Tp_allocator());
_M_deallocate(this->_M_impl._M_start,
this->_M_impl._M_end_of_storage
- this->_M_impl._M_start);
this->_M_impl._M_start = __tmp;
this->_M_impl._M_finish = __tmp + __old_size;
this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
}
}
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename _Alloc>
template<typename... _Args>
void
vector<_Tp, _Alloc>::
emplace_back(_Args&&... __args)
{
if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
{
_Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
std::forward<_Args>(__args)...);
++this->_M_impl._M_finish;
}
else
_M_emplace_back_aux(std::forward<_Args>(__args)...);
}
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename _Alloc>
typename vector<_Tp, _Alloc>::iterator
vector<_Tp, _Alloc>::
#pragma empty_line
insert(const_iterator __position, const value_type& __x)
#pragma empty_line
#pragma empty_line
#pragma empty_line
{
const size_type __n = __position - begin();
if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage
&& __position == end())
{
_Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, __x);
++this->_M_impl._M_finish;
}
else
{
#pragma empty_line
const auto __pos = begin() + (__position - cbegin());
if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
{
_Tp __x_copy = __x;
_M_insert_aux(__pos, std::move(__x_copy));
}
else
_M_insert_aux(__pos, __x);
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
return iterator(this->_M_impl._M_start + __n);
}
#pragma empty_line
template<typename _Tp, typename _Alloc>
typename vector<_Tp, _Alloc>::iterator
vector<_Tp, _Alloc>::
_M_erase(iterator __position)
{
if (__position + 1 != end())
std::move(__position + 1, end(), __position);
--this->_M_impl._M_finish;
_Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish);
return __position;
}
#pragma empty_line
template<typename _Tp, typename _Alloc>
typename vector<_Tp, _Alloc>::iterator
vector<_Tp, _Alloc>::
_M_erase(iterator __first, iterator __last)
{
if (__first != __last)
{
if (__last != end())
std::move(__last, end(), __first);
_M_erase_at_end(__first.base() + (end() - __last));
}
return __first;
}
#pragma empty_line
template<typename _Tp, typename _Alloc>
vector<_Tp, _Alloc>&
vector<_Tp, _Alloc>::
operator=(const vector<_Tp, _Alloc>& __x)
{
if (&__x != this)
{
#pragma empty_line
if (_Alloc_traits::_S_propagate_on_copy_assign())
{
if (!_Alloc_traits::_S_always_equal()
&& _M_get_Tp_allocator() != __x._M_get_Tp_allocator())
{
#pragma empty_line
this->clear();
_M_deallocate(this->_M_impl._M_start,
this->_M_impl._M_end_of_storage
- this->_M_impl._M_start);
this->_M_impl._M_start = nullptr;
this->_M_impl._M_finish = nullptr;
this->_M_impl._M_end_of_storage = nullptr;
}
std::__alloc_on_copy(_M_get_Tp_allocator(),
__x._M_get_Tp_allocator());
}
#pragma empty_line
const size_type __xlen = __x.size();
if (__xlen > capacity())
{
pointer __tmp = _M_allocate_and_copy(__xlen, __x.begin(),
__x.end());
std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
_M_get_Tp_allocator());
_M_deallocate(this->_M_impl._M_start,
this->_M_impl._M_end_of_storage
- this->_M_impl._M_start);
this->_M_impl._M_start = __tmp;
this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __xlen;
}
else if (size() >= __xlen)
{
std::_Destroy(std::copy(__x.begin(), __x.end(), begin()),
end(), _M_get_Tp_allocator());
}
else
{
std::copy(__x._M_impl._M_start, __x._M_impl._M_start + size(),
this->_M_impl._M_start);
std::__uninitialized_copy_a(__x._M_impl._M_start + size(),
__x._M_impl._M_finish,
this->_M_impl._M_finish,
_M_get_Tp_allocator());
}
this->_M_impl._M_finish = this->_M_impl._M_start + __xlen;
}
return *this;
}
#pragma empty_line
template<typename _Tp, typename _Alloc>
void
vector<_Tp, _Alloc>::
_M_fill_assign(size_t __n, const value_type& __val)
{
if (__n > capacity())
{
vector __tmp(__n, __val, _M_get_Tp_allocator());
__tmp._M_impl._M_swap_data(this->_M_impl);
}
else if (__n > size())
{
std::fill(begin(), end(), __val);
this->_M_impl._M_finish =
std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
__n - size(), __val,
_M_get_Tp_allocator());
}
else
_M_erase_at_end(std::fill_n(this->_M_impl._M_start, __n, __val));
}
#pragma empty_line
template<typename _Tp, typename _Alloc>
template<typename _InputIterator>
void
vector<_Tp, _Alloc>::
_M_assign_aux(_InputIterator __first, _InputIterator __last,
std::input_iterator_tag)
{
pointer __cur(this->_M_impl._M_start);
for (; __first != __last && __cur != this->_M_impl._M_finish;
++__cur, ++__first)
*__cur = *__first;
if (__first == __last)
_M_erase_at_end(__cur);
else
insert(end(), __first, __last);
}
#pragma empty_line
template<typename _Tp, typename _Alloc>
template<typename _ForwardIterator>
void
vector<_Tp, _Alloc>::
_M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
std::forward_iterator_tag)
{
const size_type __len = std::distance(__first, __last);
#pragma empty_line
if (__len > capacity())
{
pointer __tmp(_M_allocate_and_copy(__len, __first, __last));
std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
_M_get_Tp_allocator());
_M_deallocate(this->_M_impl._M_start,
this->_M_impl._M_end_of_storage
- this->_M_impl._M_start);
this->_M_impl._M_start = __tmp;
this->_M_impl._M_finish = this->_M_impl._M_start + __len;
this->_M_impl._M_end_of_storage = this->_M_impl._M_finish;
}
else if (size() >= __len)
_M_erase_at_end(std::copy(__first, __last, this->_M_impl._M_start));
else
{
_ForwardIterator __mid = __first;
std::advance(__mid, size());
std::copy(__first, __mid, this->_M_impl._M_start);
this->_M_impl._M_finish =
std::__uninitialized_copy_a(__mid, __last,
this->_M_impl._M_finish,
_M_get_Tp_allocator());
}
}
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename _Alloc>
template<typename... _Args>
typename vector<_Tp, _Alloc>::iterator
vector<_Tp, _Alloc>::
emplace(const_iterator __position, _Args&&... __args)
{
const size_type __n = __position - begin();
if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage
&& __position == end())
{
_Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
std::forward<_Args>(__args)...);
++this->_M_impl._M_finish;
}
else
_M_insert_aux(begin() + (__position - cbegin()),
std::forward<_Args>(__args)...);
return iterator(this->_M_impl._M_start + __n);
}
#pragma empty_line
template<typename _Tp, typename _Alloc>
template<typename... _Args>
void
vector<_Tp, _Alloc>::
_M_insert_aux(iterator __position, _Args&&... __args)
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
{
if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
{
_Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
std::move(*(this->_M_impl._M_finish - 1))
);
++this->_M_impl._M_finish;
#pragma empty_line
#pragma empty_line
#pragma empty_line
std::move_backward(__position.base(), this->_M_impl._M_finish - 2, this->_M_impl._M_finish - 1)
#pragma empty_line
;
#pragma empty_line
#pragma empty_line
#pragma empty_line
*__position = _Tp(std::forward<_Args>(__args)...);
#pragma empty_line
}
else
{
const size_type __len =
_M_check_len(size_type(1), "vector::_M_insert_aux");
const size_type __elems_before = __position - begin();
pointer __new_start(this->_M_allocate(__len));
pointer __new_finish(__new_start);
try
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
_Alloc_traits::construct(this->_M_impl,
__new_start + __elems_before,
#pragma empty_line
std::forward<_Args>(__args)...);
#pragma empty_line
#pragma empty_line
#pragma empty_line
__new_finish = pointer();
#pragma empty_line
__new_finish
= std::__uninitialized_move_if_noexcept_a
(this->_M_impl._M_start, __position.base(),
__new_start, _M_get_Tp_allocator());
#pragma empty_line
++__new_finish;
#pragma empty_line
__new_finish
= std::__uninitialized_move_if_noexcept_a
(__position.base(), this->_M_impl._M_finish,
__new_finish, _M_get_Tp_allocator());
}
catch(...)
{
if (!__new_finish)
_Alloc_traits::destroy(this->_M_impl,
__new_start + __elems_before);
else
std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator());
_M_deallocate(__new_start, __len);
throw;
}
std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
_M_get_Tp_allocator());
_M_deallocate(this->_M_impl._M_start,
this->_M_impl._M_end_of_storage
- this->_M_impl._M_start);
this->_M_impl._M_start = __new_start;
this->_M_impl._M_finish = __new_finish;
this->_M_impl._M_end_of_storage = __new_start + __len;
}
}
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename _Alloc>
template<typename... _Args>
void
vector<_Tp, _Alloc>::
_M_emplace_back_aux(_Args&&... __args)
{
const size_type __len =
_M_check_len(size_type(1), "vector::_M_emplace_back_aux");
pointer __new_start(this->_M_allocate(__len));
pointer __new_finish(__new_start);
try
{
_Alloc_traits::construct(this->_M_impl, __new_start + size(),
std::forward<_Args>(__args)...);
__new_finish = pointer();
#pragma empty_line
__new_finish
= std::__uninitialized_move_if_noexcept_a
(this->_M_impl._M_start, this->_M_impl._M_finish,
__new_start, _M_get_Tp_allocator());
#pragma empty_line
++__new_finish;
}
catch(...)
{
if (!__new_finish)
_Alloc_traits::destroy(this->_M_impl, __new_start + size());
else
std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator());
_M_deallocate(__new_start, __len);
throw;
}
std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
_M_get_Tp_allocator());
_M_deallocate(this->_M_impl._M_start,
this->_M_impl._M_end_of_storage
- this->_M_impl._M_start);
this->_M_impl._M_start = __new_start;
this->_M_impl._M_finish = __new_finish;
this->_M_impl._M_end_of_storage = __new_start + __len;
}
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename _Alloc>
void
vector<_Tp, _Alloc>::
_M_fill_insert(iterator __position, size_type __n, const value_type& __x)
{
if (__n != 0)
{
if (size_type(this->_M_impl._M_end_of_storage
- this->_M_impl._M_finish) >= __n)
{
value_type __x_copy = __x;
const size_type __elems_after = end() - __position;
pointer __old_finish(this->_M_impl._M_finish);
if (__elems_after > __n)
{
std::__uninitialized_move_a(this->_M_impl._M_finish - __n,
this->_M_impl._M_finish,
this->_M_impl._M_finish,
_M_get_Tp_allocator());
this->_M_impl._M_finish += __n;
std::move_backward(__position.base(), __old_finish - __n, __old_finish)
;
std::fill(__position.base(), __position.base() + __n,
__x_copy);
}
else
{
this->_M_impl._M_finish =
std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
__n - __elems_after,
__x_copy,
_M_get_Tp_allocator());
std::__uninitialized_move_a(__position.base(), __old_finish,
this->_M_impl._M_finish,
_M_get_Tp_allocator());
this->_M_impl._M_finish += __elems_after;
std::fill(__position.base(), __old_finish, __x_copy);
}
}
else
{
const size_type __len =
_M_check_len(__n, "vector::_M_fill_insert");
const size_type __elems_before = __position - begin();
pointer __new_start(this->_M_allocate(__len));
pointer __new_finish(__new_start);
try
{
#pragma empty_line
std::__uninitialized_fill_n_a(__new_start + __elems_before,
__n, __x,
_M_get_Tp_allocator());
__new_finish = pointer();
#pragma empty_line
__new_finish
= std::__uninitialized_move_if_noexcept_a
(this->_M_impl._M_start, __position.base(),
__new_start, _M_get_Tp_allocator());
#pragma empty_line
__new_finish += __n;
#pragma empty_line
__new_finish
= std::__uninitialized_move_if_noexcept_a
(__position.base(), this->_M_impl._M_finish,
__new_finish, _M_get_Tp_allocator());
}
catch(...)
{
if (!__new_finish)
std::_Destroy(__new_start + __elems_before,
__new_start + __elems_before + __n,
_M_get_Tp_allocator());
else
std::_Destroy(__new_start, __new_finish,
_M_get_Tp_allocator());
_M_deallocate(__new_start, __len);
throw;
}
std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
_M_get_Tp_allocator());
_M_deallocate(this->_M_impl._M_start,
this->_M_impl._M_end_of_storage
- this->_M_impl._M_start);
this->_M_impl._M_start = __new_start;
this->_M_impl._M_finish = __new_finish;
this->_M_impl._M_end_of_storage = __new_start + __len;
}
}
}
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename _Alloc>
void
vector<_Tp, _Alloc>::
_M_default_append(size_type __n)
{
if (__n != 0)
{
if (size_type(this->_M_impl._M_end_of_storage
- this->_M_impl._M_finish) >= __n)
{
this->_M_impl._M_finish =
std::__uninitialized_default_n_a(this->_M_impl._M_finish,
__n, _M_get_Tp_allocator());
}
else
{
const size_type __len =
_M_check_len(__n, "vector::_M_default_append");
const size_type __old_size = this->size();
pointer __new_start(this->_M_allocate(__len));
pointer __new_finish(__new_start);
try
{
__new_finish
= std::__uninitialized_move_if_noexcept_a
(this->_M_impl._M_start, this->_M_impl._M_finish,
__new_start, _M_get_Tp_allocator());
__new_finish =
std::__uninitialized_default_n_a(__new_finish, __n,
_M_get_Tp_allocator());
}
catch(...)
{
std::_Destroy(__new_start, __new_finish,
_M_get_Tp_allocator());
_M_deallocate(__new_start, __len);
throw;
}
std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
_M_get_Tp_allocator());
_M_deallocate(this->_M_impl._M_start,
this->_M_impl._M_end_of_storage
- this->_M_impl._M_start);
this->_M_impl._M_start = __new_start;
this->_M_impl._M_finish = __new_finish;
this->_M_impl._M_end_of_storage = __new_start + __len;
}
}
}
#pragma empty_line
template<typename _Tp, typename _Alloc>
bool
vector<_Tp, _Alloc>::
_M_shrink_to_fit()
{
if (capacity() == size())
return false;
return std::__shrink_to_fit_aux<vector>::_S_do_it(*this);
}
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename _Alloc>
template<typename _InputIterator>
void
vector<_Tp, _Alloc>::
_M_range_insert(iterator __pos, _InputIterator __first,
_InputIterator __last, std::input_iterator_tag)
{
for (; __first != __last; ++__first)
{
__pos = insert(__pos, *__first);
++__pos;
}
}
#pragma empty_line
template<typename _Tp, typename _Alloc>
template<typename _ForwardIterator>
void
vector<_Tp, _Alloc>::
_M_range_insert(iterator __position, _ForwardIterator __first,
_ForwardIterator __last, std::forward_iterator_tag)
{
if (__first != __last)
{
const size_type __n = std::distance(__first, __last);
if (size_type(this->_M_impl._M_end_of_storage
- this->_M_impl._M_finish) >= __n)
{
const size_type __elems_after = end() - __position;
pointer __old_finish(this->_M_impl._M_finish);
if (__elems_after > __n)
{
std::__uninitialized_move_a(this->_M_impl._M_finish - __n,
this->_M_impl._M_finish,
this->_M_impl._M_finish,
_M_get_Tp_allocator());
this->_M_impl._M_finish += __n;
std::move_backward(__position.base(), __old_finish - __n, __old_finish)
;
std::copy(__first, __last, __position);
}
else
{
_ForwardIterator __mid = __first;
std::advance(__mid, __elems_after);
std::__uninitialized_copy_a(__mid, __last,
this->_M_impl._M_finish,
_M_get_Tp_allocator());
this->_M_impl._M_finish += __n - __elems_after;
std::__uninitialized_move_a(__position.base(),
__old_finish,
this->_M_impl._M_finish,
_M_get_Tp_allocator());
this->_M_impl._M_finish += __elems_after;
std::copy(__first, __mid, __position);
}
}
else
{
const size_type __len =
_M_check_len(__n, "vector::_M_range_insert");
pointer __new_start(this->_M_allocate(__len));
pointer __new_finish(__new_start);
try
{
__new_finish
= std::__uninitialized_move_if_noexcept_a
(this->_M_impl._M_start, __position.base(),
__new_start, _M_get_Tp_allocator());
__new_finish
= std::__uninitialized_copy_a(__first, __last,
__new_finish,
_M_get_Tp_allocator());
__new_finish
= std::__uninitialized_move_if_noexcept_a
(__position.base(), this->_M_impl._M_finish,
__new_finish, _M_get_Tp_allocator());
}
catch(...)
{
std::_Destroy(__new_start, __new_finish,
_M_get_Tp_allocator());
_M_deallocate(__new_start, __len);
throw;
}
std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
_M_get_Tp_allocator());
_M_deallocate(this->_M_impl._M_start,
this->_M_impl._M_end_of_storage
- this->_M_impl._M_start);
this->_M_impl._M_start = __new_start;
this->_M_impl._M_finish = __new_finish;
this->_M_impl._M_end_of_storage = __new_start + __len;
}
}
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Alloc>
void
vector<bool, _Alloc>::
_M_reallocate(size_type __n)
{
_Bit_pointer __q = this->_M_allocate(__n);
iterator __start(std::__addressof(*__q), 0);
this->_M_impl._M_finish = _M_copy_aligned(begin(), end(), __start);
this->_M_deallocate();
this->_M_impl._M_start = __start;
this->_M_impl._M_end_of_storage = __q + _S_nword(__n);
}
#pragma empty_line
template<typename _Alloc>
void
vector<bool, _Alloc>::
_M_fill_insert(iterator __position, size_type __n, bool __x)
{
if (__n == 0)
return;
if (capacity() - size() >= __n)
{
std::copy_backward(__position, end(),
this->_M_impl._M_finish + difference_type(__n));
std::fill(__position, __position + difference_type(__n), __x);
this->_M_impl._M_finish += difference_type(__n);
}
else
{
const size_type __len =
_M_check_len(__n, "vector<bool>::_M_fill_insert");
_Bit_pointer __q = this->_M_allocate(__len);
iterator __start(std::__addressof(*__q), 0);
iterator __i = _M_copy_aligned(begin(), __position, __start);
std::fill(__i, __i + difference_type(__n), __x);
this->_M_impl._M_finish = std::copy(__position, end(),
__i + difference_type(__n));
this->_M_deallocate();
this->_M_impl._M_end_of_storage = __q + _S_nword(__len);
this->_M_impl._M_start = __start;
}
}
#pragma empty_line
template<typename _Alloc>
template<typename _ForwardIterator>
void
vector<bool, _Alloc>::
_M_insert_range(iterator __position, _ForwardIterator __first,
_ForwardIterator __last, std::forward_iterator_tag)
{
if (__first != __last)
{
size_type __n = std::distance(__first, __last);
if (capacity() - size() >= __n)
{
std::copy_backward(__position, end(),
this->_M_impl._M_finish
+ difference_type(__n));
std::copy(__first, __last, __position);
this->_M_impl._M_finish += difference_type(__n);
}
else
{
const size_type __len =
_M_check_len(__n, "vector<bool>::_M_insert_range");
_Bit_pointer __q = this->_M_allocate(__len);
iterator __start(std::__addressof(*__q), 0);
iterator __i = _M_copy_aligned(begin(), __position, __start);
__i = std::copy(__first, __last, __i);
this->_M_impl._M_finish = std::copy(__position, end(), __i);
this->_M_deallocate();
this->_M_impl._M_end_of_storage = __q + _S_nword(__len);
this->_M_impl._M_start = __start;
}
}
}
#pragma empty_line
template<typename _Alloc>
void
vector<bool, _Alloc>::
_M_insert_aux(iterator __position, bool __x)
{
if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr())
{
std::copy_backward(__position, this->_M_impl._M_finish,
this->_M_impl._M_finish + 1);
*__position = __x;
++this->_M_impl._M_finish;
}
else
{
const size_type __len =
_M_check_len(size_type(1), "vector<bool>::_M_insert_aux");
_Bit_pointer __q = this->_M_allocate(__len);
iterator __start(std::__addressof(*__q), 0);
iterator __i = _M_copy_aligned(begin(), __position, __start);
*__i++ = __x;
this->_M_impl._M_finish = std::copy(__position, end(), __i);
this->_M_deallocate();
this->_M_impl._M_end_of_storage = __q + _S_nword(__len);
this->_M_impl._M_start = __start;
}
}
#pragma empty_line
template<typename _Alloc>
typename vector<bool, _Alloc>::iterator
vector<bool, _Alloc>::
_M_erase(iterator __position)
{
if (__position + 1 != end())
std::copy(__position + 1, end(), __position);
--this->_M_impl._M_finish;
return __position;
}
#pragma empty_line
template<typename _Alloc>
typename vector<bool, _Alloc>::iterator
vector<bool, _Alloc>::
_M_erase(iterator __first, iterator __last)
{
if (__first != __last)
_M_erase_at_end(std::copy(__last, end(), __first));
return __first;
}
#pragma empty_line
#pragma empty_line
template<typename _Alloc>
bool
vector<bool, _Alloc>::
_M_shrink_to_fit()
{
if (capacity() - size() < int(_S_word_bit))
return false;
try
{
_M_reallocate(size());
return true;
}
catch(...)
{ return false; }
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
template<typename _Alloc>
size_t
hash<std::vector<bool, _Alloc>>::
operator()(const std::vector<bool, _Alloc>& __b) const noexcept
{
size_t __hash = 0;
using std::_S_word_bit;
using std::_Bit_type;
#pragma empty_line
const size_t __words = __b.size() / _S_word_bit;
if (__words)
{
const size_t __clength = __words * sizeof(_Bit_type);
__hash = std::_Hash_impl::hash(__b._M_impl._M_start._M_p, __clength);
}
#pragma empty_line
const size_t __extrabits = __b.size() % _S_word_bit;
if (__extrabits)
{
_Bit_type __hiword = *__b._M_impl._M_finish._M_p;
__hiword &= ~((~static_cast<_Bit_type>(0)) << __extrabits);
#pragma empty_line
const size_t __clength
= (__extrabits + 8 - 1) / 8;
if (__words)
__hash = std::_Hash_impl::hash(&__hiword, __clength, __hash);
else
__hash = std::_Hash_impl::hash(&__hiword, __clength);
}
#pragma empty_line
return __hash;
}
#pragma empty_line
#pragma empty_line
}
#pragma line 70 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/vector" 2 3
#pragma line 62 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/queue" 2 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_heap.h" 1 3
#pragma line 62 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_heap.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
template<typename _RandomAccessIterator>
inline bool
__is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
{ return std::__is_heap(__first, std::distance(__first, __last)); }
#pragma empty_line
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)); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
}
#pragma line 148 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
;
#pragma empty_line
_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());
}
#pragma line 183 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
;
#pragma empty_line
_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));
}
#pragma empty_line
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));
}
#pragma empty_line
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;
#pragma empty_line
_ValueType __value = std::move(*__result);
*__result = std::move(*__first);
std::__adjust_heap(__first, _DistanceType(0),
_DistanceType(__last - __first),
std::move(__value), __comp);
}
#pragma line 263 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
;
;
#pragma empty_line
if (__last - __first > 1)
{
--__last;
std::__pop_heap(__first, __last, __last,
__gnu_cxx::__ops::__iter_less_iter());
}
}
#pragma line 296 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
;
;
#pragma empty_line
if (__last - __first > 1)
{
--__last;
std::__pop_heap(__first, __last, __last,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
}
#pragma empty_line
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;
#pragma empty_line
if (__last - __first < 2)
return;
#pragma empty_line
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--;
}
}
#pragma line 351 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
#pragma empty_line
std::__make_heap(__first, __last,
__gnu_cxx::__ops::__iter_less_iter());
}
#pragma line 377 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
#pragma empty_line
std::__make_heap(__first, __last,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
#pragma empty_line
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);
}
}
#pragma line 412 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
;
#pragma empty_line
std::__sort_heap(__first, __last,
__gnu_cxx::__ops::__iter_less_iter());
}
#pragma line 439 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
;
#pragma empty_line
std::__sort_heap(__first, __last,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
#pragma line 466 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
#pragma empty_line
return __first +
std::__is_heap_until(__first, std::distance(__first, __last),
__gnu_cxx::__ops::__iter_less_iter());
}
#pragma line 494 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
#pragma empty_line
return __first
+ std::__is_heap_until(__first, std::distance(__first, __last),
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
#pragma line 517 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma line 530 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 63 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/queue" 2 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_function.h" 1 3
#pragma line 63 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_function.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma line 104 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_function.h" 3
template<typename _Arg, typename _Result>
struct unary_function
{
#pragma empty_line
typedef _Arg argument_type;
#pragma empty_line
#pragma empty_line
typedef _Result result_type;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Arg1, typename _Arg2, typename _Result>
struct binary_function
{
#pragma empty_line
typedef _Arg1 first_argument_type;
#pragma empty_line
#pragma empty_line
typedef _Arg2 second_argument_type;
#pragma empty_line
#pragma empty_line
typedef _Result result_type;
};
#pragma line 144 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_function.h" 3
struct __is_transparent;
#pragma empty_line
template<typename _Tp = void>
struct plus;
#pragma empty_line
template<typename _Tp = void>
struct minus;
#pragma empty_line
template<typename _Tp = void>
struct multiplies;
#pragma empty_line
template<typename _Tp = void>
struct divides;
#pragma empty_line
template<typename _Tp = void>
struct modulus;
#pragma empty_line
template<typename _Tp = void>
struct negate;
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct plus : public binary_function<_Tp, _Tp, _Tp>
{
constexpr
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x + __y; }
};
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct minus : public binary_function<_Tp, _Tp, _Tp>
{
constexpr
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x - __y; }
};
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct multiplies : public binary_function<_Tp, _Tp, _Tp>
{
constexpr
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x * __y; }
};
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct divides : public binary_function<_Tp, _Tp, _Tp>
{
constexpr
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x / __y; }
};
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct modulus : public binary_function<_Tp, _Tp, _Tp>
{
constexpr
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x % __y; }
};
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct negate : public unary_function<_Tp, _Tp>
{
constexpr
_Tp
operator()(const _Tp& __x) const
{ return -__x; }
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
typedef __is_transparent is_transparent;
};
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
typedef __is_transparent is_transparent;
};
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
typedef __is_transparent is_transparent;
};
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
typedef __is_transparent is_transparent;
};
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
typedef __is_transparent is_transparent;
};
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
typedef __is_transparent is_transparent;
};
#pragma line 330 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_function.h" 3
template<typename _Tp = void>
struct equal_to;
#pragma empty_line
template<typename _Tp = void>
struct not_equal_to;
#pragma empty_line
template<typename _Tp = void>
struct greater;
#pragma empty_line
template<typename _Tp = void>
struct less;
#pragma empty_line
template<typename _Tp = void>
struct greater_equal;
#pragma empty_line
template<typename _Tp = void>
struct less_equal;
#pragma empty_line
#pragma empty_line
#pragma empty_line
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; }
};
#pragma empty_line
#pragma empty_line
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; }
};
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct greater : public binary_function<_Tp, _Tp, bool>
{
constexpr
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x > __y; }
};
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct less : public binary_function<_Tp, _Tp, bool>
{
constexpr
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x < __y; }
};
#pragma empty_line
#pragma empty_line
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; }
};
#pragma empty_line
#pragma empty_line
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; }
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
typedef __is_transparent is_transparent;
};
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
typedef __is_transparent is_transparent;
};
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
typedef __is_transparent is_transparent;
};
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
typedef __is_transparent is_transparent;
};
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
typedef __is_transparent is_transparent;
};
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
typedef __is_transparent is_transparent;
};
#pragma line 512 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_function.h" 3
template<typename _Tp = void>
struct logical_and;
#pragma empty_line
template<typename _Tp = void>
struct logical_or;
#pragma empty_line
template<typename _Tp = void>
struct logical_not;
#pragma empty_line
#pragma empty_line
#pragma empty_line
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; }
};
#pragma empty_line
#pragma empty_line
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; }
};
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct logical_not : public unary_function<_Tp, bool>
{
constexpr
bool
operator()(const _Tp& __x) const
{ return !__x; }
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
typedef __is_transparent is_transparent;
};
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
typedef __is_transparent is_transparent;
};
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
typedef __is_transparent is_transparent;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp = void>
struct bit_and;
#pragma empty_line
template<typename _Tp = void>
struct bit_or;
#pragma empty_line
template<typename _Tp = void>
struct bit_xor;
#pragma empty_line
template<typename _Tp = void>
struct bit_not;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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; }
};
#pragma empty_line
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; }
};
#pragma empty_line
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; }
};
#pragma empty_line
template<typename _Tp>
struct bit_not : public unary_function<_Tp, _Tp>
{
constexpr
_Tp
operator()(const _Tp& __x) const
{ return ~__x; }
};
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
typedef __is_transparent is_transparent;
};
#pragma empty_line
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); }
#pragma empty_line
typedef __is_transparent is_transparent;
};
#pragma empty_line
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); }
#pragma empty_line
typedef __is_transparent is_transparent;
};
#pragma empty_line
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); }
#pragma empty_line
typedef __is_transparent is_transparent;
};
#pragma line 740 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
public:
constexpr
explicit
unary_negate(const _Predicate& __x) : _M_pred(__x) { }
#pragma empty_line
constexpr
bool
operator()(const typename _Predicate::argument_type& __x) const
{ return !_M_pred(__x); }
};
#pragma empty_line
#pragma empty_line
template<typename _Predicate>
constexpr
inline unary_negate<_Predicate>
not1(const _Predicate& __pred)
{ return unary_negate<_Predicate>(__pred); }
#pragma empty_line
#pragma empty_line
template<typename _Predicate>
class binary_negate
: public binary_function<typename _Predicate::first_argument_type,
typename _Predicate::second_argument_type, bool>
{
protected:
_Predicate _M_pred;
#pragma empty_line
public:
constexpr
explicit
binary_negate(const _Predicate& __x) : _M_pred(__x) { }
#pragma empty_line
constexpr
bool
operator()(const typename _Predicate::first_argument_type& __x,
const typename _Predicate::second_argument_type& __y) const
{ return !_M_pred(__x, __y); }
};
#pragma empty_line
#pragma empty_line
template<typename _Predicate>
constexpr
inline binary_negate<_Predicate>
not2(const _Predicate& __pred)
{ return binary_negate<_Predicate>(__pred); }
#pragma line 817 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
#pragma empty_line
public:
pointer_to_unary_function() { }
#pragma empty_line
explicit
pointer_to_unary_function(_Result (*__x)(_Arg))
: _M_ptr(__x) { }
#pragma empty_line
_Result
operator()(_Arg __x) const
{ return _M_ptr(__x); }
};
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
template<typename _Arg1, typename _Arg2, typename _Result>
class pointer_to_binary_function
: public binary_function<_Arg1, _Arg2, _Result>
{
protected:
_Result (*_M_ptr)(_Arg1, _Arg2);
#pragma empty_line
public:
pointer_to_binary_function() { }
#pragma empty_line
explicit
pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
: _M_ptr(__x) { }
#pragma empty_line
_Result
operator()(_Arg1 __x, _Arg2 __y) const
{ return _M_ptr(__x, __y); }
};
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct _Identity
: public unary_function<_Tp,_Tp>
{
_Tp&
operator()(_Tp& __x) const
{ return __x; }
#pragma empty_line
const _Tp&
operator()(const _Tp& __x) const
{ return __x; }
};
#pragma empty_line
template<typename _Pair>
struct _Select1st
: public unary_function<_Pair, typename _Pair::first_type>
{
typename _Pair::first_type&
operator()(_Pair& __x) const
{ return __x.first; }
#pragma empty_line
const typename _Pair::first_type&
operator()(const _Pair& __x) const
{ return __x.first; }
#pragma empty_line
#pragma empty_line
template<typename _Pair2>
typename _Pair2::first_type&
operator()(_Pair2& __x) const
{ return __x.first; }
#pragma empty_line
template<typename _Pair2>
const typename _Pair2::first_type&
operator()(const _Pair2& __x) const
{ return __x.first; }
#pragma empty_line
};
#pragma empty_line
template<typename _Pair>
struct _Select2nd
: public unary_function<_Pair, typename _Pair::second_type>
{
typename _Pair::second_type&
operator()(_Pair& __x) const
{ return __x.second; }
#pragma empty_line
const typename _Pair::second_type&
operator()(const _Pair& __x) const
{ return __x.second; }
};
#pragma line 937 "/home/justin/jhai/Xilinx/Vivado/2018.3/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) { }
#pragma empty_line
_Ret
operator()(_Tp* __p) const
{ return (__p->*_M_f)(); }
#pragma empty_line
private:
_Ret (_Tp::*_M_f)();
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
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) { }
#pragma empty_line
_Ret
operator()(const _Tp* __p) const
{ return (__p->*_M_f)(); }
#pragma empty_line
private:
_Ret (_Tp::*_M_f)() const;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
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) { }
#pragma empty_line
_Ret
operator()(_Tp& __r) const
{ return (__r.*_M_f)(); }
#pragma empty_line
private:
_Ret (_Tp::*_M_f)();
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
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) { }
#pragma empty_line
_Ret
operator()(const _Tp& __r) const
{ return (__r.*_M_f)(); }
#pragma empty_line
private:
_Ret (_Tp::*_M_f)() const;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
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) { }
#pragma empty_line
_Ret
operator()(_Tp* __p, _Arg __x) const
{ return (__p->*_M_f)(__x); }
#pragma empty_line
private:
_Ret (_Tp::*_M_f)(_Arg);
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
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) { }
#pragma empty_line
_Ret
operator()(const _Tp* __p, _Arg __x) const
{ return (__p->*_M_f)(__x); }
#pragma empty_line
private:
_Ret (_Tp::*_M_f)(_Arg) const;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
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) { }
#pragma empty_line
_Ret
operator()(_Tp& __r, _Arg __x) const
{ return (__r.*_M_f)(__x); }
#pragma empty_line
private:
_Ret (_Tp::*_M_f)(_Arg);
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
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) { }
#pragma empty_line
_Ret
operator()(const _Tp& __r, _Arg __x) const
{ return (__r.*_M_f)(__x); }
#pragma empty_line
private:
_Ret (_Tp::*_M_f)(_Arg) const;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Ret, typename _Tp>
inline mem_fun_t<_Ret, _Tp>
mem_fun(_Ret (_Tp::*__f)())
{ return mem_fun_t<_Ret, _Tp>(__f); }
#pragma empty_line
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); }
#pragma empty_line
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); }
#pragma empty_line
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); }
#pragma empty_line
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); }
#pragma empty_line
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); }
#pragma empty_line
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); }
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/backward/binders.h" 1 3
#pragma line 60 "/home/justin/jhai/Xilinx/Vivado/2018.3/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"
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma line 107 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
public:
binder1st(const _Operation& __x,
const typename _Operation::first_argument_type& __y)
: op(__x), value(__y) { }
#pragma empty_line
typename _Operation::result_type
operator()(const typename _Operation::second_argument_type& __x) const
{ return op(value, __x); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
typename _Operation::result_type
operator()(typename _Operation::second_argument_type& __x) const
{ return op(value, __x); }
} __attribute__ ((__deprecated__));
#pragma empty_line
#pragma empty_line
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));
}
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
public:
binder2nd(const _Operation& __x,
const typename _Operation::second_argument_type& __y)
: op(__x), value(__y) { }
#pragma empty_line
typename _Operation::result_type
operator()(const typename _Operation::first_argument_type& __x) const
{ return op(__x, value); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
typename _Operation::result_type
operator()(typename _Operation::first_argument_type& __x) const
{ return op(__x, value); }
} __attribute__ ((__deprecated__));
#pragma empty_line
#pragma empty_line
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 empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma GCC diagnostic pop
#pragma line 1128 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_function.h" 2 3
#pragma line 64 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/queue" 2 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_queue.h" 1 3
#pragma line 62 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_queue.h" 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/uses_allocator.h" 1 3
#pragma line 35 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/uses_allocator.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
struct __erased_type { };
#pragma empty_line
template<typename _Alloc, typename _Tp>
using __is_erased_or_convertible
= __or_<is_same<_Tp, __erased_type>, is_convertible<_Alloc, _Tp>>;
#pragma empty_line
#pragma empty_line
struct allocator_arg_t { explicit allocator_arg_t() = default; };
#pragma empty_line
constexpr allocator_arg_t allocator_arg = allocator_arg_t();
#pragma empty_line
template<typename _Tp, typename _Alloc, typename = __void_t<>>
struct __uses_allocator_helper
: false_type { };
#pragma empty_line
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
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename _Alloc>
struct uses_allocator
: __uses_allocator_helper<_Tp, _Alloc>::type
{ };
#pragma empty_line
struct __uses_alloc_base { };
#pragma empty_line
struct __uses_alloc0 : __uses_alloc_base
{
struct _Sink { void operator=(const void*) { } } _M_a;
};
#pragma empty_line
template<typename _Alloc>
struct __uses_alloc1 : __uses_alloc_base { const _Alloc* _M_a; };
#pragma empty_line
template<typename _Alloc>
struct __uses_alloc2 : __uses_alloc_base { const _Alloc* _M_a; };
#pragma empty_line
template<bool, typename _Tp, typename _Alloc, typename... _Args>
struct __uses_alloc;
#pragma empty_line
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");
};
#pragma empty_line
template<typename _Tp, typename _Alloc, typename... _Args>
struct __uses_alloc<false, _Tp, _Alloc, _Args...>
: __uses_alloc0 { };
#pragma empty_line
template<typename _Tp, typename _Alloc, typename... _Args>
using __uses_alloc_t =
__uses_alloc<uses_allocator<_Tp, _Alloc>::value, _Tp, _Alloc, _Args...>;
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
}
#pragma line 63 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_queue.h" 2 3
#pragma empty_line
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma line 95 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_queue.h" 3
template<typename _Tp, typename _Sequence = deque<_Tp> >
class queue
{
#pragma empty_line
typedef typename _Sequence::value_type _Sequence_value_type;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp1, typename _Seq1>
friend bool
operator==(const queue<_Tp1, _Seq1>&, const queue<_Tp1, _Seq1>&);
#pragma empty_line
template<typename _Tp1, typename _Seq1>
friend bool
operator<(const queue<_Tp1, _Seq1>&, const queue<_Tp1, _Seq1>&);
#pragma empty_line
#pragma empty_line
template<typename _Alloc>
using _Uses = typename
enable_if<uses_allocator<_Sequence, _Alloc>::value>::type;
#pragma empty_line
#pragma empty_line
public:
typedef typename _Sequence::value_type value_type;
typedef typename _Sequence::reference reference;
typedef typename _Sequence::const_reference const_reference;
typedef typename _Sequence::size_type size_type;
typedef _Sequence container_type;
#pragma empty_line
protected:
#pragma line 135 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_queue.h" 3
_Sequence c;
#pragma empty_line
public:
#pragma line 146 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_queue.h" 3
explicit
queue(const _Sequence& __c)
: c(__c) { }
#pragma empty_line
explicit
queue(_Sequence&& __c = _Sequence())
: c(std::move(__c)) { }
#pragma empty_line
template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
explicit
queue(const _Alloc& __a)
: c(__a) { }
#pragma empty_line
template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
queue(const _Sequence& __c, const _Alloc& __a)
: c(__c, __a) { }
#pragma empty_line
template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
queue(_Sequence&& __c, const _Alloc& __a)
: c(std::move(__c), __a) { }
#pragma empty_line
template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
queue(const queue& __q, const _Alloc& __a)
: c(__q.c, __a) { }
#pragma empty_line
template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
queue(queue&& __q, const _Alloc& __a)
: c(std::move(__q.c), __a) { }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
bool
empty() const
{ return c.empty(); }
#pragma empty_line
#pragma empty_line
size_type
size() const
{ return c.size(); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
reference
front()
{
;
return c.front();
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
const_reference
front() const
{
;
return c.front();
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
reference
back()
{
;
return c.back();
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
const_reference
back() const
{
;
return c.back();
}
#pragma line 241 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_queue.h" 3
void
push(const value_type& __x)
{ c.push_back(__x); }
#pragma empty_line
#pragma empty_line
void
push(value_type&& __x)
{ c.push_back(std::move(__x)); }
#pragma empty_line
template<typename... _Args>
void
emplace(_Args&&... __args)
{ c.emplace_back(std::forward<_Args>(__args)...); }
#pragma line 267 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_queue.h" 3
void
pop()
{
;
c.pop_front();
}
#pragma empty_line
#pragma empty_line
void
swap(queue& __q)
noexcept(__is_nothrow_swappable<_Tp>::value)
{
using std::swap;
swap(c, __q.c);
}
#pragma empty_line
};
#pragma line 296 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_queue.h" 3
template<typename _Tp, typename _Seq>
inline bool
operator==(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
{ return __x.c == __y.c; }
#pragma line 314 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_queue.h" 3
template<typename _Tp, typename _Seq>
inline bool
operator<(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
{ return __x.c < __y.c; }
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename _Seq>
inline bool
operator!=(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
{ return !(__x == __y); }
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename _Seq>
inline bool
operator>(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
{ return __y < __x; }
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename _Seq>
inline bool
operator<=(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
{ return !(__y < __x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename _Seq>
inline bool
operator>=(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
{ return !(__x < __y); }
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename _Seq>
inline void
swap(queue<_Tp, _Seq>& __x, queue<_Tp, _Seq>& __y)
noexcept(noexcept(__x.swap(__y)))
{ __x.swap(__y); }
#pragma empty_line
template<typename _Tp, typename _Seq, typename _Alloc>
struct uses_allocator<queue<_Tp, _Seq>, _Alloc>
: public uses_allocator<_Seq, _Alloc>::type { };
#pragma line 395 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_queue.h" 3
template<typename _Tp, typename _Sequence = vector<_Tp>,
typename _Compare = less<typename _Sequence::value_type> >
class priority_queue
{
#pragma empty_line
typedef typename _Sequence::value_type _Sequence_value_type;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Alloc>
using _Uses = typename
enable_if<uses_allocator<_Sequence, _Alloc>::value>::type;
#pragma empty_line
#pragma empty_line
public:
typedef typename _Sequence::value_type value_type;
typedef typename _Sequence::reference reference;
typedef typename _Sequence::const_reference const_reference;
typedef typename _Sequence::size_type size_type;
typedef _Sequence container_type;
#pragma empty_line
protected:
#pragma empty_line
_Sequence c;
_Compare comp;
#pragma empty_line
public:
#pragma line 437 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_queue.h" 3
explicit
priority_queue(const _Compare& __x,
const _Sequence& __s)
: c(__s), comp(__x)
{ std::make_heap(c.begin(), c.end(), comp); }
#pragma empty_line
explicit
priority_queue(const _Compare& __x = _Compare(),
_Sequence&& __s = _Sequence())
: c(std::move(__s)), comp(__x)
{ std::make_heap(c.begin(), c.end(), comp); }
#pragma empty_line
template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
explicit
priority_queue(const _Alloc& __a)
: c(__a) { }
#pragma empty_line
template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
priority_queue(const _Compare& __x, const _Alloc& __a)
: c(__x, __a) { }
#pragma empty_line
template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
priority_queue(const _Compare& __x, const _Sequence& __c,
const _Alloc& __a)
: c(__x, __c, __a) { }
#pragma empty_line
template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
priority_queue(const _Compare& __x, _Sequence&& __c, const _Alloc& __a)
: c(__x, std::move(__c), __a) { }
#pragma empty_line
template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
priority_queue(const priority_queue& __q, const _Alloc& __a)
: c(__q.c, __a) { }
#pragma empty_line
template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
priority_queue(priority_queue&& __q, const _Alloc& __a)
: c(std::move(__q.c), __a) { }
#pragma line 503 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_queue.h" 3
template<typename _InputIterator>
priority_queue(_InputIterator __first, _InputIterator __last,
const _Compare& __x,
const _Sequence& __s)
: c(__s), comp(__x)
{
;
c.insert(c.end(), __first, __last);
std::make_heap(c.begin(), c.end(), comp);
}
#pragma empty_line
template<typename _InputIterator>
priority_queue(_InputIterator __first, _InputIterator __last,
const _Compare& __x = _Compare(),
_Sequence&& __s = _Sequence())
: c(std::move(__s)), comp(__x)
{
;
c.insert(c.end(), __first, __last);
std::make_heap(c.begin(), c.end(), comp);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
bool
empty() const
{ return c.empty(); }
#pragma empty_line
#pragma empty_line
size_type
size() const
{ return c.size(); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
const_reference
top() const
{
;
return c.front();
}
#pragma line 557 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_queue.h" 3
void
push(const value_type& __x)
{
c.push_back(__x);
std::push_heap(c.begin(), c.end(), comp);
}
#pragma empty_line
#pragma empty_line
void
push(value_type&& __x)
{
c.push_back(std::move(__x));
std::push_heap(c.begin(), c.end(), comp);
}
#pragma empty_line
template<typename... _Args>
void
emplace(_Args&&... __args)
{
c.emplace_back(std::forward<_Args>(__args)...);
std::push_heap(c.begin(), c.end(), comp);
}
#pragma line 592 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_queue.h" 3
void
pop()
{
;
std::pop_heap(c.begin(), c.end(), comp);
c.pop_back();
}
#pragma empty_line
#pragma empty_line
void
swap(priority_queue& __pq)
noexcept(__is_nothrow_swappable<_Tp>::value
&& __is_nothrow_swappable<_Compare>::value)
{
using std::swap;
swap(c, __pq.c);
swap(comp, __pq.comp);
}
#pragma empty_line
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename _Sequence, typename _Compare>
inline void
swap(priority_queue<_Tp, _Sequence, _Compare>& __x,
priority_queue<_Tp, _Sequence, _Compare>& __y)
noexcept(noexcept(__x.swap(__y)))
{ __x.swap(__y); }
#pragma empty_line
template<typename _Tp, typename _Sequence, typename _Compare,
typename _Alloc>
struct uses_allocator<priority_queue<_Tp, _Sequence, _Compare>, _Alloc>
: public uses_allocator<_Sequence, _Alloc>::type { };
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 65 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/queue" 2 3
#pragma line 80 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_stream.h" 2
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iostream" 1 3
#pragma line 36 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iostream" 3
#pragma empty_line
#pragma line 37 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iostream" 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 1 3
#pragma line 36 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 3
#pragma empty_line
#pragma line 37 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 3
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ios" 1 3
#pragma line 36 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ios" 3
#pragma empty_line
#pragma line 37 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ios" 3
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iosfwd" 1 3
#pragma line 36 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iosfwd" 3
#pragma empty_line
#pragma line 37 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iosfwd" 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stringfwd.h" 1 3
#pragma line 37 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stringfwd.h" 3
#pragma empty_line
#pragma line 38 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stringfwd.h" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<class _CharT>
struct char_traits;
#pragma empty_line
template<> struct char_traits<char>;
#pragma empty_line
#pragma empty_line
template<> struct char_traits<wchar_t>;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<> struct char_traits<char16_t>;
template<> struct char_traits<char32_t>;
#pragma empty_line
#pragma empty_line
namespace __cxx11 {
#pragma empty_line
template<typename _CharT, typename _Traits = char_traits<_CharT>,
typename _Alloc = allocator<_CharT> >
class basic_string;
#pragma empty_line
#pragma empty_line
typedef basic_string<char> string;
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef basic_string<wchar_t> wstring;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef basic_string<char16_t> u16string;
#pragma empty_line
#pragma empty_line
typedef basic_string<char32_t> u32string;
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 40 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iosfwd" 2 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/postypes.h" 1 3
#pragma line 38 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/postypes.h" 3
#pragma empty_line
#pragma line 39 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/postypes.h" 3
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cwchar" 1 3
#pragma line 39 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cwchar" 3
#pragma empty_line
#pragma line 40 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cwchar" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/wchar.h" 1 3 4
#pragma line 27 "/usr/include/wchar.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4
#pragma line 28 "/usr/include/wchar.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 1 3 4
#pragma line 75 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 3 4
typedef _Complex float __cfloat128 __attribute__ ((__mode__ (__TC__)));
#pragma line 87 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 3 4
typedef __float128 _Float128;
#pragma line 120 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 1 3 4
#pragma line 24 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/long-double.h" 1 3 4
#pragma line 25 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 2 3 4
#pragma line 214 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4
typedef float _Float32;
#pragma line 251 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4
typedef double _Float64;
#pragma line 268 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4
typedef double _Float32x;
#pragma line 285 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4
typedef long double _Float64x;
#pragma line 121 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 2 3 4
#pragma line 31 "/usr/include/wchar.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include/stddef.h" 1 3 4
#pragma line 216 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 36 "/usr/include/wchar.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include/stdarg.h" 1 3 4
#pragma line 40 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 39 "/usr/include/wchar.h" 2 3 4
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/wchar.h" 1 3 4
#pragma line 41 "/usr/include/wchar.h" 2 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/types/wint_t.h" 1 3 4
#pragma line 20 "/usr/include/x86_64-linux-gnu/bits/types/wint_t.h" 3 4
typedef unsigned int wint_t;
#pragma line 42 "/usr/include/wchar.h" 2 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h" 1 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h" 1 3 4
#pragma line 13 "/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h" 3 4
typedef struct
{
int __count;
union
{
unsigned int __wch;
char __wchb[4];
} __value;
} __mbstate_t;
#pragma line 5 "/usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h" 2 3 4
#pragma empty_line
typedef __mbstate_t mbstate_t;
#pragma line 43 "/usr/include/wchar.h" 2 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/types/__FILE.h" 1 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
struct _IO_FILE;
typedef struct _IO_FILE __FILE;
#pragma line 44 "/usr/include/wchar.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/types/FILE.h" 1 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
struct _IO_FILE;
#pragma empty_line
#pragma empty_line
typedef struct _IO_FILE FILE;
#pragma line 47 "/usr/include/wchar.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/types/locale_t.h" 1 3 4
#pragma line 22 "/usr/include/x86_64-linux-gnu/bits/types/locale_t.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/types/__locale_t.h" 1 3 4
#pragma line 28 "/usr/include/x86_64-linux-gnu/bits/types/__locale_t.h" 3 4
struct __locale_struct
{
#pragma empty_line
struct __locale_data *__locales[13];
#pragma empty_line
#pragma empty_line
const unsigned short int *__ctype_b;
const int *__ctype_tolower;
const int *__ctype_toupper;
#pragma empty_line
#pragma empty_line
const char *__names[13];
};
#pragma empty_line
typedef struct __locale_struct *__locale_t;
#pragma line 23 "/usr/include/x86_64-linux-gnu/bits/types/locale_t.h" 2 3 4
#pragma empty_line
typedef __locale_t locale_t;
#pragma line 50 "/usr/include/wchar.h" 2 3 4
#pragma line 79 "/usr/include/wchar.h" 3 4
extern "C" {
#pragma empty_line
#pragma empty_line
#pragma empty_line
struct tm;
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern wchar_t *wcscpy (wchar_t *__restrict __dest,
const wchar_t *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
extern wchar_t *wcsncpy (wchar_t *__restrict __dest,
const wchar_t *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
extern wchar_t *wcscat (wchar_t *__restrict __dest,
const wchar_t *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
extern wchar_t *wcsncat (wchar_t *__restrict __dest,
const wchar_t *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
extern int wcscmp (const wchar_t *__s1, const wchar_t *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
extern int wcsncmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int wcscasecmp (const wchar_t *__s1, const wchar_t *__s2) throw ();
#pragma empty_line
#pragma empty_line
extern int wcsncasecmp (const wchar_t *__s1, const wchar_t *__s2,
size_t __n) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int wcscasecmp_l (const wchar_t *__s1, const wchar_t *__s2,
locale_t __loc) throw ();
#pragma empty_line
extern int wcsncasecmp_l (const wchar_t *__s1, const wchar_t *__s2,
size_t __n, locale_t __loc) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int wcscoll (const wchar_t *__s1, const wchar_t *__s2) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern size_t wcsxfrm (wchar_t *__restrict __s1,
const wchar_t *__restrict __s2, size_t __n) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int wcscoll_l (const wchar_t *__s1, const wchar_t *__s2,
locale_t __loc) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern size_t wcsxfrm_l (wchar_t *__s1, const wchar_t *__s2,
size_t __n, locale_t __loc) throw ();
#pragma empty_line
#pragma empty_line
extern wchar_t *wcsdup (const wchar_t *__s) throw () __attribute__ ((__malloc__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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__));
#pragma line 181 "/usr/include/wchar.h" 3 4
extern wchar_t *wcschrnul (const wchar_t *__s, wchar_t __wc)
throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern size_t wcscspn (const wchar_t *__wcs, const wchar_t *__reject)
throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
extern size_t wcsspn (const wchar_t *__wcs, const wchar_t *__accept)
throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
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__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern wchar_t *wcstok (wchar_t *__restrict __s,
const wchar_t *__restrict __delim,
wchar_t **__restrict __ptr) throw ();
#pragma empty_line
#pragma empty_line
extern size_t wcslen (const wchar_t *__s) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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__));
#pragma line 240 "/usr/include/wchar.h" 3 4
extern size_t wcsnlen (const wchar_t *__s, size_t __maxlen)
throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int wmemcmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
extern wchar_t *wmemcpy (wchar_t *__restrict __s1,
const wchar_t *__restrict __s2, size_t __n) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern wchar_t *wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n)
throw ();
#pragma empty_line
#pragma empty_line
extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern wchar_t *wmempcpy (wchar_t *__restrict __s1,
const wchar_t *__restrict __s2, size_t __n)
throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern wint_t btowc (int __c) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int wctob (wint_t __c) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int mbsinit (const mbstate_t *__ps) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern size_t mbrtowc (wchar_t *__restrict __pwc,
const char *__restrict __s, size_t __n,
mbstate_t *__restrict __p) throw ();
#pragma empty_line
#pragma empty_line
extern size_t wcrtomb (char *__restrict __s, wchar_t __wc,
mbstate_t *__restrict __ps) throw ();
#pragma empty_line
#pragma empty_line
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 ();
#pragma line 337 "/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 ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern size_t wcsrtombs (char *__restrict __dst,
const wchar_t **__restrict __src, size_t __len,
mbstate_t *__restrict __ps) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern size_t mbsnrtowcs (wchar_t *__restrict __dst,
const char **__restrict __src, size_t __nmc,
size_t __len, mbstate_t *__restrict __ps) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern size_t wcsnrtombs (char *__restrict __dst,
const wchar_t **__restrict __src,
size_t __nwc, size_t __len,
mbstate_t *__restrict __ps) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int wcwidth (wchar_t __c) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int wcswidth (const wchar_t *__s, size_t __n) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern double wcstod (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
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 ();
#pragma line 396 "/usr/include/wchar.h" 3 4
extern _Float32 wcstof32 (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64 wcstof64 (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float128 wcstof128 (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32x wcstof32x (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64x wcstof64x (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr) throw ();
#pragma line 428 "/usr/include/wchar.h" 3 4
extern long int wcstol (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern unsigned long int wcstoul (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base)
throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__extension__
extern long long int wcstoll (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base)
throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
__extension__
extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
int __base) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__extension__
extern long long int wcstoq (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base)
throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
__extension__
extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
int __base) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long int wcstol_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base,
locale_t __loc) throw ();
#pragma empty_line
extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
int __base, locale_t __loc) throw ();
#pragma empty_line
__extension__
extern long long int wcstoll_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
int __base, locale_t __loc) throw ();
#pragma empty_line
__extension__
extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
int __base, locale_t __loc)
throw ();
#pragma empty_line
extern double wcstod_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, locale_t __loc)
throw ();
#pragma empty_line
extern float wcstof_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, locale_t __loc)
throw ();
#pragma empty_line
extern long double wcstold_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
locale_t __loc) throw ();
#pragma line 511 "/usr/include/wchar.h" 3 4
extern _Float32 wcstof32_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
locale_t __loc) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64 wcstof64_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
locale_t __loc) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float128 wcstof128_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
locale_t __loc) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32x wcstof32x_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
locale_t __loc) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64x wcstof64x_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
locale_t __loc) throw ();
#pragma line 551 "/usr/include/wchar.h" 3 4
extern wchar_t *wcpcpy (wchar_t *__restrict __dest,
const wchar_t *__restrict __src) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern wchar_t *wcpncpy (wchar_t *__restrict __dest,
const wchar_t *__restrict __src, size_t __n)
throw ();
#pragma line 567 "/usr/include/wchar.h" 3 4
extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int fwide (__FILE *__fp, int __mode) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int fwprintf (__FILE *__restrict __stream,
const wchar_t *__restrict __format, ...)
;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int wprintf (const wchar_t *__restrict __format, ...)
;
#pragma empty_line
extern int swprintf (wchar_t *__restrict __s, size_t __n,
const wchar_t *__restrict __format, ...)
throw () ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int vfwprintf (__FILE *__restrict __s,
const wchar_t *__restrict __format,
__gnuc_va_list __arg)
;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int vwprintf (const wchar_t *__restrict __format,
__gnuc_va_list __arg)
;
#pragma empty_line
#pragma empty_line
extern int vswprintf (wchar_t *__restrict __s, size_t __n,
const wchar_t *__restrict __format,
__gnuc_va_list __arg)
throw () ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int fwscanf (__FILE *__restrict __stream,
const wchar_t *__restrict __format, ...)
;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int wscanf (const wchar_t *__restrict __format, ...)
;
#pragma empty_line
extern int swscanf (const wchar_t *__restrict __s,
const wchar_t *__restrict __format, ...)
throw () ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int fwscanf (__FILE *__restrict __stream, const wchar_t *__restrict __format, ...) __asm__ ("" "__isoc99_fwscanf")
#pragma empty_line
#pragma empty_line
;
extern int wscanf (const wchar_t *__restrict __format, ...) __asm__ ("" "__isoc99_wscanf")
#pragma empty_line
;
extern int swscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, ...) throw () __asm__ ("" "__isoc99_swscanf")
#pragma empty_line
#pragma empty_line
;
#pragma line 671 "/usr/include/wchar.h" 3 4
extern int vfwscanf (__FILE *__restrict __s,
const wchar_t *__restrict __format,
__gnuc_va_list __arg)
;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int vwscanf (const wchar_t *__restrict __format,
__gnuc_va_list __arg)
;
#pragma empty_line
extern int vswscanf (const wchar_t *__restrict __s,
const wchar_t *__restrict __format,
__gnuc_va_list __arg)
throw () ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int vfwscanf (__FILE *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vfwscanf")
#pragma empty_line
#pragma empty_line
;
extern int vwscanf (const wchar_t *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vwscanf")
#pragma empty_line
;
extern int vswscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) throw () __asm__ ("" "__isoc99_vswscanf")
#pragma empty_line
#pragma empty_line
;
#pragma line 726 "/usr/include/wchar.h" 3 4
extern wint_t fgetwc (__FILE *__stream);
extern wint_t getwc (__FILE *__stream);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern wint_t getwchar (void);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern wint_t fputwc (wchar_t __wc, __FILE *__stream);
extern wint_t putwc (wchar_t __wc, __FILE *__stream);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern wint_t putwchar (wchar_t __wc);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern wchar_t *fgetws (wchar_t *__restrict __ws, int __n,
__FILE *__restrict __stream);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int fputws (const wchar_t *__restrict __ws,
__FILE *__restrict __stream);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern wint_t ungetwc (wint_t __wc, __FILE *__stream);
#pragma line 781 "/usr/include/wchar.h" 3 4
extern wint_t getwc_unlocked (__FILE *__stream);
extern wint_t getwchar_unlocked (void);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern wint_t fgetwc_unlocked (__FILE *__stream);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern wint_t fputwc_unlocked (wchar_t __wc, __FILE *__stream);
#pragma line 807 "/usr/include/wchar.h" 3 4
extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream);
extern wint_t putwchar_unlocked (wchar_t __wc);
#pragma line 817 "/usr/include/wchar.h" 3 4
extern wchar_t *fgetws_unlocked (wchar_t *__restrict __ws, int __n,
__FILE *__restrict __stream);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int fputws_unlocked (const wchar_t *__restrict __ws,
__FILE *__restrict __stream);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern size_t wcsftime (wchar_t *__restrict __s, size_t __maxsize,
const wchar_t *__restrict __format,
const struct tm *__restrict __tp) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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 ();
#pragma line 856 "/usr/include/wchar.h" 3 4
}
#pragma line 45 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cwchar" 2 3
#pragma line 62 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cwchar" 3
namespace std
{
using ::mbstate_t;
}
#pragma line 135 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cwchar" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
using ::wint_t;
#pragma empty_line
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;
#pragma empty_line
using ::swprintf;
#pragma empty_line
using ::swscanf;
using ::ungetwc;
using ::vfwprintf;
#pragma empty_line
using ::vfwscanf;
#pragma empty_line
#pragma empty_line
using ::vswprintf;
#pragma empty_line
#pragma empty_line
using ::vswscanf;
#pragma empty_line
using ::vwprintf;
#pragma empty_line
using ::vwscanf;
#pragma empty_line
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;
#pragma empty_line
using ::wcstof;
#pragma empty_line
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;
#pragma line 232 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cwchar" 3
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace __gnu_cxx
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
using ::wcstold;
#pragma line 257 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cwchar" 3
using ::wcstoll;
using ::wcstoull;
#pragma empty_line
}
#pragma empty_line
namespace std
{
using ::__gnu_cxx::wcstold;
using ::__gnu_cxx::wcstoll;
using ::__gnu_cxx::wcstoull;
}
#pragma line 277 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cwchar" 3
namespace std
{
#pragma empty_line
using std::wcstof;
#pragma empty_line
#pragma empty_line
using std::vfwscanf;
#pragma empty_line
#pragma empty_line
using std::vswscanf;
#pragma empty_line
#pragma empty_line
using std::vwscanf;
#pragma empty_line
#pragma empty_line
#pragma empty_line
using std::wcstold;
using std::wcstoll;
using std::wcstoull;
#pragma empty_line
}
#pragma line 41 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/postypes.h" 2 3
#pragma line 68 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/postypes.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma line 88 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/postypes.h" 3
typedef long streamoff;
#pragma line 98 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/postypes.h" 3
typedef ptrdiff_t streamsize;
#pragma line 111 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
public:
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
fpos()
: _M_off(0), _M_state() { }
#pragma line 133 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/postypes.h" 3
fpos(streamoff __off)
: _M_off(__off), _M_state() { }
#pragma empty_line
#pragma empty_line
operator streamoff() const { return _M_off; }
#pragma empty_line
#pragma empty_line
void
state(_StateT __st)
{ _M_state = __st; }
#pragma empty_line
#pragma empty_line
_StateT
state() const
{ return _M_state; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
fpos&
operator+=(streamoff __off)
{
_M_off += __off;
return *this;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
fpos&
operator-=(streamoff __off)
{
_M_off -= __off;
return *this;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
fpos
operator+(streamoff __off) const
{
fpos __pos(*this);
__pos += __off;
return __pos;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
fpos
operator-(streamoff __off) const
{
fpos __pos(*this);
__pos -= __off;
return __pos;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
streamoff
operator-(const fpos& __other) const
{ return _M_off - __other._M_off; }
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _StateT>
inline bool
operator==(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
{ return streamoff(__lhs) == streamoff(__rhs); }
#pragma empty_line
template<typename _StateT>
inline bool
operator!=(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
{ return streamoff(__lhs) != streamoff(__rhs); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef fpos<mbstate_t> streampos;
#pragma empty_line
typedef fpos<mbstate_t> wstreampos;
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef fpos<mbstate_t> u16streampos;
#pragma empty_line
typedef fpos<mbstate_t> u32streampos;
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 41 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iosfwd" 2 3
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma line 74 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iosfwd" 3
class ios_base;
#pragma empty_line
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_ios;
#pragma empty_line
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_streambuf;
#pragma empty_line
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_istream;
#pragma empty_line
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_ostream;
#pragma empty_line
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_iostream;
#pragma empty_line
#pragma empty_line
namespace __cxx11 {
#pragma empty_line
template<typename _CharT, typename _Traits = char_traits<_CharT>,
typename _Alloc = allocator<_CharT> >
class basic_stringbuf;
#pragma empty_line
template<typename _CharT, typename _Traits = char_traits<_CharT>,
typename _Alloc = allocator<_CharT> >
class basic_istringstream;
#pragma empty_line
template<typename _CharT, typename _Traits = char_traits<_CharT>,
typename _Alloc = allocator<_CharT> >
class basic_ostringstream;
#pragma empty_line
template<typename _CharT, typename _Traits = char_traits<_CharT>,
typename _Alloc = allocator<_CharT> >
class basic_stringstream;
#pragma empty_line
}
#pragma empty_line
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_filebuf;
#pragma empty_line
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_ifstream;
#pragma empty_line
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_ofstream;
#pragma empty_line
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_fstream;
#pragma empty_line
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class istreambuf_iterator;
#pragma empty_line
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class ostreambuf_iterator;
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef basic_ios<char> ios;
#pragma empty_line
#pragma empty_line
typedef basic_streambuf<char> streambuf;
#pragma empty_line
#pragma empty_line
typedef basic_istream<char> istream;
#pragma empty_line
#pragma empty_line
typedef basic_ostream<char> ostream;
#pragma empty_line
#pragma empty_line
typedef basic_iostream<char> iostream;
#pragma empty_line
#pragma empty_line
typedef basic_stringbuf<char> stringbuf;
#pragma empty_line
#pragma empty_line
typedef basic_istringstream<char> istringstream;
#pragma empty_line
#pragma empty_line
typedef basic_ostringstream<char> ostringstream;
#pragma empty_line
#pragma empty_line
typedef basic_stringstream<char> stringstream;
#pragma empty_line
#pragma empty_line
typedef basic_filebuf<char> filebuf;
#pragma empty_line
#pragma empty_line
typedef basic_ifstream<char> ifstream;
#pragma empty_line
#pragma empty_line
typedef basic_ofstream<char> ofstream;
#pragma empty_line
#pragma empty_line
typedef basic_fstream<char> fstream;
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef basic_ios<wchar_t> wios;
#pragma empty_line
#pragma empty_line
typedef basic_streambuf<wchar_t> wstreambuf;
#pragma empty_line
#pragma empty_line
typedef basic_istream<wchar_t> wistream;
#pragma empty_line
#pragma empty_line
typedef basic_ostream<wchar_t> wostream;
#pragma empty_line
#pragma empty_line
typedef basic_iostream<wchar_t> wiostream;
#pragma empty_line
#pragma empty_line
typedef basic_stringbuf<wchar_t> wstringbuf;
#pragma empty_line
#pragma empty_line
typedef basic_istringstream<wchar_t> wistringstream;
#pragma empty_line
#pragma empty_line
typedef basic_ostringstream<wchar_t> wostringstream;
#pragma empty_line
#pragma empty_line
typedef basic_stringstream<wchar_t> wstringstream;
#pragma empty_line
#pragma empty_line
typedef basic_filebuf<wchar_t> wfilebuf;
#pragma empty_line
#pragma empty_line
typedef basic_ifstream<wchar_t> wifstream;
#pragma empty_line
#pragma empty_line
typedef basic_ofstream<wchar_t> wofstream;
#pragma empty_line
#pragma empty_line
typedef basic_fstream<wchar_t> wfstream;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 39 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ios" 2 3
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/char_traits.h" 1 3
#pragma line 37 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/char_traits.h" 3
#pragma empty_line
#pragma line 38 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/char_traits.h" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cwchar" 1 3
#pragma line 39 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cwchar" 3
#pragma empty_line
#pragma line 40 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cwchar" 3
#pragma line 42 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/char_traits.h" 2 3
#pragma empty_line
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma line 57 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
};
#pragma line 82 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
static void
assign(char_type& __c1, const char_type& __c2)
{ __c1 = __c2; }
#pragma empty_line
static constexpr bool
eq(const char_type& __c1, const char_type& __c2)
{ return __c1 == __c2; }
#pragma empty_line
static constexpr bool
lt(const char_type& __c1, const char_type& __c2)
{ return __c1 < __c2; }
#pragma empty_line
static int
compare(const char_type* __s1, const char_type* __s2, std::size_t __n);
#pragma empty_line
static std::size_t
length(const char_type* __s);
#pragma empty_line
static const char_type*
find(const char_type* __s, std::size_t __n, const char_type& __a);
#pragma empty_line
static char_type*
move(char_type* __s1, const char_type* __s2, std::size_t __n);
#pragma empty_line
static char_type*
copy(char_type* __s1, const char_type* __s2, std::size_t __n);
#pragma empty_line
static char_type*
assign(char_type* __s, std::size_t __n, char_type __a);
#pragma empty_line
static constexpr char_type
to_char_type(const int_type& __c)
{ return static_cast<char_type>(__c); }
#pragma empty_line
static constexpr int_type
to_int_type(const char_type& __c)
{ return static_cast<int_type>(__c); }
#pragma empty_line
static constexpr bool
eq_int_type(const int_type& __c1, const int_type& __c2)
{ return __c1 == __c2; }
#pragma empty_line
static constexpr int_type
eof()
{ return static_cast<int_type>(-1); }
#pragma empty_line
static constexpr int_type
not_eof(const int_type& __c)
{ return !eq_int_type(__c, eof()) ? __c : to_int_type(char_type()); }
};
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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)));
}
#pragma empty_line
template<typename _CharT>
typename char_traits<_CharT>::char_type*
char_traits<_CharT>::
copy(char_type* __s1, const char_type* __s2, std::size_t __n)
{
#pragma empty_line
std::copy(__s2, __s2 + __n, __s1);
return __s1;
}
#pragma empty_line
template<typename _CharT>
typename char_traits<_CharT>::char_type*
char_traits<_CharT>::
assign(char_type* __s, std::size_t __n, char_type __a)
{
#pragma empty_line
std::fill_n(__s, __n, __a);
return __s;
}
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma line 226 "/home/justin/jhai/Xilinx/Vivado/2018.3/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>
{ };
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
static void
assign(char_type& __c1, const char_type& __c2) noexcept
{ __c1 = __c2; }
#pragma empty_line
static constexpr bool
eq(const char_type& __c1, const char_type& __c2) noexcept
{ return __c1 == __c2; }
#pragma empty_line
static constexpr bool
lt(const char_type& __c1, const char_type& __c2) noexcept
{
#pragma empty_line
return (static_cast<unsigned char>(__c1)
< static_cast<unsigned char>(__c2));
}
#pragma empty_line
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);
}
#pragma empty_line
static size_t
length(const char_type* __s)
{ return __builtin_strlen(__s); }
#pragma empty_line
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));
}
#pragma empty_line
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));
}
#pragma empty_line
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));
}
#pragma empty_line
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));
}
#pragma empty_line
static constexpr char_type
to_char_type(const int_type& __c) noexcept
{ return static_cast<char_type>(__c); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
static constexpr int_type
to_int_type(const char_type& __c) noexcept
{ return static_cast<int_type>(static_cast<unsigned char>(__c)); }
#pragma empty_line
static constexpr bool
eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
{ return __c1 == __c2; }
#pragma empty_line
static constexpr int_type
eof() noexcept
{ return static_cast<int_type>(-1); }
#pragma empty_line
static constexpr int_type
not_eof(const int_type& __c) noexcept
{ return (__c == eof()) ? 0 : __c; }
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
static void
assign(char_type& __c1, const char_type& __c2) noexcept
{ __c1 = __c2; }
#pragma empty_line
static constexpr bool
eq(const char_type& __c1, const char_type& __c2) noexcept
{ return __c1 == __c2; }
#pragma empty_line
static constexpr bool
lt(const char_type& __c1, const char_type& __c2) noexcept
{ return __c1 < __c2; }
#pragma empty_line
static int
compare(const char_type* __s1, const char_type* __s2, size_t __n)
{
if (__n == 0)
return 0;
return wmemcmp(__s1, __s2, __n);
}
#pragma empty_line
static size_t
length(const char_type* __s)
{ return wcslen(__s); }
#pragma empty_line
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);
}
#pragma empty_line
static char_type*
move(char_type* __s1, const char_type* __s2, size_t __n)
{
if (__n == 0)
return __s1;
return wmemmove(__s1, __s2, __n);
}
#pragma empty_line
static char_type*
copy(char_type* __s1, const char_type* __s2, size_t __n)
{
if (__n == 0)
return __s1;
return wmemcpy(__s1, __s2, __n);
}
#pragma empty_line
static char_type*
assign(char_type* __s, size_t __n, char_type __a)
{
if (__n == 0)
return __s;
return wmemset(__s, __a, __n);
}
#pragma empty_line
static constexpr char_type
to_char_type(const int_type& __c) noexcept
{ return char_type(__c); }
#pragma empty_line
static constexpr int_type
to_int_type(const char_type& __c) noexcept
{ return int_type(__c); }
#pragma empty_line
static constexpr bool
eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
{ return __c1 == __c2; }
#pragma empty_line
static constexpr int_type
eof() noexcept
{ return static_cast<int_type>((0xffffffffu)); }
#pragma empty_line
static constexpr int_type
not_eof(const int_type& __c) noexcept
{ return eq_int_type(__c, eof()) ? 0 : __c; }
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdint" 1 3
#pragma line 32 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdint" 3
#pragma empty_line
#pragma line 33 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdint" 3
#pragma line 41 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdint" 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include/stdint.h" 1 3 4
#pragma line 9 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include/stdint.h" 3 4
#pragma line 1 "/usr/include/stdint.h" 1 3 4
#pragma line 26 "/usr/include/stdint.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4
#pragma line 27 "/usr/include/stdint.h" 2 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/types.h" 1 3 4
#pragma line 27 "/usr/include/x86_64-linux-gnu/bits/types.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
#pragma line 28 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/timesize.h" 1 3 4
#pragma line 29 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4
#pragma empty_line
#pragma empty_line
typedef unsigned char __u_char;
typedef unsigned short int __u_short;
typedef unsigned int __u_int;
typedef unsigned long int __u_long;
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
typedef signed long int __int64_t;
typedef unsigned long int __uint64_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __int8_t __int_least8_t;
typedef __uint8_t __uint_least8_t;
typedef __int16_t __int_least16_t;
typedef __uint16_t __uint_least16_t;
typedef __int32_t __int_least32_t;
typedef __uint32_t __uint_least32_t;
typedef __int64_t __int_least64_t;
typedef __uint64_t __uint_least64_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef long int __quad_t;
typedef unsigned long int __u_quad_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef long int __intmax_t;
typedef unsigned long int __uintmax_t;
#pragma line 141 "/usr/include/x86_64-linux-gnu/bits/types.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/typesizes.h" 1 3 4
#pragma line 142 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/time64.h" 1 3 4
#pragma line 143 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
typedef int __daddr_t;
typedef int __key_t;
#pragma empty_line
#pragma empty_line
typedef int __clockid_t;
#pragma empty_line
#pragma empty_line
typedef void * __timer_t;
#pragma empty_line
#pragma empty_line
typedef long int __blksize_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef long int __blkcnt_t;
typedef long int __blkcnt64_t;
#pragma empty_line
#pragma empty_line
typedef unsigned long int __fsblkcnt_t;
typedef unsigned long int __fsblkcnt64_t;
#pragma empty_line
#pragma empty_line
typedef unsigned long int __fsfilcnt_t;
typedef unsigned long int __fsfilcnt64_t;
#pragma empty_line
#pragma empty_line
typedef long int __fsword_t;
#pragma empty_line
typedef long int __ssize_t;
#pragma empty_line
#pragma empty_line
typedef long int __syscall_slong_t;
#pragma empty_line
typedef unsigned long int __syscall_ulong_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __off64_t __loff_t;
typedef char *__caddr_t;
#pragma empty_line
#pragma empty_line
typedef long int __intptr_t;
#pragma empty_line
#pragma empty_line
typedef unsigned int __socklen_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef int __sig_atomic_t;
#pragma line 28 "/usr/include/stdint.h" 2 3 4
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
#pragma line 30 "/usr/include/stdint.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/stdint-intn.h" 1 3 4
#pragma line 24 "/usr/include/x86_64-linux-gnu/bits/stdint-intn.h" 3 4
typedef __int8_t int8_t;
typedef __int16_t int16_t;
typedef __int32_t int32_t;
typedef __int64_t int64_t;
#pragma line 35 "/usr/include/stdint.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h" 1 3 4
#pragma line 24 "/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h" 3 4
typedef __uint8_t uint8_t;
typedef __uint16_t uint16_t;
typedef __uint32_t uint32_t;
typedef __uint64_t uint64_t;
#pragma line 38 "/usr/include/stdint.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __int_least8_t int_least8_t;
typedef __int_least16_t int_least16_t;
typedef __int_least32_t int_least32_t;
typedef __int_least64_t int_least64_t;
#pragma empty_line
#pragma empty_line
typedef __uint_least8_t uint_least8_t;
typedef __uint_least16_t uint_least16_t;
typedef __uint_least32_t uint_least32_t;
typedef __uint_least64_t uint_least64_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef signed char int_fast8_t;
#pragma empty_line
typedef long int int_fast16_t;
typedef long int int_fast32_t;
typedef long int int_fast64_t;
#pragma line 71 "/usr/include/stdint.h" 3 4
typedef unsigned char uint_fast8_t;
#pragma empty_line
typedef unsigned long int uint_fast16_t;
typedef unsigned long int uint_fast32_t;
typedef unsigned long int uint_fast64_t;
#pragma line 87 "/usr/include/stdint.h" 3 4
typedef long int intptr_t;
#pragma empty_line
#pragma empty_line
typedef unsigned long int uintptr_t;
#pragma line 101 "/usr/include/stdint.h" 3 4
typedef __intmax_t intmax_t;
typedef __uintmax_t uintmax_t;
#pragma line 10 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include/stdint.h" 2 3 4
#pragma line 42 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdint" 2 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std
{
using ::int8_t;
using ::int16_t;
using ::int32_t;
using ::int64_t;
#pragma empty_line
using ::int_fast8_t;
using ::int_fast16_t;
using ::int_fast32_t;
using ::int_fast64_t;
#pragma empty_line
using ::int_least8_t;
using ::int_least16_t;
using ::int_least32_t;
using ::int_least64_t;
#pragma empty_line
using ::intmax_t;
using ::intptr_t;
#pragma empty_line
using ::uint8_t;
using ::uint16_t;
using ::uint32_t;
using ::uint64_t;
#pragma empty_line
using ::uint_fast8_t;
using ::uint_fast16_t;
using ::uint_fast32_t;
using ::uint_fast64_t;
#pragma empty_line
using ::uint_least8_t;
using ::uint_least16_t;
using ::uint_least32_t;
using ::uint_least64_t;
#pragma empty_line
using ::uintmax_t;
using ::uintptr_t;
}
#pragma line 421 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/char_traits.h" 2 3
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
static void
assign(char_type& __c1, const char_type& __c2) noexcept
{ __c1 = __c2; }
#pragma empty_line
static constexpr bool
eq(const char_type& __c1, const char_type& __c2) noexcept
{ return __c1 == __c2; }
#pragma empty_line
static constexpr bool
lt(const char_type& __c1, const char_type& __c2) noexcept
{ return __c1 < __c2; }
#pragma empty_line
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;
}
#pragma empty_line
static size_t
length(const char_type* __s)
{
size_t __i = 0;
while (!eq(__s[__i], char_type()))
++__i;
return __i;
}
#pragma empty_line
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;
}
#pragma empty_line
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))));
}
#pragma empty_line
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))));
}
#pragma empty_line
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;
}
#pragma empty_line
static constexpr char_type
to_char_type(const int_type& __c) noexcept
{ return char_type(__c); }
#pragma empty_line
static constexpr int_type
to_int_type(const char_type& __c) noexcept
{ return int_type(__c); }
#pragma empty_line
static constexpr bool
eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
{ return __c1 == __c2; }
#pragma empty_line
static constexpr int_type
eof() noexcept
{ return static_cast<int_type>(-1); }
#pragma empty_line
static constexpr int_type
not_eof(const int_type& __c) noexcept
{ return eq_int_type(__c, eof()) ? 0 : __c; }
};
#pragma empty_line
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;
#pragma empty_line
static void
assign(char_type& __c1, const char_type& __c2) noexcept
{ __c1 = __c2; }
#pragma empty_line
static constexpr bool
eq(const char_type& __c1, const char_type& __c2) noexcept
{ return __c1 == __c2; }
#pragma empty_line
static constexpr bool
lt(const char_type& __c1, const char_type& __c2) noexcept
{ return __c1 < __c2; }
#pragma empty_line
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;
}
#pragma empty_line
static size_t
length(const char_type* __s)
{
size_t __i = 0;
while (!eq(__s[__i], char_type()))
++__i;
return __i;
}
#pragma empty_line
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;
}
#pragma empty_line
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))));
}
#pragma empty_line
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))));
}
#pragma empty_line
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;
}
#pragma empty_line
static constexpr char_type
to_char_type(const int_type& __c) noexcept
{ return char_type(__c); }
#pragma empty_line
static constexpr int_type
to_int_type(const char_type& __c) noexcept
{ return int_type(__c); }
#pragma empty_line
static constexpr bool
eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
{ return __c1 == __c2; }
#pragma empty_line
static constexpr int_type
eof() noexcept
{ return static_cast<int_type>(-1); }
#pragma empty_line
static constexpr int_type
not_eof(const int_type& __c) noexcept
{ return eq_int_type(__c, eof()) ? 0 : __c; }
};
#pragma empty_line
#pragma empty_line
}
#pragma line 41 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ios" 2 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/localefwd.h" 1 3
#pragma line 37 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/localefwd.h" 3
#pragma empty_line
#pragma line 38 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/localefwd.h" 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/c++locale.h" 1 3
#pragma line 39 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/c++locale.h" 3
#pragma empty_line
#pragma line 40 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/c++locale.h" 3
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/clocale" 1 3
#pragma line 39 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/clocale" 3
#pragma empty_line
#pragma line 40 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/clocale" 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/locale.h" 1 3 4
#pragma line 28 "/usr/include/locale.h" 3 4
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include/stddef.h" 1 3 4
#pragma line 29 "/usr/include/locale.h" 2 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/locale.h" 1 3 4
#pragma line 30 "/usr/include/locale.h" 2 3 4
#pragma empty_line
extern "C" {
#pragma line 51 "/usr/include/locale.h" 3 4
struct lconv
{
#pragma empty_line
#pragma empty_line
char *decimal_point;
char *thousands_sep;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
char *grouping;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
char p_cs_precedes;
#pragma empty_line
char p_sep_by_space;
#pragma empty_line
char n_cs_precedes;
#pragma empty_line
char n_sep_by_space;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
char p_sign_posn;
char n_sign_posn;
#pragma empty_line
#pragma empty_line
char int_p_cs_precedes;
#pragma empty_line
char int_p_sep_by_space;
#pragma empty_line
char int_n_cs_precedes;
#pragma empty_line
char int_n_sep_by_space;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
char int_p_sign_posn;
char int_n_sign_posn;
#pragma line 118 "/usr/include/locale.h" 3 4
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern char *setlocale (int __category, const char *__locale) throw ();
#pragma empty_line
#pragma empty_line
extern struct lconv *localeconv (void) throw ();
#pragma line 141 "/usr/include/locale.h" 3 4
extern locale_t newlocale (int __category_mask, const char *__locale,
locale_t __base) throw ();
#pragma line 176 "/usr/include/locale.h" 3 4
extern locale_t duplocale (locale_t __dataset) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern void freelocale (locale_t __dataset) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern locale_t uselocale (locale_t __dataset) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 43 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/clocale" 2 3
#pragma line 51 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/clocale" 3
namespace std
{
using ::lconv;
using ::setlocale;
using ::localeconv;
}
#pragma line 42 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/c++locale.h" 2 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
extern "C" __typeof(uselocale) __uselocale;
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
typedef __locale_t __c_locale;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline int
__convert_from_v(const __c_locale& __cloc __attribute__ ((__unused__)),
char* __out,
const int __size __attribute__ ((__unused__)),
const char* __fmt, ...)
{
#pragma empty_line
__c_locale __old = __gnu_cxx::__uselocale(__cloc);
#pragma line 88 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
#pragma empty_line
#pragma empty_line
const int __ret = __builtin_vsnprintf(__out, __size, __fmt, __args);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__builtin_va_end(__args);
#pragma empty_line
#pragma empty_line
__gnu_cxx::__uselocale(__old);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
return __ret;
}
#pragma empty_line
#pragma empty_line
}
#pragma line 41 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/localefwd.h" 2 3
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cctype" 1 3
#pragma line 39 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cctype" 3
#pragma empty_line
#pragma line 40 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cctype" 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/ctype.h" 1 3 4
#pragma line 28 "/usr/include/ctype.h" 3 4
extern "C" {
#pragma line 39 "/usr/include/ctype.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/endian.h" 1 3 4
#pragma line 35 "/usr/include/x86_64-linux-gnu/bits/endian.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/endianness.h" 1 3 4
#pragma line 36 "/usr/include/x86_64-linux-gnu/bits/endian.h" 2 3 4
#pragma line 40 "/usr/include/ctype.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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))
};
#pragma line 79 "/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__));
#pragma line 108 "/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 ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int tolower (int __c) throw ();
#pragma empty_line
#pragma empty_line
extern int toupper (int __c) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int isblank (int) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int isctype (int __c, int __mask) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int isascii (int __c) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int toascii (int __c) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int _toupper (int) throw ();
extern int _tolower (int) throw ();
#pragma line 251 "/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 ();
#pragma empty_line
extern int isblank_l (int, locale_t) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int __tolower_l (int __c, locale_t __l) throw ();
extern int tolower_l (int __c, locale_t __l) throw ();
#pragma empty_line
#pragma empty_line
extern int __toupper_l (int __c, locale_t __l) throw ();
extern int toupper_l (int __c, locale_t __l) throw ();
#pragma line 327 "/usr/include/ctype.h" 3 4
}
#pragma line 43 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cctype" 2 3
#pragma line 62 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std
{
using ::isblank;
}
#pragma line 43 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/localefwd.h" 2 3
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma line 55 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/localefwd.h" 3
class locale;
#pragma empty_line
template<typename _Facet>
bool
has_facet(const locale&) throw();
#pragma empty_line
template<typename _Facet>
const _Facet&
use_facet(const locale&);
#pragma empty_line
#pragma empty_line
template<typename _CharT>
bool
isspace(_CharT, const locale&);
#pragma empty_line
template<typename _CharT>
bool
isprint(_CharT, const locale&);
#pragma empty_line
template<typename _CharT>
bool
iscntrl(_CharT, const locale&);
#pragma empty_line
template<typename _CharT>
bool
isupper(_CharT, const locale&);
#pragma empty_line
template<typename _CharT>
bool
islower(_CharT, const locale&);
#pragma empty_line
template<typename _CharT>
bool
isalpha(_CharT, const locale&);
#pragma empty_line
template<typename _CharT>
bool
isdigit(_CharT, const locale&);
#pragma empty_line
template<typename _CharT>
bool
ispunct(_CharT, const locale&);
#pragma empty_line
template<typename _CharT>
bool
isxdigit(_CharT, const locale&);
#pragma empty_line
template<typename _CharT>
bool
isalnum(_CharT, const locale&);
#pragma empty_line
template<typename _CharT>
bool
isgraph(_CharT, const locale&);
#pragma empty_line
#pragma empty_line
template<typename _CharT>
bool
isblank(_CharT, const locale&);
#pragma empty_line
#pragma empty_line
template<typename _CharT>
_CharT
toupper(_CharT, const locale&);
#pragma empty_line
template<typename _CharT>
_CharT
tolower(_CharT, const locale&);
#pragma empty_line
#pragma empty_line
class ctype_base;
template<typename _CharT>
class ctype;
template<> class ctype<char>;
#pragma empty_line
template<> class ctype<wchar_t>;
#pragma empty_line
template<typename _CharT>
class ctype_byname;
#pragma empty_line
#pragma empty_line
class codecvt_base;
template<typename _InternT, typename _ExternT, typename _StateT>
class codecvt;
template<> class codecvt<char, char, mbstate_t>;
#pragma empty_line
template<> class codecvt<wchar_t, char, mbstate_t>;
#pragma empty_line
template<typename _InternT, typename _ExternT, typename _StateT>
class codecvt_byname;
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
class num_get;
template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
class num_put;
#pragma empty_line
namespace __cxx11 {
template<typename _CharT> class numpunct;
template<typename _CharT> class numpunct_byname;
}
#pragma empty_line
namespace __cxx11 {
#pragma empty_line
template<typename _CharT>
class collate;
template<typename _CharT>
class collate_byname;
}
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
class messages_base;
namespace __cxx11 {
template<typename _CharT>
class messages;
template<typename _CharT>
class messages_byname;
}
#pragma empty_line
#pragma empty_line
}
#pragma line 42 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ios" 2 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 1 3
#pragma line 37 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 3
#pragma empty_line
#pragma line 38 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 3
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/atomicity.h" 1 3
#pragma line 32 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/atomicity.h" 3
#pragma empty_line
#pragma line 33 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/atomicity.h" 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/gthr.h" 1 3
#pragma line 30 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
#pragma line 148 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/gthr.h" 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/gthr-default.h" 1 3
#pragma line 35 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/gthr-default.h" 3
#pragma line 1 "/usr/include/pthread.h" 1 3 4
#pragma line 22 "/usr/include/pthread.h" 3 4
#pragma line 1 "/usr/include/sched.h" 1 3 4
#pragma line 29 "/usr/include/sched.h" 3 4
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include/stddef.h" 1 3 4
#pragma line 30 "/usr/include/sched.h" 2 3 4
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/types/time_t.h" 1 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __time_t time_t;
#pragma line 32 "/usr/include/sched.h" 2 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h" 1 3 4
#pragma line 10 "/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h" 3 4
struct timespec
{
__time_t tv_sec;
#pragma empty_line
#pragma empty_line
#pragma empty_line
__syscall_slong_t tv_nsec;
#pragma line 26 "/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h" 3 4
};
#pragma line 33 "/usr/include/sched.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __pid_t pid_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/sched.h" 1 3 4
#pragma line 76 "/usr/include/x86_64-linux-gnu/bits/sched.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h" 1 3 4
#pragma line 23 "/usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h" 3 4
struct sched_param
{
int sched_priority;
};
#pragma line 77 "/usr/include/x86_64-linux-gnu/bits/sched.h" 2 3 4
#pragma empty_line
extern "C" {
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int clone (int (*__fn) (void *__arg), void *__child_stack,
int __flags, void *__arg, ...) throw ();
#pragma empty_line
#pragma empty_line
extern int unshare (int __flags) throw ();
#pragma empty_line
#pragma empty_line
extern int sched_getcpu (void) throw ();
#pragma empty_line
#pragma empty_line
extern int getcpu (unsigned int *, unsigned int *) throw ();
#pragma empty_line
#pragma empty_line
extern int setns (int __fd, int __nstype) throw ();
#pragma empty_line
#pragma empty_line
}
#pragma line 44 "/usr/include/sched.h" 2 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/cpu-set.h" 1 3 4
#pragma line 32 "/usr/include/x86_64-linux-gnu/bits/cpu-set.h" 3 4
typedef unsigned long int __cpu_mask;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef struct
{
__cpu_mask __bits[1024 / (8 * sizeof (__cpu_mask))];
} cpu_set_t;
#pragma line 115 "/usr/include/x86_64-linux-gnu/bits/cpu-set.h" 3 4
extern "C" {
#pragma empty_line
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 ();
#pragma empty_line
}
#pragma line 45 "/usr/include/sched.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern "C" {
#pragma empty_line
#pragma empty_line
extern int sched_setparam (__pid_t __pid, const struct sched_param *__param)
throw ();
#pragma empty_line
#pragma empty_line
extern int sched_getparam (__pid_t __pid, struct sched_param *__param) throw ();
#pragma empty_line
#pragma empty_line
extern int sched_setscheduler (__pid_t __pid, int __policy,
const struct sched_param *__param) throw ();
#pragma empty_line
#pragma empty_line
extern int sched_getscheduler (__pid_t __pid) throw ();
#pragma empty_line
#pragma empty_line
extern int sched_yield (void) throw ();
#pragma empty_line
#pragma empty_line
extern int sched_get_priority_max (int __algorithm) throw ();
#pragma empty_line
#pragma empty_line
extern int sched_get_priority_min (int __algorithm) throw ();
#pragma empty_line
#pragma empty_line
extern int sched_rr_get_interval (__pid_t __pid, struct timespec *__t) throw ();
#pragma line 121 "/usr/include/sched.h" 3 4
extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize,
const cpu_set_t *__cpuset) throw ();
#pragma empty_line
#pragma empty_line
extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize,
cpu_set_t *__cpuset) throw ();
#pragma empty_line
#pragma empty_line
}
#pragma line 23 "/usr/include/pthread.h" 2 3 4
#pragma line 1 "/usr/include/time.h" 1 3 4
#pragma line 29 "/usr/include/time.h" 3 4
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include/stddef.h" 1 3 4
#pragma line 30 "/usr/include/time.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/time.h" 1 3 4
#pragma line 73 "/usr/include/x86_64-linux-gnu/bits/time.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/timex.h" 1 3 4
#pragma line 22 "/usr/include/x86_64-linux-gnu/bits/timex.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h" 1 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
struct timeval
{
__time_t tv_sec;
__suseconds_t tv_usec;
};
#pragma line 23 "/usr/include/x86_64-linux-gnu/bits/timex.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
int tai;
#pragma empty_line
#pragma empty_line
int :32; int :32; int :32; int :32;
int :32; int :32; int :32; int :32;
int :32; int :32; int :32;
};
#pragma line 74 "/usr/include/x86_64-linux-gnu/bits/time.h" 2 3 4
#pragma empty_line
extern "C" {
#pragma empty_line
#pragma empty_line
extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) throw ();
#pragma empty_line
}
#pragma line 34 "/usr/include/time.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/types/clock_t.h" 1 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __clock_t clock_t;
#pragma line 38 "/usr/include/time.h" 2 3 4
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_tm.h" 1 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
long int tm_gmtoff;
const char *tm_zone;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
};
#pragma line 40 "/usr/include/time.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/types/clockid_t.h" 1 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __clockid_t clockid_t;
#pragma line 47 "/usr/include/time.h" 2 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/types/timer_t.h" 1 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __timer_t timer_t;
#pragma line 48 "/usr/include/time.h" 2 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h" 1 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
struct itimerspec
{
struct timespec it_interval;
struct timespec it_value;
};
#pragma line 49 "/usr/include/time.h" 2 3 4
struct sigevent;
#pragma line 68 "/usr/include/time.h" 3 4
extern "C" {
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern clock_t clock (void) throw ();
#pragma empty_line
#pragma empty_line
extern time_t time (time_t *__timer) throw ();
#pragma empty_line
#pragma empty_line
extern double difftime (time_t __time1, time_t __time0)
throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern time_t mktime (struct tm *__tp) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern size_t strftime (char *__restrict __s, size_t __maxsize,
const char *__restrict __format,
const struct tm *__restrict __tp) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern char *strptime (const char *__restrict __s,
const char *__restrict __fmt, struct tm *__tp)
throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern size_t strftime_l (char *__restrict __s, size_t __maxsize,
const char *__restrict __format,
const struct tm *__restrict __tp,
locale_t __loc) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern char *strptime_l (const char *__restrict __s,
const char *__restrict __fmt, struct tm *__tp,
locale_t __loc) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern struct tm *gmtime (const time_t *__timer) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern struct tm *localtime (const time_t *__timer) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern struct tm *gmtime_r (const time_t *__restrict __timer,
struct tm *__restrict __tp) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern struct tm *localtime_r (const time_t *__restrict __timer,
struct tm *__restrict __tp) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern char *asctime (const struct tm *__tp) throw ();
#pragma empty_line
#pragma empty_line
extern char *ctime (const time_t *__timer) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern char *asctime_r (const struct tm *__restrict __tp,
char *__restrict __buf) throw ();
#pragma empty_line
#pragma empty_line
extern char *ctime_r (const time_t *__restrict __timer,
char *__restrict __buf) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern char *__tzname[2];
extern int __daylight;
extern long int __timezone;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern char *tzname[2];
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern void tzset (void) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int daylight;
extern long int timezone;
#pragma line 190 "/usr/include/time.h" 3 4
extern time_t timegm (struct tm *__tp) throw ();
#pragma empty_line
#pragma empty_line
extern time_t timelocal (struct tm *__tp) throw ();
#pragma empty_line
#pragma empty_line
extern int dysize (int __year) throw () __attribute__ ((__const__));
#pragma line 205 "/usr/include/time.h" 3 4
extern int nanosleep (const struct timespec *__requested_time,
struct timespec *__remaining);
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int clock_getres (clockid_t __clock_id, struct timespec *__res) throw ();
#pragma empty_line
#pragma empty_line
extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) throw ();
#pragma empty_line
#pragma empty_line
extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp)
throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int clock_nanosleep (clockid_t __clock_id, int __flags,
const struct timespec *__req,
struct timespec *__rem);
#pragma empty_line
#pragma empty_line
extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int timer_create (clockid_t __clock_id,
struct sigevent *__restrict __evp,
timer_t *__restrict __timerid) throw ();
#pragma empty_line
#pragma empty_line
extern int timer_delete (timer_t __timerid) throw ();
#pragma empty_line
#pragma empty_line
extern int timer_settime (timer_t __timerid, int __flags,
const struct itimerspec *__restrict __value,
struct itimerspec *__restrict __ovalue) throw ();
#pragma empty_line
#pragma empty_line
extern int timer_gettime (timer_t __timerid, struct itimerspec *__value)
throw ();
#pragma empty_line
#pragma empty_line
extern int timer_getoverrun (timer_t __timerid) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int timespec_get (struct timespec *__ts, int __base)
throw () __attribute__ ((__nonnull__ (1)));
#pragma line 274 "/usr/include/time.h" 3 4
extern int getdate_err;
#pragma line 283 "/usr/include/time.h" 3 4
extern struct tm *getdate (const char *__string);
#pragma line 297 "/usr/include/time.h" 3 4
extern int getdate_r (const char *__restrict __string,
struct tm *__restrict __resbufp);
#pragma empty_line
#pragma empty_line
}
#pragma line 24 "/usr/include/pthread.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 1 3 4
#pragma line 23 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 1 3 4
#pragma line 44 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h" 1 3 4
#pragma line 21 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
#pragma line 22 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h" 2 3 4
#pragma line 45 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef struct __pthread_internal_list
{
struct __pthread_internal_list *__prev;
struct __pthread_internal_list *__next;
} __pthread_list_t;
#pragma empty_line
typedef struct __pthread_internal_slist
{
struct __pthread_internal_slist *__next;
} __pthread_slist_t;
#pragma line 74 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/struct_mutex.h" 1 3 4
#pragma line 22 "/usr/include/x86_64-linux-gnu/bits/struct_mutex.h" 3 4
struct __pthread_mutex_s
{
int __lock;
unsigned int __count;
int __owner;
#pragma empty_line
unsigned int __nusers;
#pragma empty_line
#pragma empty_line
#pragma empty_line
int __kind;
#pragma empty_line
short __spins;
short __elision;
__pthread_list_t __list;
#pragma line 53 "/usr/include/x86_64-linux-gnu/bits/struct_mutex.h" 3 4
};
#pragma line 75 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 2 3 4
#pragma line 87 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h" 1 3 4
#pragma line 23 "/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h" 3 4
struct __pthread_rwlock_arch_t
{
unsigned int __readers;
unsigned int __writers;
unsigned int __wrphase_futex;
unsigned int __writers_futex;
unsigned int __pad3;
unsigned int __pad4;
#pragma empty_line
int __cur_writer;
int __shared;
signed char __rwelision;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
unsigned char __pad1[7];
#pragma empty_line
#pragma empty_line
unsigned long int __pad2;
#pragma empty_line
#pragma empty_line
unsigned int __flags;
#pragma line 55 "/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h" 3 4
};
#pragma line 88 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
struct __pthread_cond_s
{
__extension__ union
{
__extension__ unsigned long long int __wseq;
struct
{
unsigned int __low;
unsigned int __high;
} __wseq32;
};
__extension__ union
{
__extension__ unsigned long long int __g1_start;
struct
{
unsigned int __low;
unsigned int __high;
} __g1_start32;
};
unsigned int __g_refs[2] ;
unsigned int __g_size[2];
unsigned int __g1_orig_size;
unsigned int __wrefs;
unsigned int __g_signals[2];
};
#pragma line 24 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef unsigned long int pthread_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef union
{
char __size[4];
int __align;
} pthread_mutexattr_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef union
{
char __size[4];
int __align;
} pthread_condattr_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef unsigned int pthread_key_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef int pthread_once_t;
#pragma empty_line
#pragma empty_line
union pthread_attr_t
{
char __size[56];
long int __align;
};
#pragma empty_line
typedef union pthread_attr_t pthread_attr_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef union
{
struct __pthread_mutex_s __data;
char __size[40];
long int __align;
} pthread_mutex_t;
#pragma empty_line
#pragma empty_line
typedef union
{
struct __pthread_cond_s __data;
char __size[48];
__extension__ long long int __align;
} pthread_cond_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef union
{
struct __pthread_rwlock_arch_t __data;
char __size[56];
long int __align;
} pthread_rwlock_t;
#pragma empty_line
typedef union
{
char __size[8];
long int __align;
} pthread_rwlockattr_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef volatile int pthread_spinlock_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef union
{
char __size[32];
long int __align;
} pthread_barrier_t;
#pragma empty_line
typedef union
{
char __size[4];
int __align;
} pthread_barrierattr_t;
#pragma line 27 "/usr/include/pthread.h" 2 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/setjmp.h" 1 3 4
#pragma line 26 "/usr/include/x86_64-linux-gnu/bits/setjmp.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
#pragma line 27 "/usr/include/x86_64-linux-gnu/bits/setjmp.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef long int __jmp_buf[8];
#pragma line 28 "/usr/include/pthread.h" 2 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
#pragma line 29 "/usr/include/pthread.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
enum
{
PTHREAD_CREATE_JOINABLE,
#pragma empty_line
PTHREAD_CREATE_DETACHED
#pragma empty_line
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
enum
{
PTHREAD_MUTEX_TIMED_NP,
PTHREAD_MUTEX_RECURSIVE_NP,
PTHREAD_MUTEX_ERRORCHECK_NP,
PTHREAD_MUTEX_ADAPTIVE_NP
#pragma empty_line
,
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
#pragma empty_line
#pragma empty_line
#pragma empty_line
, PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_TIMED_NP
#pragma empty_line
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
enum
{
PTHREAD_MUTEX_STALLED,
PTHREAD_MUTEX_STALLED_NP = PTHREAD_MUTEX_STALLED,
PTHREAD_MUTEX_ROBUST,
PTHREAD_MUTEX_ROBUST_NP = PTHREAD_MUTEX_ROBUST
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
enum
{
PTHREAD_PRIO_NONE,
PTHREAD_PRIO_INHERIT,
PTHREAD_PRIO_PROTECT
};
#pragma line 100 "/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
};
#pragma line 120 "/usr/include/pthread.h" 3 4
enum
{
PTHREAD_INHERIT_SCHED,
#pragma empty_line
PTHREAD_EXPLICIT_SCHED
#pragma empty_line
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
enum
{
PTHREAD_SCOPE_SYSTEM,
#pragma empty_line
PTHREAD_SCOPE_PROCESS
#pragma empty_line
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
enum
{
PTHREAD_PROCESS_PRIVATE,
#pragma empty_line
PTHREAD_PROCESS_SHARED
#pragma empty_line
};
#pragma line 155 "/usr/include/pthread.h" 3 4
struct _pthread_cleanup_buffer
{
void (*__routine) (void *);
void *__arg;
int __canceltype;
struct _pthread_cleanup_buffer *__prev;
};
#pragma empty_line
#pragma empty_line
enum
{
PTHREAD_CANCEL_ENABLE,
#pragma empty_line
PTHREAD_CANCEL_DISABLE
#pragma empty_line
};
enum
{
PTHREAD_CANCEL_DEFERRED,
#pragma empty_line
PTHREAD_CANCEL_ASYNCHRONOUS
#pragma empty_line
};
#pragma line 193 "/usr/include/pthread.h" 3 4
extern "C" {
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern void pthread_exit (void *__retval) __attribute__ ((__noreturn__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_join (pthread_t __th, void **__thread_return);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_tryjoin_np (pthread_t __th, void **__thread_return) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return,
const struct timespec *__abstime);
#pragma line 238 "/usr/include/pthread.h" 3 4
extern int pthread_clockjoin_np (pthread_t __th, void **__thread_return,
clockid_t __clockid,
const struct timespec *__abstime);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_detach (pthread_t __th) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern pthread_t pthread_self (void) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern int pthread_equal (pthread_t __thread1, pthread_t __thread2)
throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_attr_init (pthread_attr_t *__attr) throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
extern int pthread_attr_destroy (pthread_attr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
extern int pthread_attr_getdetachstate (const pthread_attr_t *__attr,
int *__detachstate)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
extern int pthread_attr_setdetachstate (pthread_attr_t *__attr,
int __detachstate)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_attr_getguardsize (const pthread_attr_t *__attr,
size_t *__guardsize)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
extern int pthread_attr_setguardsize (pthread_attr_t *__attr,
size_t __guardsize)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict __attr,
struct sched_param *__restrict __param)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr,
const struct sched_param *__restrict
__param) throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
extern int pthread_attr_getschedpolicy (const pthread_attr_t *__restrict
__attr, int *__restrict __policy)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
extern int pthread_attr_getinheritsched (const pthread_attr_t *__restrict
__attr, int *__restrict __inherit)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
extern int pthread_attr_setinheritsched (pthread_attr_t *__attr,
int __inherit)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_attr_getscope (const pthread_attr_t *__restrict __attr,
int *__restrict __scope)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
extern int pthread_attr_getstackaddr (const pthread_attr_t *__restrict
__attr, void **__restrict __stackaddr)
throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__deprecated__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_attr_setstackaddr (pthread_attr_t *__attr,
void *__stackaddr)
throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__));
#pragma empty_line
#pragma empty_line
extern int pthread_attr_getstacksize (const pthread_attr_t *__restrict
__attr, size_t *__restrict __stacksize)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_attr_setstacksize (pthread_attr_t *__attr,
size_t __stacksize)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_attr_getstack (const pthread_attr_t *__restrict __attr,
void **__restrict __stackaddr,
size_t *__restrict __stacksize)
throw () __attribute__ ((__nonnull__ (1, 2, 3)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr,
size_t __stacksize) throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_attr_setaffinity_np (pthread_attr_t *__attr,
size_t __cpusetsize,
const cpu_set_t *__cpuset)
throw () __attribute__ ((__nonnull__ (1, 3)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_attr_getaffinity_np (const pthread_attr_t *__attr,
size_t __cpusetsize,
cpu_set_t *__cpuset)
throw () __attribute__ ((__nonnull__ (1, 3)));
#pragma empty_line
#pragma empty_line
extern int pthread_getattr_default_np (pthread_attr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_setattr_default_np (const pthread_attr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr)
throw () __attribute__ ((__nonnull__ (2)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_setschedparam (pthread_t __target_thread, int __policy,
const struct sched_param *__param)
throw () __attribute__ ((__nonnull__ (3)));
#pragma empty_line
#pragma empty_line
extern int pthread_getschedparam (pthread_t __target_thread,
int *__restrict __policy,
struct sched_param *__restrict __param)
throw () __attribute__ ((__nonnull__ (2, 3)));
#pragma empty_line
#pragma empty_line
extern int pthread_setschedprio (pthread_t __target_thread, int __prio)
throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_getname_np (pthread_t __target_thread, char *__buf,
size_t __buflen)
throw () __attribute__ ((__nonnull__ (2)));
#pragma empty_line
#pragma empty_line
extern int pthread_setname_np (pthread_t __target_thread, const char *__name)
throw () __attribute__ ((__nonnull__ (2)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_getconcurrency (void) throw ();
#pragma empty_line
#pragma empty_line
extern int pthread_setconcurrency (int __level) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_yield (void) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_setaffinity_np (pthread_t __th, size_t __cpusetsize,
const cpu_set_t *__cpuset)
throw () __attribute__ ((__nonnull__ (3)));
#pragma empty_line
#pragma empty_line
extern int pthread_getaffinity_np (pthread_t __th, size_t __cpusetsize,
cpu_set_t *__cpuset)
throw () __attribute__ ((__nonnull__ (3)));
#pragma line 470 "/usr/include/pthread.h" 3 4
extern int pthread_once (pthread_once_t *__once_control,
void (*__init_routine) (void)) __attribute__ ((__nonnull__ (1, 2)));
#pragma line 482 "/usr/include/pthread.h" 3 4
extern int pthread_setcancelstate (int __state, int *__oldstate);
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_setcanceltype (int __type, int *__oldtype);
#pragma empty_line
#pragma empty_line
extern int pthread_cancel (pthread_t __th);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern void pthread_testcancel (void);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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__));
#pragma line 516 "/usr/include/pthread.h" 3 4
struct __pthread_cleanup_frame
{
void (*__cancel_routine) (void *);
void *__cancel_arg;
int __do_it;
int __cancel_type;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
class __pthread_cleanup_class
{
void (*__cancel_routine) (void *);
void *__cancel_arg;
int __do_it;
int __cancel_type;
#pragma empty_line
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); }
};
#pragma line 718 "/usr/include/pthread.h" 3 4
struct __jmp_buf_tag;
extern int __sigsetjmp (struct __jmp_buf_tag *__env, int __savemask) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_mutex_init (pthread_mutex_t *__mutex,
const pthread_mutexattr_t *__mutexattr)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
extern int pthread_mutex_destroy (pthread_mutex_t *__mutex)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
extern int pthread_mutex_trylock (pthread_mutex_t *__mutex)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
extern int pthread_mutex_lock (pthread_mutex_t *__mutex)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex,
const struct timespec *__restrict
__abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_mutex_clocklock (pthread_mutex_t *__restrict __mutex,
clockid_t __clockid,
const struct timespec *__restrict
__abstime) throw () __attribute__ ((__nonnull__ (1, 3)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_mutex_unlock (pthread_mutex_t *__mutex)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_mutex_getprioceiling (const pthread_mutex_t *
__restrict __mutex,
int *__restrict __prioceiling)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex,
int __prioceiling,
int *__restrict __old_ceiling)
throw () __attribute__ ((__nonnull__ (1, 3)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_mutex_consistent (pthread_mutex_t *__mutex)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
extern int pthread_mutex_consistent_np (pthread_mutex_t *__mutex)
throw () __attribute__ ((__nonnull__ (1)));
#pragma line 789 "/usr/include/pthread.h" 3 4
extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
extern int pthread_mutexattr_getpshared (const pthread_mutexattr_t *
__restrict __attr,
int *__restrict __pshared)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr,
int __pshared)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_mutexattr_gettype (const pthread_mutexattr_t *__restrict
__attr, int *__restrict __kind)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_mutexattr_getprotocol (const pthread_mutexattr_t *
__restrict __attr,
int *__restrict __protocol)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_mutexattr_setprotocol (pthread_mutexattr_t *__attr,
int __protocol)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
extern int pthread_mutexattr_getprioceiling (const pthread_mutexattr_t *
__restrict __attr,
int *__restrict __prioceiling)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
extern int pthread_mutexattr_setprioceiling (pthread_mutexattr_t *__attr,
int __prioceiling)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_mutexattr_getrobust (const pthread_mutexattr_t *__attr,
int *__robustness)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
extern int pthread_mutexattr_getrobust_np (const pthread_mutexattr_t *__attr,
int *__robustness)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_mutexattr_setrobust (pthread_mutexattr_t *__attr,
int __robustness)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
extern int pthread_mutexattr_setrobust_np (pthread_mutexattr_t *__attr,
int __robustness)
throw () __attribute__ ((__nonnull__ (1)));
#pragma line 871 "/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)));
#pragma empty_line
#pragma empty_line
extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock,
const struct timespec *__restrict
__abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_rwlock_clockrdlock (pthread_rwlock_t *__restrict __rwlock,
clockid_t __clockid,
const struct timespec *__restrict
__abstime) throw () __attribute__ ((__nonnull__ (1, 3)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock,
const struct timespec *__restrict
__abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_rwlock_clockwrlock (pthread_rwlock_t *__restrict __rwlock,
clockid_t __clockid,
const struct timespec *__restrict
__abstime) throw () __attribute__ ((__nonnull__ (1, 3)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *
__restrict __attr,
int *__restrict __pshared)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr,
int __pshared)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
extern int pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t *
__restrict __attr,
int *__restrict __pref)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr,
int __pref) throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_cond_init (pthread_cond_t *__restrict __cond,
const pthread_condattr_t *__restrict __cond_attr)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
extern int pthread_cond_destroy (pthread_cond_t *__cond)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
extern int pthread_cond_signal (pthread_cond_t *__cond)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
extern int pthread_cond_broadcast (pthread_cond_t *__cond)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_cond_wait (pthread_cond_t *__restrict __cond,
pthread_mutex_t *__restrict __mutex)
__attribute__ ((__nonnull__ (1, 2)));
#pragma line 997 "/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)));
#pragma line 1010 "/usr/include/pthread.h" 3 4
extern int pthread_cond_clockwait (pthread_cond_t *__restrict __cond,
pthread_mutex_t *__restrict __mutex,
__clockid_t __clock_id,
const struct timespec *__restrict __abstime)
__attribute__ ((__nonnull__ (1, 2, 4)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_condattr_init (pthread_condattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
extern int pthread_condattr_destroy (pthread_condattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
extern int pthread_condattr_getpshared (const pthread_condattr_t *
__restrict __attr,
int *__restrict __pshared)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
extern int pthread_condattr_setpshared (pthread_condattr_t *__attr,
int __pshared) throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_condattr_getclock (const pthread_condattr_t *
__restrict __attr,
__clockid_t *__restrict __clock_id)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
extern int pthread_condattr_setclock (pthread_condattr_t *__attr,
__clockid_t __clock_id)
throw () __attribute__ ((__nonnull__ (1)));
#pragma line 1056 "/usr/include/pthread.h" 3 4
extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
extern int pthread_spin_destroy (pthread_spinlock_t *__lock)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
extern int pthread_spin_lock (pthread_spinlock_t *__lock)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
extern int pthread_spin_trylock (pthread_spinlock_t *__lock)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
extern int pthread_spin_unlock (pthread_spinlock_t *__lock)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier,
const pthread_barrierattr_t *__restrict
__attr, unsigned int __count)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
extern int pthread_barrier_destroy (pthread_barrier_t *__barrier)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
extern int pthread_barrier_wait (pthread_barrier_t *__barrier)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t *
__restrict __attr,
int *__restrict __pshared)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr,
int __pshared)
throw () __attribute__ ((__nonnull__ (1)));
#pragma line 1123 "/usr/include/pthread.h" 3 4
extern int pthread_key_create (pthread_key_t *__key,
void (*__destr_function) (void *))
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
extern int pthread_key_delete (pthread_key_t __key) throw ();
#pragma empty_line
#pragma empty_line
extern void *pthread_getspecific (pthread_key_t __key) throw ();
#pragma empty_line
#pragma empty_line
extern int pthread_setspecific (pthread_key_t __key,
const void *__pointer) throw () ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pthread_getcpuclockid (pthread_t __thread_id,
__clockid_t *__clock_id)
throw () __attribute__ ((__nonnull__ (2)));
#pragma line 1157 "/usr/include/pthread.h" 3 4
extern int pthread_atfork (void (*__prepare) (void),
void (*__parent) (void),
void (*__child) (void)) throw ();
#pragma line 1171 "/usr/include/pthread.h" 3 4
}
#pragma line 36 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/gthr-default.h" 2 3
#pragma line 47 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 101 "/home/justin/jhai/Xilinx/Vivado/2018.3/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")));
#pragma empty_line
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")));
#pragma empty_line
static __typeof(pthread_cancel) __gthrw_pthread_cancel __attribute__ ((__weakref__("pthread_cancel")));
#pragma empty_line
static __typeof(sched_yield) __gthrw_sched_yield __attribute__ ((__weakref__("sched_yield")));
#pragma empty_line
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")));
#pragma empty_line
static __typeof(pthread_mutex_timedlock) __gthrw_pthread_mutex_timedlock __attribute__ ((__weakref__("pthread_mutex_timedlock")));
#pragma empty_line
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")));
#pragma empty_line
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")));
#pragma empty_line
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")));
#pragma line 236 "/home/justin/jhai/Xilinx/Vivado/2018.3/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")));
#pragma line 246 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma line 658 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
}
#pragma empty_line
static inline int
__gthread_join (__gthread_t __threadid, void **__value_ptr)
{
return __gthrw_pthread_join (__threadid, __value_ptr);
}
#pragma empty_line
static inline int
__gthread_detach (__gthread_t __threadid)
{
return __gthrw_pthread_detach (__threadid);
}
#pragma empty_line
static inline int
__gthread_equal (__gthread_t __t1, __gthread_t __t2)
{
return __gthrw_pthread_equal (__t1, __t2);
}
#pragma empty_line
static inline __gthread_t
__gthread_self (void)
{
return __gthrw_pthread_self ();
}
#pragma empty_line
static inline int
__gthread_yield (void)
{
return __gthrw_sched_yield ();
}
#pragma empty_line
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;
}
#pragma empty_line
static inline int
__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *))
{
return __gthrw_pthread_key_create (__key, __dtor);
}
#pragma empty_line
static inline int
__gthread_key_delete (__gthread_key_t __key)
{
return __gthrw_pthread_key_delete (__key);
}
#pragma empty_line
static inline void *
__gthread_getspecific (__gthread_key_t __key)
{
return __gthrw_pthread_getspecific (__key);
}
#pragma empty_line
static inline int
__gthread_setspecific (__gthread_key_t __key, const void *__ptr)
{
return __gthrw_pthread_setspecific (__key, __ptr);
}
#pragma empty_line
static inline void
__gthread_mutex_init_function (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
__gthrw_pthread_mutex_init (__mutex, __null);
}
#pragma empty_line
static inline int
__gthread_mutex_destroy (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
return __gthrw_pthread_mutex_destroy (__mutex);
else
return 0;
}
#pragma empty_line
static inline int
__gthread_mutex_lock (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
return __gthrw_pthread_mutex_lock (__mutex);
else
return 0;
}
#pragma empty_line
static inline int
__gthread_mutex_trylock (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
return __gthrw_pthread_mutex_trylock (__mutex);
else
return 0;
}
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
static inline int
__gthread_mutex_unlock (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
return __gthrw_pthread_mutex_unlock (__mutex);
else
return 0;
}
#pragma line 807 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
}
#pragma empty_line
static inline int
__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)
{
return __gthread_mutex_trylock (__mutex);
}
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
static inline int
__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
{
return __gthread_mutex_unlock (__mutex);
}
#pragma empty_line
static inline int
__gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t *__mutex)
{
return __gthread_mutex_destroy (__mutex);
}
#pragma line 849 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
}
#pragma empty_line
static inline int
__gthread_cond_signal (__gthread_cond_t *__cond)
{
return __gthrw_pthread_cond_signal (__cond);
}
#pragma empty_line
static inline int
__gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex)
{
return __gthrw_pthread_cond_wait (__cond, __mutex);
}
#pragma empty_line
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);
}
#pragma empty_line
static inline int
__gthread_cond_wait_recursive (__gthread_cond_t *__cond,
__gthread_recursive_mutex_t *__mutex)
{
return __gthread_cond_wait (__cond, __mutex);
}
#pragma empty_line
static inline int
__gthread_cond_destroy (__gthread_cond_t* __cond)
{
return __gthrw_pthread_cond_destroy (__cond);
}
#pragma line 149 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/gthr.h" 2 3
#pragma empty_line
#pragma empty_line
#pragma GCC visibility pop
#pragma line 36 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/atomicity.h" 2 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/atomic_word.h" 1 3
#pragma line 32 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 37 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/atomicity.h" 2 3
#pragma empty_line
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static inline _Atomic_word
__exchange_and_add(volatile _Atomic_word* __mem, int __val)
{ return __atomic_fetch_add(__mem, __val, 4); }
#pragma empty_line
static inline void
__atomic_add(volatile _Atomic_word* __mem, int __val)
{ __atomic_fetch_add(__mem, __val, 4); }
#pragma line 64 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma empty_line
static inline void
__atomic_add_single(_Atomic_word* __mem, int __val)
{ *__mem += __val; }
#pragma empty_line
static inline _Atomic_word
__attribute__ ((__unused__))
__exchange_and_add_dispatch(_Atomic_word* __mem, int __val)
{
#pragma empty_line
if (__gthread_active_p())
return __exchange_and_add(__mem, __val);
else
return __exchange_and_add_single(__mem, __val);
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
static inline void
__attribute__ ((__unused__))
__atomic_add_dispatch(_Atomic_word* __mem, int __val)
{
#pragma empty_line
if (__gthread_active_p())
__atomic_add(__mem, __val);
else
__atomic_add_single(__mem, __val);
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
}
#pragma line 40 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 2 3
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 1 3
#pragma line 37 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 3
#pragma empty_line
#pragma line 38 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/string" 1 3
#pragma line 36 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/string" 3
#pragma empty_line
#pragma line 37 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/string" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ostream_insert.h" 1 3
#pragma line 33 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ostream_insert.h" 3
#pragma empty_line
#pragma line 34 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ostream_insert.h" 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/cxxabi_forced.h" 1 3
#pragma line 34 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/cxxabi_forced.h" 3
#pragma empty_line
#pragma line 35 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/cxxabi_forced.h" 3
#pragma empty_line
#pragma GCC visibility push(default)
#pragma empty_line
#pragma empty_line
namespace __cxxabiv1
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
class __forced_unwind
{
virtual ~__forced_unwind() throw();
#pragma empty_line
#pragma empty_line
virtual void __pure_dummy() = 0;
};
}
#pragma empty_line
#pragma empty_line
#pragma GCC visibility pop
#pragma line 37 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ostream_insert.h" 2 3
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
const streamsize __put = __out.rdbuf()->sputn(__s, __n);
if (__put != __n)
__out.setstate(__ios_base::badbit);
}
#pragma empty_line
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;
#pragma empty_line
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;
}
}
}
#pragma empty_line
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;
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern template ostream& __ostream_insert(ostream&, const char*, streamsize);
#pragma empty_line
#pragma empty_line
extern template wostream& __ostream_insert(wostream&, const wchar_t*,
streamsize);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 45 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/string" 2 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 1 3
#pragma line 37 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
#pragma empty_line
#pragma line 38 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
#pragma line 47 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace __cxx11 {
#pragma line 71 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
static const size_type npos = static_cast<size_type>(-1);
#pragma empty_line
private:
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef const_iterator __const_iterator;
#pragma empty_line
#pragma empty_line
#pragma empty_line
struct _Alloc_hider : allocator_type
{
_Alloc_hider(pointer __dat, const _Alloc& __a = _Alloc())
: allocator_type(__a), _M_p(__dat) { }
#pragma empty_line
pointer _M_p;
};
#pragma empty_line
_Alloc_hider _M_dataplus;
size_type _M_string_length;
#pragma empty_line
enum { _S_local_capacity = 15 / sizeof(_CharT) };
#pragma empty_line
union
{
_CharT _M_local_buf[_S_local_capacity + 1];
size_type _M_allocated_capacity;
};
#pragma empty_line
void
_M_data(pointer __p)
{ _M_dataplus._M_p = __p; }
#pragma empty_line
void
_M_length(size_type __length)
{ _M_string_length = __length; }
#pragma empty_line
pointer
_M_data() const
{ return _M_dataplus._M_p; }
#pragma empty_line
pointer
_M_local_data()
{
#pragma empty_line
return std::pointer_traits<pointer>::pointer_to(*_M_local_buf);
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
const_pointer
_M_local_data() const
{
#pragma empty_line
return std::pointer_traits<const_pointer>::pointer_to(*_M_local_buf);
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
void
_M_capacity(size_type __capacity)
{ _M_allocated_capacity = __capacity; }
#pragma empty_line
void
_M_set_length(size_type __n)
{
_M_length(__n);
traits_type::assign(_M_data()[__n], _CharT());
}
#pragma empty_line
bool
_M_is_local() const
{ return _M_data() == _M_local_data(); }
#pragma empty_line
#pragma empty_line
pointer
_M_create(size_type&, size_type);
#pragma empty_line
void
_M_dispose()
{
if (!_M_is_local())
_M_destroy(_M_allocated_capacity);
}
#pragma empty_line
void
_M_destroy(size_type __size) throw()
{ _Alloc_traits::deallocate(_M_get_allocator(), _M_data(), __size + 1); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
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());
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Integer>
void
_M_construct_aux(_Integer __beg, _Integer __end, std::__true_type)
{ _M_construct_aux_2(static_cast<size_type>(__beg), __end); }
#pragma empty_line
void
_M_construct_aux_2(size_type __req, _CharT __c)
{ _M_construct(__req, __c); }
#pragma empty_line
template<typename _InIterator>
void
_M_construct(_InIterator __beg, _InIterator __end)
{
typedef typename std::__is_integer<_InIterator>::__type _Integral;
_M_construct_aux(__beg, __end, _Integral());
}
#pragma empty_line
#pragma empty_line
template<typename _InIterator>
void
_M_construct(_InIterator __beg, _InIterator __end,
std::input_iterator_tag);
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _FwdIterator>
void
_M_construct(_FwdIterator __beg, _FwdIterator __end,
std::forward_iterator_tag);
#pragma empty_line
void
_M_construct(size_type __req, _CharT __c);
#pragma empty_line
allocator_type&
_M_get_allocator()
{ return _M_dataplus; }
#pragma empty_line
const allocator_type&
_M_get_allocator() const
{ return _M_dataplus; }
#pragma empty_line
private:
#pragma line 258 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma empty_line
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));
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
bool
_M_disjunct(const _CharT* __s) const noexcept
{
return (less<const _CharT*>()(__s, _M_data())
|| less<const _CharT*>()(_M_data() + this->size(), __s));
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
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);
}
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
static void
_S_copy_chars(_CharT* __p, iterator __k1, iterator __k2) noexcept
{ _S_copy_chars(__p, __k1.base(), __k2.base()); }
#pragma empty_line
static void
_S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2)
noexcept
{ _S_copy_chars(__p, __k1.base(), __k2.base()); }
#pragma empty_line
static void
_S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2) noexcept
{ _S_copy(__p, __k1, __k2 - __k1); }
#pragma empty_line
static void
_S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
noexcept
{ _S_copy(__p, __k1, __k2 - __k1); }
#pragma empty_line
static int
_S_compare(size_type __n1, size_type __n2) noexcept
{
const difference_type __d = difference_type(__n1 - __n2);
#pragma empty_line
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);
}
#pragma empty_line
void
_M_assign(const basic_string& __rcs);
#pragma empty_line
void
_M_mutate(size_type __pos, size_type __len1, const _CharT* __s,
size_type __len2);
#pragma empty_line
void
_M_erase(size_type __pos, size_type __n);
#pragma empty_line
public:
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
basic_string()
noexcept(is_nothrow_default_constructible<_Alloc>::value)
: _M_dataplus(_M_local_data())
{ _M_set_length(0); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
explicit
basic_string(const _Alloc& __a) noexcept
: _M_dataplus(_M_local_data(), __a)
{ _M_set_length(0); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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()); }
#pragma line 410 "/home/justin/jhai/Xilinx/Vivado/2018.3/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));
}
#pragma line 426 "/home/justin/jhai/Xilinx/Vivado/2018.3/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));
}
#pragma line 444 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc())
: _M_dataplus(_M_local_data(), __a)
{ _M_construct(__n, __c); }
#pragma line 476 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
_M_length(__str.length());
__str._M_data(__str._M_local_data());
__str._M_set_length(0);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
basic_string(initializer_list<_CharT> __l, const _Alloc& __a = _Alloc())
: _M_dataplus(_M_local_data(), __a)
{ _M_construct(__l.begin(), __l.end()); }
#pragma empty_line
basic_string(const basic_string& __str, const _Alloc& __a)
: _M_dataplus(_M_local_data(), __a)
{ _M_construct(__str.begin(), __str.end()); }
#pragma empty_line
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());
}
#pragma line 544 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
template<typename _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
#pragma empty_line
#pragma empty_line
#pragma empty_line
basic_string(_InputIterator __beg, _InputIterator __end,
const _Alloc& __a = _Alloc())
: _M_dataplus(_M_local_data(), __a)
{ _M_construct(__beg, __end); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
~basic_string()
{ _M_dispose(); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
basic_string&
operator=(const basic_string& __str)
{
#pragma empty_line
if (_Alloc_traits::_S_propagate_on_copy_assign())
{
if (!_Alloc_traits::_S_always_equal() && !_M_is_local()
&& _M_get_allocator() != __str._M_get_allocator())
{
#pragma empty_line
_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());
}
#pragma empty_line
return this->assign(__str);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
basic_string&
operator=(const _CharT* __s)
{ return this->assign(__s); }
#pragma line 599 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma line 617 "/home/justin/jhai/Xilinx/Vivado/2018.3/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())
{
#pragma empty_line
_M_destroy(_M_allocated_capacity);
_M_data(_M_local_data());
_M_set_length(0);
}
#pragma empty_line
std::__alloc_on_move(_M_get_allocator(), __str._M_get_allocator());
#pragma empty_line
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);
}
#pragma empty_line
_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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
basic_string&
operator=(initializer_list<_CharT> __l)
{
this->assign(__l.begin(), __l.size());
return *this;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
iterator
begin() noexcept
{ return iterator(_M_data()); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
const_iterator
begin() const noexcept
{ return const_iterator(_M_data()); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
iterator
end() noexcept
{ return iterator(_M_data() + this->size()); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
const_iterator
end() const noexcept
{ return const_iterator(_M_data() + this->size()); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
reverse_iterator
rbegin() noexcept
{ return reverse_iterator(this->end()); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
const_reverse_iterator
rbegin() const noexcept
{ return const_reverse_iterator(this->end()); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
reverse_iterator
rend() noexcept
{ return reverse_iterator(this->begin()); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
const_reverse_iterator
rend() const noexcept
{ return const_reverse_iterator(this->begin()); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
const_iterator
cbegin() const noexcept
{ return const_iterator(this->_M_data()); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
const_iterator
cend() const noexcept
{ return const_iterator(this->_M_data() + this->size()); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
const_reverse_iterator
crbegin() const noexcept
{ return const_reverse_iterator(this->end()); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
const_reverse_iterator
crend() const noexcept
{ return const_reverse_iterator(this->begin()); }
#pragma empty_line
#pragma empty_line
public:
#pragma empty_line
#pragma empty_line
#pragma empty_line
size_type
size() const noexcept
{ return _M_string_length; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
size_type
length() const noexcept
{ return _M_string_length; }
#pragma empty_line
#pragma empty_line
size_type
max_size() const noexcept
{ return (_Alloc_traits::max_size(_M_get_allocator()) - 1) / 2; }
#pragma line 813 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
void
resize(size_type __n, _CharT __c);
#pragma line 826 "/home/justin/jhai/Xilinx/Vivado/2018.3/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()); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
void
shrink_to_fit() noexcept
{
#pragma empty_line
if (capacity() > size())
{
try
{ reserve(0); }
catch(...)
{ }
}
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
size_type
capacity() const noexcept
{
return _M_is_local() ? size_type(_S_local_capacity)
: _M_allocated_capacity;
}
#pragma line 875 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
void
reserve(size_type __res_arg = 0);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
void
clear() noexcept
{ _M_set_length(0); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
bool
empty() const noexcept
{ return this->size() == 0; }
#pragma line 904 "/home/justin/jhai/Xilinx/Vivado/2018.3/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];
}
#pragma line 921 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
reference
operator[](size_type __pos)
{
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
;
return _M_data()[__pos];
}
#pragma line 942 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)")
#pragma empty_line
,
__n, this->size());
return _M_data()[__n];
}
#pragma line 963 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)")
#pragma empty_line
,
__n, this->size());
return _M_data()[__n];
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
reference
front() noexcept
{
;
return operator[](0);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
const_reference
front() const noexcept
{
;
return operator[](0);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
reference
back() noexcept
{
;
return operator[](this->size() - 1);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
const_reference
back() const noexcept
{
;
return operator[](this->size() - 1);
}
#pragma line 1026 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
basic_string&
operator+=(const _CharT* __s)
{ return this->append(__s); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
basic_string&
operator+=(_CharT __c)
{
this->push_back(__c);
return *this;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
basic_string&
operator+=(initializer_list<_CharT> __l)
{ return this->append(__l.begin(), __l.size()); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
basic_string&
append(const basic_string& __str)
{ return _M_append(__str._M_data(), __str.size()); }
#pragma line 1084 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
basic_string&
append(const _CharT* __s, size_type __n)
{
;
_M_check_length(size_type(0), __n, "basic_string::append");
return _M_append(__s, __n);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
}
#pragma line 1126 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
basic_string&
append(initializer_list<_CharT> __l)
{ return this->append(__l.begin(), __l.size()); }
#pragma line 1150 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
template<class _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
#pragma empty_line
#pragma empty_line
#pragma empty_line
basic_string&
append(_InputIterator __first, _InputIterator __last)
{ return this->replace(end(), end(), __first, __last); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
basic_string&
assign(const basic_string& __str)
{
this->_M_assign(__str);
return *this;
}
#pragma line 1194 "/home/justin/jhai/Xilinx/Vivado/2018.3/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())
{
#pragma empty_line
#pragma empty_line
return *this = std::move(__str);
}
#pragma line 1217 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)); }
#pragma line 1233 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
}
#pragma line 1249 "/home/justin/jhai/Xilinx/Vivado/2018.3/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));
}
#pragma line 1266 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 1279 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
template<class _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
#pragma empty_line
#pragma empty_line
#pragma empty_line
basic_string&
assign(_InputIterator __first, _InputIterator __last)
{ return this->replace(begin(), end(), __first, __last); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
basic_string&
assign(initializer_list<_CharT> __l)
{ return this->assign(__l.begin(), __l.size()); }
#pragma line 1315 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
}
#pragma line 1357 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
}
#pragma line 1393 "/home/justin/jhai/Xilinx/Vivado/2018.3/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());
}
#pragma line 1413 "/home/justin/jhai/Xilinx/Vivado/2018.3/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()); }
#pragma line 1436 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)); }
#pragma line 1459 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 1478 "/home/justin/jhai/Xilinx/Vivado/2018.3/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));
}
#pragma line 1502 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 1520 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
}
#pragma line 1544 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma line 1560 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
iterator
erase(__const_iterator __position)
{
#pragma empty_line
;
const size_type __pos = __position - begin();
this->_M_erase(__pos, size_type(1));
return iterator(_M_data() + __pos);
}
#pragma line 1579 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
iterator
erase(__const_iterator __first, __const_iterator __last)
{
#pragma empty_line
;
const size_type __pos = __first - begin();
this->_M_erase(__pos, __last - __first);
return iterator(this->_M_data() + __pos);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
void
pop_back() noexcept
{
;
_M_erase(size() - 1, 1);
}
#pragma line 1620 "/home/justin/jhai/Xilinx/Vivado/2018.3/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()); }
#pragma line 1642 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)); }
#pragma line 1667 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
}
#pragma line 1692 "/home/justin/jhai/Xilinx/Vivado/2018.3/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));
}
#pragma line 1716 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 1734 "/home/justin/jhai/Xilinx/Vivado/2018.3/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()); }
#pragma line 1754 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
;
return this->replace(__i1 - begin(), __i2 - __i1, __s, __n);
}
#pragma line 1776 "/home/justin/jhai/Xilinx/Vivado/2018.3/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));
}
#pragma line 1797 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
;
return _M_replace_aux(__i1 - begin(), __i2 - __i1, __n, __c);
}
#pragma line 1822 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
;
;
return this->_M_replace_dispatch(__i1, __i2, __k1, __k2,
std::__false_type());
}
#pragma line 1854 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
;
;
return this->replace(__i1 - begin(), __i2 - __i1,
__k1, __k2 - __k1);
}
#pragma empty_line
basic_string&
replace(__const_iterator __i1, __const_iterator __i2,
const _CharT* __k1, const _CharT* __k2)
{
#pragma empty_line
;
;
return this->replace(__i1 - begin(), __i2 - __i1,
__k1, __k2 - __k1);
}
#pragma empty_line
basic_string&
replace(__const_iterator __i1, __const_iterator __i2,
iterator __k1, iterator __k2)
{
#pragma empty_line
;
;
return this->replace(__i1 - begin(), __i2 - __i1,
__k1.base(), __k2 - __k1);
}
#pragma empty_line
basic_string&
replace(__const_iterator __i1, __const_iterator __i2,
const_iterator __k1, const_iterator __k2)
{
#pragma empty_line
;
;
return this->replace(__i1 - begin(), __i2 - __i1,
__k1.base(), __k2 - __k1);
}
#pragma line 1913 "/home/justin/jhai/Xilinx/Vivado/2018.3/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()); }
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
template<class _InputIterator>
basic_string&
_M_replace_dispatch(const_iterator __i1, const_iterator __i2,
_InputIterator __k1, _InputIterator __k2,
__false_type);
#pragma empty_line
basic_string&
_M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
_CharT __c);
#pragma empty_line
basic_string&
_M_replace(size_type __pos, size_type __len1, const _CharT* __s,
const size_type __len2);
#pragma empty_line
basic_string&
_M_append(const _CharT* __s, size_type __n);
#pragma empty_line
public:
#pragma line 1956 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 1966 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
void
swap(basic_string& __s) noexcept;
#pragma line 1976 "/home/justin/jhai/Xilinx/Vivado/2018.3/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(); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
const _CharT*
data() const noexcept
{ return _M_data(); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
allocator_type
get_allocator() const noexcept
{ return _M_get_allocator(); }
#pragma line 2009 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 2022 "/home/justin/jhai/Xilinx/Vivado/2018.3/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()); }
#pragma line 2037 "/home/justin/jhai/Xilinx/Vivado/2018.3/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));
}
#pragma line 2054 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 2067 "/home/justin/jhai/Xilinx/Vivado/2018.3/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()); }
#pragma line 2084 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 2097 "/home/justin/jhai/Xilinx/Vivado/2018.3/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));
}
#pragma line 2114 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 2128 "/home/justin/jhai/Xilinx/Vivado/2018.3/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()); }
#pragma line 2145 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 2158 "/home/justin/jhai/Xilinx/Vivado/2018.3/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));
}
#pragma line 2177 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 2192 "/home/justin/jhai/Xilinx/Vivado/2018.3/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()); }
#pragma line 2209 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 2222 "/home/justin/jhai/Xilinx/Vivado/2018.3/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));
}
#pragma line 2241 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 2255 "/home/justin/jhai/Xilinx/Vivado/2018.3/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()); }
#pragma line 2272 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 2286 "/home/justin/jhai/Xilinx/Vivado/2018.3/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));
}
#pragma line 2303 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 2318 "/home/justin/jhai/Xilinx/Vivado/2018.3/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()); }
#pragma line 2335 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 2349 "/home/justin/jhai/Xilinx/Vivado/2018.3/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));
}
#pragma line 2366 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 2382 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 2401 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
#pragma empty_line
int __r = traits_type::compare(_M_data(), __str.data(), __len);
if (!__r)
__r = _S_compare(__size, __osize);
return __r;
}
#pragma line 2433 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 2459 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 2477 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 3
int
compare(const _CharT* __s) const;
#pragma line 2501 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 2528 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
};
}
#pragma line 4927 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT,_Traits,_Alloc>
operator+(const _CharT* __lhs,
const basic_string<_CharT,_Traits,_Alloc>& __rhs);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT,_Traits,_Alloc>
operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
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)); }
#pragma empty_line
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)); }
#pragma empty_line
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));
}
#pragma empty_line
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)); }
#pragma empty_line
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)); }
#pragma empty_line
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)); }
#pragma empty_line
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)); }
#pragma line 5048 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma empty_line
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())); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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; }
#pragma line 5095 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator!=(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ return !(__lhs == __rhs); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
{ return !(__lhs == __rhs); }
#pragma line 5133 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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; }
#pragma line 5171 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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; }
#pragma line 5209 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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; }
#pragma line 5247 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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; }
#pragma line 5285 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 5305 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
#pragma empty_line
template<>
basic_istream<char>&
operator>>(basic_istream<char>& __is, basic_string<char>& __str);
#pragma line 5323 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
return __ostream_insert(__os, __str.data(), __str.size());
}
#pragma line 5346 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
#pragma line 5363 "/home/justin/jhai/Xilinx/Vivado/2018.3/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')); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
template<>
basic_istream<char>&
getline(basic_istream<char>& __in, basic_string<char>& __str,
char __delim);
#pragma empty_line
#pragma empty_line
template<>
basic_istream<wchar_t>&
getline(basic_istream<wchar_t>& __in, basic_string<wchar_t>& __str,
wchar_t __delim);
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/string_conversions.h" 1 3
#pragma line 32 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/string_conversions.h" 3
#pragma empty_line
#pragma line 33 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/string_conversions.h" 3
#pragma line 41 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/string_conversions.h" 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 1 3
#pragma line 39 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 3
#pragma empty_line
#pragma line 40 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 3
#pragma line 75 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 3
#pragma line 1 "/usr/include/stdlib.h" 1 3 4
#pragma line 25 "/usr/include/stdlib.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4
#pragma line 26 "/usr/include/stdlib.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include/stddef.h" 1 3 4
#pragma line 32 "/usr/include/stdlib.h" 2 3 4
#pragma empty_line
extern "C" {
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/waitflags.h" 1 3 4
#pragma line 52 "/usr/include/x86_64-linux-gnu/bits/waitflags.h" 3 4
typedef enum
{
P_ALL,
P_PID,
P_PGID
} idtype_t;
#pragma line 40 "/usr/include/stdlib.h" 2 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/waitstatus.h" 1 3 4
#pragma line 41 "/usr/include/stdlib.h" 2 3 4
#pragma line 58 "/usr/include/stdlib.h" 3 4
typedef struct
{
int quot;
int rem;
} div_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef struct
{
long int quot;
long int rem;
} ldiv_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__extension__ typedef struct
{
long long int quot;
long long int rem;
} lldiv_t;
#pragma line 97 "/usr/include/stdlib.h" 3 4
extern size_t __ctype_get_mb_cur_max (void) throw () ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern double atof (const char *__nptr)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
#pragma empty_line
extern int atoi (const char *__nptr)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
#pragma empty_line
extern long int atol (const char *__nptr)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
__extension__ extern long long int atoll (const char *__nptr)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern double strtod (const char *__restrict __nptr,
char **__restrict __endptr)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern float strtof (const char *__restrict __nptr,
char **__restrict __endptr) throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
extern long double strtold (const char *__restrict __nptr,
char **__restrict __endptr)
throw () __attribute__ ((__nonnull__ (1)));
#pragma line 140 "/usr/include/stdlib.h" 3 4
extern _Float32 strtof32 (const char *__restrict __nptr,
char **__restrict __endptr)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64 strtof64 (const char *__restrict __nptr,
char **__restrict __endptr)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float128 strtof128 (const char *__restrict __nptr,
char **__restrict __endptr)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32x strtof32x (const char *__restrict __nptr,
char **__restrict __endptr)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64x strtof64x (const char *__restrict __nptr,
char **__restrict __endptr)
throw () __attribute__ ((__nonnull__ (1)));
#pragma line 176 "/usr/include/stdlib.h" 3 4
extern long int strtol (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
extern unsigned long int strtoul (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
__extension__
extern long long int strtoq (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
__extension__
extern unsigned long long int strtouq (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__extension__
extern long long int strtoll (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
__extension__
extern unsigned long long int strtoull (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int strfromd (char *__dest, size_t __size, const char *__format,
double __f)
throw () __attribute__ ((__nonnull__ (3)));
#pragma empty_line
extern int strfromf (char *__dest, size_t __size, const char *__format,
float __f)
throw () __attribute__ ((__nonnull__ (3)));
#pragma empty_line
extern int strfroml (char *__dest, size_t __size, const char *__format,
long double __f)
throw () __attribute__ ((__nonnull__ (3)));
#pragma line 232 "/usr/include/stdlib.h" 3 4
extern int strfromf32 (char *__dest, size_t __size, const char * __format,
_Float32 __f)
throw () __attribute__ ((__nonnull__ (3)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int strfromf64 (char *__dest, size_t __size, const char * __format,
_Float64 __f)
throw () __attribute__ ((__nonnull__ (3)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int strfromf128 (char *__dest, size_t __size, const char * __format,
_Float128 __f)
throw () __attribute__ ((__nonnull__ (3)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int strfromf32x (char *__dest, size_t __size, const char * __format,
_Float32x __f)
throw () __attribute__ ((__nonnull__ (3)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int strfromf64x (char *__dest, size_t __size, const char * __format,
_Float64x __f)
throw () __attribute__ ((__nonnull__ (3)));
#pragma line 274 "/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)));
#pragma empty_line
extern unsigned long int strtoul_l (const char *__restrict __nptr,
char **__restrict __endptr,
int __base, locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 4)));
#pragma empty_line
__extension__
extern long long int strtoll_l (const char *__restrict __nptr,
char **__restrict __endptr, int __base,
locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 4)));
#pragma empty_line
__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)));
#pragma empty_line
extern double strtod_l (const char *__restrict __nptr,
char **__restrict __endptr, locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 3)));
#pragma empty_line
extern float strtof_l (const char *__restrict __nptr,
char **__restrict __endptr, locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 3)));
#pragma empty_line
extern long double strtold_l (const char *__restrict __nptr,
char **__restrict __endptr,
locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 3)));
#pragma line 316 "/usr/include/stdlib.h" 3 4
extern _Float32 strtof32_l (const char *__restrict __nptr,
char **__restrict __endptr,
locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 3)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64 strtof64_l (const char *__restrict __nptr,
char **__restrict __endptr,
locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 3)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float128 strtof128_l (const char *__restrict __nptr,
char **__restrict __endptr,
locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 3)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32x strtof32x_l (const char *__restrict __nptr,
char **__restrict __endptr,
locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 3)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64x strtof64x_l (const char *__restrict __nptr,
char **__restrict __endptr,
locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 3)));
#pragma line 385 "/usr/include/stdlib.h" 3 4
extern char *l64a (long int __n) throw () ;
#pragma empty_line
#pragma empty_line
extern long int a64l (const char *__s)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/sys/types.h" 1 3 4
#pragma line 27 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
extern "C" {
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
typedef __loff_t loff_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __ino_t ino_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __ino64_t ino64_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __dev_t dev_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __gid_t gid_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __mode_t mode_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __nlink_t nlink_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __uid_t uid_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __off_t off_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __off64_t off64_t;
#pragma line 103 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
typedef __id_t id_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __ssize_t ssize_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __daddr_t daddr_t;
typedef __caddr_t caddr_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __key_t key_t;
#pragma line 134 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
typedef __useconds_t useconds_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __suseconds_t suseconds_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include/stddef.h" 1 3 4
#pragma line 145 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef unsigned long int ulong;
typedef unsigned short int ushort;
typedef unsigned int uint;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __uint8_t u_int8_t;
typedef __uint16_t u_int16_t;
typedef __uint32_t u_int32_t;
typedef __uint64_t u_int64_t;
#pragma empty_line
#pragma empty_line
typedef int register_t __attribute__ ((__mode__ (__word__)));
#pragma line 176 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
#pragma line 1 "/usr/include/endian.h" 1 3 4
#pragma line 35 "/usr/include/endian.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 1 3 4
#pragma line 33 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 3 4
static __inline __uint16_t
__bswap_16 (__uint16_t __bsx)
{
#pragma empty_line
return __builtin_bswap16 (__bsx);
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static __inline __uint32_t
__bswap_32 (__uint32_t __bsx)
{
#pragma empty_line
return __builtin_bswap32 (__bsx);
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 69 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 3 4
__extension__ static __inline __uint64_t
__bswap_64 (__uint64_t __bsx)
{
#pragma empty_line
return __builtin_bswap64 (__bsx);
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 36 "/usr/include/endian.h" 2 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/uintn-identity.h" 1 3 4
#pragma line 32 "/usr/include/x86_64-linux-gnu/bits/uintn-identity.h" 3 4
static __inline __uint16_t
__uint16_identity (__uint16_t __x)
{
return __x;
}
#pragma empty_line
static __inline __uint32_t
__uint32_identity (__uint32_t __x)
{
return __x;
}
#pragma empty_line
static __inline __uint64_t
__uint64_identity (__uint64_t __x)
{
return __x;
}
#pragma line 37 "/usr/include/endian.h" 2 3 4
#pragma line 177 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/sys/select.h" 1 3 4
#pragma line 30 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/select.h" 1 3 4
#pragma line 22 "/usr/include/x86_64-linux-gnu/bits/select.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
#pragma line 23 "/usr/include/x86_64-linux-gnu/bits/select.h" 2 3 4
#pragma line 31 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/types/sigset_t.h" 1 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h" 1 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef struct
{
unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
} __sigset_t;
#pragma line 5 "/usr/include/x86_64-linux-gnu/bits/types/sigset_t.h" 2 3 4
#pragma empty_line
#pragma empty_line
typedef __sigset_t sigset_t;
#pragma line 34 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4
#pragma line 49 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
typedef long int __fd_mask;
#pragma line 59 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
typedef struct
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
__fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))];
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
} fd_set;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __fd_mask fd_mask;
#pragma line 91 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
extern "C" {
#pragma line 101 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
extern int select (int __nfds, fd_set *__restrict __readfds,
fd_set *__restrict __writefds,
fd_set *__restrict __exceptfds,
struct timeval *__restrict __timeout);
#pragma line 113 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
extern int pselect (int __nfds, fd_set *__restrict __readfds,
fd_set *__restrict __writefds,
fd_set *__restrict __exceptfds,
const struct timespec *__restrict __timeout,
const __sigset_t *__restrict __sigmask);
#pragma line 126 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
}
#pragma line 180 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __blksize_t blksize_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __blkcnt_t blkcnt_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __fsblkcnt_t fsblkcnt_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __fsfilcnt_t fsfilcnt_t;
#pragma line 219 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
typedef __blkcnt64_t blkcnt64_t;
typedef __fsblkcnt64_t fsblkcnt64_t;
typedef __fsfilcnt64_t fsfilcnt64_t;
#pragma line 230 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
}
#pragma line 395 "/usr/include/stdlib.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long int random (void) throw ();
#pragma empty_line
#pragma empty_line
extern void srandom (unsigned int __seed) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern char *initstate (unsigned int __seed, char *__statebuf,
size_t __statelen) throw () __attribute__ ((__nonnull__ (2)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern char *setstate (char *__statebuf) throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
};
#pragma empty_line
extern int random_r (struct random_data *__restrict __buf,
int32_t *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
extern int srandom_r (unsigned int __seed, struct random_data *__buf)
throw () __attribute__ ((__nonnull__ (2)));
#pragma empty_line
extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
size_t __statelen,
struct random_data *__restrict __buf)
throw () __attribute__ ((__nonnull__ (2, 4)));
#pragma empty_line
extern int setstate_r (char *__restrict __statebuf,
struct random_data *__restrict __buf)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int rand (void) throw ();
#pragma empty_line
extern void srand (unsigned int __seed) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int rand_r (unsigned int *__seed) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern double drand48 (void) throw ();
extern double erand48 (unsigned short int __xsubi[3]) throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
extern long int lrand48 (void) throw ();
extern long int nrand48 (unsigned short int __xsubi[3])
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
extern long int mrand48 (void) throw ();
extern long int jrand48 (unsigned short int __xsubi[3])
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
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)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
struct drand48_data
{
unsigned short int __x[3];
unsigned short int __old_x[3];
unsigned short int __c;
unsigned short int __init;
__extension__ unsigned long long int __a;
#pragma empty_line
};
#pragma empty_line
#pragma empty_line
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)));
#pragma empty_line
#pragma empty_line
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)));
#pragma empty_line
#pragma empty_line
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)));
#pragma empty_line
#pragma empty_line
extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
throw () __attribute__ ((__nonnull__ (2)));
#pragma empty_line
extern int seed48_r (unsigned short int __seed16v[3],
struct drand48_data *__buffer) throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
extern int lcong48_r (unsigned short int __param[7],
struct drand48_data *__buffer)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern void *malloc (size_t __size) throw () __attribute__ ((__malloc__))
__attribute__ ((__alloc_size__ (1))) ;
#pragma empty_line
extern void *calloc (size_t __nmemb, size_t __size)
throw () __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (1, 2))) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern void *realloc (void *__ptr, size_t __size)
throw () __attribute__ ((__warn_unused_result__)) __attribute__ ((__alloc_size__ (2)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size)
throw () __attribute__ ((__warn_unused_result__))
__attribute__ ((__alloc_size__ (2, 3)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern void free (void *__ptr) throw ();
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/alloca.h" 1 3 4
#pragma line 24 "/usr/include/alloca.h" 3 4
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include/stddef.h" 1 3 4
#pragma line 25 "/usr/include/alloca.h" 2 3 4
#pragma empty_line
extern "C" {
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern void *alloca (size_t __size) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 569 "/usr/include/stdlib.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern void *valloc (size_t __size) throw () __attribute__ ((__malloc__))
__attribute__ ((__alloc_size__ (1))) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
throw () __attribute__ ((__nonnull__ (1))) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern void *aligned_alloc (size_t __alignment, size_t __size)
throw () __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (2))) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern void abort (void) throw () __attribute__ ((__noreturn__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int atexit (void (*__func) (void)) throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern "C++" int at_quick_exit (void (*__func) (void))
throw () __asm ("at_quick_exit") __attribute__ ((__nonnull__ (1)));
#pragma line 610 "/usr/include/stdlib.h" 3 4
extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern void exit (int __status) throw () __attribute__ ((__noreturn__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern void quick_exit (int __status) throw () __attribute__ ((__noreturn__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern void _Exit (int __status) throw () __attribute__ ((__noreturn__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern char *getenv (const char *__name) throw () __attribute__ ((__nonnull__ (1))) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern char *secure_getenv (const char *__name)
throw () __attribute__ ((__nonnull__ (1))) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int putenv (char *__string) throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int setenv (const char *__name, const char *__value, int __replace)
throw () __attribute__ ((__nonnull__ (2)));
#pragma empty_line
#pragma empty_line
extern int unsetenv (const char *__name) throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int clearenv (void) throw ();
#pragma line 675 "/usr/include/stdlib.h" 3 4
extern char *mktemp (char *__template) throw () __attribute__ ((__nonnull__ (1)));
#pragma line 688 "/usr/include/stdlib.h" 3 4
extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ;
#pragma line 698 "/usr/include/stdlib.h" 3 4
extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ;
#pragma line 710 "/usr/include/stdlib.h" 3 4
extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ;
#pragma line 720 "/usr/include/stdlib.h" 3 4
extern int mkstemps64 (char *__template, int __suffixlen)
__attribute__ ((__nonnull__ (1))) ;
#pragma line 731 "/usr/include/stdlib.h" 3 4
extern char *mkdtemp (char *__template) throw () __attribute__ ((__nonnull__ (1))) ;
#pragma line 742 "/usr/include/stdlib.h" 3 4
extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
#pragma line 752 "/usr/include/stdlib.h" 3 4
extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
#pragma line 762 "/usr/include/stdlib.h" 3 4
extern int mkostemps (char *__template, int __suffixlen, int __flags)
__attribute__ ((__nonnull__ (1))) ;
#pragma line 774 "/usr/include/stdlib.h" 3 4
extern int mkostemps64 (char *__template, int __suffixlen, int __flags)
__attribute__ ((__nonnull__ (1))) ;
#pragma line 784 "/usr/include/stdlib.h" 3 4
extern int system (const char *__command) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern char *canonicalize_file_name (const char *__name)
throw () __attribute__ ((__nonnull__ (1))) ;
#pragma line 800 "/usr/include/stdlib.h" 3 4
extern char *realpath (const char *__restrict __name,
char *__restrict __resolved) throw () ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef int (*__compar_fn_t) (const void *, const void *);
#pragma empty_line
#pragma empty_line
typedef __compar_fn_t comparison_fn_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef int (*__compar_d_fn_t) (const void *, const void *, void *);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern void *bsearch (const void *__key, const void *__base,
size_t __nmemb, size_t __size, __compar_fn_t __compar)
__attribute__ ((__nonnull__ (1, 2, 5))) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern void qsort (void *__base, size_t __nmemb, size_t __size,
__compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4)));
#pragma empty_line
extern void qsort_r (void *__base, size_t __nmemb, size_t __size,
__compar_d_fn_t __compar, void *__arg)
__attribute__ ((__nonnull__ (1, 4)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int abs (int __x) throw () __attribute__ ((__const__)) ;
extern long int labs (long int __x) throw () __attribute__ ((__const__)) ;
#pragma empty_line
#pragma empty_line
__extension__ extern long long int llabs (long long int __x)
throw () __attribute__ ((__const__)) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern div_t div (int __numer, int __denom)
throw () __attribute__ ((__const__)) ;
extern ldiv_t ldiv (long int __numer, long int __denom)
throw () __attribute__ ((__const__)) ;
#pragma empty_line
#pragma empty_line
__extension__ extern lldiv_t lldiv (long long int __numer,
long long int __denom)
throw () __attribute__ ((__const__)) ;
#pragma line 872 "/usr/include/stdlib.h" 3 4
extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern char *gcvt (double __value, int __ndigit, char *__buf)
throw () __attribute__ ((__nonnull__ (3))) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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))) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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)));
#pragma empty_line
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)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int mblen (const char *__s, size_t __n) throw ();
#pragma empty_line
#pragma empty_line
extern int mbtowc (wchar_t *__restrict __pwc,
const char *__restrict __s, size_t __n) throw ();
#pragma empty_line
#pragma empty_line
extern int wctomb (char *__s, wchar_t __wchar) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern size_t mbstowcs (wchar_t *__restrict __pwcs,
const char *__restrict __s, size_t __n) throw ();
#pragma empty_line
extern size_t wcstombs (char *__restrict __s,
const wchar_t *__restrict __pwcs, size_t __n)
throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int rpmatch (const char *__response) throw () __attribute__ ((__nonnull__ (1))) ;
#pragma line 957 "/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))) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int posix_openpt (int __oflag) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int grantpt (int __fd) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int unlockpt (int __fd) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern char *ptsname (int __fd) throw () ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int ptsname_r (int __fd, char *__buf, size_t __buflen)
throw () __attribute__ ((__nonnull__ (2)));
#pragma empty_line
#pragma empty_line
extern int getpt (void);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int getloadavg (double __loadavg[], int __nelem)
throw () __attribute__ ((__nonnull__ (1)));
#pragma line 1013 "/usr/include/stdlib.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/stdlib-float.h" 1 3 4
#pragma line 1014 "/usr/include/stdlib.h" 2 3 4
#pragma line 1023 "/usr/include/stdlib.h" 3 4
}
#pragma line 76 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 2 3
#pragma line 118 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 3
extern "C++"
{
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
using ::div_t;
using ::ldiv_t;
#pragma empty_line
using ::abort;
using ::abs;
using ::atexit;
#pragma empty_line
#pragma empty_line
using ::at_quick_exit;
#pragma empty_line
#pragma empty_line
using ::atof;
using ::atoi;
using ::atol;
using ::bsearch;
using ::calloc;
using ::div;
using ::exit;
using ::free;
using ::getenv;
using ::labs;
using ::ldiv;
using ::malloc;
#pragma empty_line
using ::mblen;
using ::mbstowcs;
using ::mbtowc;
#pragma empty_line
using ::qsort;
#pragma empty_line
#pragma empty_line
using ::quick_exit;
#pragma empty_line
#pragma empty_line
using ::rand;
using ::realloc;
using ::srand;
using ::strtod;
using ::strtol;
using ::strtoul;
using ::system;
#pragma empty_line
using ::wcstombs;
using ::wctomb;
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline long
abs(long __i) { return __builtin_labs(__i); }
#pragma empty_line
inline ldiv_t
div(long __i, long __j) { return ldiv(__i, __j); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline long long
abs(long long __x) { return __builtin_llabs (__x); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline __int128
abs(__int128 __x) { return __x >= 0 ? __x : -__x; }
#pragma line 201 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 3
#pragma empty_line
}
#pragma line 215 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 3
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
using ::lldiv_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
using ::_Exit;
#pragma empty_line
#pragma empty_line
#pragma empty_line
using ::llabs;
#pragma empty_line
inline lldiv_t
div(long long __n, long long __d)
{ lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; }
#pragma empty_line
using ::lldiv;
#pragma line 247 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 3
using ::atoll;
using ::strtoll;
using ::strtoull;
#pragma empty_line
using ::strtof;
using ::strtold;
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
namespace std
{
#pragma empty_line
using ::__gnu_cxx::lldiv_t;
#pragma empty_line
using ::__gnu_cxx::_Exit;
#pragma empty_line
using ::__gnu_cxx::llabs;
using ::__gnu_cxx::div;
using ::__gnu_cxx::lldiv;
#pragma empty_line
using ::__gnu_cxx::atoll;
using ::__gnu_cxx::strtof;
using ::__gnu_cxx::strtoll;
using ::__gnu_cxx::strtoull;
using ::__gnu_cxx::strtold;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 42 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/string_conversions.h" 2 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cwchar" 1 3
#pragma line 39 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cwchar" 3
#pragma empty_line
#pragma line 40 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cwchar" 3
#pragma line 43 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/string_conversions.h" 2 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdio" 1 3
#pragma line 39 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdio" 3
#pragma empty_line
#pragma line 40 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdio" 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/stdio.h" 1 3 4
#pragma line 27 "/usr/include/stdio.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4
#pragma line 28 "/usr/include/stdio.h" 2 3 4
#pragma empty_line
extern "C" {
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include/stddef.h" 1 3 4
#pragma line 34 "/usr/include/stdio.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include/stdarg.h" 1 3 4
#pragma line 37 "/usr/include/stdio.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h" 1 3 4
#pragma line 10 "/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h" 3 4
typedef struct _G_fpos_t
{
__off_t __pos;
__mbstate_t __state;
} __fpos_t;
#pragma line 40 "/usr/include/stdio.h" 2 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h" 1 3 4
#pragma line 10 "/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h" 3 4
typedef struct _G_fpos64_t
{
__off64_t __pos;
__mbstate_t __state;
} __fpos64_t;
#pragma line 41 "/usr/include/stdio.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h" 1 3 4
#pragma line 35 "/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h" 3 4
struct _IO_FILE;
struct _IO_marker;
struct _IO_codecvt;
struct _IO_wide_data;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef void _IO_lock_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
struct _IO_FILE
{
int _flags;
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
char *_IO_save_base;
char *_IO_backup_base;
char *_IO_save_end;
#pragma empty_line
struct _IO_marker *_markers;
#pragma empty_line
struct _IO_FILE *_chain;
#pragma empty_line
int _fileno;
int _flags2;
__off_t _old_offset;
#pragma empty_line
#pragma empty_line
unsigned short _cur_column;
signed char _vtable_offset;
char _shortbuf[1];
#pragma empty_line
_IO_lock_t *_lock;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__off64_t _offset;
#pragma empty_line
struct _IO_codecvt *_codecvt;
struct _IO_wide_data *_wide_data;
struct _IO_FILE *_freeres_list;
void *_freeres_buf;
size_t __pad5;
int _mode;
#pragma empty_line
char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)];
};
#pragma line 44 "/usr/include/stdio.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h" 1 3 4
#pragma line 27 "/usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h" 3 4
typedef __ssize_t cookie_read_function_t (void *__cookie, char *__buf,
size_t __nbytes);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __ssize_t cookie_write_function_t (void *__cookie, const char *__buf,
size_t __nbytes);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef int cookie_seek_function_t (void *__cookie, __off64_t *__pos, int __w);
#pragma empty_line
#pragma empty_line
typedef int cookie_close_function_t (void *__cookie);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef struct _IO_cookie_io_functions_t
{
cookie_read_function_t *read;
cookie_write_function_t *write;
cookie_seek_function_t *seek;
cookie_close_function_t *close;
} cookie_io_functions_t;
#pragma line 47 "/usr/include/stdio.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __gnuc_va_list va_list;
#pragma line 84 "/usr/include/stdio.h" 3 4
typedef __fpos_t fpos_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __fpos64_t fpos64_t;
#pragma line 133 "/usr/include/stdio.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/stdio_lim.h" 1 3 4
#pragma line 134 "/usr/include/stdio.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern FILE *stdin;
extern FILE *stdout;
extern FILE *stderr;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int remove (const char *__filename) throw ();
#pragma empty_line
extern int rename (const char *__old, const char *__new) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int renameat (int __oldfd, const char *__old, int __newfd,
const char *__new) throw ();
#pragma line 164 "/usr/include/stdio.h" 3 4
extern int renameat2 (int __oldfd, const char *__old, int __newfd,
const char *__new, unsigned int __flags) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern FILE *tmpfile (void) ;
#pragma line 183 "/usr/include/stdio.h" 3 4
extern FILE *tmpfile64 (void) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern char *tmpnam (char *__s) throw () ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern char *tmpnam_r (char *__s) throw () ;
#pragma line 204 "/usr/include/stdio.h" 3 4
extern char *tempnam (const char *__dir, const char *__pfx)
throw () __attribute__ ((__malloc__)) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int fclose (FILE *__stream);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int fflush (FILE *__stream);
#pragma line 227 "/usr/include/stdio.h" 3 4
extern int fflush_unlocked (FILE *__stream);
#pragma line 237 "/usr/include/stdio.h" 3 4
extern int fcloseall (void);
#pragma line 246 "/usr/include/stdio.h" 3 4
extern FILE *fopen (const char *__restrict __filename,
const char *__restrict __modes) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern FILE *freopen (const char *__restrict __filename,
const char *__restrict __modes,
FILE *__restrict __stream) ;
#pragma line 270 "/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) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern FILE *fdopen (int __fd, const char *__modes) throw () ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern FILE *fopencookie (void *__restrict __magic_cookie,
const char *__restrict __modes,
cookie_io_functions_t __io_funcs) throw () ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern FILE *fmemopen (void *__s, size_t __len, const char *__modes)
throw () ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) throw () ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
int __modes, size_t __n) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
size_t __size) throw ();
#pragma empty_line
#pragma empty_line
extern void setlinebuf (FILE *__stream) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int fprintf (FILE *__restrict __stream,
const char *__restrict __format, ...);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int printf (const char *__restrict __format, ...);
#pragma empty_line
extern int sprintf (char *__restrict __s,
const char *__restrict __format, ...) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int vfprintf (FILE *__restrict __s, const char *__restrict __format,
__gnuc_va_list __arg);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg);
#pragma empty_line
extern int vsprintf (char *__restrict __s, const char *__restrict __format,
__gnuc_va_list __arg) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int snprintf (char *__restrict __s, size_t __maxlen,
const char *__restrict __format, ...)
throw () __attribute__ ((__format__ (__printf__, 3, 4)));
#pragma empty_line
extern int vsnprintf (char *__restrict __s, size_t __maxlen,
const char *__restrict __format, __gnuc_va_list __arg)
throw () __attribute__ ((__format__ (__printf__, 3, 0)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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))) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int fscanf (FILE *__restrict __stream,
const char *__restrict __format, ...) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int scanf (const char *__restrict __format, ...) ;
#pragma empty_line
extern int sscanf (const char *__restrict __s,
const char *__restrict __format, ...) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int fscanf (FILE *__restrict __stream, const char *__restrict __format, ...) __asm__ ("" "__isoc99_fscanf")
#pragma empty_line
;
extern int scanf (const char *__restrict __format, ...) __asm__ ("" "__isoc99_scanf")
;
extern int sscanf (const char *__restrict __s, const char *__restrict __format, ...) throw () __asm__ ("" "__isoc99_sscanf")
#pragma empty_line
;
#pragma line 432 "/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))) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg)
__attribute__ ((__format__ (__scanf__, 1, 0))) ;
#pragma empty_line
#pragma empty_line
extern int vsscanf (const char *__restrict __s,
const char *__restrict __format, __gnuc_va_list __arg)
throw () __attribute__ ((__format__ (__scanf__, 2, 0)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vfscanf")
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__format__ (__scanf__, 2, 0))) ;
extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vscanf")
#pragma empty_line
__attribute__ ((__format__ (__scanf__, 1, 0))) ;
extern int vsscanf (const char *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) throw () __asm__ ("" "__isoc99_vsscanf")
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__format__ (__scanf__, 2, 0)));
#pragma line 485 "/usr/include/stdio.h" 3 4
extern int fgetc (FILE *__stream);
extern int getc (FILE *__stream);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int getchar (void);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int getc_unlocked (FILE *__stream);
extern int getchar_unlocked (void);
#pragma line 510 "/usr/include/stdio.h" 3 4
extern int fgetc_unlocked (FILE *__stream);
#pragma line 521 "/usr/include/stdio.h" 3 4
extern int fputc (int __c, FILE *__stream);
extern int putc (int __c, FILE *__stream);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int putchar (int __c);
#pragma line 537 "/usr/include/stdio.h" 3 4
extern int fputc_unlocked (int __c, FILE *__stream);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int putc_unlocked (int __c, FILE *__stream);
extern int putchar_unlocked (int __c);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int getw (FILE *__stream);
#pragma empty_line
#pragma empty_line
extern int putw (int __w, FILE *__stream);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
;
#pragma line 587 "/usr/include/stdio.h" 3 4
extern char *fgets_unlocked (char *__restrict __s, int __n,
FILE *__restrict __stream) ;
#pragma line 603 "/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) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __ssize_t getline (char **__restrict __lineptr,
size_t *__restrict __n,
FILE *__restrict __stream) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int fputs (const char *__restrict __s, FILE *__restrict __stream);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int puts (const char *__s);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int ungetc (int __c, FILE *__stream);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern size_t fread (void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __stream) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern size_t fwrite (const void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __s);
#pragma line 662 "/usr/include/stdio.h" 3 4
extern int fputs_unlocked (const char *__restrict __s,
FILE *__restrict __stream);
#pragma line 673 "/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);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int fseek (FILE *__stream, long int __off, int __whence);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long int ftell (FILE *__stream) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern void rewind (FILE *__stream);
#pragma line 707 "/usr/include/stdio.h" 3 4
extern int fseeko (FILE *__stream, __off_t __off, int __whence);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __off_t ftello (FILE *__stream) ;
#pragma line 731 "/usr/include/stdio.h" 3 4
extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int fsetpos (FILE *__stream, const fpos_t *__pos);
#pragma line 750 "/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);
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern void clearerr (FILE *__stream) throw ();
#pragma empty_line
extern int feof (FILE *__stream) throw () ;
#pragma empty_line
extern int ferror (FILE *__stream) throw () ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern void clearerr_unlocked (FILE *__stream) throw ();
extern int feof_unlocked (FILE *__stream) throw () ;
extern int ferror_unlocked (FILE *__stream) throw () ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern void perror (const char *__s);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/sys_errlist.h" 1 3 4
#pragma line 26 "/usr/include/x86_64-linux-gnu/bits/sys_errlist.h" 3 4
extern int sys_nerr;
extern const char *const sys_errlist[];
#pragma empty_line
#pragma empty_line
extern int _sys_nerr;
extern const char *const _sys_errlist[];
#pragma line 782 "/usr/include/stdio.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int fileno (FILE *__stream) throw () ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int fileno_unlocked (FILE *__stream) throw () ;
#pragma line 800 "/usr/include/stdio.h" 3 4
extern FILE *popen (const char *__command, const char *__modes) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int pclose (FILE *__stream);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern char *ctermid (char *__s) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern char *cuserid (char *__s);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
struct obstack;
#pragma empty_line
#pragma empty_line
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)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern void flockfile (FILE *__stream) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int ftrylockfile (FILE *__stream) throw () ;
#pragma empty_line
#pragma empty_line
extern void funlockfile (FILE *__stream) throw ();
#pragma line 858 "/usr/include/stdio.h" 3 4
extern int __uflow (FILE *);
extern int __overflow (FILE *, int);
#pragma line 873 "/usr/include/stdio.h" 3 4
}
#pragma line 43 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdio" 2 3
#pragma line 96 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdio" 3
namespace std
{
using ::FILE;
using ::fpos_t;
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
using ::tmpnam;
#pragma empty_line
using ::ungetc;
using ::vfprintf;
using ::vprintf;
using ::vsprintf;
}
#pragma line 157 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdio" 3
namespace __gnu_cxx
{
#pragma line 175 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdio" 3
using ::snprintf;
using ::vfscanf;
using ::vscanf;
using ::vsnprintf;
using ::vsscanf;
#pragma empty_line
}
#pragma empty_line
namespace std
{
using ::__gnu_cxx::snprintf;
using ::__gnu_cxx::vfscanf;
using ::__gnu_cxx::vscanf;
using ::__gnu_cxx::vsnprintf;
using ::__gnu_cxx::vsscanf;
}
#pragma line 44 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/string_conversions.h" 2 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cerrno" 1 3
#pragma line 39 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cerrno" 3
#pragma empty_line
#pragma line 40 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cerrno" 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/errno.h" 1 3 4
#pragma line 28 "/usr/include/errno.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/errno.h" 1 3 4
#pragma line 26 "/usr/include/x86_64-linux-gnu/bits/errno.h" 3 4
#pragma line 1 "/usr/include/linux/errno.h" 1 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/asm/errno.h" 1 3 4
#pragma line 1 "/usr/include/asm-generic/errno.h" 1 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/asm-generic/errno-base.h" 1 3 4
#pragma line 6 "/usr/include/asm-generic/errno.h" 2 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/asm/errno.h" 2 3 4
#pragma line 1 "/usr/include/linux/errno.h" 2 3 4
#pragma line 27 "/usr/include/x86_64-linux-gnu/bits/errno.h" 2 3 4
#pragma line 29 "/usr/include/errno.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern "C" {
#pragma empty_line
#pragma empty_line
extern int *__errno_location (void) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern char *program_invocation_name;
extern char *program_invocation_short_name;
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/types/error_t.h" 1 3 4
#pragma line 22 "/usr/include/x86_64-linux-gnu/bits/types/error_t.h" 3 4
typedef int error_t;
#pragma line 49 "/usr/include/errno.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 43 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cerrno" 2 3
#pragma line 45 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ext/string_conversions.h" 2 3
#pragma empty_line
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
_CharT* __endptr;
#pragma empty_line
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;
#pragma empty_line
const _TRet __tmp = __convf(__str, &__endptr, __base...);
#pragma empty_line
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;
#pragma empty_line
if (__idx)
*__idx = __endptr - __str;
#pragma empty_line
return __ret;
}
#pragma empty_line
#pragma empty_line
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, ...)
{
#pragma empty_line
#pragma empty_line
_CharT* __s = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
* __n));
#pragma empty_line
__builtin_va_list __args;
__builtin_va_start(__args, __fmt);
#pragma empty_line
const int __len = __convf(__s, __n, __fmt, __args);
#pragma empty_line
__builtin_va_end(__args);
#pragma empty_line
return _String(__s, __s + __len);
}
#pragma empty_line
#pragma empty_line
}
#pragma line 5403 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.h" 2 3
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
namespace __cxx11 {
#pragma empty_line
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
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); }
#pragma empty_line
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); }
#pragma empty_line
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); }
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
inline float
stof(const string& __str, size_t* __idx = 0)
{ return __gnu_cxx::__stoa(&std::strtof, "stof", __str.c_str(), __idx); }
#pragma empty_line
inline double
stod(const string& __str, size_t* __idx = 0)
{ return __gnu_cxx::__stoa(&std::strtod, "stod", __str.c_str(), __idx); }
#pragma empty_line
inline long double
stold(const string& __str, size_t* __idx = 0)
{ return __gnu_cxx::__stoa(&std::strtold, "stold", __str.c_str(), __idx); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline string
to_string(int __val)
{ return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, 4 * sizeof(int),
"%d", __val); }
#pragma empty_line
inline string
to_string(unsigned __val)
{ return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
4 * sizeof(unsigned),
"%u", __val); }
#pragma empty_line
inline string
to_string(long __val)
{ return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, 4 * sizeof(long),
"%ld", __val); }
#pragma empty_line
inline string
to_string(unsigned long __val)
{ return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
4 * sizeof(unsigned long),
"%lu", __val); }
#pragma empty_line
inline string
to_string(long long __val)
{ return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
4 * sizeof(long long),
"%lld", __val); }
#pragma empty_line
inline string
to_string(unsigned long long __val)
{ return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
4 * sizeof(unsigned long long),
"%llu", __val); }
#pragma empty_line
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);
}
#pragma empty_line
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);
}
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
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); }
#pragma empty_line
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); }
#pragma empty_line
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); }
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
inline float
stof(const wstring& __str, size_t* __idx = 0)
{ return __gnu_cxx::__stoa(&std::wcstof, "stof", __str.c_str(), __idx); }
#pragma empty_line
inline double
stod(const wstring& __str, size_t* __idx = 0)
{ return __gnu_cxx::__stoa(&std::wcstod, "stod", __str.c_str(), __idx); }
#pragma empty_line
inline long double
stold(const wstring& __str, size_t* __idx = 0)
{ return __gnu_cxx::__stoa(&std::wcstold, "stold", __str.c_str(), __idx); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline wstring
to_wstring(int __val)
{ return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, 4 * sizeof(int),
L"%d", __val); }
#pragma empty_line
inline wstring
to_wstring(unsigned __val)
{ return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
4 * sizeof(unsigned),
L"%u", __val); }
#pragma empty_line
inline wstring
to_wstring(long __val)
{ return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, 4 * sizeof(long),
L"%ld", __val); }
#pragma empty_line
inline wstring
to_wstring(unsigned long __val)
{ return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
4 * sizeof(unsigned long),
L"%lu", __val); }
#pragma empty_line
inline wstring
to_wstring(long long __val)
{ return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
4 * sizeof(long long),
L"%lld", __val); }
#pragma empty_line
inline wstring
to_wstring(unsigned long long __val)
{ return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
4 * sizeof(unsigned long long),
L"%llu", __val); }
#pragma empty_line
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);
}
#pragma empty_line
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);
}
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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()); }
};
#pragma empty_line
template<>
struct __is_fast_hash<hash<string>> : std::false_type
{ };
#pragma empty_line
#pragma empty_line
#pragma empty_line
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)); }
};
#pragma empty_line
template<>
struct __is_fast_hash<hash<wstring>> : std::false_type
{ };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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)); }
};
#pragma empty_line
template<>
struct __is_fast_hash<hash<u16string>> : std::false_type
{ };
#pragma empty_line
#pragma empty_line
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)); }
};
#pragma empty_line
template<>
struct __is_fast_hash<hash<u32string>> : std::false_type
{ };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline namespace literals
{
inline namespace string_literals
{
#pragma empty_line
__attribute ((__abi_tag__ ("cxx11")))
inline basic_string<char>
operator""s(const char* __str, size_t __len)
{ return basic_string<char>{__str, __len}; }
#pragma empty_line
#pragma empty_line
__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}; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
__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}; }
#pragma empty_line
__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}; }
#pragma empty_line
#pragma empty_line
}
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 53 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/string" 2 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.tcc" 1 3
#pragma line 42 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.tcc" 3
#pragma empty_line
#pragma line 43 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_string.tcc" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
const typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::npos;
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
void
basic_string<_CharT, _Traits, _Alloc>::
swap(basic_string& __s) noexcept
{
if (this == &__s)
return;
#pragma empty_line
_Alloc_traits::_S_on_swap(_M_get_allocator(), __s._M_get_allocator());
#pragma empty_line
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);
}
#pragma empty_line
const size_type __tmp_length = length();
_M_length(__s.length());
__s._M_length(__tmp_length);
}
#pragma empty_line
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)
{
#pragma empty_line
#pragma empty_line
if (__capacity > max_size())
std::__throw_length_error(("basic_string::_M_create"));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
if (__capacity > __old_capacity && __capacity < 2 * __old_capacity)
{
__capacity = 2 * __old_capacity;
#pragma empty_line
if (__capacity > max_size())
__capacity = max_size();
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
return _Alloc_traits::allocate(_M_get_allocator(), __capacity + 1);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
#pragma empty_line
while (__beg != __end && __len < __capacity)
{
_M_data()[__len++] = *__beg;
++__beg;
}
#pragma empty_line
try
{
while (__beg != __end)
{
if (__len == __capacity)
{
#pragma empty_line
__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;
}
#pragma empty_line
_M_set_length(__len);
}
#pragma empty_line
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)
{
#pragma empty_line
if (__gnu_cxx::__is_null_pointer(__beg) && __beg != __end)
std::__throw_logic_error(("basic_string::" "_M_construct null not valid")
);
#pragma empty_line
size_type __dnew = static_cast<size_type>(std::distance(__beg, __end));
#pragma empty_line
if (__dnew > size_type(_S_local_capacity))
{
_M_data(_M_create(__dnew, size_type(0)));
_M_capacity(__dnew);
}
#pragma empty_line
#pragma empty_line
try
{ this->_S_copy_chars(_M_data(), __beg, __end); }
catch(...)
{
_M_dispose();
throw;
}
#pragma empty_line
_M_set_length(__dnew);
}
#pragma empty_line
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);
}
#pragma empty_line
if (__n)
this->_S_assign(_M_data(), __n, __c);
#pragma empty_line
_M_set_length(__n);
}
#pragma empty_line
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();
#pragma empty_line
if (__rsize > __capacity)
{
size_type __new_capacity = __rsize;
pointer __tmp = _M_create(__new_capacity, __capacity);
_M_dispose();
_M_data(__tmp);
_M_capacity(__new_capacity);
}
#pragma empty_line
if (__rsize)
this->_S_copy(_M_data(), __str._M_data(), __rsize);
#pragma empty_line
_M_set_length(__rsize);
}
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
void
basic_string<_CharT, _Traits, _Alloc>::
reserve(size_type __res)
{
#pragma empty_line
if (__res < length())
__res = length();
#pragma empty_line
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());
}
}
}
#pragma empty_line
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;
#pragma empty_line
size_type __new_capacity = length() + __len2 - __len1;
pointer __r = _M_create(__new_capacity, capacity());
#pragma empty_line
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);
#pragma empty_line
_M_dispose();
_M_data(__r);
_M_capacity(__new_capacity);
}
#pragma empty_line
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;
#pragma empty_line
if (__how_much && __n)
this->_S_move(_M_data() + __pos, _M_data() + __pos + __n, __how_much);
#pragma empty_line
_M_set_length(length() - __n);
}
#pragma empty_line
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);
}
#pragma empty_line
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();
#pragma empty_line
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);
#pragma empty_line
this->_M_set_length(__len);
return *this;
}
#pragma empty_line
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());
}
#pragma empty_line
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");
#pragma empty_line
const size_type __old_size = this->size();
const size_type __new_size = __old_size + __n2 - __n1;
#pragma empty_line
if (__new_size <= this->capacity())
{
pointer __p = this->_M_data() + __pos1;
#pragma empty_line
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);
#pragma empty_line
if (__n2)
this->_S_assign(this->_M_data() + __pos1, __n2, __c);
#pragma empty_line
this->_M_set_length(__new_size);
return *this;
}
#pragma empty_line
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");
#pragma empty_line
const size_type __old_size = this->size();
const size_type __new_size = __old_size + __len2 - __len1;
#pragma empty_line
if (__new_size <= this->capacity())
{
pointer __p = this->_M_data() + __pos;
#pragma empty_line
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
{
#pragma empty_line
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);
#pragma empty_line
this->_M_set_length(__new_size);
return *this;
}
#pragma empty_line
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);
#pragma empty_line
return __n;
}
#pragma line 1145 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma empty_line
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;
}
#pragma empty_line
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();
#pragma empty_line
if (__n == 0)
return __pos <= __size ? __pos : npos;
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
__size_type __extracted = 0;
typename __ios_base::iostate __err = __ios_base::goodbit;
typename __istream_type::sentry __cerb(__in, false);
if (__cerb)
{
try
{
#pragma empty_line
__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();
#pragma empty_line
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);
#pragma empty_line
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(...)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
__in._M_setstate(__ios_base::badbit);
}
}
#pragma empty_line
if (!__extracted)
__err |= __ios_base::failbit;
if (__err)
__in.setstate(__err);
return __in;
}
#pragma empty_line
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;
#pragma empty_line
__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();
#pragma empty_line
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();
}
#pragma empty_line
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(...)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
__in._M_setstate(__ios_base::badbit);
}
}
if (!__extracted)
__err |= __ios_base::failbit;
if (__err)
__in.setstate(__err);
return __in;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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&);
#pragma empty_line
#pragma empty_line
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&);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 54 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/string" 2 3
#pragma line 41 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 2 3
#pragma empty_line
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma line 62 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 3
class locale
{
public:
#pragma empty_line
#pragma empty_line
typedef int category;
#pragma empty_line
#pragma empty_line
class facet;
class id;
class _Impl;
#pragma empty_line
friend class facet;
friend class _Impl;
#pragma empty_line
template<typename _Facet>
friend bool
has_facet(const locale&) throw();
#pragma empty_line
template<typename _Facet>
friend const _Facet&
use_facet(const locale&);
#pragma empty_line
template<typename _Cache>
friend struct __use_cache;
#pragma line 98 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
#pragma line 117 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 3
locale() throw();
#pragma line 126 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 3
locale(const locale& __other) throw();
#pragma line 136 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 3
explicit
locale(const char* __s);
#pragma line 151 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
#pragma line 162 "/home/justin/jhai/Xilinx/Vivado/2018.3/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()) { }
#pragma line 177 "/home/justin/jhai/Xilinx/Vivado/2018.3/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) { }
#pragma line 192 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
#pragma line 205 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
#pragma empty_line
#pragma empty_line
~locale() throw();
#pragma line 219 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 3
const locale&
operator=(const locale& __other) throw();
#pragma line 234 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute ((__abi_tag__ ("cxx11")))
string
name() const;
#pragma line 254 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 3
bool
operator==(const locale& __other) const throw();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
bool
operator!=(const locale& __other) const throw()
{ return !(this->operator==(__other)); }
#pragma line 282 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 298 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 3
static locale
global(const locale& __loc);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static const locale&
classic();
#pragma empty_line
private:
#pragma empty_line
_Impl* _M_impl;
#pragma empty_line
#pragma empty_line
static _Impl* _S_classic;
#pragma empty_line
#pragma empty_line
static _Impl* _S_global;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static const char* const* const _S_categories;
#pragma line 333 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 3
enum { _S_categories_size = 6 + 6 };
#pragma empty_line
#pragma empty_line
static __gthread_once_t _S_once;
#pragma empty_line
#pragma empty_line
explicit
locale(_Impl*) throw();
#pragma empty_line
static void
_S_initialize();
#pragma empty_line
static void
_S_initialize_once() throw();
#pragma empty_line
static category
_S_normalize_category(category);
#pragma empty_line
void
_M_coalesce(const locale& __base, const locale& __add, category __cat);
#pragma empty_line
#pragma empty_line
static const id* const _S_twinned_facets[];
#pragma empty_line
};
#pragma line 371 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
mutable _Atomic_word _M_refcount;
#pragma empty_line
#pragma empty_line
static __c_locale _S_c_locale;
#pragma empty_line
#pragma empty_line
static const char _S_c_name[2];
#pragma empty_line
#pragma empty_line
static __gthread_once_t _S_once;
#pragma empty_line
#pragma empty_line
static void
_S_initialize_once();
#pragma empty_line
protected:
#pragma line 402 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{ }
#pragma empty_line
#pragma empty_line
virtual
~facet();
#pragma empty_line
static void
_S_create_c_locale(__c_locale& __cloc, const char* __s,
__c_locale __old = 0);
#pragma empty_line
static __c_locale
_S_clone_c_locale(__c_locale& __cloc) throw();
#pragma empty_line
static void
_S_destroy_c_locale(__c_locale& __cloc);
#pragma empty_line
static __c_locale
_S_lc_ctype_c_locale(__c_locale __cloc, const char* __s);
#pragma empty_line
#pragma empty_line
#pragma empty_line
static __c_locale
_S_get_c_locale();
#pragma empty_line
__attribute__ ((__const__)) static const char*
_S_get_c_name() throw();
#pragma line 438 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 3
facet(const facet&) = delete;
#pragma empty_line
facet&
operator=(const facet&) = delete;
#pragma empty_line
#pragma empty_line
private:
void
_M_add_reference() const throw()
{ __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
#pragma empty_line
void
_M_remove_reference() const throw()
{
#pragma empty_line
;
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
{
;
try
{ delete this; }
catch(...)
{ }
}
}
#pragma empty_line
class __shim;
#pragma empty_line
const facet* _M_sso_shim(const id*) const;
const facet* _M_cow_shim(const id*) const;
};
#pragma line 482 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
template<typename _Facet>
friend const _Facet&
use_facet(const locale&);
#pragma empty_line
template<typename _Facet>
friend bool
has_facet(const locale&) throw();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
mutable size_t _M_index;
#pragma empty_line
#pragma empty_line
static _Atomic_word _S_refcount;
#pragma empty_line
void
operator=(const id&);
#pragma empty_line
id(const id&);
#pragma empty_line
public:
#pragma empty_line
#pragma empty_line
#pragma empty_line
id() { }
#pragma empty_line
size_t
_M_id() const throw();
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
class locale::_Impl
{
public:
#pragma empty_line
friend class locale;
friend class locale::facet;
#pragma empty_line
template<typename _Facet>
friend bool
has_facet(const locale&) throw();
#pragma empty_line
template<typename _Facet>
friend const _Facet&
use_facet(const locale&);
#pragma empty_line
template<typename _Cache>
friend struct __use_cache;
#pragma empty_line
private:
#pragma empty_line
_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[];
#pragma empty_line
void
_M_add_reference() throw()
{ __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
#pragma empty_line
void
_M_remove_reference() throw()
{
#pragma empty_line
;
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
{
;
try
{ delete this; }
catch(...)
{ }
}
}
#pragma empty_line
_Impl(const _Impl&, size_t);
_Impl(const char*, size_t);
_Impl(size_t) throw();
#pragma empty_line
~_Impl() throw();
#pragma empty_line
_Impl(const _Impl&);
#pragma empty_line
void
operator=(const _Impl&);
#pragma empty_line
bool
_M_check_same_name()
{
bool __ret = true;
if (_M_names[1])
#pragma empty_line
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;
}
#pragma empty_line
void
_M_replace_categories(const _Impl*, category);
#pragma empty_line
void
_M_replace_category(const _Impl*, const locale::id* const*);
#pragma empty_line
void
_M_replace_facet(const _Impl*, const locale::id*);
#pragma empty_line
void
_M_install_facet(const locale::id*, const facet*);
#pragma empty_line
template<typename _Facet>
void
_M_init_facet(_Facet* __facet)
{ _M_install_facet(&_Facet::id, __facet); }
#pragma empty_line
template<typename _Facet>
void
_M_init_facet_unchecked(_Facet* __facet)
{
__facet->_M_add_reference();
_M_facets[_Facet::id._M_id()] = __facet;
}
#pragma empty_line
void
_M_install_cache(const facet*, size_t);
#pragma empty_line
void _M_init_extra(facet**);
void _M_init_extra(void*, void*, const char*, const char*);
};
#pragma line 640 "/home/justin/jhai/Xilinx/Vivado/2018.3/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:
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;
#pragma empty_line
#pragma empty_line
protected:
#pragma empty_line
#pragma empty_line
__c_locale _M_c_locale_collate;
#pragma empty_line
public:
#pragma empty_line
static locale::id id;
#pragma line 667 "/home/justin/jhai/Xilinx/Vivado/2018.3/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())
{ }
#pragma line 681 "/home/justin/jhai/Xilinx/Vivado/2018.3/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))
{ }
#pragma line 698 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 717 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 731 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
#pragma empty_line
int
_M_compare(const _CharT*, const _CharT*) const throw();
#pragma empty_line
size_t
_M_transform(_CharT*, const _CharT*, size_t) const throw();
#pragma empty_line
protected:
#pragma empty_line
virtual
~collate()
{ _S_destroy_c_locale(_M_c_locale_collate); }
#pragma line 760 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 774 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 787 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
};
#pragma empty_line
template<typename _CharT>
locale::id collate<_CharT>::id;
#pragma empty_line
#pragma empty_line
template<>
int
collate<char>::_M_compare(const char*, const char*) const throw();
#pragma empty_line
template<>
size_t
collate<char>::_M_transform(char*, const char*, size_t) const throw();
#pragma empty_line
#pragma empty_line
template<>
int
collate<wchar_t>::_M_compare(const wchar_t*, const wchar_t*) const throw();
#pragma empty_line
template<>
size_t
collate<wchar_t>::_M_transform(wchar_t*, const wchar_t*, size_t) const throw();
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _CharT>
class __cxx11:: collate_byname : public collate<_CharT>
{
public:
#pragma empty_line
#pragma empty_line
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;
#pragma empty_line
#pragma empty_line
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);
}
}
#pragma empty_line
#pragma empty_line
explicit
collate_byname(const string& __s, size_t __refs = 0)
: collate_byname(__s.c_str(), __refs) { }
#pragma empty_line
#pragma empty_line
protected:
virtual
~collate_byname() { }
};
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.tcc" 1 3
#pragma line 37 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.tcc" 3
#pragma empty_line
#pragma line 38 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.tcc" 3
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
template<typename _Facet>
locale::
locale(const locale& __other, _Facet* __f)
{
_M_impl = new _Impl(*__other._M_impl, 1);
#pragma empty_line
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;
}
#pragma empty_line
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);
}
#pragma empty_line
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);
}
#pragma line 102 "/home/justin/jhai/Xilinx/Vivado/2018.3/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
#pragma empty_line
&& dynamic_cast<const _Facet*>(__facets[__i]));
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 130 "/home/justin/jhai/Xilinx/Vivado/2018.3/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();
#pragma empty_line
return dynamic_cast<const _Facet&>(*__facets[__i]);
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _CharT>
int
collate<_CharT>::_M_compare(const _CharT*, const _CharT*) const throw ()
{ return 0; }
#pragma empty_line
#pragma empty_line
template<typename _CharT>
size_t
collate<_CharT>::_M_transform(_CharT*, const _CharT*, size_t) const throw ()
{ return 0; }
#pragma empty_line
template<typename _CharT>
int
collate<_CharT>::
do_compare(const _CharT* __lo1, const _CharT* __hi1,
const _CharT* __lo2, const _CharT* __hi2) const
{
#pragma empty_line
#pragma empty_line
const string_type __one(__lo1, __hi1);
const string_type __two(__lo2, __hi2);
#pragma empty_line
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();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
for (;;)
{
const int __res = _M_compare(__p, __q);
if (__res)
return __res;
#pragma empty_line
__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;
#pragma empty_line
__p++;
__q++;
}
}
#pragma empty_line
template<typename _CharT>
typename collate<_CharT>::string_type
collate<_CharT>::
do_transform(const _CharT* __lo, const _CharT* __hi) const
{
string_type __ret;
#pragma empty_line
#pragma empty_line
const string_type __str(__lo, __hi);
#pragma empty_line
const _CharT* __p = __str.c_str();
const _CharT* __pend = __str.data() + __str.length();
#pragma empty_line
size_t __len = (__hi - __lo) * 2;
#pragma empty_line
_CharT* __c = new _CharT[__len];
#pragma empty_line
try
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
for (;;)
{
#pragma empty_line
size_t __res = _M_transform(__c, __p, __len);
#pragma empty_line
#pragma empty_line
if (__res >= __len)
{
__len = __res + 1;
delete [] __c, __c = 0;
__c = new _CharT[__len];
__res = _M_transform(__c, __p, __len);
}
#pragma empty_line
__ret.append(__c, __res);
__p += char_traits<_CharT>::length(__p);
if (__p == __pend)
break;
#pragma empty_line
__p++;
__ret.push_back(_CharT());
}
}
catch(...)
{
delete [] __c;
throw;
}
#pragma empty_line
delete [] __c;
#pragma empty_line
return __ret;
}
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern template class collate<char>;
extern template class collate_byname<char>;
#pragma empty_line
extern template
const collate<char>&
use_facet<collate<char> >(const locale&);
#pragma empty_line
extern template
bool
has_facet<collate<char> >(const locale&);
#pragma empty_line
#pragma empty_line
extern template class collate<wchar_t>;
extern template class collate_byname<wchar_t>;
#pragma empty_line
extern template
const collate<wchar_t>&
use_facet<collate<wchar_t> >(const locale&);
#pragma empty_line
extern template
bool
has_facet<collate<wchar_t> >(const locale&);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 851 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_classes.h" 2 3
#pragma line 42 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 2 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/system_error" 1 3
#pragma line 32 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/system_error" 3
#pragma empty_line
#pragma line 33 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/system_error" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/error_constants.h" 1 3
#pragma line 34 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/error_constants.h" 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cerrno" 1 3
#pragma line 39 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cerrno" 3
#pragma empty_line
#pragma line 40 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cerrno" 3
#pragma line 35 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/error_constants.h" 2 3
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
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,
#pragma empty_line
#pragma empty_line
bad_message = 74,
#pragma empty_line
#pragma empty_line
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,
#pragma empty_line
#pragma empty_line
identifier_removed = 43,
#pragma empty_line
#pragma empty_line
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,
#pragma empty_line
#pragma empty_line
no_link = 67,
#pragma empty_line
#pragma empty_line
no_lock_available = 37,
#pragma empty_line
#pragma empty_line
no_message_available = 61,
#pragma empty_line
#pragma empty_line
no_message = 42,
no_protocol_option = 92,
no_space_on_device = 28,
#pragma empty_line
#pragma empty_line
no_stream_resources = 63,
#pragma empty_line
#pragma empty_line
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,
#pragma empty_line
#pragma empty_line
not_a_stream = 60,
#pragma empty_line
#pragma empty_line
not_connected = 107,
not_enough_memory = 12,
#pragma empty_line
#pragma empty_line
not_supported = 95,
#pragma empty_line
#pragma empty_line
#pragma empty_line
operation_canceled = 125,
#pragma empty_line
#pragma empty_line
operation_in_progress = 115,
operation_not_permitted = 1,
operation_not_supported = 95,
operation_would_block = 11,
#pragma empty_line
#pragma empty_line
owner_dead = 130,
#pragma empty_line
#pragma empty_line
permission_denied = 13,
#pragma empty_line
#pragma empty_line
protocol_error = 71,
#pragma empty_line
#pragma empty_line
protocol_not_supported = 93,
read_only_file_system = 30,
resource_deadlock_would_occur = 35,
resource_unavailable_try_again = 11,
result_out_of_range = 34,
#pragma empty_line
#pragma empty_line
state_not_recoverable = 131,
#pragma empty_line
#pragma empty_line
#pragma empty_line
stream_timeout = 62,
#pragma empty_line
#pragma empty_line
#pragma empty_line
text_file_busy = 26,
#pragma empty_line
#pragma empty_line
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,
#pragma empty_line
#pragma empty_line
value_too_large = 75,
#pragma empty_line
#pragma empty_line
wrong_protocol_type = 91
};
#pragma empty_line
#pragma empty_line
}
#pragma line 40 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/system_error" 2 3
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/stdexcept" 1 3
#pragma line 36 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/stdexcept" 3
#pragma empty_line
#pragma line 37 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/stdexcept" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
struct __cow_string
{
union {
const char* _M_p;
char _M_bytes[sizeof(const char*)];
};
#pragma empty_line
__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();
#pragma empty_line
__cow_string(__cow_string&&) noexcept;
__cow_string& operator=(__cow_string&&) noexcept;
#pragma empty_line
};
#pragma empty_line
typedef basic_string<char> __sso_string;
#pragma line 113 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/stdexcept" 3
class logic_error : public exception
{
__cow_string _M_msg;
#pragma empty_line
public:
#pragma empty_line
explicit
logic_error(const string& __arg) ;
#pragma empty_line
#pragma empty_line
explicit
logic_error(const char*) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
logic_error(const logic_error&) noexcept;
logic_error& operator=(const logic_error&) noexcept;
#pragma empty_line
#pragma empty_line
virtual ~logic_error() noexcept;
#pragma empty_line
#pragma empty_line
#pragma empty_line
virtual const char*
what() const noexcept;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
class domain_error : public logic_error
{
public:
explicit domain_error(const string& __arg) ;
#pragma empty_line
explicit domain_error(const char*) ;
#pragma empty_line
virtual ~domain_error() noexcept;
};
#pragma empty_line
#pragma empty_line
class invalid_argument : public logic_error
{
public:
explicit invalid_argument(const string& __arg) ;
#pragma empty_line
explicit invalid_argument(const char*) ;
#pragma empty_line
virtual ~invalid_argument() noexcept;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
class length_error : public logic_error
{
public:
explicit length_error(const string& __arg) ;
#pragma empty_line
explicit length_error(const char*) ;
#pragma empty_line
virtual ~length_error() noexcept;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
class out_of_range : public logic_error
{
public:
explicit out_of_range(const string& __arg) ;
#pragma empty_line
explicit out_of_range(const char*) ;
#pragma empty_line
virtual ~out_of_range() noexcept;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
class runtime_error : public exception
{
__cow_string _M_msg;
#pragma empty_line
public:
#pragma empty_line
explicit
runtime_error(const string& __arg) ;
#pragma empty_line
#pragma empty_line
explicit
runtime_error(const char*) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
runtime_error(const runtime_error&) noexcept;
runtime_error& operator=(const runtime_error&) noexcept;
#pragma empty_line
#pragma empty_line
virtual ~runtime_error() noexcept;
#pragma empty_line
#pragma empty_line
#pragma empty_line
virtual const char*
what() const noexcept;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
};
#pragma empty_line
#pragma empty_line
class range_error : public runtime_error
{
public:
explicit range_error(const string& __arg) ;
#pragma empty_line
explicit range_error(const char*) ;
#pragma empty_line
virtual ~range_error() noexcept;
};
#pragma empty_line
#pragma empty_line
class overflow_error : public runtime_error
{
public:
explicit overflow_error(const string& __arg) ;
#pragma empty_line
explicit overflow_error(const char*) ;
#pragma empty_line
virtual ~overflow_error() noexcept;
};
#pragma empty_line
#pragma empty_line
class underflow_error : public runtime_error
{
public:
explicit underflow_error(const string& __arg) ;
#pragma empty_line
explicit underflow_error(const char*) ;
#pragma empty_line
virtual ~underflow_error() noexcept;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 42 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/system_error" 2 3
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
class error_code;
class error_condition;
class system_error;
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_error_code_enum : public false_type { };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct is_error_condition_enum : public false_type { };
#pragma empty_line
template<>
struct is_error_condition_enum<errc>
: public true_type { };
#pragma empty_line
inline namespace _V2 {
#pragma empty_line
#pragma empty_line
class error_category
{
public:
constexpr error_category() noexcept = default;
#pragma empty_line
virtual ~error_category();
#pragma empty_line
error_category(const error_category&) = delete;
error_category& operator=(const error_category&) = delete;
#pragma empty_line
virtual const char*
name() const noexcept = 0;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
private:
__attribute ((__abi_tag__ ("cxx11")))
virtual __cow_string
_M_message(int) const;
#pragma empty_line
public:
__attribute ((__abi_tag__ ("cxx11")))
virtual string
message(int) const = 0;
#pragma line 102 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
virtual bool
equivalent(int __i, const error_condition& __cond) const noexcept;
#pragma empty_line
virtual bool
equivalent(const error_code& __code, int __i) const noexcept;
#pragma empty_line
bool
operator<(const error_category& __other) const noexcept
{ return less<const error_category*>()(this, &__other); }
#pragma empty_line
bool
operator==(const error_category& __other) const noexcept
{ return this == &__other; }
#pragma empty_line
bool
operator!=(const error_category& __other) const noexcept
{ return this != &__other; }
};
#pragma empty_line
#pragma empty_line
__attribute__ ((__const__)) const error_category& system_category() noexcept;
__attribute__ ((__const__)) const error_category& generic_category() noexcept;
#pragma empty_line
}
#pragma empty_line
error_code make_error_code(errc) noexcept;
#pragma empty_line
template<typename _Tp>
struct hash;
#pragma empty_line
#pragma empty_line
#pragma empty_line
struct error_code
{
error_code() noexcept
: _M_value(0), _M_cat(&system_category()) { }
#pragma empty_line
error_code(int __v, const error_category& __cat) noexcept
: _M_value(__v), _M_cat(&__cat) { }
#pragma empty_line
template<typename _ErrorCodeEnum, typename = typename
enable_if<is_error_code_enum<_ErrorCodeEnum>::value>::type>
error_code(_ErrorCodeEnum __e) noexcept
{ *this = make_error_code(__e); }
#pragma empty_line
void
assign(int __v, const error_category& __cat) noexcept
{
_M_value = __v;
_M_cat = &__cat;
}
#pragma empty_line
void
clear() noexcept
{ assign(0, system_category()); }
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
int
value() const noexcept { return _M_value; }
#pragma empty_line
const error_category&
category() const noexcept { return *_M_cat; }
#pragma empty_line
error_condition
default_error_condition() const noexcept;
#pragma empty_line
__attribute ((__abi_tag__ ("cxx11")))
string
message() const
{ return category().message(value()); }
#pragma empty_line
explicit operator bool() const noexcept
{ return _M_value != 0; }
#pragma empty_line
#pragma empty_line
private:
friend class hash<error_code>;
#pragma empty_line
int _M_value;
const error_category* _M_cat;
};
#pragma empty_line
#pragma empty_line
inline error_code
make_error_code(errc __e) noexcept
{ return error_code(static_cast<int>(__e), generic_category()); }
#pragma empty_line
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()));
}
#pragma empty_line
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()); }
#pragma empty_line
error_condition make_error_condition(errc) noexcept;
#pragma empty_line
#pragma empty_line
#pragma empty_line
struct error_condition
{
error_condition() noexcept
: _M_value(0), _M_cat(&generic_category()) { }
#pragma empty_line
error_condition(int __v, const error_category& __cat) noexcept
: _M_value(__v), _M_cat(&__cat) { }
#pragma empty_line
template<typename _ErrorConditionEnum, typename = typename
enable_if<is_error_condition_enum<_ErrorConditionEnum>::value>::type>
error_condition(_ErrorConditionEnum __e) noexcept
{ *this = make_error_condition(__e); }
#pragma empty_line
void
assign(int __v, const error_category& __cat) noexcept
{
_M_value = __v;
_M_cat = &__cat;
}
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
void
clear() noexcept
{ assign(0, generic_category()); }
#pragma empty_line
#pragma empty_line
int
value() const noexcept { return _M_value; }
#pragma empty_line
const error_category&
category() const noexcept { return *_M_cat; }
#pragma empty_line
__attribute ((__abi_tag__ ("cxx11")))
string
message() const
{ return category().message(value()); }
#pragma empty_line
explicit operator bool() const noexcept
{ return _M_value != 0; }
#pragma empty_line
#pragma empty_line
private:
int _M_value;
const error_category* _M_cat;
};
#pragma empty_line
#pragma empty_line
inline error_condition
make_error_condition(errc __e) noexcept
{ return error_condition(static_cast<int>(__e), generic_category()); }
#pragma empty_line
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()));
}
#pragma empty_line
#pragma empty_line
inline bool
operator==(const error_code& __lhs, const error_code& __rhs) noexcept
{ return (__lhs.category() == __rhs.category()
&& __lhs.value() == __rhs.value()); }
#pragma empty_line
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()));
}
#pragma empty_line
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()));
}
#pragma empty_line
inline bool
operator==(const error_condition& __lhs,
const error_condition& __rhs) noexcept
{
return (__lhs.category() == __rhs.category()
&& __lhs.value() == __rhs.value());
}
#pragma empty_line
inline bool
operator!=(const error_code& __lhs, const error_code& __rhs) noexcept
{ return !(__lhs == __rhs); }
#pragma empty_line
inline bool
operator!=(const error_code& __lhs, const error_condition& __rhs) noexcept
{ return !(__lhs == __rhs); }
#pragma empty_line
inline bool
operator!=(const error_condition& __lhs, const error_code& __rhs) noexcept
{ return !(__lhs == __rhs); }
#pragma empty_line
inline bool
operator!=(const error_condition& __lhs,
const error_condition& __rhs) noexcept
{ return !(__lhs == __rhs); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
class system_error : public std::runtime_error
{
private:
error_code _M_code;
#pragma empty_line
public:
system_error(error_code __ec = error_code())
: runtime_error(__ec.message()), _M_code(__ec) { }
#pragma empty_line
system_error(error_code __ec, const string& __what)
: runtime_error(__what + ": " + __ec.message()), _M_code(__ec) { }
#pragma empty_line
system_error(error_code __ec, const char* __what)
: runtime_error(__what + (": " + __ec.message())), _M_code(__ec) { }
#pragma empty_line
system_error(int __v, const error_category& __ecat, const char* __what)
: system_error(error_code(__v, __ecat), __what) { }
#pragma empty_line
system_error(int __v, const error_category& __ecat)
: runtime_error(error_code(__v, __ecat).message()),
_M_code(__v, __ecat) { }
#pragma empty_line
system_error(int __v, const error_category& __ecat, const string& __what)
: runtime_error(__what + ": " + error_code(__v, __ecat).message()),
_M_code(__v, __ecat) { }
#pragma empty_line
virtual ~system_error() noexcept;
#pragma empty_line
const error_code&
code() const noexcept { return _M_code; }
};
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
}
};
#pragma empty_line
#pragma empty_line
}
#pragma line 47 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 2 3
#pragma empty_line
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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
};
#pragma empty_line
inline constexpr _Ios_Fmtflags
operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
{ return _Ios_Fmtflags(static_cast<int>(__a) & static_cast<int>(__b)); }
#pragma empty_line
inline constexpr _Ios_Fmtflags
operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
{ return _Ios_Fmtflags(static_cast<int>(__a) | static_cast<int>(__b)); }
#pragma empty_line
inline constexpr _Ios_Fmtflags
operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
{ return _Ios_Fmtflags(static_cast<int>(__a) ^ static_cast<int>(__b)); }
#pragma empty_line
inline constexpr _Ios_Fmtflags
operator~(_Ios_Fmtflags __a)
{ return _Ios_Fmtflags(~static_cast<int>(__a)); }
#pragma empty_line
inline const _Ios_Fmtflags&
operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
{ return __a = __a | __b; }
#pragma empty_line
inline const _Ios_Fmtflags&
operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
{ return __a = __a & __b; }
#pragma empty_line
inline const _Ios_Fmtflags&
operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
{ return __a = __a ^ __b; }
#pragma empty_line
#pragma empty_line
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
};
#pragma empty_line
inline constexpr _Ios_Openmode
operator&(_Ios_Openmode __a, _Ios_Openmode __b)
{ return _Ios_Openmode(static_cast<int>(__a) & static_cast<int>(__b)); }
#pragma empty_line
inline constexpr _Ios_Openmode
operator|(_Ios_Openmode __a, _Ios_Openmode __b)
{ return _Ios_Openmode(static_cast<int>(__a) | static_cast<int>(__b)); }
#pragma empty_line
inline constexpr _Ios_Openmode
operator^(_Ios_Openmode __a, _Ios_Openmode __b)
{ return _Ios_Openmode(static_cast<int>(__a) ^ static_cast<int>(__b)); }
#pragma empty_line
inline constexpr _Ios_Openmode
operator~(_Ios_Openmode __a)
{ return _Ios_Openmode(~static_cast<int>(__a)); }
#pragma empty_line
inline const _Ios_Openmode&
operator|=(_Ios_Openmode& __a, _Ios_Openmode __b)
{ return __a = __a | __b; }
#pragma empty_line
inline const _Ios_Openmode&
operator&=(_Ios_Openmode& __a, _Ios_Openmode __b)
{ return __a = __a & __b; }
#pragma empty_line
inline const _Ios_Openmode&
operator^=(_Ios_Openmode& __a, _Ios_Openmode __b)
{ return __a = __a ^ __b; }
#pragma empty_line
#pragma empty_line
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
};
#pragma empty_line
inline constexpr _Ios_Iostate
operator&(_Ios_Iostate __a, _Ios_Iostate __b)
{ return _Ios_Iostate(static_cast<int>(__a) & static_cast<int>(__b)); }
#pragma empty_line
inline constexpr _Ios_Iostate
operator|(_Ios_Iostate __a, _Ios_Iostate __b)
{ return _Ios_Iostate(static_cast<int>(__a) | static_cast<int>(__b)); }
#pragma empty_line
inline constexpr _Ios_Iostate
operator^(_Ios_Iostate __a, _Ios_Iostate __b)
{ return _Ios_Iostate(static_cast<int>(__a) ^ static_cast<int>(__b)); }
#pragma empty_line
inline constexpr _Ios_Iostate
operator~(_Ios_Iostate __a)
{ return _Ios_Iostate(~static_cast<int>(__a)); }
#pragma empty_line
inline const _Ios_Iostate&
operator|=(_Ios_Iostate& __a, _Ios_Iostate __b)
{ return __a = __a | __b; }
#pragma empty_line
inline const _Ios_Iostate&
operator&=(_Ios_Iostate& __a, _Ios_Iostate __b)
{ return __a = __a & __b; }
#pragma empty_line
inline const _Ios_Iostate&
operator^=(_Ios_Iostate& __a, _Ios_Iostate __b)
{ return __a = __a ^ __b; }
#pragma empty_line
#pragma empty_line
enum _Ios_Seekdir
{
_S_beg = 0,
_S_cur = 1,
_S_end = 2,
_S_ios_seekdir_end = 1L << 16
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
enum class io_errc { stream = 1 };
#pragma empty_line
template <> struct is_error_code_enum<io_errc> : public true_type { };
#pragma empty_line
const error_category& iostream_category() noexcept;
#pragma empty_line
inline error_code
make_error_code(io_errc e) noexcept
{ return error_code(static_cast<int>(e), iostream_category()); }
#pragma empty_line
inline error_condition
make_error_condition(io_errc e) noexcept
{ return error_condition(static_cast<int>(e), iostream_category()); }
#pragma line 228 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 3
class ios_base
{
#pragma line 246 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 3
public:
#pragma line 255 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
#pragma empty_line
#pragma empty_line
explicit
failure(const string&, const error_code&);
#pragma empty_line
explicit
failure(const char*, const error_code& = io_errc::stream);
#pragma empty_line
#pragma empty_line
virtual
~failure() throw();
#pragma empty_line
virtual const char*
what() const throw();
};
#pragma line 323 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 3
typedef _Ios_Fmtflags fmtflags;
#pragma empty_line
#pragma empty_line
static const fmtflags boolalpha = _S_boolalpha;
#pragma empty_line
#pragma empty_line
static const fmtflags dec = _S_dec;
#pragma empty_line
#pragma empty_line
static const fmtflags fixed = _S_fixed;
#pragma empty_line
#pragma empty_line
static const fmtflags hex = _S_hex;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static const fmtflags internal = _S_internal;
#pragma empty_line
#pragma empty_line
#pragma empty_line
static const fmtflags left = _S_left;
#pragma empty_line
#pragma empty_line
static const fmtflags oct = _S_oct;
#pragma empty_line
#pragma empty_line
#pragma empty_line
static const fmtflags right = _S_right;
#pragma empty_line
#pragma empty_line
static const fmtflags scientific = _S_scientific;
#pragma empty_line
#pragma empty_line
#pragma empty_line
static const fmtflags showbase = _S_showbase;
#pragma empty_line
#pragma empty_line
#pragma empty_line
static const fmtflags showpoint = _S_showpoint;
#pragma empty_line
#pragma empty_line
static const fmtflags showpos = _S_showpos;
#pragma empty_line
#pragma empty_line
static const fmtflags skipws = _S_skipws;
#pragma empty_line
#pragma empty_line
static const fmtflags unitbuf = _S_unitbuf;
#pragma empty_line
#pragma empty_line
#pragma empty_line
static const fmtflags uppercase = _S_uppercase;
#pragma empty_line
#pragma empty_line
static const fmtflags adjustfield = _S_adjustfield;
#pragma empty_line
#pragma empty_line
static const fmtflags basefield = _S_basefield;
#pragma empty_line
#pragma empty_line
static const fmtflags floatfield = _S_floatfield;
#pragma line 398 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 3
typedef _Ios_Iostate iostate;
#pragma empty_line
#pragma empty_line
#pragma empty_line
static const iostate badbit = _S_badbit;
#pragma empty_line
#pragma empty_line
static const iostate eofbit = _S_eofbit;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static const iostate failbit = _S_failbit;
#pragma empty_line
#pragma empty_line
static const iostate goodbit = _S_goodbit;
#pragma line 429 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 3
typedef _Ios_Openmode openmode;
#pragma empty_line
#pragma empty_line
static const openmode app = _S_app;
#pragma empty_line
#pragma empty_line
static const openmode ate = _S_ate;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static const openmode binary = _S_bin;
#pragma empty_line
#pragma empty_line
static const openmode in = _S_in;
#pragma empty_line
#pragma empty_line
static const openmode out = _S_out;
#pragma empty_line
#pragma empty_line
static const openmode trunc = _S_trunc;
#pragma line 461 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 3
typedef _Ios_Seekdir seekdir;
#pragma empty_line
#pragma empty_line
static const seekdir beg = _S_beg;
#pragma empty_line
#pragma empty_line
static const seekdir cur = _S_cur;
#pragma empty_line
#pragma empty_line
static const seekdir end = _S_end;
#pragma empty_line
#pragma empty_line
typedef int io_state;
typedef int open_mode;
typedef int seek_dir;
#pragma empty_line
typedef std::streampos streampos;
typedef std::streamoff streamoff;
#pragma line 487 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 3
enum event
{
erase_event,
imbue_event,
copyfmt_event
};
#pragma line 504 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
#pragma line 516 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 3
void
register_callback(event_callback __fn, int __index);
#pragma empty_line
protected:
streamsize _M_precision;
streamsize _M_width;
fmtflags _M_flags;
iostate _M_exception;
iostate _M_streambuf_state;
#pragma empty_line
#pragma empty_line
#pragma empty_line
struct _Callback_list
{
#pragma empty_line
_Callback_list* _M_next;
ios_base::event_callback _M_fn;
int _M_index;
_Atomic_word _M_refcount;
#pragma empty_line
_Callback_list(ios_base::event_callback __fn, int __index,
_Callback_list* __cb)
: _M_next(__cb), _M_fn(__fn), _M_index(__index), _M_refcount(0) { }
#pragma empty_line
void
_M_add_reference() { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
#pragma empty_line
#pragma empty_line
int
_M_remove_reference()
{
#pragma empty_line
;
int __res = __gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1);
if (__res == 0)
{
;
}
return __res;
}
};
#pragma empty_line
_Callback_list* _M_callbacks;
#pragma empty_line
void
_M_call_callbacks(event __ev) throw();
#pragma empty_line
void
_M_dispose_callbacks(void) throw();
#pragma empty_line
#pragma empty_line
struct _Words
{
void* _M_pword;
long _M_iword;
_Words() : _M_pword(0), _M_iword(0) { }
};
#pragma empty_line
#pragma empty_line
_Words _M_word_zero;
#pragma empty_line
#pragma empty_line
#pragma empty_line
enum { _S_local_word_size = 8 };
_Words _M_local_word[_S_local_word_size];
#pragma empty_line
#pragma empty_line
int _M_word_size;
_Words* _M_word;
#pragma empty_line
_Words&
_M_grow_words(int __index, bool __iword);
#pragma empty_line
#pragma empty_line
locale _M_ios_locale;
#pragma empty_line
void
_M_init() throw();
#pragma empty_line
public:
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
class Init
{
friend class ios_base;
public:
Init();
~Init();
#pragma empty_line
private:
static _Atomic_word _S_refcount;
static bool _S_synced_with_stdio;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
fmtflags
flags() const
{ return _M_flags; }
#pragma line 629 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma line 645 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma line 662 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
void
unsetf(fmtflags __mask)
{ _M_flags &= ~__mask; }
#pragma line 688 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 3
streamsize
precision() const
{ return _M_precision; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
streamsize
precision(streamsize __prec)
{
streamsize __old = _M_precision;
_M_precision = __prec;
return __old;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
streamsize
width() const
{ return _M_width; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
streamsize
width(streamsize __wide)
{
streamsize __old = _M_width;
_M_width = __wide;
return __old;
}
#pragma line 739 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 3
static bool
sync_with_stdio(bool __sync = true);
#pragma line 751 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 3
locale
imbue(const locale& __loc) throw();
#pragma line 762 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 3
locale
getloc() const
{ return _M_ios_locale; }
#pragma line 773 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma line 792 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 3
static int
xalloc() throw();
#pragma line 808 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma line 829 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma line 846 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 3
virtual ~ios_base();
#pragma empty_line
protected:
ios_base() throw ();
#pragma line 860 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ios_base.h" 3
public:
ios_base(const ios_base&) = delete;
#pragma empty_line
ios_base&
operator=(const ios_base&) = delete;
#pragma empty_line
protected:
void
_M_move(ios_base&) noexcept;
#pragma empty_line
void
_M_swap(ios_base& __rhs) noexcept;
#pragma empty_line
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline ios_base&
boolalpha(ios_base& __base)
{
__base.setf(ios_base::boolalpha);
return __base;
}
#pragma empty_line
#pragma empty_line
inline ios_base&
noboolalpha(ios_base& __base)
{
__base.unsetf(ios_base::boolalpha);
return __base;
}
#pragma empty_line
#pragma empty_line
inline ios_base&
showbase(ios_base& __base)
{
__base.setf(ios_base::showbase);
return __base;
}
#pragma empty_line
#pragma empty_line
inline ios_base&
noshowbase(ios_base& __base)
{
__base.unsetf(ios_base::showbase);
return __base;
}
#pragma empty_line
#pragma empty_line
inline ios_base&
showpoint(ios_base& __base)
{
__base.setf(ios_base::showpoint);
return __base;
}
#pragma empty_line
#pragma empty_line
inline ios_base&
noshowpoint(ios_base& __base)
{
__base.unsetf(ios_base::showpoint);
return __base;
}
#pragma empty_line
#pragma empty_line
inline ios_base&
showpos(ios_base& __base)
{
__base.setf(ios_base::showpos);
return __base;
}
#pragma empty_line
#pragma empty_line
inline ios_base&
noshowpos(ios_base& __base)
{
__base.unsetf(ios_base::showpos);
return __base;
}
#pragma empty_line
#pragma empty_line
inline ios_base&
skipws(ios_base& __base)
{
__base.setf(ios_base::skipws);
return __base;
}
#pragma empty_line
#pragma empty_line
inline ios_base&
noskipws(ios_base& __base)
{
__base.unsetf(ios_base::skipws);
return __base;
}
#pragma empty_line
#pragma empty_line
inline ios_base&
uppercase(ios_base& __base)
{
__base.setf(ios_base::uppercase);
return __base;
}
#pragma empty_line
#pragma empty_line
inline ios_base&
nouppercase(ios_base& __base)
{
__base.unsetf(ios_base::uppercase);
return __base;
}
#pragma empty_line
#pragma empty_line
inline ios_base&
unitbuf(ios_base& __base)
{
__base.setf(ios_base::unitbuf);
return __base;
}
#pragma empty_line
#pragma empty_line
inline ios_base&
nounitbuf(ios_base& __base)
{
__base.unsetf(ios_base::unitbuf);
return __base;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline ios_base&
internal(ios_base& __base)
{
__base.setf(ios_base::internal, ios_base::adjustfield);
return __base;
}
#pragma empty_line
#pragma empty_line
inline ios_base&
left(ios_base& __base)
{
__base.setf(ios_base::left, ios_base::adjustfield);
return __base;
}
#pragma empty_line
#pragma empty_line
inline ios_base&
right(ios_base& __base)
{
__base.setf(ios_base::right, ios_base::adjustfield);
return __base;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline ios_base&
dec(ios_base& __base)
{
__base.setf(ios_base::dec, ios_base::basefield);
return __base;
}
#pragma empty_line
#pragma empty_line
inline ios_base&
hex(ios_base& __base)
{
__base.setf(ios_base::hex, ios_base::basefield);
return __base;
}
#pragma empty_line
#pragma empty_line
inline ios_base&
oct(ios_base& __base)
{
__base.setf(ios_base::oct, ios_base::basefield);
return __base;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline ios_base&
fixed(ios_base& __base)
{
__base.setf(ios_base::fixed, ios_base::floatfield);
return __base;
}
#pragma empty_line
#pragma empty_line
inline ios_base&
scientific(ios_base& __base)
{
__base.setf(ios_base::scientific, ios_base::floatfield);
return __base;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline ios_base&
hexfloat(ios_base& __base)
{
__base.setf(ios_base::fixed | ios_base::scientific, ios_base::floatfield);
return __base;
}
#pragma empty_line
#pragma empty_line
inline ios_base&
defaultfloat(ios_base& __base)
{
__base.unsetf(ios_base::floatfield);
return __base;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 43 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ios" 2 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 1 3
#pragma line 36 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
#pragma empty_line
#pragma line 37 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
#pragma line 45 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
template<typename _CharT, typename _Traits>
streamsize
__copy_streambufs_eof(basic_streambuf<_CharT, _Traits>*,
basic_streambuf<_CharT, _Traits>*, bool&);
#pragma line 119 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
template<typename _CharT, typename _Traits>
class basic_streambuf
{
public:
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef basic_streambuf<char_type, traits_type> __streambuf_type;
#pragma empty_line
#pragma empty_line
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>;
#pragma empty_line
friend streamsize
__copy_streambufs_eof<>(basic_streambuf*, basic_streambuf*, bool&);
#pragma empty_line
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*);
#pragma empty_line
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&);
#pragma empty_line
template<typename _CharT2, typename _Traits2>
friend basic_istream<_CharT2, _Traits2>&
operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2*);
#pragma empty_line
template<typename _CharT2, typename _Traits2, typename _Alloc>
friend basic_istream<_CharT2, _Traits2>&
operator>>(basic_istream<_CharT2, _Traits2>&,
basic_string<_CharT2, _Traits2, _Alloc>&);
#pragma empty_line
template<typename _CharT2, typename _Traits2, typename _Alloc>
friend basic_istream<_CharT2, _Traits2>&
getline(basic_istream<_CharT2, _Traits2>&,
basic_string<_CharT2, _Traits2, _Alloc>&, _CharT2);
#pragma empty_line
protected:
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
locale _M_buf_locale;
#pragma empty_line
public:
#pragma empty_line
virtual
~basic_streambuf()
{ }
#pragma line 208 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma line 225 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
locale
getloc() const
{ return _M_buf_locale; }
#pragma line 238 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 250 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 262 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
int
pubsync() { return this->sync(); }
#pragma line 283 "/home/justin/jhai/Xilinx/Vivado/2018.3/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();
}
#pragma line 297 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma line 315 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma line 337 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma line 356 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 371 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma line 396 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma line 423 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma line 449 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
protected:
#pragma line 463 "/home/justin/jhai/Xilinx/Vivado/2018.3/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())
{ }
#pragma line 481 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
char_type*
eback() const { return _M_in_beg; }
#pragma empty_line
char_type*
gptr() const { return _M_in_cur; }
#pragma empty_line
char_type*
egptr() const { return _M_in_end; }
#pragma line 497 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
void
gbump(int __n) { _M_in_cur += __n; }
#pragma line 508 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma line 528 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
char_type*
pbase() const { return _M_out_beg; }
#pragma empty_line
char_type*
pptr() const { return _M_out_cur; }
#pragma empty_line
char_type*
epptr() const { return _M_out_end; }
#pragma line 544 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
void
pbump(int __n) { _M_out_cur += __n; }
#pragma line 554 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma line 575 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
virtual void
imbue(const locale& __loc)
{ }
#pragma line 590 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma line 601 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)); }
#pragma line 613 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)); }
#pragma line 626 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
virtual int
sync() { return 0; }
#pragma line 648 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
virtual streamsize
showmanyc() { return 0; }
#pragma line 664 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
virtual streamsize
xsgetn(char_type* __s, streamsize __n);
#pragma line 686 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
virtual int_type
underflow()
{ return traits_type::eof(); }
#pragma line 699 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma line 723 "/home/justin/jhai/Xilinx/Vivado/2018.3/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(); }
#pragma line 741 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 3
virtual streamsize
xsputn(const char_type* __s, streamsize __n);
#pragma line 767 "/home/justin/jhai/Xilinx/Vivado/2018.3/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(); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
public:
#pragma line 782 "/home/justin/jhai/Xilinx/Vivado/2018.3/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();
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
void
__safe_gbump(streamsize __n) { _M_in_cur += __n; }
#pragma empty_line
void
__safe_pbump(streamsize __n) { _M_out_cur += __n; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
protected:
#pragma empty_line
basic_streambuf(const basic_streambuf&);
#pragma empty_line
basic_streambuf&
operator=(const basic_streambuf&);
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
};
#pragma empty_line
#pragma empty_line
template<typename _CharT, typename _Traits>
std::basic_streambuf<_CharT, _Traits>::
basic_streambuf(const basic_streambuf&) = default;
#pragma empty_line
template<typename _CharT, typename _Traits>
std::basic_streambuf<_CharT, _Traits>&
std::basic_streambuf<_CharT, _Traits>::
operator=(const basic_streambuf&) = default;
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<>
streamsize
__copy_streambufs_eof(basic_streambuf<char>* __sbin,
basic_streambuf<char>* __sbout, bool& __ineof);
#pragma empty_line
template<>
streamsize
__copy_streambufs_eof(basic_streambuf<wchar_t>* __sbin,
basic_streambuf<wchar_t>* __sbout, bool& __ineof);
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/streambuf.tcc" 1 3
#pragma line 37 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/streambuf.tcc" 3
#pragma empty_line
#pragma line 38 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/streambuf.tcc" 3
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
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;
}
#pragma empty_line
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);
}
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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&);
#pragma empty_line
#pragma empty_line
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&);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 851 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/streambuf" 2 3
#pragma line 44 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ios" 2 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_ios.h" 1 3
#pragma line 33 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_ios.h" 3
#pragma empty_line
#pragma line 34 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_ios.h" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 1 3
#pragma line 37 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
#pragma empty_line
#pragma line 38 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cwctype" 1 3
#pragma line 39 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cwctype" 3
#pragma empty_line
#pragma line 40 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cwctype" 3
#pragma line 50 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cwctype" 3
#pragma line 1 "/usr/include/wctype.h" 1 3 4
#pragma line 38 "/usr/include/wctype.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/wctype-wchar.h" 1 3 4
#pragma line 38 "/usr/include/x86_64-linux-gnu/bits/wctype-wchar.h" 3 4
typedef unsigned long int wctype_t;
#pragma line 56 "/usr/include/x86_64-linux-gnu/bits/wctype-wchar.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,
#pragma empty_line
_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))))
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern "C" {
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int iswalnum (wint_t __wc) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int iswalpha (wint_t __wc) throw ();
#pragma empty_line
#pragma empty_line
extern int iswcntrl (wint_t __wc) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int iswdigit (wint_t __wc) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int iswgraph (wint_t __wc) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int iswlower (wint_t __wc) throw ();
#pragma empty_line
#pragma empty_line
extern int iswprint (wint_t __wc) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int iswpunct (wint_t __wc) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int iswspace (wint_t __wc) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int iswupper (wint_t __wc) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int iswxdigit (wint_t __wc) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int iswblank (wint_t __wc) throw ();
#pragma line 155 "/usr/include/x86_64-linux-gnu/bits/wctype-wchar.h" 3 4
extern wctype_t wctype (const char *__property) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int iswctype (wint_t __wc, wctype_t __desc) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern wint_t towlower (wint_t __wc) throw ();
#pragma empty_line
#pragma empty_line
extern wint_t towupper (wint_t __wc) throw ();
#pragma empty_line
}
#pragma line 39 "/usr/include/wctype.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern "C" {
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef const __int32_t *wctrans_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern wctrans_t wctrans (const char *__property) throw ();
#pragma empty_line
#pragma empty_line
extern wint_t towctrans (wint_t __wc, wctrans_t __desc) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int iswalnum_l (wint_t __wc, locale_t __locale) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int iswalpha_l (wint_t __wc, locale_t __locale) throw ();
#pragma empty_line
#pragma empty_line
extern int iswcntrl_l (wint_t __wc, locale_t __locale) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int iswdigit_l (wint_t __wc, locale_t __locale) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int iswgraph_l (wint_t __wc, locale_t __locale) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int iswlower_l (wint_t __wc, locale_t __locale) throw ();
#pragma empty_line
#pragma empty_line
extern int iswprint_l (wint_t __wc, locale_t __locale) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int iswpunct_l (wint_t __wc, locale_t __locale) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int iswspace_l (wint_t __wc, locale_t __locale) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int iswupper_l (wint_t __wc, locale_t __locale) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int iswxdigit_l (wint_t __wc, locale_t __locale) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int iswblank_l (wint_t __wc, locale_t __locale) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern wctype_t wctype_l (const char *__property, locale_t __locale)
throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int iswctype_l (wint_t __wc, wctype_t __desc, locale_t __locale)
throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern wint_t towlower_l (wint_t __wc, locale_t __locale) throw ();
#pragma empty_line
#pragma empty_line
extern wint_t towupper_l (wint_t __wc, locale_t __locale) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern wctrans_t wctrans_l (const char *__property, locale_t __locale)
throw ();
#pragma empty_line
#pragma empty_line
extern wint_t towctrans_l (wint_t __wc, wctrans_t __desc,
locale_t __locale) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 51 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cwctype" 2 3
#pragma line 80 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cwctype" 3
namespace std
{
using ::wctrans_t;
using ::wctype_t;
using ::wint_t;
#pragma empty_line
using ::iswalnum;
using ::iswalpha;
#pragma empty_line
using ::iswblank;
#pragma empty_line
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;
}
#pragma line 40 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 2 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cctype" 1 3
#pragma line 39 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cctype" 3
#pragma empty_line
#pragma line 40 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cctype" 3
#pragma line 41 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 2 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/ctype_base.h" 1 3
#pragma line 36 "/home/justin/jhai/Xilinx/Vivado/2018.3/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")))
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
struct ctype_base
{
#pragma empty_line
typedef const int* __to_type;
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
static const mask blank = _ISblank;
#pragma empty_line
};
#pragma empty_line
#pragma empty_line
}
#pragma line 42 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 2 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/streambuf_iterator.h" 1 3
#pragma line 33 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/streambuf_iterator.h" 3
#pragma empty_line
#pragma line 34 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/streambuf_iterator.h" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma line 49 "/home/justin/jhai/Xilinx/Vivado/2018.3/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*,
#pragma empty_line
#pragma empty_line
_CharT>
#pragma empty_line
#pragma empty_line
#pragma empty_line
{
public:
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
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>);
#pragma empty_line
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*);
#pragma empty_line
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&);
#pragma empty_line
private:
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
mutable streambuf_type* _M_sbuf;
mutable int_type _M_c;
#pragma empty_line
public:
#pragma empty_line
constexpr istreambuf_iterator() noexcept
: _M_sbuf(0), _M_c(traits_type::eof()) { }
#pragma empty_line
#pragma empty_line
istreambuf_iterator(const istreambuf_iterator&) noexcept = default;
#pragma empty_line
~istreambuf_iterator() = default;
#pragma empty_line
#pragma empty_line
#pragma empty_line
istreambuf_iterator(istream_type& __s) noexcept
: _M_sbuf(__s.rdbuf()), _M_c(traits_type::eof()) { }
#pragma empty_line
#pragma empty_line
istreambuf_iterator(streambuf_type* __s) noexcept
: _M_sbuf(__s), _M_c(traits_type::eof()) { }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
char_type
operator*() const
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
return traits_type::to_char_type(_M_get());
}
#pragma empty_line
#pragma empty_line
istreambuf_iterator&
operator++()
{
#pragma empty_line
#pragma empty_line
;
if (_M_sbuf)
{
_M_sbuf->sbumpc();
_M_c = traits_type::eof();
}
return *this;
}
#pragma empty_line
#pragma empty_line
istreambuf_iterator
operator++(int)
{
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
istreambuf_iterator __old = *this;
if (_M_sbuf)
{
__old._M_c = _M_sbuf->sbumpc();
_M_c = traits_type::eof();
}
return __old;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
bool
equal(const istreambuf_iterator& __b) const
{ return _M_at_eof() == __b._M_at_eof(); }
#pragma empty_line
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;
}
#pragma empty_line
bool
_M_at_eof() const
{
const int_type __eof = traits_type::eof();
return traits_type::eq_int_type(_M_get(), __eof);
}
};
#pragma empty_line
template<typename _CharT, typename _Traits>
inline bool
operator==(const istreambuf_iterator<_CharT, _Traits>& __a,
const istreambuf_iterator<_CharT, _Traits>& __b)
{ return __a.equal(__b); }
#pragma empty_line
template<typename _CharT, typename _Traits>
inline bool
operator!=(const istreambuf_iterator<_CharT, _Traits>& __a,
const istreambuf_iterator<_CharT, _Traits>& __b)
{ return !__a.equal(__b); }
#pragma empty_line
#pragma empty_line
template<typename _CharT, typename _Traits>
class ostreambuf_iterator
: public iterator<output_iterator_tag, void, void, void, void>
{
public:
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef _CharT char_type;
typedef _Traits traits_type;
typedef basic_streambuf<_CharT, _Traits> streambuf_type;
typedef basic_ostream<_CharT, _Traits> ostream_type;
#pragma empty_line
#pragma empty_line
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>);
#pragma empty_line
private:
streambuf_type* _M_sbuf;
bool _M_failed;
#pragma empty_line
public:
#pragma empty_line
ostreambuf_iterator(ostream_type& __s) noexcept
: _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { }
#pragma empty_line
#pragma empty_line
ostreambuf_iterator(streambuf_type* __s) noexcept
: _M_sbuf(__s), _M_failed(!_M_sbuf) { }
#pragma empty_line
#pragma empty_line
ostreambuf_iterator&
operator=(_CharT __c)
{
if (!_M_failed &&
_Traits::eq_int_type(_M_sbuf->sputc(__c), _Traits::eof()))
_M_failed = true;
return *this;
}
#pragma empty_line
#pragma empty_line
ostreambuf_iterator&
operator*()
{ return *this; }
#pragma empty_line
#pragma empty_line
ostreambuf_iterator&
operator++(int)
{ return *this; }
#pragma empty_line
#pragma empty_line
ostreambuf_iterator&
operator++()
{ return *this; }
#pragma empty_line
#pragma empty_line
bool
failed() const noexcept
{ return _M_failed; }
#pragma empty_line
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;
}
};
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
#pragma empty_line
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;
}
#pragma empty_line
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;
#pragma empty_line
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();
}
#pragma empty_line
if (!traits_type::eq_int_type(__c, traits_type::eof()))
__first._M_c = __c;
else
__first._M_sbuf = 0;
}
return __first;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 49 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 2 3
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma line 71 "/home/justin/jhai/Xilinx/Vivado/2018.3/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();
#pragma empty_line
#pragma empty_line
template<>
void
__convert_to_v(const char*, float&, ios_base::iostate&,
const __c_locale&) throw();
#pragma empty_line
template<>
void
__convert_to_v(const char*, double&, ios_base::iostate&,
const __c_locale&) throw();
#pragma empty_line
template<>
void
__convert_to_v(const char*, long double&, ios_base::iostate&,
const __c_locale&) throw();
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _CharT>
_CharT*
__add_grouping(_CharT* __s, _CharT __sep,
const char* __gbeg, size_t __gsize,
const _CharT* __first, const _CharT* __last);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _CharT>
inline
ostreambuf_iterator<_CharT>
__write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len)
{
__s._M_put(__ws, __len);
return __s;
}
#pragma empty_line
#pragma empty_line
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;
}
#pragma line 149 "/home/justin/jhai/Xilinx/Vivado/2018.3/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:
#pragma empty_line
#pragma empty_line
typedef _CharT char_type;
#pragma line 168 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 185 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 201 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 217 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 231 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 246 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 260 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 275 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 292 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 311 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 330 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 352 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
protected:
explicit
__ctype_abstract_base(size_t __refs = 0): facet(__refs) { }
#pragma empty_line
virtual
~__ctype_abstract_base() { }
#pragma line 377 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 396 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 415 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 434 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 452 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 469 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 485 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 502 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 521 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 542 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 563 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 588 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
};
#pragma line 611 "/home/justin/jhai/Xilinx/Vivado/2018.3/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:
#pragma empty_line
typedef _CharT char_type;
typedef typename __ctype_abstract_base<_CharT>::mask mask;
#pragma empty_line
#pragma empty_line
static locale::id id;
#pragma empty_line
explicit
ctype(size_t __refs = 0) : __ctype_abstract_base<_CharT>(__refs) { }
#pragma empty_line
protected:
virtual
~ctype();
#pragma empty_line
virtual bool
do_is(mask __m, char_type __c) const;
#pragma empty_line
virtual const char_type*
do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
#pragma empty_line
virtual const char_type*
do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
#pragma empty_line
virtual const char_type*
do_scan_not(mask __m, const char_type* __lo,
const char_type* __hi) const;
#pragma empty_line
virtual char_type
do_toupper(char_type __c) const;
#pragma empty_line
virtual const char_type*
do_toupper(char_type* __lo, const char_type* __hi) const;
#pragma empty_line
virtual char_type
do_tolower(char_type __c) const;
#pragma empty_line
virtual const char_type*
do_tolower(char_type* __lo, const char_type* __hi) const;
#pragma empty_line
virtual char_type
do_widen(char __c) const;
#pragma empty_line
virtual const char*
do_widen(const char* __lo, const char* __hi, char_type* __dest) const;
#pragma empty_line
virtual char
do_narrow(char_type, char __dfault) const;
#pragma empty_line
virtual const char_type*
do_narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char* __to) const;
};
#pragma empty_line
template<typename _CharT>
locale::id ctype<_CharT>::id;
#pragma line 680 "/home/justin/jhai/Xilinx/Vivado/2018.3/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:
#pragma empty_line
#pragma empty_line
typedef char char_type;
#pragma empty_line
protected:
#pragma empty_line
__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;
#pragma empty_line
#pragma empty_line
public:
#pragma empty_line
static locale::id id;
#pragma empty_line
static const size_t table_size = 1 + static_cast<unsigned char>(-1);
#pragma line 717 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
#pragma line 730 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
#pragma line 743 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
inline bool
is(mask __m, char __c) const;
#pragma line 758 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 772 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 786 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 801 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 818 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 834 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 851 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 871 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
}
#pragma line 898 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
}
#pragma line 929 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma line 962 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
const mask*
table() const throw()
{ return _M_table; }
#pragma empty_line
#pragma empty_line
static const mask*
classic_table() throw();
protected:
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
virtual
~ctype();
#pragma line 1011 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 1028 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 1044 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 1061 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 1081 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma line 1104 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma line 1130 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma line 1156 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma empty_line
private:
void _M_narrow_init() const;
void _M_widen_init() const;
};
#pragma line 1181 "/home/justin/jhai/Xilinx/Vivado/2018.3/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:
#pragma empty_line
#pragma empty_line
typedef wchar_t char_type;
typedef wctype_t __wmask_type;
#pragma empty_line
protected:
__c_locale _M_c_locale_ctype;
#pragma empty_line
#pragma empty_line
bool _M_narrow_ok;
char _M_narrow[128];
wint_t _M_widen[1 + static_cast<unsigned char>(-1)];
#pragma empty_line
#pragma empty_line
mask _M_bit[16];
__wmask_type _M_wmask[16];
#pragma empty_line
public:
#pragma empty_line
#pragma empty_line
static locale::id id;
#pragma line 1214 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
explicit
ctype(size_t __refs = 0);
#pragma line 1225 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
#pragma empty_line
protected:
__wmask_type
_M_convert_to_wmask(const mask __m) const throw();
#pragma empty_line
#pragma empty_line
virtual
~ctype();
#pragma line 1249 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 1268 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 1286 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 1304 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 1321 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 1338 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 1354 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 1371 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 1391 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
virtual char_type
do_widen(char __c) const;
#pragma line 1413 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 1436 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 1462 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
#pragma empty_line
void
_M_initialize_ctype() throw();
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _CharT>
class ctype_byname : public ctype<_CharT>
{
public:
typedef typename ctype<_CharT>::mask mask;
#pragma empty_line
explicit
ctype_byname(const char* __s, size_t __refs = 0);
#pragma empty_line
#pragma empty_line
explicit
ctype_byname(const string& __s, size_t __refs = 0)
: ctype_byname(__s.c_str(), __refs) { }
#pragma empty_line
#pragma empty_line
protected:
virtual
~ctype_byname() { };
};
#pragma empty_line
#pragma empty_line
template<>
class ctype_byname<char> : public ctype<char>
{
public:
explicit
ctype_byname(const char* __s, size_t __refs = 0);
#pragma empty_line
#pragma empty_line
explicit
ctype_byname(const string& __s, size_t __refs = 0);
#pragma empty_line
#pragma empty_line
protected:
virtual
~ctype_byname();
};
#pragma empty_line
#pragma empty_line
template<>
class ctype_byname<wchar_t> : public ctype<wchar_t>
{
public:
explicit
ctype_byname(const char* __s, size_t __refs = 0);
#pragma empty_line
#pragma empty_line
explicit
ctype_byname(const string& __s, size_t __refs = 0);
#pragma empty_line
#pragma empty_line
protected:
virtual
~ctype_byname();
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/ctype_inline.h" 1 3
#pragma line 37 "/home/justin/jhai/Xilinx/Vivado/2018.3/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")))
{
#pragma empty_line
#pragma empty_line
bool
ctype<char>::
is(mask __m, char __c) const
{ return _M_table[static_cast<unsigned char>(__c)] & __m; }
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
}
#pragma line 1535 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 2 3
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
class __num_base
{
public:
#pragma empty_line
#pragma empty_line
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
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static const char* _S_atoms_out;
#pragma empty_line
#pragma empty_line
#pragma empty_line
static const char* _S_atoms_in;
#pragma empty_line
enum
{
_S_iminus,
_S_iplus,
_S_ix,
_S_iX,
_S_izero,
_S_ie = _S_izero + 14,
_S_iE = _S_izero + 20,
_S_iend = 26
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
static void
_S_format_float(const ios_base& __io, char* __fptr, char __mod) throw();
};
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
_CharT _M_atoms_out[__num_base::_S_oend];
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
_CharT _M_atoms_in[__num_base::_S_iend];
#pragma empty_line
bool _M_allocated;
#pragma empty_line
__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)
{ }
#pragma empty_line
~__numpunct_cache();
#pragma empty_line
void
_M_cache(const locale& __loc);
#pragma empty_line
private:
__numpunct_cache&
operator=(const __numpunct_cache&);
#pragma empty_line
explicit
__numpunct_cache(const __numpunct_cache&);
};
#pragma empty_line
template<typename _CharT>
__numpunct_cache<_CharT>::~__numpunct_cache()
{
if (_M_allocated)
{
delete [] _M_grouping;
delete [] _M_truename;
delete [] _M_falsename;
}
}
#pragma empty_line
namespace __cxx11 {
#pragma line 1665 "/home/justin/jhai/Xilinx/Vivado/2018.3/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:
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;
#pragma empty_line
typedef __numpunct_cache<_CharT> __cache_type;
#pragma empty_line
protected:
__cache_type* _M_data;
#pragma empty_line
public:
#pragma empty_line
static locale::id id;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
explicit
numpunct(size_t __refs = 0)
: facet(__refs), _M_data(0)
{ _M_initialize_numpunct(); }
#pragma line 1703 "/home/justin/jhai/Xilinx/Vivado/2018.3/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(); }
#pragma line 1717 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 1731 "/home/justin/jhai/Xilinx/Vivado/2018.3/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(); }
#pragma line 1744 "/home/justin/jhai/Xilinx/Vivado/2018.3/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(); }
#pragma line 1775 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
string
grouping() const
{ return this->do_grouping(); }
#pragma line 1788 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
string_type
truename() const
{ return this->do_truename(); }
#pragma line 1801 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
string_type
falsename() const
{ return this->do_falsename(); }
#pragma empty_line
protected:
#pragma empty_line
virtual
~numpunct();
#pragma line 1818 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma line 1830 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma line 1843 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma line 1856 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma line 1869 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma empty_line
#pragma empty_line
void
_M_initialize_numpunct(__c_locale __cloc = 0);
};
#pragma empty_line
template<typename _CharT>
locale::id numpunct<_CharT>::id;
#pragma empty_line
template<>
numpunct<char>::~numpunct();
#pragma empty_line
template<>
void
numpunct<char>::_M_initialize_numpunct(__c_locale __cloc);
#pragma empty_line
#pragma empty_line
template<>
numpunct<wchar_t>::~numpunct();
#pragma empty_line
template<>
void
numpunct<wchar_t>::_M_initialize_numpunct(__c_locale __cloc);
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _CharT>
class numpunct_byname : public numpunct<_CharT>
{
public:
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;
#pragma empty_line
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);
}
}
#pragma empty_line
#pragma empty_line
explicit
numpunct_byname(const string& __s, size_t __refs = 0)
: numpunct_byname(__s.c_str(), __refs) { }
#pragma empty_line
#pragma empty_line
protected:
virtual
~numpunct_byname() { }
};
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma line 1947 "/home/justin/jhai/Xilinx/Vivado/2018.3/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:
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef _CharT char_type;
typedef _InIter iter_type;
#pragma empty_line
#pragma empty_line
#pragma empty_line
static locale::id id;
#pragma line 1968 "/home/justin/jhai/Xilinx/Vivado/2018.3/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) { }
#pragma line 1994 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 2031 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
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); }
#pragma empty_line
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); }
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
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); }
#pragma line 2091 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
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); }
#pragma empty_line
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); }
#pragma line 2134 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
protected:
#pragma empty_line
virtual ~num_get() { }
#pragma empty_line
__attribute ((__abi_tag__ ("cxx11")))
iter_type
_M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&,
string&) const;
#pragma empty_line
template<typename _ValueT>
__attribute ((__abi_tag__ ("cxx11")))
iter_type
_M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&,
_ValueT&) const;
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma line 2207 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
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); }
#pragma empty_line
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); }
#pragma empty_line
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); }
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
virtual iter_type
do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, float&) const;
#pragma empty_line
virtual iter_type
do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
double&) const;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
virtual iter_type
do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
long double&) const;
#pragma empty_line
#pragma empty_line
virtual iter_type
do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, void*&) const;
#pragma line 2270 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 3
};
#pragma empty_line
template<typename _CharT, typename _InIter>
locale::id num_get<_CharT, _InIter>::id;
#pragma line 2288 "/home/justin/jhai/Xilinx/Vivado/2018.3/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:
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef _CharT char_type;
typedef _OutIter iter_type;
#pragma empty_line
#pragma empty_line
#pragma empty_line
static locale::id id;
#pragma line 2309 "/home/justin/jhai/Xilinx/Vivado/2018.3/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) { }
#pragma line 2327 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 2369 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
iter_type
put(iter_type __s, ios_base& __io, char_type __fill,
unsigned long __v) const
{ return this->do_put(__s, __io, __fill, __v); }
#pragma empty_line
#pragma empty_line
iter_type
put(iter_type __s, ios_base& __io, char_type __fill, long long __v) const
{ return this->do_put(__s, __io, __fill, __v); }
#pragma empty_line
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); }
#pragma line 2432 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
iter_type
put(iter_type __s, ios_base& __io, char_type __fill,
long double __v) const
{ return this->do_put(__s, __io, __fill, __v); }
#pragma line 2457 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
protected:
template<typename _ValueT>
iter_type
_M_insert_float(iter_type, ios_base& __io, char_type __fill,
char __mod, _ValueT __v) const;
#pragma empty_line
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;
#pragma empty_line
template<typename _ValueT>
iter_type
_M_insert_int(iter_type, ios_base& __io, char_type __fill,
_ValueT __v) const;
#pragma empty_line
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;
#pragma empty_line
void
_M_pad(char_type __fill, streamsize __w, ios_base& __io,
char_type* __new, const char_type* __cs, int& __len) const;
#pragma empty_line
#pragma empty_line
virtual
~num_put() { };
#pragma line 2505 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
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); }
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
virtual iter_type
do_put(iter_type, ios_base&, char_type, double) const;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
virtual iter_type
do_put(iter_type, ios_base&, char_type, long double) const;
#pragma empty_line
#pragma empty_line
virtual iter_type
do_put(iter_type, ios_base&, char_type, const void*) const;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
};
#pragma empty_line
template <typename _CharT, typename _OutIter>
locale::id num_put<_CharT, _OutIter>::id;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _CharT>
inline bool
isspace(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c); }
#pragma empty_line
#pragma empty_line
template<typename _CharT>
inline bool
isprint(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c); }
#pragma empty_line
#pragma empty_line
template<typename _CharT>
inline bool
iscntrl(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c); }
#pragma empty_line
#pragma empty_line
template<typename _CharT>
inline bool
isupper(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c); }
#pragma empty_line
#pragma empty_line
template<typename _CharT>
inline bool
islower(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c); }
#pragma empty_line
#pragma empty_line
template<typename _CharT>
inline bool
isalpha(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c); }
#pragma empty_line
#pragma empty_line
template<typename _CharT>
inline bool
isdigit(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c); }
#pragma empty_line
#pragma empty_line
template<typename _CharT>
inline bool
ispunct(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c); }
#pragma empty_line
#pragma empty_line
template<typename _CharT>
inline bool
isxdigit(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c); }
#pragma empty_line
#pragma empty_line
template<typename _CharT>
inline bool
isalnum(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c); }
#pragma empty_line
#pragma empty_line
template<typename _CharT>
inline bool
isgraph(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _CharT>
inline bool
isblank(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::blank, __c); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _CharT>
inline _CharT
toupper(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).toupper(__c); }
#pragma empty_line
#pragma empty_line
template<typename _CharT>
inline _CharT
tolower(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).tolower(__c); }
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.tcc" 1 3
#pragma line 33 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.tcc" 3
#pragma empty_line
#pragma line 34 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.tcc" 3
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Facet>
struct __use_cache
{
const _Facet*
operator() (const locale& __loc) const;
};
#pragma empty_line
#pragma empty_line
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]);
}
};
#pragma empty_line
template<typename _CharT>
void
__numpunct_cache<_CharT>::_M_cache(const locale& __loc)
{
const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
#pragma empty_line
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));
#pragma empty_line
const basic_string<_CharT>& __tn = __np.truename();
_M_truename_size = __tn.size();
__truename = new _CharT[_M_truename_size];
__tn.copy(__truename, _M_truename_size);
#pragma empty_line
const basic_string<_CharT>& __fn = __np.falsename();
_M_falsename_size = __fn.size();
__falsename = new _CharT[_M_falsename_size];
__fn.copy(__falsename, _M_falsename_size);
#pragma empty_line
_M_decimal_point = __np.decimal_point();
_M_thousands_sep = __np.thousands_sep();
#pragma empty_line
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);
#pragma empty_line
_M_grouping = __grouping;
_M_truename = __truename;
_M_falsename = __falsename;
_M_allocated = true;
}
catch(...)
{
delete [] __grouping;
delete [] __truename;
delete [] __falsename;
throw;
}
}
#pragma line 139 "/home/justin/jhai/Xilinx/Vivado/2018.3/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 ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
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();
#pragma empty_line
#pragma empty_line
bool __testeof = __beg == __end;
#pragma empty_line
#pragma empty_line
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;
}
}
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
if (++__beg != __end)
__c = *__beg;
else
__testeof = true;
}
else
break;
}
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
if (!__lc->_M_allocated)
#pragma empty_line
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)
{
#pragma empty_line
__xtrc += 'e';
__found_sci = true;
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
if (++__beg != __end)
__c = *__beg;
else
__testeof = true;
}
else
while (!__testeof)
{
#pragma empty_line
#pragma empty_line
if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
{
if (!__found_dec && !__found_sci)
{
#pragma empty_line
#pragma empty_line
if (__sep_pos)
{
__found_grouping += static_cast<char>(__sep_pos);
__sep_pos = 0;
}
else
{
#pragma empty_line
#pragma empty_line
__xtrc.clear();
break;
}
}
else
break;
}
else if (__c == __lc->_M_decimal_point)
{
if (!__found_dec && !__found_sci)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
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)
{
#pragma empty_line
if (__found_grouping.size() && !__found_dec)
__found_grouping += static_cast<char>(__sep_pos);
__xtrc += 'e';
__found_sci = true;
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
if (++__beg != __end)
__c = *__beg;
else
__testeof = true;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
if (__found_grouping.size())
{
#pragma empty_line
if (!__found_dec && !__found_sci)
__found_grouping += static_cast<char>(__sep_pos);
#pragma empty_line
if (!std::__verify_grouping(__lc->_M_grouping,
__lc->_M_grouping_size,
__found_grouping))
__err = ios_base::failbit;
}
#pragma empty_line
return __beg;
}
#pragma empty_line
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();
#pragma empty_line
#pragma empty_line
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);
#pragma empty_line
#pragma empty_line
bool __testeof = __beg == __end;
#pragma empty_line
#pragma empty_line
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;
}
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
if (++__beg != __end)
{
__c = *__beg;
if (!__found_zero)
break;
}
else
__testeof = true;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
const size_t __len = (__base == 16 ? __num_base::_S_iend
- __num_base::_S_izero : __base);
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
if (!__lc->_M_allocated)
#pragma empty_line
while (!__testeof)
{
__digit = _M_find(__lit_zero, __len, __c);
if (__digit == -1)
break;
#pragma empty_line
if (__result > __smax)
__testoverflow = true;
else
{
__result *= __base;
__testoverflow |= __result > __max - __digit;
__result += __digit;
++__sep_pos;
}
#pragma empty_line
if (++__beg != __end)
__c = *__beg;
else
__testeof = true;
}
else
while (!__testeof)
{
#pragma empty_line
#pragma empty_line
if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
{
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
__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;
}
}
#pragma empty_line
if (++__beg != __end)
__c = *__beg;
else
__testeof = true;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
if (__found_grouping.size())
{
#pragma empty_line
__found_grouping += static_cast<char>(__sep_pos);
#pragma empty_line
if (!std::__verify_grouping(__lc->_M_grouping,
__lc->_M_grouping_size,
__found_grouping))
__err = ios_base::failbit;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
if (__testeof)
__err |= ios_base::eofbit;
return __beg;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
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))
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
long __l = -1;
__beg = _M_extract_int(__beg, __end, __io, __err, __l);
if (__l == 0 || __l == 1)
__v = bool(__l);
else
{
#pragma empty_line
#pragma empty_line
__v = true;
__err = ios_base::failbit;
if (__beg == __end)
__err |= ios_base::eofbit;
}
}
else
{
#pragma empty_line
typedef __numpunct_cache<_CharT> __cache_type;
__use_cache<__cache_type> __uc;
const locale& __loc = __io._M_getloc();
const __cache_type* __lc = __uc(__loc);
#pragma empty_line
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;
}
#pragma empty_line
const char_type __c = *__beg;
#pragma empty_line
if (!__donef)
__testf = __c == __lc->_M_falsename[__n];
#pragma empty_line
if (!__testf && __donet)
break;
#pragma empty_line
if (!__donet)
__testt = __c == __lc->_M_truename[__n];
#pragma empty_line
if (!__testt && __donef)
break;
#pragma empty_line
if (!__testt && !__testf)
break;
#pragma empty_line
++__n;
++__beg;
#pragma empty_line
__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
{
#pragma empty_line
#pragma empty_line
__v = false;
__err = ios_base::failbit;
if (__testeof)
__err |= ios_base::eofbit;
}
}
return __beg;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma line 735 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma empty_line
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
{
#pragma empty_line
typedef ios_base::fmtflags fmtflags;
const fmtflags __fmt = __io.flags();
__io.flags((__fmt & ~ios_base::basefield) | ios_base::hex);
#pragma empty_line
typedef __gnu_cxx::__conditional_type<(sizeof(void*)
<= sizeof(unsigned long)),
unsigned long, unsigned long long>::__type _UIntPtrType;
#pragma empty_line
_UIntPtrType __ul;
__beg = _M_extract_int(__beg, __end, __io, __err, __ul);
#pragma empty_line
#pragma empty_line
__io.flags(__fmt);
#pragma empty_line
__v = reinterpret_cast<void*>(__ul);
return __beg;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
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
{
#pragma empty_line
#pragma empty_line
__pad<_CharT, char_traits<_CharT> >::_S_pad(__io, __fill, __new,
__cs, __w, __len);
__len = static_cast<int>(__w);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
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))
{
#pragma empty_line
do
{
*--__buf = __lit[(__v % 10) + __num_base::_S_odigits];
__v /= 10;
}
while (__v != 0);
}
else if ((__flags & ios_base::basefield) == ios_base::oct)
{
#pragma empty_line
do
{
*--__buf = __lit[(__v & 0x7) + __num_base::_S_odigits];
__v >>= 3;
}
while (__v != 0);
}
else
{
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
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();
#pragma empty_line
#pragma empty_line
const int __ilen = 5 * sizeof(_ValueT);
_CharT* __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
* __ilen));
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
if (__lc->_M_use_grouping)
{
#pragma empty_line
#pragma empty_line
_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;
}
#pragma empty_line
#pragma empty_line
if (__builtin_expect(__dec, true))
{
#pragma empty_line
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
{
#pragma empty_line
const bool __uppercase = __flags & ios_base::uppercase;
*--__cs = __lit[__num_base::_S_ox + __uppercase];
#pragma empty_line
*--__cs = __lit[__num_base::_S_odigits];
__len += 2;
}
}
#pragma empty_line
#pragma empty_line
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);
#pragma empty_line
#pragma empty_line
#pragma empty_line
return std::__write(__s, __cs, __len);
}
#pragma empty_line
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
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
const int __declen = __p ? __p - __cs : __len;
_CharT* __p2 = std::__add_grouping(__new, __sep, __grouping,
__grouping_size,
__cs, __cs + __declen);
#pragma empty_line
#pragma empty_line
int __newlen = __p2 - __new;
if (__p)
{
char_traits<_CharT>::copy(__p2, __p, __len - __declen);
__newlen += __len - __declen;
}
__len = __newlen;
}
#pragma line 971 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
#pragma empty_line
#pragma empty_line
const streamsize __prec = __io.precision() < 0 ? 6 : __io.precision();
#pragma empty_line
const int __max_digits =
__gnu_cxx::__numeric_traits<_ValueT>::__digits10;
#pragma empty_line
#pragma empty_line
int __len;
#pragma empty_line
char __fbuf[16];
__num_base::_S_format_float(__io, __fbuf, __mod);
#pragma empty_line
#pragma empty_line
#pragma empty_line
const bool __use_prec =
(__io.flags() & ios_base::floatfield) != ios_base::floatfield;
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
#pragma empty_line
#pragma empty_line
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);
}
#pragma line 1044 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
#pragma empty_line
_CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
* __len));
__ctype.widen(__cs, __cs + __len, __ws);
#pragma empty_line
#pragma empty_line
_CharT* __wp = 0;
const char* __p = char_traits<char>::find(__cs, __len, '.');
if (__p)
{
__wp = __ws + (__p - __cs);
*__wp = __lc->_M_decimal_point;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
if (__lc->_M_use_grouping
&& (__wp || __len < 3 || (__cs[1] <= '9' && __cs[2] <= '9'
&& __cs[1] >= '0' && __cs[2] >= '0')))
{
#pragma empty_line
#pragma empty_line
_CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
* __len * 2));
#pragma empty_line
streamsize __off = 0;
if (__cs[0] == '-' || __cs[0] == '+')
{
__off = 1;
__ws2[0] = __ws[0];
__len -= 1;
}
#pragma empty_line
_M_group_float(__lc->_M_grouping, __lc->_M_grouping_size,
__lc->_M_thousands_sep, __wp, __ws2 + __off,
__ws + __off, __len);
__len += __off;
#pragma empty_line
__ws = __ws2;
}
#pragma empty_line
#pragma empty_line
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);
#pragma empty_line
#pragma empty_line
#pragma empty_line
return std::__write(__s, __ws, __len);
}
#pragma empty_line
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);
#pragma empty_line
const _CharT* __name = __v ? __lc->_M_truename
: __lc->_M_falsename;
int __len = __v ? __lc->_M_truename_size
: __lc->_M_falsename_size;
#pragma empty_line
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));
#pragma empty_line
char_traits<_CharT>::assign(__ps, __plen, __fill);
__io.width(0);
#pragma empty_line
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;
}
#pragma empty_line
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); }
#pragma line 1169 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
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));
#pragma empty_line
typedef __gnu_cxx::__conditional_type<(sizeof(const void*)
<= sizeof(unsigned long)),
unsigned long, unsigned long long>::__type _UIntPtrType;
#pragma empty_line
__s = _M_insert_int(__s, __io, __fill,
reinterpret_cast<_UIntPtrType>(__v));
__io.flags(__flags);
return __s;
}
#pragma empty_line
#pragma empty_line
#pragma line 1206 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
#pragma empty_line
if (__adjust == ios_base::left)
{
_Traits::copy(__news, __olds, __oldlen);
_Traits::assign(__news + __oldlen, __plen, __fill);
return;
}
#pragma empty_line
size_t __mod = 0;
if (__adjust == ios_base::internal)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
const locale& __loc = __io._M_getloc();
const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
#pragma empty_line
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;
}
#pragma empty_line
}
_Traits::assign(__news, __plen, __fill);
_Traits::copy(__news + __plen, __olds + __mod, __oldlen - __mod);
}
#pragma empty_line
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;
#pragma empty_line
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;
}
#pragma empty_line
while (__first != __last)
*__s++ = *__first++;
#pragma empty_line
while (__ctr--)
{
*__s++ = __sep;
for (char __i = __gbeg[__idx]; __i > 0; --__i)
*__s++ = *__first++;
}
#pragma empty_line
while (__idx--)
{
*__s++ = __sep;
for (char __i = __gbeg[__idx]; __i > 0; --__i)
*__s++ = *__first++;
}
#pragma empty_line
return __s;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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>;
#pragma empty_line
extern template
const ctype<char>&
use_facet<ctype<char> >(const locale&);
#pragma empty_line
extern template
const numpunct<char>&
use_facet<numpunct<char> >(const locale&);
#pragma empty_line
extern template
const num_put<char>&
use_facet<num_put<char> >(const locale&);
#pragma empty_line
extern template
const num_get<char>&
use_facet<num_get<char> >(const locale&);
#pragma empty_line
extern template
bool
has_facet<ctype<char> >(const locale&);
#pragma empty_line
extern template
bool
has_facet<numpunct<char> >(const locale&);
#pragma empty_line
extern template
bool
has_facet<num_put<char> >(const locale&);
#pragma empty_line
extern template
bool
has_facet<num_get<char> >(const locale&);
#pragma empty_line
#pragma empty_line
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>;
#pragma empty_line
extern template
const ctype<wchar_t>&
use_facet<ctype<wchar_t> >(const locale&);
#pragma empty_line
extern template
const numpunct<wchar_t>&
use_facet<numpunct<wchar_t> >(const locale&);
#pragma empty_line
extern template
const num_put<wchar_t>&
use_facet<num_put<wchar_t> >(const locale&);
#pragma empty_line
extern template
const num_get<wchar_t>&
use_facet<num_get<wchar_t> >(const locale&);
#pragma empty_line
extern template
bool
has_facet<ctype<wchar_t> >(const locale&);
#pragma empty_line
extern template
bool
has_facet<numpunct<wchar_t> >(const locale&);
#pragma empty_line
extern template
bool
has_facet<num_put<wchar_t> >(const locale&);
#pragma empty_line
extern template
bool
has_facet<num_get<wchar_t> >(const locale&);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 2652 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets.h" 2 3
#pragma line 38 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_ios.h" 2 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
template<typename _Facet>
inline const _Facet&
__check_facet(const _Facet* __f)
{
if (!__f)
__throw_bad_cast();
return *__f;
}
#pragma line 66 "/home/justin/jhai/Xilinx/Vivado/2018.3/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:
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
#pragma empty_line
protected:
basic_ostream<_CharT, _Traits>* _M_tie;
mutable char_type _M_fill;
mutable bool _M_fill_init;
basic_streambuf<_CharT, _Traits>* _M_streambuf;
#pragma empty_line
#pragma empty_line
const __ctype_type* _M_ctype;
#pragma empty_line
const __num_put_type* _M_num_put;
#pragma empty_line
const __num_get_type* _M_num_get;
#pragma empty_line
public:
#pragma line 117 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_ios.h" 3
explicit operator bool() const
{ return !this->fail(); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
bool
operator!() const
{ return this->fail(); }
#pragma line 136 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_ios.h" 3
iostate
rdstate() const
{ return _M_streambuf_state; }
#pragma line 147 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_ios.h" 3
void
clear(iostate __state = goodbit);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
void
setstate(iostate __state)
{ this->clear(this->rdstate() | __state); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
void
_M_setstate(iostate __state)
{
#pragma empty_line
#pragma empty_line
_M_streambuf_state |= __state;
if (this->exceptions() & __state)
throw;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
bool
good() const
{ return this->rdstate() == 0; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
bool
eof() const
{ return (this->rdstate() & eofbit) != 0; }
#pragma line 200 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
bool
bad() const
{ return (this->rdstate() & badbit) != 0; }
#pragma line 221 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_ios.h" 3
iostate
exceptions() const
{ return _M_exception; }
#pragma line 256 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
virtual
~basic_ios() { }
#pragma line 294 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma line 306 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
basic_streambuf<_CharT, _Traits>*
rdbuf() const
{ return _M_streambuf; }
#pragma line 346 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
#pragma line 360 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_ios.h" 3
basic_ios&
copyfmt(const basic_ios& __rhs);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
char_type
fill() const
{
if (!_M_fill_init)
{
_M_fill = this->widen(' ');
_M_fill_init = true;
}
return _M_fill;
}
#pragma line 389 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma line 409 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_ios.h" 3
locale
imbue(const locale& __loc);
#pragma line 429 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 448 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
protected:
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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)
{ }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
void
init(basic_streambuf<_CharT, _Traits>* __sb);
#pragma empty_line
#pragma empty_line
basic_ios(const basic_ios&) = delete;
basic_ios& operator=(const basic_ios&) = delete;
#pragma empty_line
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;
}
#pragma empty_line
void
move(basic_ios&& __rhs)
{ this->move(__rhs); }
#pragma empty_line
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);
}
#pragma empty_line
void
set_rdbuf(basic_streambuf<_CharT, _Traits>* __sb)
{ _M_streambuf = __sb; }
#pragma empty_line
#pragma empty_line
void
_M_cache_locale(const locale& __loc);
};
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_ios.tcc" 1 3
#pragma line 33 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_ios.tcc" 3
#pragma empty_line
#pragma line 34 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_ios.tcc" 3
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
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"));
}
#pragma empty_line
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;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_ios<_CharT, _Traits>&
basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs)
{
#pragma empty_line
#pragma empty_line
if (this != &__rhs)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
_Words* __words = (__rhs._M_word_size <= _S_local_word_size) ?
_M_local_word : new _Words[__rhs._M_word_size];
#pragma empty_line
#pragma empty_line
_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();
#pragma empty_line
#pragma empty_line
_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;
#pragma empty_line
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);
#pragma empty_line
_M_call_callbacks(copyfmt_event);
#pragma empty_line
#pragma empty_line
this->exceptions(__rhs.exceptions());
}
return *this;
}
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
void
basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __sb)
{
#pragma empty_line
ios_base::_M_init();
#pragma empty_line
#pragma empty_line
_M_cache_locale(_M_ios_locale);
#pragma line 146 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_ios.tcc" 3
_M_fill = _CharT();
_M_fill_init = false;
#pragma empty_line
_M_tie = 0;
_M_exception = goodbit;
_M_streambuf = __sb;
_M_streambuf_state = __sb ? goodbit : badbit;
}
#pragma empty_line
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;
#pragma empty_line
if (__builtin_expect(has_facet<__num_put_type>(__loc), true))
_M_num_put = &use_facet<__num_put_type>(__loc);
else
_M_num_put = 0;
#pragma empty_line
if (__builtin_expect(has_facet<__num_get_type>(__loc), true))
_M_num_get = &use_facet<__num_get_type>(__loc);
else
_M_num_get = 0;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern template class basic_ios<char>;
#pragma empty_line
#pragma empty_line
extern template class basic_ios<wchar_t>;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 517 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/basic_ios.h" 2 3
#pragma line 45 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ios" 2 3
#pragma line 39 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 2 3
#pragma empty_line
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma line 57 "/home/justin/jhai/Xilinx/Vivado/2018.3/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:
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
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;
#pragma line 83 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 3
explicit
basic_ostream(__streambuf_type* __sb)
{ this->init(__sb); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
virtual
~basic_ostream() { }
#pragma empty_line
#pragma empty_line
class sentry;
friend class sentry;
#pragma line 107 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 3
__ostream_type&
operator<<(__ostream_type& (*__pf)(__ostream_type&))
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
return __pf(*this);
}
#pragma empty_line
__ostream_type&
operator<<(__ios_type& (*__pf)(__ios_type&))
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
__pf(*this);
return *this;
}
#pragma empty_line
__ostream_type&
operator<<(ios_base& (*__pf) (ios_base&))
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
__pf(*this);
return *this;
}
#pragma line 165 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 3
__ostream_type&
operator<<(long __n)
{ return _M_insert(__n); }
#pragma empty_line
__ostream_type&
operator<<(unsigned long __n)
{ return _M_insert(__n); }
#pragma empty_line
__ostream_type&
operator<<(bool __n)
{ return _M_insert(__n); }
#pragma empty_line
__ostream_type&
operator<<(short __n);
#pragma empty_line
__ostream_type&
operator<<(unsigned short __n)
{
#pragma empty_line
#pragma empty_line
return _M_insert(static_cast<unsigned long>(__n));
}
#pragma empty_line
__ostream_type&
operator<<(int __n);
#pragma empty_line
__ostream_type&
operator<<(unsigned int __n)
{
#pragma empty_line
#pragma empty_line
return _M_insert(static_cast<unsigned long>(__n));
}
#pragma empty_line
#pragma empty_line
__ostream_type&
operator<<(long long __n)
{ return _M_insert(__n); }
#pragma empty_line
__ostream_type&
operator<<(unsigned long long __n)
{ return _M_insert(__n); }
#pragma line 219 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 3
__ostream_type&
operator<<(double __f)
{ return _M_insert(__f); }
#pragma empty_line
__ostream_type&
operator<<(float __f)
{
#pragma empty_line
#pragma empty_line
return _M_insert(static_cast<double>(__f));
}
#pragma empty_line
__ostream_type&
operator<<(long double __f)
{ return _M_insert(__f); }
#pragma line 244 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 3
__ostream_type&
operator<<(const void* __p)
{ return _M_insert(__p); }
#pragma line 269 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 3
__ostream_type&
operator<<(__streambuf_type* __sb);
#pragma line 302 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 3
__ostream_type&
put(char_type __c);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
}
#pragma line 334 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 3
__ostream_type&
write(const char_type* __s, streamsize __n);
#pragma line 347 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 3
__ostream_type&
flush();
#pragma line 357 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 3
pos_type
tellp();
#pragma line 368 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 3
__ostream_type&
seekp(pos_type);
#pragma line 380 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 3
__ostream_type&
seekp(off_type, ios_base::seekdir);
#pragma empty_line
protected:
basic_ostream()
{ this->init(0); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
basic_ostream(basic_iostream<_CharT, _Traits>&) { }
#pragma empty_line
basic_ostream(const basic_ostream&) = delete;
#pragma empty_line
basic_ostream(basic_ostream&& __rhs)
: __ios_type()
{ __ios_type::move(__rhs); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
basic_ostream& operator=(const basic_ostream&) = delete;
#pragma empty_line
basic_ostream&
operator=(basic_ostream&& __rhs)
{
swap(__rhs);
return *this;
}
#pragma empty_line
void
swap(basic_ostream& __rhs)
{ __ios_type::swap(__rhs); }
#pragma empty_line
#pragma empty_line
template<typename _ValueT>
__ostream_type&
_M_insert(_ValueT __v);
};
#pragma line 425 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 3
template <typename _CharT, typename _Traits>
class basic_ostream<_CharT, _Traits>::sentry
{
#pragma empty_line
bool _M_ok;
basic_ostream<_CharT, _Traits>& _M_os;
#pragma empty_line
public:
#pragma line 444 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 3
explicit
sentry(basic_ostream<_CharT, _Traits>& __os);
#pragma line 454 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 3
~sentry()
{
#pragma empty_line
if (bool(_M_os.flags() & ios_base::unitbuf) && !uncaught_exception())
{
#pragma empty_line
if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() == -1)
_M_os.setstate(ios_base::badbit);
}
}
#pragma line 473 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 3
explicit
#pragma empty_line
operator bool() const
{ return _M_ok; }
};
#pragma line 495 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
template<typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __out, char __c)
{ return (__out << __out.widen(__c)); }
#pragma empty_line
#pragma empty_line
template <class _Traits>
inline basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, char __c)
{ return __ostream_insert(__out, &__c, 1); }
#pragma empty_line
#pragma empty_line
template<class _Traits>
inline basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, signed char __c)
{ return (__out << static_cast<char>(__c)); }
#pragma empty_line
template<class _Traits>
inline basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c)
{ return (__out << static_cast<char>(__c)); }
#pragma line 537 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits> &
operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s);
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
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)); }
#pragma empty_line
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)); }
#pragma line 588 "/home/justin/jhai/Xilinx/Vivado/2018.3/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'))); }
#pragma line 600 "/home/justin/jhai/Xilinx/Vivado/2018.3/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()); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits>&
flush(basic_ostream<_CharT, _Traits>& __os)
{ return __os.flush(); }
#pragma line 626 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ostream.tcc" 1 3
#pragma line 37 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ostream.tcc" 3
#pragma empty_line
#pragma line 38 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/ostream.tcc" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>::sentry::
sentry(basic_ostream<_CharT, _Traits>& __os)
: _M_ok(false), _M_os(__os)
{
#pragma empty_line
if (__os.tie() && __os.good())
__os.tie()->flush();
#pragma empty_line
if (__os.good())
_M_ok = true;
else
__os.setstate(ios_base::failbit);
}
#pragma empty_line
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;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::
operator<<(short __n)
{
#pragma empty_line
#pragma empty_line
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));
}
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::
operator<<(int __n)
{
#pragma empty_line
#pragma empty_line
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));
}
#pragma empty_line
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;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::
put(char_type __c)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::
write(const _CharT* __s, streamsize __n)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::
flush()
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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())
{
#pragma empty_line
#pragma empty_line
const pos_type __p = this->rdbuf()->pubseekpos(__pos,
ios_base::out);
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
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())
{
#pragma empty_line
#pragma empty_line
const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
ios_base::out);
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
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
{
#pragma empty_line
#pragma empty_line
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]);
#pragma empty_line
_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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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*);
#pragma empty_line
extern template ostream& ostream::_M_insert(long);
extern template ostream& ostream::_M_insert(unsigned long);
extern template ostream& ostream::_M_insert(bool);
#pragma empty_line
extern template ostream& ostream::_M_insert(long long);
extern template ostream& ostream::_M_insert(unsigned long long);
#pragma empty_line
extern template ostream& ostream::_M_insert(double);
extern template ostream& ostream::_M_insert(long double);
extern template ostream& ostream::_M_insert(const void*);
#pragma empty_line
#pragma empty_line
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*);
#pragma empty_line
extern template wostream& wostream::_M_insert(long);
extern template wostream& wostream::_M_insert(unsigned long);
extern template wostream& wostream::_M_insert(bool);
#pragma empty_line
extern template wostream& wostream::_M_insert(long long);
extern template wostream& wostream::_M_insert(unsigned long long);
#pragma empty_line
extern template wostream& wostream::_M_insert(double);
extern template wostream& wostream::_M_insert(long double);
extern template wostream& wostream::_M_insert(const void*);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 639 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ostream" 2 3
#pragma line 40 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iostream" 2 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 1 3
#pragma line 36 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
#pragma empty_line
#pragma line 37 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma line 57 "/home/justin/jhai/Xilinx/Vivado/2018.3/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:
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
protected:
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
streamsize _M_gcount;
#pragma empty_line
public:
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
explicit
basic_istream(__streambuf_type* __sb)
: _M_gcount(streamsize(0))
{ this->init(__sb); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
virtual
~basic_istream()
{ _M_gcount = streamsize(0); }
#pragma empty_line
#pragma empty_line
class sentry;
friend class sentry;
#pragma line 119 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
__istream_type&
operator>>(__istream_type& (*__pf)(__istream_type&))
{ return __pf(*this); }
#pragma empty_line
__istream_type&
operator>>(__ios_type& (*__pf)(__ios_type&))
{
__pf(*this);
return *this;
}
#pragma empty_line
__istream_type&
operator>>(ios_base& (*__pf)(ios_base&))
{
__pf(*this);
return *this;
}
#pragma line 167 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
__istream_type&
operator>>(bool& __n)
{ return _M_extract(__n); }
#pragma empty_line
__istream_type&
operator>>(short& __n);
#pragma empty_line
__istream_type&
operator>>(unsigned short& __n)
{ return _M_extract(__n); }
#pragma empty_line
__istream_type&
operator>>(int& __n);
#pragma empty_line
__istream_type&
operator>>(unsigned int& __n)
{ return _M_extract(__n); }
#pragma empty_line
__istream_type&
operator>>(long& __n)
{ return _M_extract(__n); }
#pragma empty_line
__istream_type&
operator>>(unsigned long& __n)
{ return _M_extract(__n); }
#pragma empty_line
#pragma empty_line
__istream_type&
operator>>(long long& __n)
{ return _M_extract(__n); }
#pragma empty_line
__istream_type&
operator>>(unsigned long long& __n)
{ return _M_extract(__n); }
#pragma line 213 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
__istream_type&
operator>>(float& __f)
{ return _M_extract(__f); }
#pragma empty_line
__istream_type&
operator>>(double& __f)
{ return _M_extract(__f); }
#pragma empty_line
__istream_type&
operator>>(long double& __f)
{ return _M_extract(__f); }
#pragma line 234 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
__istream_type&
operator>>(void*& __p)
{ return _M_extract(__p); }
#pragma line 258 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
__istream_type&
operator>>(__streambuf_type* __sb);
#pragma line 268 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
streamsize
gcount() const
{ return _M_gcount; }
#pragma line 301 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
int_type
get();
#pragma line 315 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
__istream_type&
get(char_type& __c);
#pragma line 342 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
__istream_type&
get(char_type* __s, streamsize __n, char_type __delim);
#pragma line 353 "/home/justin/jhai/Xilinx/Vivado/2018.3/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')); }
#pragma line 376 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
__istream_type&
get(__streambuf_type& __sb, char_type __delim);
#pragma line 386 "/home/justin/jhai/Xilinx/Vivado/2018.3/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')); }
#pragma line 415 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
__istream_type&
getline(char_type* __s, streamsize __n, char_type __delim);
#pragma line 426 "/home/justin/jhai/Xilinx/Vivado/2018.3/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')); }
#pragma line 450 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
__istream_type&
ignore(streamsize __n, int_type __delim);
#pragma empty_line
__istream_type&
ignore(streamsize __n);
#pragma empty_line
__istream_type&
ignore();
#pragma line 467 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
int_type
peek();
#pragma line 485 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
__istream_type&
read(char_type* __s, streamsize __n);
#pragma line 504 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
streamsize
readsome(char_type* __s, streamsize __n);
#pragma line 521 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
__istream_type&
putback(char_type __c);
#pragma line 537 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
__istream_type&
unget();
#pragma line 555 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
int
sync();
#pragma line 570 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
pos_type
tellg();
#pragma line 585 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
__istream_type&
seekg(pos_type);
#pragma line 601 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
__istream_type&
seekg(off_type, ios_base::seekdir);
#pragma empty_line
#pragma empty_line
protected:
basic_istream()
: _M_gcount(streamsize(0))
{ this->init(0); }
#pragma empty_line
#pragma empty_line
basic_istream(const basic_istream&) = delete;
#pragma empty_line
basic_istream(basic_istream&& __rhs)
: __ios_type(), _M_gcount(__rhs._M_gcount)
{
__ios_type::move(__rhs);
__rhs._M_gcount = 0;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
basic_istream& operator=(const basic_istream&) = delete;
#pragma empty_line
basic_istream&
operator=(basic_istream&& __rhs)
{
swap(__rhs);
return *this;
}
#pragma empty_line
void
swap(basic_istream& __rhs)
{
__ios_type::swap(__rhs);
std::swap(_M_gcount, __rhs._M_gcount);
}
#pragma empty_line
#pragma empty_line
template<typename _ValueT>
__istream_type&
_M_extract(_ValueT& __v);
};
#pragma empty_line
#pragma empty_line
template<>
basic_istream<char>&
basic_istream<char>::
getline(char_type* __s, streamsize __n, char_type __delim);
#pragma empty_line
template<>
basic_istream<char>&
basic_istream<char>::
ignore(streamsize __n);
#pragma empty_line
template<>
basic_istream<char>&
basic_istream<char>::
ignore(streamsize __n, int_type __delim);
#pragma empty_line
#pragma empty_line
template<>
basic_istream<wchar_t>&
basic_istream<wchar_t>::
getline(char_type* __s, streamsize __n, char_type __delim);
#pragma empty_line
template<>
basic_istream<wchar_t>&
basic_istream<wchar_t>::
ignore(streamsize __n);
#pragma empty_line
template<>
basic_istream<wchar_t>&
basic_istream<wchar_t>::
ignore(streamsize __n, int_type __delim);
#pragma line 685 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
template<typename _CharT, typename _Traits>
class basic_istream<_CharT, _Traits>::sentry
{
#pragma empty_line
bool _M_ok;
#pragma empty_line
public:
#pragma empty_line
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;
#pragma line 721 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
explicit
sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
#pragma line 732 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 3
explicit
#pragma empty_line
operator bool() const
{ return _M_ok; }
};
#pragma line 750 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
#pragma empty_line
template<class _Traits>
inline basic_istream<char, _Traits>&
operator>>(basic_istream<char, _Traits>& __in, unsigned char& __c)
{ return (__in >> reinterpret_cast<char&>(__c)); }
#pragma empty_line
template<class _Traits>
inline basic_istream<char, _Traits>&
operator>>(basic_istream<char, _Traits>& __in, signed char& __c)
{ return (__in >> reinterpret_cast<char&>(__c)); }
#pragma line 792 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
#pragma empty_line
#pragma empty_line
template<>
basic_istream<char>&
operator>>(basic_istream<char>& __in, char* __s);
#pragma empty_line
template<class _Traits>
inline basic_istream<char, _Traits>&
operator>>(basic_istream<char, _Traits>& __in, unsigned char* __s)
{ return (__in >> reinterpret_cast<char*>(__s)); }
#pragma empty_line
template<class _Traits>
inline basic_istream<char, _Traits>&
operator>>(basic_istream<char, _Traits>& __in, signed char* __s)
{ return (__in >> reinterpret_cast<char*>(__s)); }
#pragma line 823 "/home/justin/jhai/Xilinx/Vivado/2018.3/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:
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef basic_ostream<_CharT, _Traits> __ostream_type;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
explicit
basic_iostream(basic_streambuf<_CharT, _Traits>* __sb)
: __istream_type(__sb), __ostream_type(__sb) { }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
virtual
~basic_iostream() { }
#pragma empty_line
protected:
basic_iostream()
: __istream_type(), __ostream_type() { }
#pragma empty_line
#pragma empty_line
basic_iostream(const basic_iostream&) = delete;
#pragma empty_line
basic_iostream(basic_iostream&& __rhs)
: __istream_type(std::move(__rhs)), __ostream_type(*this)
{ }
#pragma empty_line
#pragma empty_line
#pragma empty_line
basic_iostream& operator=(const basic_iostream&) = delete;
#pragma empty_line
basic_iostream&
operator=(basic_iostream&& __rhs)
{
swap(__rhs);
return *this;
}
#pragma empty_line
void
swap(basic_iostream& __rhs)
{ __istream_type::swap(__rhs); }
#pragma empty_line
};
#pragma line 906 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
#pragma line 922 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/istream.tcc" 1 3
#pragma line 37 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/istream.tcc" 3
#pragma empty_line
#pragma line 38 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/istream.tcc" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
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();
#pragma empty_line
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();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
if (traits_type::eq_int_type(__c, __eof))
__err |= ios_base::eofbit;
}
}
#pragma empty_line
if (__in.good() && __err == ios_base::goodbit)
_M_ok = true;
else
{
__err |= ios_base::failbit;
__in.setstate(__err);
}
}
#pragma empty_line
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;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
operator>>(short& __n)
{
#pragma empty_line
#pragma empty_line
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);
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
operator>>(int& __n)
{
#pragma empty_line
#pragma empty_line
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);
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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();
#pragma empty_line
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;
}
#pragma empty_line
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();
#pragma empty_line
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;
}
#pragma empty_line
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();
#pragma empty_line
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); }
}
#pragma empty_line
#pragma empty_line
if (__n > 0)
*__s = char_type();
if (!_M_gcount)
__err |= ios_base::failbit;
if (__err)
this->setstate(__err);
return *this;
}
#pragma empty_line
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);
#pragma empty_line
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;
}
#pragma empty_line
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();
#pragma empty_line
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); }
}
#pragma empty_line
#pragma empty_line
if (__n > 0)
*__s = char_type();
if (!_M_gcount)
__err |= ios_base::failbit;
if (__err)
this->setstate(__err);
return *this;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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();
#pragma empty_line
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;
}
#pragma empty_line
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();
#pragma line 513 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma empty_line
if (__large_ignore)
_M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
#pragma empty_line
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;
}
#pragma empty_line
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();
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
if (__large_ignore)
_M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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
{
#pragma empty_line
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;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
putback(char_type __c)
{
#pragma empty_line
#pragma empty_line
_M_gcount = 0;
#pragma empty_line
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;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
unget(void)
{
#pragma empty_line
#pragma empty_line
_M_gcount = 0;
#pragma empty_line
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;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
int
basic_istream<_CharT, _Traits>::
sync(void)
{
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
typename basic_istream<_CharT, _Traits>::pos_type
basic_istream<_CharT, _Traits>::
tellg(void)
{
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
seekg(pos_type __pos)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
this->clear(this->rdstate() & ~ios_base::eofbit);
sentry __cerb(*this, true);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
try
{
if (!this->fail())
{
#pragma empty_line
const pos_type __p = this->rdbuf()->pubseekpos(__pos,
ios_base::in);
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
seekg(off_type __off, ios_base::seekdir __dir)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
this->clear(this->rdstate() & ~ios_base::eofbit);
sentry __cerb(*this, true);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
try
{
if (!this->fail())
{
#pragma empty_line
const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
ios_base::in);
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
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;
}
#pragma empty_line
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;
#pragma empty_line
streamsize __extracted = 0;
ios_base::iostate __err = ios_base::goodbit;
typename __istream_type::sentry __cerb(__in, false);
if (__cerb)
{
try
{
#pragma empty_line
streamsize __num = __in.width();
if (__num <= 0)
__num = __gnu_cxx::__numeric_traits<streamsize>::__max;
#pragma empty_line
const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
#pragma empty_line
const int_type __eof = _Traits::eof();
__streambuf_type* __sb = __in.rdbuf();
int_type __c = __sb->sgetc();
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
#pragma empty_line
*__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;
}
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
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();
#pragma empty_line
while (!_Traits::eq_int_type(__c, __eof)
&& __ct.is(ctype_base::space, _Traits::to_char_type(__c)))
__c = __sb->snextc();
#pragma empty_line
if (_Traits::eq_int_type(__c, __eof))
__in.setstate(ios_base::eofbit);
return __in;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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*);
#pragma empty_line
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&);
#pragma empty_line
extern template istream& istream::_M_extract(long long&);
extern template istream& istream::_M_extract(unsigned long long&);
#pragma empty_line
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*&);
#pragma empty_line
extern template class basic_iostream<char>;
#pragma empty_line
#pragma empty_line
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*);
#pragma empty_line
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&);
#pragma empty_line
extern template wistream& wistream::_M_extract(long long&);
extern template wistream& wistream::_M_extract(unsigned long long&);
#pragma empty_line
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*&);
#pragma empty_line
extern template class basic_iostream<wchar_t>;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 935 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/istream" 2 3
#pragma line 41 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iostream" 2 3
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma line 60 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
#pragma empty_line
extern wistream wcin;
extern wostream wcout;
extern wostream wcerr;
extern wostream wclog;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static ios_base::Init __ioinit;
#pragma empty_line
#pragma empty_line
}
#pragma line 81 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_stream.h" 2
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/typeinfo" 1 3
#pragma line 32 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/typeinfo" 3
#pragma empty_line
#pragma line 33 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/typeinfo" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma GCC visibility push(default)
#pragma empty_line
extern "C++" {
#pragma empty_line
namespace __cxxabiv1
{
class __class_type_info;
}
#pragma line 80 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/typeinfo" 3
namespace std
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
class type_info
{
public:
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
virtual ~type_info();
#pragma empty_line
#pragma empty_line
#pragma empty_line
const char* name() const noexcept
{ return __name[0] == '*' ? __name + 1 : __name; }
#pragma line 115 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma empty_line
bool operator==(const type_info& __arg) const noexcept
{
return ((__name == __arg.__name)
|| (__name[0] != '*' &&
__builtin_strcmp (__name, __arg.__name) == 0));
}
#pragma line 136 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/typeinfo" 3
bool operator!=(const type_info& __arg) const noexcept
{ return !operator==(__arg); }
#pragma empty_line
#pragma empty_line
size_t hash_code() const noexcept
{
#pragma empty_line
return _Hash_bytes(name(), __builtin_strlen(name()),
static_cast<size_t>(0xc70f6907UL));
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
virtual bool __is_pointer_p() const;
#pragma empty_line
#pragma empty_line
virtual bool __is_function_p() const;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
virtual bool __do_catch(const type_info *__thr_type, void **__thr_obj,
unsigned __outer) const;
#pragma empty_line
#pragma empty_line
virtual bool __do_upcast(const __cxxabiv1::__class_type_info *__target,
void **__obj_ptr) const;
#pragma empty_line
protected:
const char *__name;
#pragma empty_line
explicit type_info(const char *__n): __name(__n) { }
#pragma empty_line
private:
#pragma empty_line
type_info& operator=(const type_info&);
type_info(const type_info&);
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
class bad_cast : public exception
{
public:
bad_cast() noexcept { }
#pragma empty_line
#pragma empty_line
#pragma empty_line
virtual ~bad_cast() noexcept;
#pragma empty_line
#pragma empty_line
virtual const char* what() const noexcept;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
class bad_typeid : public exception
{
public:
bad_typeid () noexcept { }
#pragma empty_line
#pragma empty_line
#pragma empty_line
virtual ~bad_typeid() noexcept;
#pragma empty_line
#pragma empty_line
virtual const char* what() const noexcept;
};
}
#pragma empty_line
}
#pragma empty_line
#pragma GCC visibility pop
#pragma line 82 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_stream.h" 2
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/sstream" 1 3
#pragma line 36 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/sstream" 3
#pragma empty_line
#pragma line 37 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/sstream" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
namespace __cxx11 {
#pragma line 64 "/home/justin/jhai/Xilinx/Vivado/2018.3/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:
#pragma empty_line
typedef _CharT char_type;
typedef _Traits traits_type;
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
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;
#pragma empty_line
protected:
#pragma empty_line
ios_base::openmode _M_mode;
#pragma empty_line
#pragma empty_line
__string_type _M_string;
#pragma empty_line
public:
#pragma line 99 "/home/justin/jhai/Xilinx/Vivado/2018.3/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()
{ }
#pragma line 112 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
#pragma empty_line
basic_stringbuf(const basic_stringbuf&) = delete;
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
basic_stringbuf&
operator=(const basic_stringbuf&) = delete;
#pragma empty_line
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;
}
#pragma empty_line
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);
}
#pragma line 165 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/sstream" 3
__string_type
str() const
{
__string_type __ret;
if (this->pptr())
{
#pragma empty_line
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;
}
#pragma line 189 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/sstream" 3
void
str(const __string_type& __s)
{
#pragma empty_line
#pragma empty_line
_M_string.assign(__s.data(), __s.size());
_M_stringbuf_init(_M_mode);
}
#pragma empty_line
protected:
#pragma empty_line
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);
}
#pragma empty_line
virtual streamsize
showmanyc()
{
streamsize __ret = -1;
if (_M_mode & ios_base::in)
{
_M_update_egptr();
__ret = this->egptr() - this->gptr();
}
return __ret;
}
#pragma empty_line
virtual int_type
underflow();
#pragma empty_line
virtual int_type
pbackfail(int_type __c = traits_type::eof());
#pragma empty_line
virtual int_type
overflow(int_type __c = traits_type::eof());
#pragma line 242 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
_M_string.clear();
#pragma empty_line
#pragma empty_line
_M_sync(__s, __n, 0);
}
return this;
}
#pragma empty_line
virtual pos_type
seekoff(off_type __off, ios_base::seekdir __way,
ios_base::openmode __mode = ios_base::in | ios_base::out);
#pragma empty_line
virtual pos_type
seekpos(pos_type __sp,
ios_base::openmode __mode = ios_base::in | ios_base::out);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
void
_M_sync(char_type* __base, __size_type __i, __size_type __o);
#pragma empty_line
#pragma empty_line
#pragma empty_line
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());
}
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
void
_M_pbump(char_type* __pbeg, char_type* __pend, off_type __off);
#pragma empty_line
private:
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
}
#pragma empty_line
~__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]);
}
#pragma empty_line
basic_stringbuf* _M_to;
off_type _M_goff[3];
off_type _M_poff[3];
};
#pragma line 343 "/home/justin/jhai/Xilinx/Vivado/2018.3/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))
{ }
#pragma empty_line
};
#pragma line 366 "/home/justin/jhai/Xilinx/Vivado/2018.3/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:
#pragma empty_line
typedef _CharT char_type;
typedef _Traits traits_type;
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
private:
__stringbuf_type _M_stringbuf;
#pragma empty_line
public:
#pragma line 402 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 420 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
~basic_istringstream()
{ }
#pragma empty_line
#pragma empty_line
basic_istringstream(const basic_istringstream&) = delete;
#pragma empty_line
basic_istringstream(basic_istringstream&& __rhs)
: __istream_type(std::move(__rhs)),
_M_stringbuf(std::move(__rhs._M_stringbuf))
{ __istream_type::set_rdbuf(&_M_stringbuf); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
basic_istringstream&
operator=(const basic_istringstream&) = delete;
#pragma empty_line
basic_istringstream&
operator=(basic_istringstream&& __rhs)
{
__istream_type::operator=(std::move(__rhs));
_M_stringbuf = std::move(__rhs._M_stringbuf);
return *this;
}
#pragma empty_line
void
swap(basic_istringstream& __rhs)
{
__istream_type::swap(__rhs);
_M_stringbuf.swap(__rhs._M_stringbuf);
}
#pragma line 471 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/sstream" 3
__stringbuf_type*
rdbuf() const
{ return const_cast<__stringbuf_type*>(&_M_stringbuf); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__string_type
str() const
{ return _M_stringbuf.str(); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
void
str(const __string_type& __s)
{ _M_stringbuf.str(__s); }
};
#pragma line 510 "/home/justin/jhai/Xilinx/Vivado/2018.3/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:
#pragma empty_line
typedef _CharT char_type;
typedef _Traits traits_type;
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
private:
__stringbuf_type _M_stringbuf;
#pragma empty_line
public:
#pragma line 546 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 564 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
~basic_ostringstream()
{ }
#pragma empty_line
#pragma empty_line
basic_ostringstream(const basic_ostringstream&) = delete;
#pragma empty_line
basic_ostringstream(basic_ostringstream&& __rhs)
: __ostream_type(std::move(__rhs)),
_M_stringbuf(std::move(__rhs._M_stringbuf))
{ __ostream_type::set_rdbuf(&_M_stringbuf); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
basic_ostringstream&
operator=(const basic_ostringstream&) = delete;
#pragma empty_line
basic_ostringstream&
operator=(basic_ostringstream&& __rhs)
{
__ostream_type::operator=(std::move(__rhs));
_M_stringbuf = std::move(__rhs._M_stringbuf);
return *this;
}
#pragma empty_line
void
swap(basic_ostringstream& __rhs)
{
__ostream_type::swap(__rhs);
_M_stringbuf.swap(__rhs._M_stringbuf);
}
#pragma line 615 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/sstream" 3
__stringbuf_type*
rdbuf() const
{ return const_cast<__stringbuf_type*>(&_M_stringbuf); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__string_type
str() const
{ return _M_stringbuf.str(); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
void
str(const __string_type& __s)
{ _M_stringbuf.str(__s); }
};
#pragma line 654 "/home/justin/jhai/Xilinx/Vivado/2018.3/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:
#pragma empty_line
typedef _CharT char_type;
typedef _Traits traits_type;
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
private:
__stringbuf_type _M_stringbuf;
#pragma empty_line
public:
#pragma line 689 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 705 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
~basic_stringstream()
{ }
#pragma empty_line
#pragma empty_line
basic_stringstream(const basic_stringstream&) = delete;
#pragma empty_line
basic_stringstream(basic_stringstream&& __rhs)
: __iostream_type(std::move(__rhs)),
_M_stringbuf(std::move(__rhs._M_stringbuf))
{ __iostream_type::set_rdbuf(&_M_stringbuf); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
basic_stringstream&
operator=(const basic_stringstream&) = delete;
#pragma empty_line
basic_stringstream&
operator=(basic_stringstream&& __rhs)
{
__iostream_type::operator=(std::move(__rhs));
_M_stringbuf = std::move(__rhs._M_stringbuf);
return *this;
}
#pragma empty_line
void
swap(basic_stringstream& __rhs)
{
__iostream_type::swap(__rhs);
_M_stringbuf.swap(__rhs._M_stringbuf);
}
#pragma line 756 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/sstream" 3
__stringbuf_type*
rdbuf() const
{ return const_cast<__stringbuf_type*>(&_M_stringbuf); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__string_type
str() const
{ return _M_stringbuf.str(); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
void
str(const __string_type& __s)
{ _M_stringbuf.str(__s); }
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
}
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/sstream.tcc" 1 3
#pragma line 37 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/sstream.tcc" 3
#pragma empty_line
#pragma line 38 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/sstream.tcc" 3
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
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())
{
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
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();
#pragma empty_line
const bool __testeof = traits_type::eq_int_type(__c, traits_type::eof());
if (__builtin_expect(__testeof, false))
return traits_type::not_eof(__c);
#pragma empty_line
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();
#pragma empty_line
#pragma empty_line
#pragma empty_line
const char_type __conv = traits_type::to_char_type(__c);
if (!__testput)
{
#pragma line 110 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma empty_line
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)
{
#pragma empty_line
_M_update_egptr();
#pragma empty_line
if (this->gptr() < this->egptr())
__ret = traits_type::to_int_type(*this->gptr());
}
return __ret;
}
#pragma empty_line
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);
#pragma empty_line
#pragma empty_line
#pragma empty_line
const char_type* __beg = __testin ? this->eback() : this->pbase();
if ((__beg || !__off) && (__testin || __testout || __testboth))
{
_M_update_egptr();
#pragma empty_line
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;
#pragma empty_line
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;
}
#pragma empty_line
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;
#pragma empty_line
const char_type* __beg = __testin ? this->eback() : this->pbase();
if ((__beg || !off_type(__sp)) && (__testin || __testout))
{
_M_update_egptr();
#pragma empty_line
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;
}
#pragma empty_line
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();
#pragma empty_line
if (__base != _M_string.data())
{
#pragma empty_line
__endg += __i;
__i = 0;
__endp = __endg;
}
#pragma empty_line
if (__testin)
this->setg(__base, __base + __i, __endg);
if (__testout)
{
_M_pbump(__base, __endp, __o);
#pragma empty_line
#pragma empty_line
#pragma empty_line
if (!__testin)
this->setg(__endg, __endg, __endg);
}
}
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern template class basic_stringbuf<char>;
extern template class basic_istringstream<char>;
extern template class basic_ostringstream<char>;
extern template class basic_stringstream<char>;
#pragma empty_line
#pragma empty_line
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>;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 814 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/sstream" 2 3
#pragma line 84 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_stream.h" 2
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cxxabi.h" 1 3
#pragma line 44 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cxxabi.h" 3
#pragma empty_line
#pragma line 45 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cxxabi.h" 3
#pragma empty_line
#pragma GCC visibility push(default)
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include/stddef.h" 1 3 4
#pragma line 149 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 426 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef decltype(nullptr) nullptr_t;
#pragma line 49 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cxxabi.h" 2 3
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/cxxabi_tweaks.h" 1 3
#pragma line 34 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/cxxabi_tweaks.h" 3
namespace __cxxabiv1
{
extern "C"
{
#pragma line 46 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/cxxabi_tweaks.h" 3
__extension__ typedef int __guard __attribute__((mode (__DI__)));
#pragma empty_line
#pragma empty_line
typedef void __cxa_vec_ctor_return_type;
#pragma empty_line
#pragma empty_line
typedef void __cxa_cdtor_return_type;
#pragma empty_line
#pragma empty_line
}
}
#pragma line 51 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cxxabi.h" 2 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace __cxxabiv1
{
extern "C"
{
#pragma empty_line
#pragma empty_line
typedef __cxa_cdtor_return_type (*__cxa_cdtor_type)(void *);
#pragma empty_line
#pragma empty_line
void*
__cxa_vec_new(size_t __element_count, size_t __element_size,
size_t __padding_size, __cxa_cdtor_type __constructor,
__cxa_cdtor_type __destructor);
#pragma empty_line
void*
__cxa_vec_new2(size_t __element_count, size_t __element_size,
size_t __padding_size, __cxa_cdtor_type __constructor,
__cxa_cdtor_type __destructor, void *(*__alloc) (size_t),
void (*__dealloc) (void*));
#pragma empty_line
void*
__cxa_vec_new3(size_t __element_count, size_t __element_size,
size_t __padding_size, __cxa_cdtor_type __constructor,
__cxa_cdtor_type __destructor, void *(*__alloc) (size_t),
void (*__dealloc) (void*, size_t));
#pragma empty_line
#pragma empty_line
__cxa_vec_ctor_return_type
__cxa_vec_ctor(void* __array_address, size_t __element_count,
size_t __element_size, __cxa_cdtor_type __constructor,
__cxa_cdtor_type __destructor);
#pragma empty_line
__cxa_vec_ctor_return_type
__cxa_vec_cctor(void* __dest_array, void* __src_array,
size_t __element_count, size_t __element_size,
__cxa_cdtor_return_type (*__constructor) (void*, void*),
__cxa_cdtor_type __destructor);
#pragma empty_line
#pragma empty_line
void
__cxa_vec_dtor(void* __array_address, size_t __element_count,
size_t __element_size, __cxa_cdtor_type __destructor);
#pragma empty_line
void
__cxa_vec_cleanup(void* __array_address, size_t __element_count, size_t __s,
__cxa_cdtor_type __destructor) noexcept;
#pragma empty_line
#pragma empty_line
void
__cxa_vec_delete(void* __array_address, size_t __element_size,
size_t __padding_size, __cxa_cdtor_type __destructor);
#pragma empty_line
void
__cxa_vec_delete2(void* __array_address, size_t __element_size,
size_t __padding_size, __cxa_cdtor_type __destructor,
void (*__dealloc) (void*));
#pragma empty_line
void
__cxa_vec_delete3(void* __array_address, size_t __element_size,
size_t __padding_size, __cxa_cdtor_type __destructor,
void (*__dealloc) (void*, size_t));
#pragma empty_line
int
__cxa_guard_acquire(__guard*);
#pragma empty_line
void
__cxa_guard_release(__guard*) noexcept;
#pragma empty_line
void
__cxa_guard_abort(__guard*) noexcept;
#pragma empty_line
#pragma empty_line
int
__cxa_atexit(void (*)(void*), void*, void*) noexcept;
#pragma empty_line
int
__cxa_finalize(void*);
#pragma empty_line
#pragma empty_line
int
__cxa_thread_atexit(void (*)(void*), void*, void *) noexcept;
#pragma empty_line
#pragma empty_line
void
__cxa_pure_virtual(void) __attribute__ ((__noreturn__));
#pragma empty_line
void
__cxa_deleted_virtual(void) __attribute__ ((__noreturn__));
#pragma empty_line
#pragma empty_line
void
__cxa_bad_cast() __attribute__((__noreturn__));
#pragma empty_line
void
__cxa_bad_typeid() __attribute__((__noreturn__));
#pragma empty_line
void
__cxa_throw_bad_array_new_length() __attribute__((__noreturn__));
#pragma line 197 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cxxabi.h" 3
char*
__cxa_demangle(const char* __mangled_name, char* __output_buffer,
size_t* __length, int* __status);
#pragma empty_line
#pragma empty_line
}
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace __cxxabiv1
{
#pragma empty_line
class __fundamental_type_info : public std::type_info
{
public:
explicit
__fundamental_type_info(const char* __n) : std::type_info(__n) { }
#pragma empty_line
virtual
~__fundamental_type_info();
};
#pragma empty_line
#pragma empty_line
class __array_type_info : public std::type_info
{
public:
explicit
__array_type_info(const char* __n) : std::type_info(__n) { }
#pragma empty_line
virtual
~__array_type_info();
};
#pragma empty_line
#pragma empty_line
class __function_type_info : public std::type_info
{
public:
explicit
__function_type_info(const char* __n) : std::type_info(__n) { }
#pragma empty_line
virtual
~__function_type_info();
#pragma empty_line
protected:
#pragma empty_line
virtual bool
__is_function_p() const;
};
#pragma empty_line
#pragma empty_line
class __enum_type_info : public std::type_info
{
public:
explicit
__enum_type_info(const char* __n) : std::type_info(__n) { }
#pragma empty_line
virtual
~__enum_type_info();
};
#pragma empty_line
#pragma empty_line
class __pbase_type_info : public std::type_info
{
public:
unsigned int __flags;
const std::type_info* __pointee;
#pragma empty_line
explicit
__pbase_type_info(const char* __n, int __quals,
const std::type_info* __type)
: std::type_info(__n), __flags(__quals), __pointee(__type)
{ }
#pragma empty_line
virtual
~__pbase_type_info();
#pragma empty_line
#pragma empty_line
enum __masks
{
__const_mask = 0x1,
__volatile_mask = 0x2,
__restrict_mask = 0x4,
__incomplete_mask = 0x8,
__incomplete_class_mask = 0x10,
__transaction_safe_mask = 0x20
};
#pragma empty_line
protected:
__pbase_type_info(const __pbase_type_info&);
#pragma empty_line
__pbase_type_info&
operator=(const __pbase_type_info&);
#pragma empty_line
#pragma empty_line
virtual bool
__do_catch(const std::type_info* __thr_type, void** __thr_obj,
unsigned int __outer) const;
#pragma empty_line
inline virtual bool
__pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
unsigned __outer) const;
};
#pragma empty_line
inline bool __pbase_type_info::
__pointer_catch (const __pbase_type_info *thrown_type,
void **thr_obj,
unsigned outer) const
{
return __pointee->__do_catch (thrown_type->__pointee, thr_obj, outer + 2);
}
#pragma empty_line
#pragma empty_line
class __pointer_type_info : public __pbase_type_info
{
public:
explicit
__pointer_type_info(const char* __n, int __quals,
const std::type_info* __type)
: __pbase_type_info (__n, __quals, __type) { }
#pragma empty_line
#pragma empty_line
virtual
~__pointer_type_info();
#pragma empty_line
protected:
#pragma empty_line
virtual bool
__is_pointer_p() const;
#pragma empty_line
virtual bool
__pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
unsigned __outer) const;
};
#pragma empty_line
class __class_type_info;
#pragma empty_line
#pragma empty_line
class __pointer_to_member_type_info : public __pbase_type_info
{
public:
__class_type_info* __context;
#pragma empty_line
explicit
__pointer_to_member_type_info(const char* __n, int __quals,
const std::type_info* __type,
__class_type_info* __klass)
: __pbase_type_info(__n, __quals, __type), __context(__klass) { }
#pragma empty_line
virtual
~__pointer_to_member_type_info();
#pragma empty_line
protected:
__pointer_to_member_type_info(const __pointer_to_member_type_info&);
#pragma empty_line
__pointer_to_member_type_info&
operator=(const __pointer_to_member_type_info&);
#pragma empty_line
#pragma empty_line
virtual bool
__pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
unsigned __outer) const;
};
#pragma empty_line
#pragma empty_line
class __base_class_type_info
{
public:
const __class_type_info* __base_type;
#pragma empty_line
#pragma empty_line
#pragma empty_line
long __offset_flags;
#pragma empty_line
#pragma empty_line
enum __offset_flags_masks
{
__virtual_mask = 0x1,
__public_mask = 0x2,
__hwm_bit = 2,
__offset_shift = 8
};
#pragma empty_line
#pragma empty_line
bool
__is_virtual_p() const
{ return __offset_flags & __virtual_mask; }
#pragma empty_line
bool
__is_public_p() const
{ return __offset_flags & __public_mask; }
#pragma empty_line
ptrdiff_t
__offset() const
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
return static_cast<ptrdiff_t>(__offset_flags) >> __offset_shift;
}
};
#pragma empty_line
#pragma empty_line
class __class_type_info : public std::type_info
{
public:
explicit
__class_type_info (const char *__n) : type_info(__n) { }
#pragma empty_line
virtual
~__class_type_info ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
enum __sub_kind
{
#pragma empty_line
__unknown = 0,
#pragma empty_line
#pragma empty_line
#pragma empty_line
__not_contained,
#pragma empty_line
#pragma empty_line
__contained_ambig,
#pragma empty_line
#pragma empty_line
__contained_virtual_mask = __base_class_type_info::__virtual_mask,
#pragma empty_line
#pragma empty_line
__contained_public_mask = __base_class_type_info::__public_mask,
#pragma empty_line
#pragma empty_line
__contained_mask = 1 << __base_class_type_info::__hwm_bit,
#pragma empty_line
__contained_private = __contained_mask,
__contained_public = __contained_mask | __contained_public_mask
};
#pragma empty_line
struct __upcast_result;
struct __dyncast_result;
#pragma empty_line
protected:
#pragma empty_line
virtual bool
__do_upcast(const __class_type_info* __dst_type, void**__obj_ptr) const;
#pragma empty_line
virtual bool
__do_catch(const type_info* __thr_type, void** __thr_obj,
unsigned __outer) const;
#pragma empty_line
public:
#pragma empty_line
#pragma empty_line
virtual bool
__do_upcast(const __class_type_info* __dst, const void* __obj,
__upcast_result& __restrict __result) const;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline __sub_kind
__find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
const __class_type_info* __src_type,
const void* __src_ptr) const;
#pragma line 479 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cxxabi.h" 3
virtual bool
__do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
const __class_type_info* __dst_type, const void* __obj_ptr,
const __class_type_info* __src_type, const void* __src_ptr,
__dyncast_result& __result) const;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
virtual __sub_kind
__do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
const __class_type_info* __src_type,
const void* __src_ptr) const;
};
#pragma empty_line
#pragma empty_line
class __si_class_type_info : public __class_type_info
{
public:
const __class_type_info* __base_type;
#pragma empty_line
explicit
__si_class_type_info(const char *__n, const __class_type_info *__base)
: __class_type_info(__n), __base_type(__base) { }
#pragma empty_line
virtual
~__si_class_type_info();
#pragma empty_line
protected:
__si_class_type_info(const __si_class_type_info&);
#pragma empty_line
__si_class_type_info&
operator=(const __si_class_type_info&);
#pragma empty_line
#pragma empty_line
virtual bool
__do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
const __class_type_info* __dst_type, const void* __obj_ptr,
const __class_type_info* __src_type, const void* __src_ptr,
__dyncast_result& __result) const;
#pragma empty_line
virtual __sub_kind
__do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
const __class_type_info* __src_type,
const void* __sub_ptr) const;
#pragma empty_line
virtual bool
__do_upcast(const __class_type_info*__dst, const void*__obj,
__upcast_result& __restrict __result) const;
};
#pragma empty_line
#pragma empty_line
class __vmi_class_type_info : public __class_type_info
{
public:
unsigned int __flags;
unsigned int __base_count;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__base_class_type_info __base_info[1];
#pragma empty_line
explicit
__vmi_class_type_info(const char* __n, int ___flags)
: __class_type_info(__n), __flags(___flags), __base_count(0) { }
#pragma empty_line
virtual
~__vmi_class_type_info();
#pragma empty_line
#pragma empty_line
enum __flags_masks
{
__non_diamond_repeat_mask = 0x1,
__diamond_shaped_mask = 0x2,
__flags_unknown_mask = 0x10
};
#pragma empty_line
protected:
#pragma empty_line
virtual bool
__do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
const __class_type_info* __dst_type, const void* __obj_ptr,
const __class_type_info* __src_type, const void* __src_ptr,
__dyncast_result& __result) const;
#pragma empty_line
virtual __sub_kind
__do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
const __class_type_info* __src_type,
const void* __src_ptr) const;
#pragma empty_line
virtual bool
__do_upcast(const __class_type_info* __dst, const void* __obj,
__upcast_result& __restrict __result) const;
};
#pragma empty_line
#pragma empty_line
struct __cxa_exception;
struct __cxa_refcounted_exception;
struct __cxa_dependent_exception;
struct __cxa_eh_globals;
#pragma empty_line
extern "C"
{
#pragma line 592 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cxxabi.h" 3
void*
__dynamic_cast(const void* __src_ptr,
const __class_type_info* __src_type,
const __class_type_info* __dst_type,
ptrdiff_t __src2dst);
#pragma line 605 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cxxabi.h" 3
__cxa_eh_globals*
__cxa_get_globals() noexcept __attribute__ ((__const__));
#pragma empty_line
__cxa_eh_globals*
__cxa_get_globals_fast() noexcept __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
void*
__cxa_allocate_exception(size_t) noexcept;
#pragma empty_line
#pragma empty_line
void
__cxa_free_exception(void*) noexcept;
#pragma empty_line
#pragma empty_line
void
__cxa_throw(void*, std::type_info*, void ( *) (void *))
__attribute__((__noreturn__));
#pragma empty_line
#pragma empty_line
void*
__cxa_get_exception_ptr(void*) noexcept __attribute__ ((__pure__));
#pragma empty_line
void*
__cxa_begin_catch(void*) noexcept;
#pragma empty_line
void
__cxa_end_catch();
#pragma empty_line
void
__cxa_rethrow() __attribute__((__noreturn__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
std::type_info*
__cxa_current_exception_type() noexcept __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__cxa_dependent_exception*
__cxa_allocate_dependent_exception() noexcept;
#pragma empty_line
#pragma empty_line
void
__cxa_free_dependent_exception(__cxa_dependent_exception*) noexcept;
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
class __foreign_exception
{
virtual ~__foreign_exception() throw();
virtual void __pure_dummy() = 0;
};
#pragma empty_line
}
#pragma line 684 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cxxabi.h" 3
namespace abi = __cxxabiv1;
#pragma empty_line
namespace __gnu_cxx
{
#pragma line 700 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cxxabi.h" 3
class recursive_init_error: public std::exception
{
public:
recursive_init_error() throw() { }
virtual ~recursive_init_error() throw ();
};
}
#pragma empty_line
#pragma empty_line
#pragma GCC visibility pop
#pragma line 92 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_stream.h" 2
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/stdlib.h" 1 3
#pragma line 36 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/stdlib.h" 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 1 3
#pragma line 39 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 3
#pragma empty_line
#pragma line 40 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 3
#pragma line 37 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/stdlib.h" 2 3
#pragma empty_line
using std::abort;
using std::atexit;
using std::exit;
#pragma empty_line
#pragma empty_line
using std::at_quick_exit;
#pragma empty_line
#pragma empty_line
using std::quick_exit;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
using std::div_t;
using std::ldiv_t;
#pragma empty_line
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;
#pragma empty_line
using std::mblen;
using std::mbstowcs;
using std::mbtowc;
#pragma empty_line
using std::qsort;
using std::rand;
using std::realloc;
using std::srand;
using std::strtod;
using std::strtol;
using std::strtoul;
using std::system;
#pragma empty_line
using std::wcstombs;
using std::wctomb;
#pragma line 93 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_stream.h" 2
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 95 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_stream.h"
namespace hls {
#pragma empty_line
template<typename __STREAM_T__>
class stream
{
protected:
std::string _name;
std::deque<__STREAM_T__> _data;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
public:
#pragma empty_line
#pragma empty_line
stream() {
static unsigned _counter = 1;
std::stringstream ss;
#pragma empty_line
char* _demangle_name = abi::__cxa_demangle(typeid(*this).name(), 0, 0, 0);
if (_demangle_name) {
_name = _demangle_name;
free(_demangle_name);
}
else {
_name = "hls_stream";
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
ss << _counter++;
_name += "." + ss.str();
}
#pragma empty_line
stream(const std::string name) {
#pragma empty_line
#pragma empty_line
_name = name;
}
#pragma empty_line
#pragma empty_line
private:
stream(const stream< __STREAM_T__ >& chn):
_name(chn._name), _data(chn._data) {
}
#pragma empty_line
stream& operator = (const stream< __STREAM_T__ >& chn) {
_name = chn._name;
_data = chn._data;
return *this;
}
#pragma empty_line
public:
#pragma empty_line
void operator >> (__STREAM_T__& rdata) {
read(rdata);
}
#pragma empty_line
void operator << (const __STREAM_T__& wdata) {
write(wdata);
}
#pragma empty_line
#pragma empty_line
public:
#pragma empty_line
#pragma empty_line
virtual ~stream() {
if (!_data.empty())
{
std::cout << "WARNING: Hls::stream '"
<< _name
<< "' contains leftover data,"
<< " which may result in RTL simulation hanging."
<< std::endl;
}
}
#pragma empty_line
#pragma empty_line
bool empty() {
#pragma empty_line
#pragma empty_line
#pragma empty_line
return _data.empty();
}
#pragma empty_line
bool full() const { return false; }
#pragma empty_line
#pragma empty_line
void read(__STREAM_T__& head) {
head = read();
}
#pragma line 202 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_stream.h"
__STREAM_T__ read() {
__STREAM_T__ elem;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
if (_data.empty()) {
std::cout << "WARNING: Hls::stream '"
<< _name
<< "' is read while empty,"
<< " which may result in RTL simulation hanging."
<< std::endl;
elem = __STREAM_T__();
} else {
elem = _data.front();
_data.pop_front();
}
return elem;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
void write(const __STREAM_T__& tail) {
#pragma empty_line
#pragma empty_line
#pragma empty_line
_data.push_back(tail);
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
bool read_nb(__STREAM_T__& head) {
#pragma empty_line
#pragma empty_line
#pragma empty_line
bool is_empty = _data.empty();
if (is_empty) {
head = __STREAM_T__();
} else {
__STREAM_T__ elem(_data.front());
_data.pop_front();
head = elem;
}
return !is_empty;
}
#pragma empty_line
#pragma empty_line
bool write_nb(const __STREAM_T__& tail) {
bool is_full = full();
write(tail);
return !is_full;
}
#pragma empty_line
#pragma empty_line
size_t size() {
return _data.size();
}
};
#pragma empty_line
}
#pragma line 4 "/home/justin/jhai/paulchowresearch2020/xvc/test_hls_server/test_hls_server.h" 2
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int.h" 1
#pragma line 54 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int.h"
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_common.h" 1
#pragma line 56 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_common.h"
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_decl.h" 1
#pragma line 100 "/home/justin/jhai/Xilinx/Vivado/2018.3/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,
};
#pragma line 122 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_decl.h"
enum ap_o_mode {
AP_SAT,
AP_SAT_ZERO,
AP_SAT_SYM,
AP_WRAP,
AP_WRAP_SM,
};
#pragma line 179 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_decl.h"
template <int _AP_W, bool _AP_S>
struct ap_int_base;
#pragma empty_line
template <int _AP_W>
struct ap_int;
#pragma empty_line
template <int _AP_W>
struct ap_uint;
#pragma empty_line
template <int _AP_W, bool _AP_S>
struct ap_range_ref;
#pragma empty_line
template <int _AP_W, bool _AP_S>
struct ap_bit_ref;
#pragma empty_line
template <int _AP_W1, typename _AP_T1, int _AP_W2, typename _AP_T2>
struct ap_concat_ref;
#pragma empty_line
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;
#pragma empty_line
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;
#pragma empty_line
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;
#pragma empty_line
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;
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
enum BaseMode { AP_BIN = 2, AP_OCT = 8, AP_DEC = 10, AP_HEX = 16 };
#pragma line 232 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_decl.h"
typedef signed long long ap_slong;
typedef unsigned long long ap_ulong;
#pragma empty_line
#pragma empty_line
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
};
#pragma line 57 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_common.h" 2
#pragma line 65 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_common.h"
#pragma line 1 "/usr/include/assert.h" 1 3 4
#pragma line 66 "/usr/include/assert.h" 3 4
#pragma empty_line
#pragma line 66 "/usr/include/assert.h" 3 4
extern "C" {
#pragma empty_line
#pragma empty_line
extern void __assert_fail (const char *__assertion, const char *__file,
unsigned int __line, const char *__function)
throw () __attribute__ ((__noreturn__));
#pragma empty_line
#pragma empty_line
extern void __assert_perror_fail (int __errnum, const char *__file,
unsigned int __line, const char *__function)
throw () __attribute__ ((__noreturn__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern void __assert (const char *__assertion, const char *__file, int __line)
throw () __attribute__ ((__noreturn__));
#pragma empty_line
#pragma empty_line
}
#pragma line 66 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_common.h" 2
#pragma line 76 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_common.h"
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/stdlib.h" 1 3
#pragma line 77 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_common.h" 2
#pragma line 156 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_common.h"
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/climits" 1 3
#pragma line 39 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/climits" 3
#pragma empty_line
#pragma line 40 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/climits" 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include-fixed/limits.h" 1 3 4
#pragma line 34 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include-fixed/limits.h" 3 4
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include-fixed/syslimits.h" 1 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include-fixed/limits.h" 1 3 4
#pragma line 168 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include-fixed/limits.h" 3 4
#pragma line 1 "/usr/include/limits.h" 1 3 4
#pragma line 26 "/usr/include/limits.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4
#pragma line 27 "/usr/include/limits.h" 2 3 4
#pragma line 183 "/usr/include/limits.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 1 3 4
#pragma line 27 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
#pragma line 28 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 2 3 4
#pragma line 161 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/local_lim.h" 1 3 4
#pragma line 38 "/usr/include/x86_64-linux-gnu/bits/local_lim.h" 3 4
#pragma line 1 "/usr/include/linux/limits.h" 1 3 4
#pragma line 39 "/usr/include/x86_64-linux-gnu/bits/local_lim.h" 2 3 4
#pragma line 162 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 2 3 4
#pragma line 184 "/usr/include/limits.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/posix2_lim.h" 1 3 4
#pragma line 188 "/usr/include/limits.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/xopen_lim.h" 1 3 4
#pragma line 64 "/usr/include/x86_64-linux-gnu/bits/xopen_lim.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/uio_lim.h" 1 3 4
#pragma line 65 "/usr/include/x86_64-linux-gnu/bits/xopen_lim.h" 2 3 4
#pragma line 192 "/usr/include/limits.h" 2 3 4
#pragma line 169 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include-fixed/limits.h" 2 3 4
#pragma line 8 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include-fixed/syslimits.h" 2 3 4
#pragma line 35 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include-fixed/limits.h" 2 3 4
#pragma line 43 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/climits" 2 3
#pragma line 157 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_common.h" 2
#pragma empty_line
#pragma line 157 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_common.h"
enum { CHAR_IS_SIGNED =
#pragma line 157 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_common.h" 3 4
(-0x7f - 1)
#pragma line 157 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_common.h"
< 0 };
#pragma empty_line
#pragma empty_line
namespace _ap_type {
template <typename _Tp>
struct is_signed {
static const bool value = _Tp(-1) < _Tp(1);
};
#pragma empty_line
template <typename _Tp>
struct is_integral {
static const bool value = false;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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; };
#pragma empty_line
#pragma empty_line
template <bool, typename _Tp = void>
struct enable_if {};
#pragma empty_line
template <typename _Tp>
struct enable_if<true, _Tp> {
typedef _Tp type;
};
#pragma empty_line
template <typename _Tp>
struct remove_const {
typedef _Tp type;
};
#pragma empty_line
template <typename _Tp>
struct remove_const<_Tp const> {
typedef _Tp type;
};
}
#pragma line 574 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_common.h"
static inline unsigned char guess_radix(const char* s) {
unsigned char rd = 10;
const char* p = s;
#pragma empty_line
if (p[0] == '-' || p[0] == '+') ++p;
#pragma empty_line
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;
}
#pragma line 602 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_common.h"
class half;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cmath" 1 3
#pragma line 39 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cmath" 3
#pragma empty_line
#pragma line 40 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cmath" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/math.h" 1 3 4
#pragma line 27 "/usr/include/math.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4
#pragma line 28 "/usr/include/math.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 34 "/usr/include/math.h" 3 4
extern "C" {
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/math-vector.h" 1 3 4
#pragma line 25 "/usr/include/x86_64-linux-gnu/bits/math-vector.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h" 1 3 4
#pragma line 26 "/usr/include/x86_64-linux-gnu/bits/math-vector.h" 2 3 4
#pragma line 41 "/usr/include/math.h" 2 3 4
#pragma line 138 "/usr/include/math.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/flt-eval-method.h" 1 3 4
#pragma line 139 "/usr/include/math.h" 2 3 4
#pragma line 149 "/usr/include/math.h" 3 4
typedef float float_t;
typedef double double_t;
#pragma line 190 "/usr/include/math.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/fp-logb.h" 1 3 4
#pragma line 191 "/usr/include/math.h" 2 3 4
#pragma line 233 "/usr/include/math.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/fp-fast.h" 1 3 4
#pragma line 234 "/usr/include/math.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
enum
{
FP_INT_UPWARD =
#pragma empty_line
0,
FP_INT_DOWNWARD =
#pragma empty_line
1,
FP_INT_TOWARDZERO =
#pragma empty_line
2,
FP_INT_TONEARESTFROMZERO =
#pragma empty_line
3,
FP_INT_TONEAREST =
#pragma empty_line
4,
};
#pragma line 289 "/usr/include/math.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 1 3 4
#pragma line 21 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 3 4
extern int __fpclassify (double __value) throw ()
__attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern int __signbit (double __value) throw ()
__attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int __isinf (double __value) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern int __finite (double __value) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern int __isnan (double __value) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern int __iseqsig (double __x, double __y) throw ();
#pragma empty_line
#pragma empty_line
extern int __issignaling (double __value) throw ()
__attribute__ ((__const__));
#pragma line 290 "/usr/include/math.h" 2 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4
#pragma line 53 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern double acos (double __x) throw (); extern double __acos (double __x) throw ();
#pragma empty_line
extern double asin (double __x) throw (); extern double __asin (double __x) throw ();
#pragma empty_line
extern double atan (double __x) throw (); extern double __atan (double __x) throw ();
#pragma empty_line
extern double atan2 (double __y, double __x) throw (); extern double __atan2 (double __y, double __x) throw ();
#pragma empty_line
#pragma empty_line
extern double cos (double __x) throw (); extern double __cos (double __x) throw ();
#pragma empty_line
extern double sin (double __x) throw (); extern double __sin (double __x) throw ();
#pragma empty_line
extern double tan (double __x) throw (); extern double __tan (double __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern double cosh (double __x) throw (); extern double __cosh (double __x) throw ();
#pragma empty_line
extern double sinh (double __x) throw (); extern double __sinh (double __x) throw ();
#pragma empty_line
extern double tanh (double __x) throw (); extern double __tanh (double __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern void sincos (double __x, double *__sinx, double *__cosx) throw (); extern void __sincos (double __x, double *__sinx, double *__cosx) throw ()
;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern double acosh (double __x) throw (); extern double __acosh (double __x) throw ();
#pragma empty_line
extern double asinh (double __x) throw (); extern double __asinh (double __x) throw ();
#pragma empty_line
extern double atanh (double __x) throw (); extern double __atanh (double __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern double exp (double __x) throw (); extern double __exp (double __x) throw ();
#pragma empty_line
#pragma empty_line
extern double frexp (double __x, int *__exponent) throw (); extern double __frexp (double __x, int *__exponent) throw ();
#pragma empty_line
#pragma empty_line
extern double ldexp (double __x, int __exponent) throw (); extern double __ldexp (double __x, int __exponent) throw ();
#pragma empty_line
#pragma empty_line
extern double log (double __x) throw (); extern double __log (double __x) throw ();
#pragma empty_line
#pragma empty_line
extern double log10 (double __x) throw (); extern double __log10 (double __x) throw ();
#pragma empty_line
#pragma empty_line
extern double modf (double __x, double *__iptr) throw (); extern double __modf (double __x, double *__iptr) throw () __attribute__ ((__nonnull__ (2)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern double exp10 (double __x) throw (); extern double __exp10 (double __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern double expm1 (double __x) throw (); extern double __expm1 (double __x) throw ();
#pragma empty_line
#pragma empty_line
extern double log1p (double __x) throw (); extern double __log1p (double __x) throw ();
#pragma empty_line
#pragma empty_line
extern double logb (double __x) throw (); extern double __logb (double __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern double exp2 (double __x) throw (); extern double __exp2 (double __x) throw ();
#pragma empty_line
#pragma empty_line
extern double log2 (double __x) throw (); extern double __log2 (double __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern double pow (double __x, double __y) throw (); extern double __pow (double __x, double __y) throw ();
#pragma empty_line
#pragma empty_line
extern double sqrt (double __x) throw (); extern double __sqrt (double __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern double hypot (double __x, double __y) throw (); extern double __hypot (double __x, double __y) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern double cbrt (double __x) throw (); extern double __cbrt (double __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern double ceil (double __x) throw () __attribute__ ((__const__)); extern double __ceil (double __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern double fabs (double __x) throw () __attribute__ ((__const__)); extern double __fabs (double __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern double floor (double __x) throw () __attribute__ ((__const__)); extern double __floor (double __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern double fmod (double __x, double __y) throw (); extern double __fmod (double __x, double __y) throw ();
#pragma line 182 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern int finite (double __value) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern double drem (double __x, double __y) throw (); extern double __drem (double __x, double __y) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern double significand (double __x) throw (); extern double __significand (double __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern double copysign (double __x, double __y) throw () __attribute__ ((__const__)); extern double __copysign (double __x, double __y) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern double nan (const char *__tagb) throw (); extern double __nan (const char *__tagb) throw ();
#pragma line 217 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
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 ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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 ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern double tgamma (double) throw (); extern double __tgamma (double) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern double gamma (double) throw (); extern double __gamma (double) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern double lgamma_r (double, int *__signgamp) throw (); extern double __lgamma_r (double, int *__signgamp) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern double rint (double __x) throw (); extern double __rint (double __x) throw ();
#pragma empty_line
#pragma empty_line
extern double nextafter (double __x, double __y) throw (); extern double __nextafter (double __x, double __y) throw ();
#pragma empty_line
extern double nexttoward (double __x, long double __y) throw (); extern double __nexttoward (double __x, long double __y) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern double nextdown (double __x) throw (); extern double __nextdown (double __x) throw ();
#pragma empty_line
extern double nextup (double __x) throw (); extern double __nextup (double __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern double remainder (double __x, double __y) throw (); extern double __remainder (double __x, double __y) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern double scalbn (double __x, int __n) throw (); extern double __scalbn (double __x, int __n) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int ilogb (double __x) throw (); extern int __ilogb (double __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long int llogb (double __x) throw (); extern long int __llogb (double __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern double scalbln (double __x, long int __n) throw (); extern double __scalbln (double __x, long int __n) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern double nearbyint (double __x) throw (); extern double __nearbyint (double __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern double round (double __x) throw () __attribute__ ((__const__)); extern double __round (double __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern double trunc (double __x) throw () __attribute__ ((__const__)); extern double __trunc (double __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern double remquo (double __x, double __y, int *__quo) throw (); extern double __remquo (double __x, double __y, int *__quo) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long int lrint (double __x) throw (); extern long int __lrint (double __x) throw ();
__extension__
extern long long int llrint (double __x) throw (); extern long long int __llrint (double __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long int lround (double __x) throw (); extern long int __lround (double __x) throw ();
__extension__
extern long long int llround (double __x) throw (); extern long long int __llround (double __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern double fdim (double __x, double __y) throw (); extern double __fdim (double __x, double __y) throw ();
#pragma empty_line
#pragma empty_line
extern double fmax (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmax (double __x, double __y) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern double fmin (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmin (double __x, double __y) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern double fma (double __x, double __y, double __z) throw (); extern double __fma (double __x, double __y, double __z) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern double roundeven (double __x) throw () __attribute__ ((__const__)); extern double __roundeven (double __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __intmax_t fromfp (double __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfp (double __x, int __round, unsigned int __width) throw ()
;
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __uintmax_t ufromfp (double __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfp (double __x, int __round, unsigned int __width) throw ()
;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __intmax_t fromfpx (double __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpx (double __x, int __round, unsigned int __width) throw ()
;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __uintmax_t ufromfpx (double __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpx (double __x, int __round, unsigned int __width) throw ()
;
#pragma empty_line
#pragma empty_line
extern double fmaxmag (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmaxmag (double __x, double __y) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern double fminmag (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fminmag (double __x, double __y) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern int canonicalize (double *__cx, const double *__x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int totalorder (const double *__x, const double *__y) throw ()
#pragma empty_line
__attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
extern int totalordermag (const double *__x, const double *__y) throw ()
#pragma empty_line
__attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
extern double getpayload (const double *__x) throw (); extern double __getpayload (const double *__x) throw ();
#pragma empty_line
#pragma empty_line
extern int setpayload (double *__x, double __payload) throw ();
#pragma empty_line
#pragma empty_line
extern int setpayloadsig (double *__x, double __payload) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern double scalb (double __x, double __n) throw (); extern double __scalb (double __x, double __n) throw ();
#pragma line 291 "/usr/include/math.h" 2 3 4
#pragma line 306 "/usr/include/math.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 1 3 4
#pragma line 21 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 3 4
extern int __fpclassifyf (float __value) throw ()
__attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern int __signbitf (float __value) throw ()
__attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int __isinff (float __value) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern int __finitef (float __value) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern int __isnanf (float __value) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern int __iseqsigf (float __x, float __y) throw ();
#pragma empty_line
#pragma empty_line
extern int __issignalingf (float __value) throw ()
__attribute__ ((__const__));
#pragma line 307 "/usr/include/math.h" 2 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4
#pragma line 53 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern float acosf (float __x) throw (); extern float __acosf (float __x) throw ();
#pragma empty_line
extern float asinf (float __x) throw (); extern float __asinf (float __x) throw ();
#pragma empty_line
extern float atanf (float __x) throw (); extern float __atanf (float __x) throw ();
#pragma empty_line
extern float atan2f (float __y, float __x) throw (); extern float __atan2f (float __y, float __x) throw ();
#pragma empty_line
#pragma empty_line
extern float cosf (float __x) throw (); extern float __cosf (float __x) throw ();
#pragma empty_line
extern float sinf (float __x) throw (); extern float __sinf (float __x) throw ();
#pragma empty_line
extern float tanf (float __x) throw (); extern float __tanf (float __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern float coshf (float __x) throw (); extern float __coshf (float __x) throw ();
#pragma empty_line
extern float sinhf (float __x) throw (); extern float __sinhf (float __x) throw ();
#pragma empty_line
extern float tanhf (float __x) throw (); extern float __tanhf (float __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern void sincosf (float __x, float *__sinx, float *__cosx) throw (); extern void __sincosf (float __x, float *__sinx, float *__cosx) throw ()
;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern float acoshf (float __x) throw (); extern float __acoshf (float __x) throw ();
#pragma empty_line
extern float asinhf (float __x) throw (); extern float __asinhf (float __x) throw ();
#pragma empty_line
extern float atanhf (float __x) throw (); extern float __atanhf (float __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern float expf (float __x) throw (); extern float __expf (float __x) throw ();
#pragma empty_line
#pragma empty_line
extern float frexpf (float __x, int *__exponent) throw (); extern float __frexpf (float __x, int *__exponent) throw ();
#pragma empty_line
#pragma empty_line
extern float ldexpf (float __x, int __exponent) throw (); extern float __ldexpf (float __x, int __exponent) throw ();
#pragma empty_line
#pragma empty_line
extern float logf (float __x) throw (); extern float __logf (float __x) throw ();
#pragma empty_line
#pragma empty_line
extern float log10f (float __x) throw (); extern float __log10f (float __x) throw ();
#pragma empty_line
#pragma empty_line
extern float modff (float __x, float *__iptr) throw (); extern float __modff (float __x, float *__iptr) throw () __attribute__ ((__nonnull__ (2)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern float exp10f (float __x) throw (); extern float __exp10f (float __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern float expm1f (float __x) throw (); extern float __expm1f (float __x) throw ();
#pragma empty_line
#pragma empty_line
extern float log1pf (float __x) throw (); extern float __log1pf (float __x) throw ();
#pragma empty_line
#pragma empty_line
extern float logbf (float __x) throw (); extern float __logbf (float __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern float exp2f (float __x) throw (); extern float __exp2f (float __x) throw ();
#pragma empty_line
#pragma empty_line
extern float log2f (float __x) throw (); extern float __log2f (float __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern float powf (float __x, float __y) throw (); extern float __powf (float __x, float __y) throw ();
#pragma empty_line
#pragma empty_line
extern float sqrtf (float __x) throw (); extern float __sqrtf (float __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern float hypotf (float __x, float __y) throw (); extern float __hypotf (float __x, float __y) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern float cbrtf (float __x) throw (); extern float __cbrtf (float __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern float ceilf (float __x) throw () __attribute__ ((__const__)); extern float __ceilf (float __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern float fabsf (float __x) throw () __attribute__ ((__const__)); extern float __fabsf (float __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern float floorf (float __x) throw () __attribute__ ((__const__)); extern float __floorf (float __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern float fmodf (float __x, float __y) throw (); extern float __fmodf (float __x, float __y) throw ();
#pragma line 177 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern int isinff (float __value) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int finitef (float __value) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern float dremf (float __x, float __y) throw (); extern float __dremf (float __x, float __y) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern float significandf (float __x) throw (); extern float __significandf (float __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern float copysignf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern float nanf (const char *__tagb) throw (); extern float __nanf (const char *__tagb) throw ();
#pragma line 211 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern int isnanf (float __value) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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 ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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 ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern float tgammaf (float) throw (); extern float __tgammaf (float) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern float gammaf (float) throw (); extern float __gammaf (float) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern float lgammaf_r (float, int *__signgamp) throw (); extern float __lgammaf_r (float, int *__signgamp) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern float rintf (float __x) throw (); extern float __rintf (float __x) throw ();
#pragma empty_line
#pragma empty_line
extern float nextafterf (float __x, float __y) throw (); extern float __nextafterf (float __x, float __y) throw ();
#pragma empty_line
extern float nexttowardf (float __x, long double __y) throw (); extern float __nexttowardf (float __x, long double __y) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern float nextdownf (float __x) throw (); extern float __nextdownf (float __x) throw ();
#pragma empty_line
extern float nextupf (float __x) throw (); extern float __nextupf (float __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern float remainderf (float __x, float __y) throw (); extern float __remainderf (float __x, float __y) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern float scalbnf (float __x, int __n) throw (); extern float __scalbnf (float __x, int __n) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int ilogbf (float __x) throw (); extern int __ilogbf (float __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long int llogbf (float __x) throw (); extern long int __llogbf (float __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern float scalblnf (float __x, long int __n) throw (); extern float __scalblnf (float __x, long int __n) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern float nearbyintf (float __x) throw (); extern float __nearbyintf (float __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern float roundf (float __x) throw () __attribute__ ((__const__)); extern float __roundf (float __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern float truncf (float __x) throw () __attribute__ ((__const__)); extern float __truncf (float __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern float remquof (float __x, float __y, int *__quo) throw (); extern float __remquof (float __x, float __y, int *__quo) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long int lrintf (float __x) throw (); extern long int __lrintf (float __x) throw ();
__extension__
extern long long int llrintf (float __x) throw (); extern long long int __llrintf (float __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long int lroundf (float __x) throw (); extern long int __lroundf (float __x) throw ();
__extension__
extern long long int llroundf (float __x) throw (); extern long long int __llroundf (float __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern float fdimf (float __x, float __y) throw (); extern float __fdimf (float __x, float __y) throw ();
#pragma empty_line
#pragma empty_line
extern float fmaxf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fmaxf (float __x, float __y) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern float fminf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fminf (float __x, float __y) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern float fmaf (float __x, float __y, float __z) throw (); extern float __fmaf (float __x, float __y, float __z) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern float roundevenf (float __x) throw () __attribute__ ((__const__)); extern float __roundevenf (float __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __intmax_t fromfpf (float __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpf (float __x, int __round, unsigned int __width) throw ()
;
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __uintmax_t ufromfpf (float __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpf (float __x, int __round, unsigned int __width) throw ()
;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __intmax_t fromfpxf (float __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxf (float __x, int __round, unsigned int __width) throw ()
;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __uintmax_t ufromfpxf (float __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxf (float __x, int __round, unsigned int __width) throw ()
;
#pragma empty_line
#pragma empty_line
extern float fmaxmagf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fmaxmagf (float __x, float __y) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern float fminmagf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fminmagf (float __x, float __y) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern int canonicalizef (float *__cx, const float *__x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int totalorderf (const float *__x, const float *__y) throw ()
#pragma empty_line
__attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
extern int totalordermagf (const float *__x, const float *__y) throw ()
#pragma empty_line
__attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
extern float getpayloadf (const float *__x) throw (); extern float __getpayloadf (const float *__x) throw ();
#pragma empty_line
#pragma empty_line
extern int setpayloadf (float *__x, float __payload) throw ();
#pragma empty_line
#pragma empty_line
extern int setpayloadsigf (float *__x, float __payload) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern float scalbf (float __x, float __n) throw (); extern float __scalbf (float __x, float __n) throw ();
#pragma line 308 "/usr/include/math.h" 2 3 4
#pragma line 349 "/usr/include/math.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 1 3 4
#pragma line 21 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 3 4
extern int __fpclassifyl (long double __value) throw ()
__attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern int __signbitl (long double __value) throw ()
__attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int __isinfl (long double __value) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern int __finitel (long double __value) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern int __isnanl (long double __value) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern int __iseqsigl (long double __x, long double __y) throw ();
#pragma empty_line
#pragma empty_line
extern int __issignalingl (long double __value) throw ()
__attribute__ ((__const__));
#pragma line 350 "/usr/include/math.h" 2 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4
#pragma line 53 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern long double acosl (long double __x) throw (); extern long double __acosl (long double __x) throw ();
#pragma empty_line
extern long double asinl (long double __x) throw (); extern long double __asinl (long double __x) throw ();
#pragma empty_line
extern long double atanl (long double __x) throw (); extern long double __atanl (long double __x) throw ();
#pragma empty_line
extern long double atan2l (long double __y, long double __x) throw (); extern long double __atan2l (long double __y, long double __x) throw ();
#pragma empty_line
#pragma empty_line
extern long double cosl (long double __x) throw (); extern long double __cosl (long double __x) throw ();
#pragma empty_line
extern long double sinl (long double __x) throw (); extern long double __sinl (long double __x) throw ();
#pragma empty_line
extern long double tanl (long double __x) throw (); extern long double __tanl (long double __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long double coshl (long double __x) throw (); extern long double __coshl (long double __x) throw ();
#pragma empty_line
extern long double sinhl (long double __x) throw (); extern long double __sinhl (long double __x) throw ();
#pragma empty_line
extern long double tanhl (long double __x) throw (); extern long double __tanhl (long double __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
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 ()
;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long double acoshl (long double __x) throw (); extern long double __acoshl (long double __x) throw ();
#pragma empty_line
extern long double asinhl (long double __x) throw (); extern long double __asinhl (long double __x) throw ();
#pragma empty_line
extern long double atanhl (long double __x) throw (); extern long double __atanhl (long double __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long double expl (long double __x) throw (); extern long double __expl (long double __x) throw ();
#pragma empty_line
#pragma empty_line
extern long double frexpl (long double __x, int *__exponent) throw (); extern long double __frexpl (long double __x, int *__exponent) throw ();
#pragma empty_line
#pragma empty_line
extern long double ldexpl (long double __x, int __exponent) throw (); extern long double __ldexpl (long double __x, int __exponent) throw ();
#pragma empty_line
#pragma empty_line
extern long double logl (long double __x) throw (); extern long double __logl (long double __x) throw ();
#pragma empty_line
#pragma empty_line
extern long double log10l (long double __x) throw (); extern long double __log10l (long double __x) throw ();
#pragma empty_line
#pragma empty_line
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)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long double exp10l (long double __x) throw (); extern long double __exp10l (long double __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long double expm1l (long double __x) throw (); extern long double __expm1l (long double __x) throw ();
#pragma empty_line
#pragma empty_line
extern long double log1pl (long double __x) throw (); extern long double __log1pl (long double __x) throw ();
#pragma empty_line
#pragma empty_line
extern long double logbl (long double __x) throw (); extern long double __logbl (long double __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long double exp2l (long double __x) throw (); extern long double __exp2l (long double __x) throw ();
#pragma empty_line
#pragma empty_line
extern long double log2l (long double __x) throw (); extern long double __log2l (long double __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long double powl (long double __x, long double __y) throw (); extern long double __powl (long double __x, long double __y) throw ();
#pragma empty_line
#pragma empty_line
extern long double sqrtl (long double __x) throw (); extern long double __sqrtl (long double __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long double hypotl (long double __x, long double __y) throw (); extern long double __hypotl (long double __x, long double __y) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long double cbrtl (long double __x) throw (); extern long double __cbrtl (long double __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long double ceill (long double __x) throw () __attribute__ ((__const__)); extern long double __ceill (long double __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern long double fabsl (long double __x) throw () __attribute__ ((__const__)); extern long double __fabsl (long double __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern long double floorl (long double __x) throw () __attribute__ ((__const__)); extern long double __floorl (long double __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern long double fmodl (long double __x, long double __y) throw (); extern long double __fmodl (long double __x, long double __y) throw ();
#pragma line 177 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern int isinfl (long double __value) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int finitel (long double __value) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern long double dreml (long double __x, long double __y) throw (); extern long double __dreml (long double __x, long double __y) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long double significandl (long double __x) throw (); extern long double __significandl (long double __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long double nanl (const char *__tagb) throw (); extern long double __nanl (const char *__tagb) throw ();
#pragma line 211 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern int isnanl (long double __value) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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 ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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 ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long double tgammal (long double) throw (); extern long double __tgammal (long double) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long double gammal (long double) throw (); extern long double __gammal (long double) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long double lgammal_r (long double, int *__signgamp) throw (); extern long double __lgammal_r (long double, int *__signgamp) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long double rintl (long double __x) throw (); extern long double __rintl (long double __x) throw ();
#pragma empty_line
#pragma empty_line
extern long double nextafterl (long double __x, long double __y) throw (); extern long double __nextafterl (long double __x, long double __y) throw ();
#pragma empty_line
extern long double nexttowardl (long double __x, long double __y) throw (); extern long double __nexttowardl (long double __x, long double __y) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long double nextdownl (long double __x) throw (); extern long double __nextdownl (long double __x) throw ();
#pragma empty_line
extern long double nextupl (long double __x) throw (); extern long double __nextupl (long double __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long double remainderl (long double __x, long double __y) throw (); extern long double __remainderl (long double __x, long double __y) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long double scalbnl (long double __x, int __n) throw (); extern long double __scalbnl (long double __x, int __n) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int ilogbl (long double __x) throw (); extern int __ilogbl (long double __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long int llogbl (long double __x) throw (); extern long int __llogbl (long double __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long double scalblnl (long double __x, long int __n) throw (); extern long double __scalblnl (long double __x, long int __n) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long double nearbyintl (long double __x) throw (); extern long double __nearbyintl (long double __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long double roundl (long double __x) throw () __attribute__ ((__const__)); extern long double __roundl (long double __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long double truncl (long double __x) throw () __attribute__ ((__const__)); extern long double __truncl (long double __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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 ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long int lrintl (long double __x) throw (); extern long int __lrintl (long double __x) throw ();
__extension__
extern long long int llrintl (long double __x) throw (); extern long long int __llrintl (long double __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long int lroundl (long double __x) throw (); extern long int __lroundl (long double __x) throw ();
__extension__
extern long long int llroundl (long double __x) throw (); extern long long int __llroundl (long double __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long double fdiml (long double __x, long double __y) throw (); extern long double __fdiml (long double __x, long double __y) throw ();
#pragma empty_line
#pragma empty_line
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__));
#pragma empty_line
#pragma empty_line
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__));
#pragma empty_line
#pragma empty_line
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 ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long double roundevenl (long double __x) throw () __attribute__ ((__const__)); extern long double __roundevenl (long double __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __intmax_t fromfpl (long double __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpl (long double __x, int __round, unsigned int __width) throw ()
;
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __uintmax_t ufromfpl (long double __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpl (long double __x, int __round, unsigned int __width) throw ()
;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __intmax_t fromfpxl (long double __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxl (long double __x, int __round, unsigned int __width) throw ()
;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __uintmax_t ufromfpxl (long double __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxl (long double __x, int __round, unsigned int __width) throw ()
;
#pragma empty_line
#pragma empty_line
extern long double fmaxmagl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fmaxmagl (long double __x, long double __y) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern long double fminmagl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fminmagl (long double __x, long double __y) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern int canonicalizel (long double *__cx, const long double *__x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int totalorderl (const long double *__x, const long double *__y) throw ()
#pragma empty_line
__attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
extern int totalordermagl (const long double *__x, const long double *__y) throw ()
#pragma empty_line
__attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
extern long double getpayloadl (const long double *__x) throw (); extern long double __getpayloadl (const long double *__x) throw ();
#pragma empty_line
#pragma empty_line
extern int setpayloadl (long double *__x, long double __payload) throw ();
#pragma empty_line
#pragma empty_line
extern int setpayloadsigl (long double *__x, long double __payload) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long double scalbl (long double __x, long double __n) throw (); extern long double __scalbl (long double __x, long double __n) throw ();
#pragma line 351 "/usr/include/math.h" 2 3 4
#pragma line 389 "/usr/include/math.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4
#pragma line 53 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern _Float32 acosf32 (_Float32 __x) throw (); extern _Float32 __acosf32 (_Float32 __x) throw ();
#pragma empty_line
extern _Float32 asinf32 (_Float32 __x) throw (); extern _Float32 __asinf32 (_Float32 __x) throw ();
#pragma empty_line
extern _Float32 atanf32 (_Float32 __x) throw (); extern _Float32 __atanf32 (_Float32 __x) throw ();
#pragma empty_line
extern _Float32 atan2f32 (_Float32 __y, _Float32 __x) throw (); extern _Float32 __atan2f32 (_Float32 __y, _Float32 __x) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32 cosf32 (_Float32 __x) throw (); extern _Float32 __cosf32 (_Float32 __x) throw ();
#pragma empty_line
extern _Float32 sinf32 (_Float32 __x) throw (); extern _Float32 __sinf32 (_Float32 __x) throw ();
#pragma empty_line
extern _Float32 tanf32 (_Float32 __x) throw (); extern _Float32 __tanf32 (_Float32 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32 coshf32 (_Float32 __x) throw (); extern _Float32 __coshf32 (_Float32 __x) throw ();
#pragma empty_line
extern _Float32 sinhf32 (_Float32 __x) throw (); extern _Float32 __sinhf32 (_Float32 __x) throw ();
#pragma empty_line
extern _Float32 tanhf32 (_Float32 __x) throw (); extern _Float32 __tanhf32 (_Float32 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern void sincosf32 (_Float32 __x, _Float32 *__sinx, _Float32 *__cosx) throw (); extern void __sincosf32 (_Float32 __x, _Float32 *__sinx, _Float32 *__cosx) throw ()
;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32 acoshf32 (_Float32 __x) throw (); extern _Float32 __acoshf32 (_Float32 __x) throw ();
#pragma empty_line
extern _Float32 asinhf32 (_Float32 __x) throw (); extern _Float32 __asinhf32 (_Float32 __x) throw ();
#pragma empty_line
extern _Float32 atanhf32 (_Float32 __x) throw (); extern _Float32 __atanhf32 (_Float32 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32 expf32 (_Float32 __x) throw (); extern _Float32 __expf32 (_Float32 __x) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32 frexpf32 (_Float32 __x, int *__exponent) throw (); extern _Float32 __frexpf32 (_Float32 __x, int *__exponent) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32 ldexpf32 (_Float32 __x, int __exponent) throw (); extern _Float32 __ldexpf32 (_Float32 __x, int __exponent) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32 logf32 (_Float32 __x) throw (); extern _Float32 __logf32 (_Float32 __x) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32 log10f32 (_Float32 __x) throw (); extern _Float32 __log10f32 (_Float32 __x) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32 modff32 (_Float32 __x, _Float32 *__iptr) throw (); extern _Float32 __modff32 (_Float32 __x, _Float32 *__iptr) throw () __attribute__ ((__nonnull__ (2)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32 exp10f32 (_Float32 __x) throw (); extern _Float32 __exp10f32 (_Float32 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32 expm1f32 (_Float32 __x) throw (); extern _Float32 __expm1f32 (_Float32 __x) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32 log1pf32 (_Float32 __x) throw (); extern _Float32 __log1pf32 (_Float32 __x) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32 logbf32 (_Float32 __x) throw (); extern _Float32 __logbf32 (_Float32 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32 exp2f32 (_Float32 __x) throw (); extern _Float32 __exp2f32 (_Float32 __x) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32 log2f32 (_Float32 __x) throw (); extern _Float32 __log2f32 (_Float32 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32 powf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __powf32 (_Float32 __x, _Float32 __y) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32 sqrtf32 (_Float32 __x) throw (); extern _Float32 __sqrtf32 (_Float32 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32 hypotf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __hypotf32 (_Float32 __x, _Float32 __y) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32 cbrtf32 (_Float32 __x) throw (); extern _Float32 __cbrtf32 (_Float32 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32 ceilf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __ceilf32 (_Float32 __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern _Float32 fabsf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __fabsf32 (_Float32 __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern _Float32 floorf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __floorf32 (_Float32 __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern _Float32 fmodf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __fmodf32 (_Float32 __x, _Float32 __y) throw ();
#pragma line 196 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern _Float32 copysignf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern _Float32 __copysignf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32 nanf32 (const char *__tagb) throw (); extern _Float32 __nanf32 (const char *__tagb) throw ();
#pragma line 217 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern _Float32 j0f32 (_Float32) throw (); extern _Float32 __j0f32 (_Float32) throw ();
extern _Float32 j1f32 (_Float32) throw (); extern _Float32 __j1f32 (_Float32) throw ();
extern _Float32 jnf32 (int, _Float32) throw (); extern _Float32 __jnf32 (int, _Float32) throw ();
extern _Float32 y0f32 (_Float32) throw (); extern _Float32 __y0f32 (_Float32) throw ();
extern _Float32 y1f32 (_Float32) throw (); extern _Float32 __y1f32 (_Float32) throw ();
extern _Float32 ynf32 (int, _Float32) throw (); extern _Float32 __ynf32 (int, _Float32) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32 erff32 (_Float32) throw (); extern _Float32 __erff32 (_Float32) throw ();
extern _Float32 erfcf32 (_Float32) throw (); extern _Float32 __erfcf32 (_Float32) throw ();
extern _Float32 lgammaf32 (_Float32) throw (); extern _Float32 __lgammaf32 (_Float32) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32 tgammaf32 (_Float32) throw (); extern _Float32 __tgammaf32 (_Float32) throw ();
#pragma line 249 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern _Float32 lgammaf32_r (_Float32, int *__signgamp) throw (); extern _Float32 __lgammaf32_r (_Float32, int *__signgamp) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32 rintf32 (_Float32 __x) throw (); extern _Float32 __rintf32 (_Float32 __x) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32 nextafterf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __nextafterf32 (_Float32 __x, _Float32 __y) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32 nextdownf32 (_Float32 __x) throw (); extern _Float32 __nextdownf32 (_Float32 __x) throw ();
#pragma empty_line
extern _Float32 nextupf32 (_Float32 __x) throw (); extern _Float32 __nextupf32 (_Float32 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32 remainderf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __remainderf32 (_Float32 __x, _Float32 __y) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32 scalbnf32 (_Float32 __x, int __n) throw (); extern _Float32 __scalbnf32 (_Float32 __x, int __n) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int ilogbf32 (_Float32 __x) throw (); extern int __ilogbf32 (_Float32 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long int llogbf32 (_Float32 __x) throw (); extern long int __llogbf32 (_Float32 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32 scalblnf32 (_Float32 __x, long int __n) throw (); extern _Float32 __scalblnf32 (_Float32 __x, long int __n) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32 nearbyintf32 (_Float32 __x) throw (); extern _Float32 __nearbyintf32 (_Float32 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32 roundf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __roundf32 (_Float32 __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32 truncf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __truncf32 (_Float32 __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32 remquof32 (_Float32 __x, _Float32 __y, int *__quo) throw (); extern _Float32 __remquof32 (_Float32 __x, _Float32 __y, int *__quo) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long int lrintf32 (_Float32 __x) throw (); extern long int __lrintf32 (_Float32 __x) throw ();
__extension__
extern long long int llrintf32 (_Float32 __x) throw (); extern long long int __llrintf32 (_Float32 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long int lroundf32 (_Float32 __x) throw (); extern long int __lroundf32 (_Float32 __x) throw ();
__extension__
extern long long int llroundf32 (_Float32 __x) throw (); extern long long int __llroundf32 (_Float32 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32 fdimf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __fdimf32 (_Float32 __x, _Float32 __y) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32 fmaxf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern _Float32 __fmaxf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern _Float32 fminf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern _Float32 __fminf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern _Float32 fmaf32 (_Float32 __x, _Float32 __y, _Float32 __z) throw (); extern _Float32 __fmaf32 (_Float32 __x, _Float32 __y, _Float32 __z) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32 roundevenf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __roundevenf32 (_Float32 __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __intmax_t fromfpf32 (_Float32 __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpf32 (_Float32 __x, int __round, unsigned int __width) throw ()
;
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __uintmax_t ufromfpf32 (_Float32 __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpf32 (_Float32 __x, int __round, unsigned int __width) throw ()
;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __intmax_t fromfpxf32 (_Float32 __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxf32 (_Float32 __x, int __round, unsigned int __width) throw ()
;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __uintmax_t ufromfpxf32 (_Float32 __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxf32 (_Float32 __x, int __round, unsigned int __width) throw ()
;
#pragma empty_line
#pragma empty_line
extern _Float32 fmaxmagf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern _Float32 __fmaxmagf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern _Float32 fminmagf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern _Float32 __fminmagf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern int canonicalizef32 (_Float32 *__cx, const _Float32 *__x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int totalorderf32 (const _Float32 *__x, const _Float32 *__y) throw ()
#pragma empty_line
__attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
extern int totalordermagf32 (const _Float32 *__x, const _Float32 *__y) throw ()
#pragma empty_line
__attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
extern _Float32 getpayloadf32 (const _Float32 *__x) throw (); extern _Float32 __getpayloadf32 (const _Float32 *__x) throw ();
#pragma empty_line
#pragma empty_line
extern int setpayloadf32 (_Float32 *__x, _Float32 __payload) throw ();
#pragma empty_line
#pragma empty_line
extern int setpayloadsigf32 (_Float32 *__x, _Float32 __payload) throw ();
#pragma line 390 "/usr/include/math.h" 2 3 4
#pragma line 406 "/usr/include/math.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4
#pragma line 53 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern _Float64 acosf64 (_Float64 __x) throw (); extern _Float64 __acosf64 (_Float64 __x) throw ();
#pragma empty_line
extern _Float64 asinf64 (_Float64 __x) throw (); extern _Float64 __asinf64 (_Float64 __x) throw ();
#pragma empty_line
extern _Float64 atanf64 (_Float64 __x) throw (); extern _Float64 __atanf64 (_Float64 __x) throw ();
#pragma empty_line
extern _Float64 atan2f64 (_Float64 __y, _Float64 __x) throw (); extern _Float64 __atan2f64 (_Float64 __y, _Float64 __x) throw ();
#pragma empty_line
#pragma empty_line
extern _Float64 cosf64 (_Float64 __x) throw (); extern _Float64 __cosf64 (_Float64 __x) throw ();
#pragma empty_line
extern _Float64 sinf64 (_Float64 __x) throw (); extern _Float64 __sinf64 (_Float64 __x) throw ();
#pragma empty_line
extern _Float64 tanf64 (_Float64 __x) throw (); extern _Float64 __tanf64 (_Float64 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64 coshf64 (_Float64 __x) throw (); extern _Float64 __coshf64 (_Float64 __x) throw ();
#pragma empty_line
extern _Float64 sinhf64 (_Float64 __x) throw (); extern _Float64 __sinhf64 (_Float64 __x) throw ();
#pragma empty_line
extern _Float64 tanhf64 (_Float64 __x) throw (); extern _Float64 __tanhf64 (_Float64 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern void sincosf64 (_Float64 __x, _Float64 *__sinx, _Float64 *__cosx) throw (); extern void __sincosf64 (_Float64 __x, _Float64 *__sinx, _Float64 *__cosx) throw ()
;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64 acoshf64 (_Float64 __x) throw (); extern _Float64 __acoshf64 (_Float64 __x) throw ();
#pragma empty_line
extern _Float64 asinhf64 (_Float64 __x) throw (); extern _Float64 __asinhf64 (_Float64 __x) throw ();
#pragma empty_line
extern _Float64 atanhf64 (_Float64 __x) throw (); extern _Float64 __atanhf64 (_Float64 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64 expf64 (_Float64 __x) throw (); extern _Float64 __expf64 (_Float64 __x) throw ();
#pragma empty_line
#pragma empty_line
extern _Float64 frexpf64 (_Float64 __x, int *__exponent) throw (); extern _Float64 __frexpf64 (_Float64 __x, int *__exponent) throw ();
#pragma empty_line
#pragma empty_line
extern _Float64 ldexpf64 (_Float64 __x, int __exponent) throw (); extern _Float64 __ldexpf64 (_Float64 __x, int __exponent) throw ();
#pragma empty_line
#pragma empty_line
extern _Float64 logf64 (_Float64 __x) throw (); extern _Float64 __logf64 (_Float64 __x) throw ();
#pragma empty_line
#pragma empty_line
extern _Float64 log10f64 (_Float64 __x) throw (); extern _Float64 __log10f64 (_Float64 __x) throw ();
#pragma empty_line
#pragma empty_line
extern _Float64 modff64 (_Float64 __x, _Float64 *__iptr) throw (); extern _Float64 __modff64 (_Float64 __x, _Float64 *__iptr) throw () __attribute__ ((__nonnull__ (2)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64 exp10f64 (_Float64 __x) throw (); extern _Float64 __exp10f64 (_Float64 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64 expm1f64 (_Float64 __x) throw (); extern _Float64 __expm1f64 (_Float64 __x) throw ();
#pragma empty_line
#pragma empty_line
extern _Float64 log1pf64 (_Float64 __x) throw (); extern _Float64 __log1pf64 (_Float64 __x) throw ();
#pragma empty_line
#pragma empty_line
extern _Float64 logbf64 (_Float64 __x) throw (); extern _Float64 __logbf64 (_Float64 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64 exp2f64 (_Float64 __x) throw (); extern _Float64 __exp2f64 (_Float64 __x) throw ();
#pragma empty_line
#pragma empty_line
extern _Float64 log2f64 (_Float64 __x) throw (); extern _Float64 __log2f64 (_Float64 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64 powf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __powf64 (_Float64 __x, _Float64 __y) throw ();
#pragma empty_line
#pragma empty_line
extern _Float64 sqrtf64 (_Float64 __x) throw (); extern _Float64 __sqrtf64 (_Float64 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64 hypotf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __hypotf64 (_Float64 __x, _Float64 __y) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64 cbrtf64 (_Float64 __x) throw (); extern _Float64 __cbrtf64 (_Float64 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64 ceilf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __ceilf64 (_Float64 __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern _Float64 fabsf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __fabsf64 (_Float64 __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern _Float64 floorf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __floorf64 (_Float64 __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern _Float64 fmodf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __fmodf64 (_Float64 __x, _Float64 __y) throw ();
#pragma line 196 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern _Float64 copysignf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern _Float64 __copysignf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64 nanf64 (const char *__tagb) throw (); extern _Float64 __nanf64 (const char *__tagb) throw ();
#pragma line 217 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern _Float64 j0f64 (_Float64) throw (); extern _Float64 __j0f64 (_Float64) throw ();
extern _Float64 j1f64 (_Float64) throw (); extern _Float64 __j1f64 (_Float64) throw ();
extern _Float64 jnf64 (int, _Float64) throw (); extern _Float64 __jnf64 (int, _Float64) throw ();
extern _Float64 y0f64 (_Float64) throw (); extern _Float64 __y0f64 (_Float64) throw ();
extern _Float64 y1f64 (_Float64) throw (); extern _Float64 __y1f64 (_Float64) throw ();
extern _Float64 ynf64 (int, _Float64) throw (); extern _Float64 __ynf64 (int, _Float64) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64 erff64 (_Float64) throw (); extern _Float64 __erff64 (_Float64) throw ();
extern _Float64 erfcf64 (_Float64) throw (); extern _Float64 __erfcf64 (_Float64) throw ();
extern _Float64 lgammaf64 (_Float64) throw (); extern _Float64 __lgammaf64 (_Float64) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64 tgammaf64 (_Float64) throw (); extern _Float64 __tgammaf64 (_Float64) throw ();
#pragma line 249 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern _Float64 lgammaf64_r (_Float64, int *__signgamp) throw (); extern _Float64 __lgammaf64_r (_Float64, int *__signgamp) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64 rintf64 (_Float64 __x) throw (); extern _Float64 __rintf64 (_Float64 __x) throw ();
#pragma empty_line
#pragma empty_line
extern _Float64 nextafterf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __nextafterf64 (_Float64 __x, _Float64 __y) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64 nextdownf64 (_Float64 __x) throw (); extern _Float64 __nextdownf64 (_Float64 __x) throw ();
#pragma empty_line
extern _Float64 nextupf64 (_Float64 __x) throw (); extern _Float64 __nextupf64 (_Float64 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64 remainderf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __remainderf64 (_Float64 __x, _Float64 __y) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64 scalbnf64 (_Float64 __x, int __n) throw (); extern _Float64 __scalbnf64 (_Float64 __x, int __n) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int ilogbf64 (_Float64 __x) throw (); extern int __ilogbf64 (_Float64 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long int llogbf64 (_Float64 __x) throw (); extern long int __llogbf64 (_Float64 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64 scalblnf64 (_Float64 __x, long int __n) throw (); extern _Float64 __scalblnf64 (_Float64 __x, long int __n) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64 nearbyintf64 (_Float64 __x) throw (); extern _Float64 __nearbyintf64 (_Float64 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64 roundf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __roundf64 (_Float64 __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64 truncf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __truncf64 (_Float64 __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64 remquof64 (_Float64 __x, _Float64 __y, int *__quo) throw (); extern _Float64 __remquof64 (_Float64 __x, _Float64 __y, int *__quo) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long int lrintf64 (_Float64 __x) throw (); extern long int __lrintf64 (_Float64 __x) throw ();
__extension__
extern long long int llrintf64 (_Float64 __x) throw (); extern long long int __llrintf64 (_Float64 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long int lroundf64 (_Float64 __x) throw (); extern long int __lroundf64 (_Float64 __x) throw ();
__extension__
extern long long int llroundf64 (_Float64 __x) throw (); extern long long int __llroundf64 (_Float64 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64 fdimf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __fdimf64 (_Float64 __x, _Float64 __y) throw ();
#pragma empty_line
#pragma empty_line
extern _Float64 fmaxf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern _Float64 __fmaxf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern _Float64 fminf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern _Float64 __fminf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern _Float64 fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) throw (); extern _Float64 __fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64 roundevenf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __roundevenf64 (_Float64 __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __intmax_t fromfpf64 (_Float64 __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpf64 (_Float64 __x, int __round, unsigned int __width) throw ()
;
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __uintmax_t ufromfpf64 (_Float64 __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpf64 (_Float64 __x, int __round, unsigned int __width) throw ()
;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __intmax_t fromfpxf64 (_Float64 __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxf64 (_Float64 __x, int __round, unsigned int __width) throw ()
;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __uintmax_t ufromfpxf64 (_Float64 __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxf64 (_Float64 __x, int __round, unsigned int __width) throw ()
;
#pragma empty_line
#pragma empty_line
extern _Float64 fmaxmagf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern _Float64 __fmaxmagf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern _Float64 fminmagf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern _Float64 __fminmagf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern int canonicalizef64 (_Float64 *__cx, const _Float64 *__x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int totalorderf64 (const _Float64 *__x, const _Float64 *__y) throw ()
#pragma empty_line
__attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
extern int totalordermagf64 (const _Float64 *__x, const _Float64 *__y) throw ()
#pragma empty_line
__attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
extern _Float64 getpayloadf64 (const _Float64 *__x) throw (); extern _Float64 __getpayloadf64 (const _Float64 *__x) throw ();
#pragma empty_line
#pragma empty_line
extern int setpayloadf64 (_Float64 *__x, _Float64 __payload) throw ();
#pragma empty_line
#pragma empty_line
extern int setpayloadsigf64 (_Float64 *__x, _Float64 __payload) throw ();
#pragma line 407 "/usr/include/math.h" 2 3 4
#pragma line 420 "/usr/include/math.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 1 3 4
#pragma line 21 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 3 4
extern int __fpclassifyf128 (_Float128 __value) throw ()
__attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern int __signbitf128 (_Float128 __value) throw ()
__attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int __isinff128 (_Float128 __value) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern int __finitef128 (_Float128 __value) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern int __isnanf128 (_Float128 __value) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern int __iseqsigf128 (_Float128 __x, _Float128 __y) throw ();
#pragma empty_line
#pragma empty_line
extern int __issignalingf128 (_Float128 __value) throw ()
__attribute__ ((__const__));
#pragma line 421 "/usr/include/math.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4
#pragma line 53 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern _Float128 acosf128 (_Float128 __x) throw (); extern _Float128 __acosf128 (_Float128 __x) throw ();
#pragma empty_line
extern _Float128 asinf128 (_Float128 __x) throw (); extern _Float128 __asinf128 (_Float128 __x) throw ();
#pragma empty_line
extern _Float128 atanf128 (_Float128 __x) throw (); extern _Float128 __atanf128 (_Float128 __x) throw ();
#pragma empty_line
extern _Float128 atan2f128 (_Float128 __y, _Float128 __x) throw (); extern _Float128 __atan2f128 (_Float128 __y, _Float128 __x) throw ();
#pragma empty_line
#pragma empty_line
extern _Float128 cosf128 (_Float128 __x) throw (); extern _Float128 __cosf128 (_Float128 __x) throw ();
#pragma empty_line
extern _Float128 sinf128 (_Float128 __x) throw (); extern _Float128 __sinf128 (_Float128 __x) throw ();
#pragma empty_line
extern _Float128 tanf128 (_Float128 __x) throw (); extern _Float128 __tanf128 (_Float128 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float128 coshf128 (_Float128 __x) throw (); extern _Float128 __coshf128 (_Float128 __x) throw ();
#pragma empty_line
extern _Float128 sinhf128 (_Float128 __x) throw (); extern _Float128 __sinhf128 (_Float128 __x) throw ();
#pragma empty_line
extern _Float128 tanhf128 (_Float128 __x) throw (); extern _Float128 __tanhf128 (_Float128 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern void sincosf128 (_Float128 __x, _Float128 *__sinx, _Float128 *__cosx) throw (); extern void __sincosf128 (_Float128 __x, _Float128 *__sinx, _Float128 *__cosx) throw ()
;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float128 acoshf128 (_Float128 __x) throw (); extern _Float128 __acoshf128 (_Float128 __x) throw ();
#pragma empty_line
extern _Float128 asinhf128 (_Float128 __x) throw (); extern _Float128 __asinhf128 (_Float128 __x) throw ();
#pragma empty_line
extern _Float128 atanhf128 (_Float128 __x) throw (); extern _Float128 __atanhf128 (_Float128 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float128 expf128 (_Float128 __x) throw (); extern _Float128 __expf128 (_Float128 __x) throw ();
#pragma empty_line
#pragma empty_line
extern _Float128 frexpf128 (_Float128 __x, int *__exponent) throw (); extern _Float128 __frexpf128 (_Float128 __x, int *__exponent) throw ();
#pragma empty_line
#pragma empty_line
extern _Float128 ldexpf128 (_Float128 __x, int __exponent) throw (); extern _Float128 __ldexpf128 (_Float128 __x, int __exponent) throw ();
#pragma empty_line
#pragma empty_line
extern _Float128 logf128 (_Float128 __x) throw (); extern _Float128 __logf128 (_Float128 __x) throw ();
#pragma empty_line
#pragma empty_line
extern _Float128 log10f128 (_Float128 __x) throw (); extern _Float128 __log10f128 (_Float128 __x) throw ();
#pragma empty_line
#pragma empty_line
extern _Float128 modff128 (_Float128 __x, _Float128 *__iptr) throw (); extern _Float128 __modff128 (_Float128 __x, _Float128 *__iptr) throw () __attribute__ ((__nonnull__ (2)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float128 exp10f128 (_Float128 __x) throw (); extern _Float128 __exp10f128 (_Float128 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float128 expm1f128 (_Float128 __x) throw (); extern _Float128 __expm1f128 (_Float128 __x) throw ();
#pragma empty_line
#pragma empty_line
extern _Float128 log1pf128 (_Float128 __x) throw (); extern _Float128 __log1pf128 (_Float128 __x) throw ();
#pragma empty_line
#pragma empty_line
extern _Float128 logbf128 (_Float128 __x) throw (); extern _Float128 __logbf128 (_Float128 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float128 exp2f128 (_Float128 __x) throw (); extern _Float128 __exp2f128 (_Float128 __x) throw ();
#pragma empty_line
#pragma empty_line
extern _Float128 log2f128 (_Float128 __x) throw (); extern _Float128 __log2f128 (_Float128 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float128 powf128 (_Float128 __x, _Float128 __y) throw (); extern _Float128 __powf128 (_Float128 __x, _Float128 __y) throw ();
#pragma empty_line
#pragma empty_line
extern _Float128 sqrtf128 (_Float128 __x) throw (); extern _Float128 __sqrtf128 (_Float128 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float128 hypotf128 (_Float128 __x, _Float128 __y) throw (); extern _Float128 __hypotf128 (_Float128 __x, _Float128 __y) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float128 cbrtf128 (_Float128 __x) throw (); extern _Float128 __cbrtf128 (_Float128 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float128 ceilf128 (_Float128 __x) throw () __attribute__ ((__const__)); extern _Float128 __ceilf128 (_Float128 __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern _Float128 fabsf128 (_Float128 __x) throw () __attribute__ ((__const__)); extern _Float128 __fabsf128 (_Float128 __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern _Float128 floorf128 (_Float128 __x) throw () __attribute__ ((__const__)); extern _Float128 __floorf128 (_Float128 __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern _Float128 fmodf128 (_Float128 __x, _Float128 __y) throw (); extern _Float128 __fmodf128 (_Float128 __x, _Float128 __y) throw ();
#pragma line 196 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern _Float128 copysignf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__)); extern _Float128 __copysignf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float128 nanf128 (const char *__tagb) throw (); extern _Float128 __nanf128 (const char *__tagb) throw ();
#pragma line 217 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern _Float128 j0f128 (_Float128) throw (); extern _Float128 __j0f128 (_Float128) throw ();
extern _Float128 j1f128 (_Float128) throw (); extern _Float128 __j1f128 (_Float128) throw ();
extern _Float128 jnf128 (int, _Float128) throw (); extern _Float128 __jnf128 (int, _Float128) throw ();
extern _Float128 y0f128 (_Float128) throw (); extern _Float128 __y0f128 (_Float128) throw ();
extern _Float128 y1f128 (_Float128) throw (); extern _Float128 __y1f128 (_Float128) throw ();
extern _Float128 ynf128 (int, _Float128) throw (); extern _Float128 __ynf128 (int, _Float128) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float128 erff128 (_Float128) throw (); extern _Float128 __erff128 (_Float128) throw ();
extern _Float128 erfcf128 (_Float128) throw (); extern _Float128 __erfcf128 (_Float128) throw ();
extern _Float128 lgammaf128 (_Float128) throw (); extern _Float128 __lgammaf128 (_Float128) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float128 tgammaf128 (_Float128) throw (); extern _Float128 __tgammaf128 (_Float128) throw ();
#pragma line 249 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern _Float128 lgammaf128_r (_Float128, int *__signgamp) throw (); extern _Float128 __lgammaf128_r (_Float128, int *__signgamp) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float128 rintf128 (_Float128 __x) throw (); extern _Float128 __rintf128 (_Float128 __x) throw ();
#pragma empty_line
#pragma empty_line
extern _Float128 nextafterf128 (_Float128 __x, _Float128 __y) throw (); extern _Float128 __nextafterf128 (_Float128 __x, _Float128 __y) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float128 nextdownf128 (_Float128 __x) throw (); extern _Float128 __nextdownf128 (_Float128 __x) throw ();
#pragma empty_line
extern _Float128 nextupf128 (_Float128 __x) throw (); extern _Float128 __nextupf128 (_Float128 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float128 remainderf128 (_Float128 __x, _Float128 __y) throw (); extern _Float128 __remainderf128 (_Float128 __x, _Float128 __y) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float128 scalbnf128 (_Float128 __x, int __n) throw (); extern _Float128 __scalbnf128 (_Float128 __x, int __n) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int ilogbf128 (_Float128 __x) throw (); extern int __ilogbf128 (_Float128 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long int llogbf128 (_Float128 __x) throw (); extern long int __llogbf128 (_Float128 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float128 scalblnf128 (_Float128 __x, long int __n) throw (); extern _Float128 __scalblnf128 (_Float128 __x, long int __n) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float128 nearbyintf128 (_Float128 __x) throw (); extern _Float128 __nearbyintf128 (_Float128 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float128 roundf128 (_Float128 __x) throw () __attribute__ ((__const__)); extern _Float128 __roundf128 (_Float128 __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float128 truncf128 (_Float128 __x) throw () __attribute__ ((__const__)); extern _Float128 __truncf128 (_Float128 __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float128 remquof128 (_Float128 __x, _Float128 __y, int *__quo) throw (); extern _Float128 __remquof128 (_Float128 __x, _Float128 __y, int *__quo) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long int lrintf128 (_Float128 __x) throw (); extern long int __lrintf128 (_Float128 __x) throw ();
__extension__
extern long long int llrintf128 (_Float128 __x) throw (); extern long long int __llrintf128 (_Float128 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long int lroundf128 (_Float128 __x) throw (); extern long int __lroundf128 (_Float128 __x) throw ();
__extension__
extern long long int llroundf128 (_Float128 __x) throw (); extern long long int __llroundf128 (_Float128 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float128 fdimf128 (_Float128 __x, _Float128 __y) throw (); extern _Float128 __fdimf128 (_Float128 __x, _Float128 __y) throw ();
#pragma empty_line
#pragma empty_line
extern _Float128 fmaxf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__)); extern _Float128 __fmaxf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern _Float128 fminf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__)); extern _Float128 __fminf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern _Float128 fmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) throw (); extern _Float128 __fmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float128 roundevenf128 (_Float128 __x) throw () __attribute__ ((__const__)); extern _Float128 __roundevenf128 (_Float128 __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __intmax_t fromfpf128 (_Float128 __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpf128 (_Float128 __x, int __round, unsigned int __width) throw ()
;
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __uintmax_t ufromfpf128 (_Float128 __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpf128 (_Float128 __x, int __round, unsigned int __width) throw ()
;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __intmax_t fromfpxf128 (_Float128 __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxf128 (_Float128 __x, int __round, unsigned int __width) throw ()
;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __uintmax_t ufromfpxf128 (_Float128 __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxf128 (_Float128 __x, int __round, unsigned int __width) throw ()
;
#pragma empty_line
#pragma empty_line
extern _Float128 fmaxmagf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__)); extern _Float128 __fmaxmagf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern _Float128 fminmagf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__)); extern _Float128 __fminmagf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern int canonicalizef128 (_Float128 *__cx, const _Float128 *__x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int totalorderf128 (const _Float128 *__x, const _Float128 *__y) throw ()
#pragma empty_line
__attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
extern int totalordermagf128 (const _Float128 *__x, const _Float128 *__y) throw ()
#pragma empty_line
__attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
extern _Float128 getpayloadf128 (const _Float128 *__x) throw (); extern _Float128 __getpayloadf128 (const _Float128 *__x) throw ();
#pragma empty_line
#pragma empty_line
extern int setpayloadf128 (_Float128 *__x, _Float128 __payload) throw ();
#pragma empty_line
#pragma empty_line
extern int setpayloadsigf128 (_Float128 *__x, _Float128 __payload) throw ();
#pragma line 424 "/usr/include/math.h" 2 3 4
#pragma line 440 "/usr/include/math.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4
#pragma line 53 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern _Float32x acosf32x (_Float32x __x) throw (); extern _Float32x __acosf32x (_Float32x __x) throw ();
#pragma empty_line
extern _Float32x asinf32x (_Float32x __x) throw (); extern _Float32x __asinf32x (_Float32x __x) throw ();
#pragma empty_line
extern _Float32x atanf32x (_Float32x __x) throw (); extern _Float32x __atanf32x (_Float32x __x) throw ();
#pragma empty_line
extern _Float32x atan2f32x (_Float32x __y, _Float32x __x) throw (); extern _Float32x __atan2f32x (_Float32x __y, _Float32x __x) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32x cosf32x (_Float32x __x) throw (); extern _Float32x __cosf32x (_Float32x __x) throw ();
#pragma empty_line
extern _Float32x sinf32x (_Float32x __x) throw (); extern _Float32x __sinf32x (_Float32x __x) throw ();
#pragma empty_line
extern _Float32x tanf32x (_Float32x __x) throw (); extern _Float32x __tanf32x (_Float32x __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32x coshf32x (_Float32x __x) throw (); extern _Float32x __coshf32x (_Float32x __x) throw ();
#pragma empty_line
extern _Float32x sinhf32x (_Float32x __x) throw (); extern _Float32x __sinhf32x (_Float32x __x) throw ();
#pragma empty_line
extern _Float32x tanhf32x (_Float32x __x) throw (); extern _Float32x __tanhf32x (_Float32x __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern void sincosf32x (_Float32x __x, _Float32x *__sinx, _Float32x *__cosx) throw (); extern void __sincosf32x (_Float32x __x, _Float32x *__sinx, _Float32x *__cosx) throw ()
;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32x acoshf32x (_Float32x __x) throw (); extern _Float32x __acoshf32x (_Float32x __x) throw ();
#pragma empty_line
extern _Float32x asinhf32x (_Float32x __x) throw (); extern _Float32x __asinhf32x (_Float32x __x) throw ();
#pragma empty_line
extern _Float32x atanhf32x (_Float32x __x) throw (); extern _Float32x __atanhf32x (_Float32x __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32x expf32x (_Float32x __x) throw (); extern _Float32x __expf32x (_Float32x __x) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32x frexpf32x (_Float32x __x, int *__exponent) throw (); extern _Float32x __frexpf32x (_Float32x __x, int *__exponent) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32x ldexpf32x (_Float32x __x, int __exponent) throw (); extern _Float32x __ldexpf32x (_Float32x __x, int __exponent) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32x logf32x (_Float32x __x) throw (); extern _Float32x __logf32x (_Float32x __x) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32x log10f32x (_Float32x __x) throw (); extern _Float32x __log10f32x (_Float32x __x) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32x modff32x (_Float32x __x, _Float32x *__iptr) throw (); extern _Float32x __modff32x (_Float32x __x, _Float32x *__iptr) throw () __attribute__ ((__nonnull__ (2)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32x exp10f32x (_Float32x __x) throw (); extern _Float32x __exp10f32x (_Float32x __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32x expm1f32x (_Float32x __x) throw (); extern _Float32x __expm1f32x (_Float32x __x) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32x log1pf32x (_Float32x __x) throw (); extern _Float32x __log1pf32x (_Float32x __x) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32x logbf32x (_Float32x __x) throw (); extern _Float32x __logbf32x (_Float32x __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32x exp2f32x (_Float32x __x) throw (); extern _Float32x __exp2f32x (_Float32x __x) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32x log2f32x (_Float32x __x) throw (); extern _Float32x __log2f32x (_Float32x __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32x powf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __powf32x (_Float32x __x, _Float32x __y) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32x sqrtf32x (_Float32x __x) throw (); extern _Float32x __sqrtf32x (_Float32x __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32x hypotf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __hypotf32x (_Float32x __x, _Float32x __y) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32x cbrtf32x (_Float32x __x) throw (); extern _Float32x __cbrtf32x (_Float32x __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32x ceilf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __ceilf32x (_Float32x __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern _Float32x fabsf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __fabsf32x (_Float32x __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern _Float32x floorf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __floorf32x (_Float32x __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern _Float32x fmodf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __fmodf32x (_Float32x __x, _Float32x __y) throw ();
#pragma line 196 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern _Float32x copysignf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern _Float32x __copysignf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32x nanf32x (const char *__tagb) throw (); extern _Float32x __nanf32x (const char *__tagb) throw ();
#pragma line 217 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern _Float32x j0f32x (_Float32x) throw (); extern _Float32x __j0f32x (_Float32x) throw ();
extern _Float32x j1f32x (_Float32x) throw (); extern _Float32x __j1f32x (_Float32x) throw ();
extern _Float32x jnf32x (int, _Float32x) throw (); extern _Float32x __jnf32x (int, _Float32x) throw ();
extern _Float32x y0f32x (_Float32x) throw (); extern _Float32x __y0f32x (_Float32x) throw ();
extern _Float32x y1f32x (_Float32x) throw (); extern _Float32x __y1f32x (_Float32x) throw ();
extern _Float32x ynf32x (int, _Float32x) throw (); extern _Float32x __ynf32x (int, _Float32x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32x erff32x (_Float32x) throw (); extern _Float32x __erff32x (_Float32x) throw ();
extern _Float32x erfcf32x (_Float32x) throw (); extern _Float32x __erfcf32x (_Float32x) throw ();
extern _Float32x lgammaf32x (_Float32x) throw (); extern _Float32x __lgammaf32x (_Float32x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32x tgammaf32x (_Float32x) throw (); extern _Float32x __tgammaf32x (_Float32x) throw ();
#pragma line 249 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern _Float32x lgammaf32x_r (_Float32x, int *__signgamp) throw (); extern _Float32x __lgammaf32x_r (_Float32x, int *__signgamp) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32x rintf32x (_Float32x __x) throw (); extern _Float32x __rintf32x (_Float32x __x) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32x nextafterf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __nextafterf32x (_Float32x __x, _Float32x __y) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32x nextdownf32x (_Float32x __x) throw (); extern _Float32x __nextdownf32x (_Float32x __x) throw ();
#pragma empty_line
extern _Float32x nextupf32x (_Float32x __x) throw (); extern _Float32x __nextupf32x (_Float32x __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32x remainderf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __remainderf32x (_Float32x __x, _Float32x __y) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32x scalbnf32x (_Float32x __x, int __n) throw (); extern _Float32x __scalbnf32x (_Float32x __x, int __n) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int ilogbf32x (_Float32x __x) throw (); extern int __ilogbf32x (_Float32x __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long int llogbf32x (_Float32x __x) throw (); extern long int __llogbf32x (_Float32x __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32x scalblnf32x (_Float32x __x, long int __n) throw (); extern _Float32x __scalblnf32x (_Float32x __x, long int __n) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32x nearbyintf32x (_Float32x __x) throw (); extern _Float32x __nearbyintf32x (_Float32x __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32x roundf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __roundf32x (_Float32x __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32x truncf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __truncf32x (_Float32x __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32x remquof32x (_Float32x __x, _Float32x __y, int *__quo) throw (); extern _Float32x __remquof32x (_Float32x __x, _Float32x __y, int *__quo) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long int lrintf32x (_Float32x __x) throw (); extern long int __lrintf32x (_Float32x __x) throw ();
__extension__
extern long long int llrintf32x (_Float32x __x) throw (); extern long long int __llrintf32x (_Float32x __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long int lroundf32x (_Float32x __x) throw (); extern long int __lroundf32x (_Float32x __x) throw ();
__extension__
extern long long int llroundf32x (_Float32x __x) throw (); extern long long int __llroundf32x (_Float32x __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32x fdimf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __fdimf32x (_Float32x __x, _Float32x __y) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32x fmaxf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern _Float32x __fmaxf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern _Float32x fminf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern _Float32x __fminf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern _Float32x fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) throw (); extern _Float32x __fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float32x roundevenf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __roundevenf32x (_Float32x __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __intmax_t fromfpf32x (_Float32x __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpf32x (_Float32x __x, int __round, unsigned int __width) throw ()
;
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __uintmax_t ufromfpf32x (_Float32x __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpf32x (_Float32x __x, int __round, unsigned int __width) throw ()
;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __intmax_t fromfpxf32x (_Float32x __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxf32x (_Float32x __x, int __round, unsigned int __width) throw ()
;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __uintmax_t ufromfpxf32x (_Float32x __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxf32x (_Float32x __x, int __round, unsigned int __width) throw ()
;
#pragma empty_line
#pragma empty_line
extern _Float32x fmaxmagf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern _Float32x __fmaxmagf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern _Float32x fminmagf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern _Float32x __fminmagf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern int canonicalizef32x (_Float32x *__cx, const _Float32x *__x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int totalorderf32x (const _Float32x *__x, const _Float32x *__y) throw ()
#pragma empty_line
__attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
extern int totalordermagf32x (const _Float32x *__x, const _Float32x *__y) throw ()
#pragma empty_line
__attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
extern _Float32x getpayloadf32x (const _Float32x *__x) throw (); extern _Float32x __getpayloadf32x (const _Float32x *__x) throw ();
#pragma empty_line
#pragma empty_line
extern int setpayloadf32x (_Float32x *__x, _Float32x __payload) throw ();
#pragma empty_line
#pragma empty_line
extern int setpayloadsigf32x (_Float32x *__x, _Float32x __payload) throw ();
#pragma line 441 "/usr/include/math.h" 2 3 4
#pragma line 457 "/usr/include/math.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4
#pragma line 53 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern _Float64x acosf64x (_Float64x __x) throw (); extern _Float64x __acosf64x (_Float64x __x) throw ();
#pragma empty_line
extern _Float64x asinf64x (_Float64x __x) throw (); extern _Float64x __asinf64x (_Float64x __x) throw ();
#pragma empty_line
extern _Float64x atanf64x (_Float64x __x) throw (); extern _Float64x __atanf64x (_Float64x __x) throw ();
#pragma empty_line
extern _Float64x atan2f64x (_Float64x __y, _Float64x __x) throw (); extern _Float64x __atan2f64x (_Float64x __y, _Float64x __x) throw ();
#pragma empty_line
#pragma empty_line
extern _Float64x cosf64x (_Float64x __x) throw (); extern _Float64x __cosf64x (_Float64x __x) throw ();
#pragma empty_line
extern _Float64x sinf64x (_Float64x __x) throw (); extern _Float64x __sinf64x (_Float64x __x) throw ();
#pragma empty_line
extern _Float64x tanf64x (_Float64x __x) throw (); extern _Float64x __tanf64x (_Float64x __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64x coshf64x (_Float64x __x) throw (); extern _Float64x __coshf64x (_Float64x __x) throw ();
#pragma empty_line
extern _Float64x sinhf64x (_Float64x __x) throw (); extern _Float64x __sinhf64x (_Float64x __x) throw ();
#pragma empty_line
extern _Float64x tanhf64x (_Float64x __x) throw (); extern _Float64x __tanhf64x (_Float64x __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern void sincosf64x (_Float64x __x, _Float64x *__sinx, _Float64x *__cosx) throw (); extern void __sincosf64x (_Float64x __x, _Float64x *__sinx, _Float64x *__cosx) throw ()
;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64x acoshf64x (_Float64x __x) throw (); extern _Float64x __acoshf64x (_Float64x __x) throw ();
#pragma empty_line
extern _Float64x asinhf64x (_Float64x __x) throw (); extern _Float64x __asinhf64x (_Float64x __x) throw ();
#pragma empty_line
extern _Float64x atanhf64x (_Float64x __x) throw (); extern _Float64x __atanhf64x (_Float64x __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64x expf64x (_Float64x __x) throw (); extern _Float64x __expf64x (_Float64x __x) throw ();
#pragma empty_line
#pragma empty_line
extern _Float64x frexpf64x (_Float64x __x, int *__exponent) throw (); extern _Float64x __frexpf64x (_Float64x __x, int *__exponent) throw ();
#pragma empty_line
#pragma empty_line
extern _Float64x ldexpf64x (_Float64x __x, int __exponent) throw (); extern _Float64x __ldexpf64x (_Float64x __x, int __exponent) throw ();
#pragma empty_line
#pragma empty_line
extern _Float64x logf64x (_Float64x __x) throw (); extern _Float64x __logf64x (_Float64x __x) throw ();
#pragma empty_line
#pragma empty_line
extern _Float64x log10f64x (_Float64x __x) throw (); extern _Float64x __log10f64x (_Float64x __x) throw ();
#pragma empty_line
#pragma empty_line
extern _Float64x modff64x (_Float64x __x, _Float64x *__iptr) throw (); extern _Float64x __modff64x (_Float64x __x, _Float64x *__iptr) throw () __attribute__ ((__nonnull__ (2)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64x exp10f64x (_Float64x __x) throw (); extern _Float64x __exp10f64x (_Float64x __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64x expm1f64x (_Float64x __x) throw (); extern _Float64x __expm1f64x (_Float64x __x) throw ();
#pragma empty_line
#pragma empty_line
extern _Float64x log1pf64x (_Float64x __x) throw (); extern _Float64x __log1pf64x (_Float64x __x) throw ();
#pragma empty_line
#pragma empty_line
extern _Float64x logbf64x (_Float64x __x) throw (); extern _Float64x __logbf64x (_Float64x __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64x exp2f64x (_Float64x __x) throw (); extern _Float64x __exp2f64x (_Float64x __x) throw ();
#pragma empty_line
#pragma empty_line
extern _Float64x log2f64x (_Float64x __x) throw (); extern _Float64x __log2f64x (_Float64x __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64x powf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __powf64x (_Float64x __x, _Float64x __y) throw ();
#pragma empty_line
#pragma empty_line
extern _Float64x sqrtf64x (_Float64x __x) throw (); extern _Float64x __sqrtf64x (_Float64x __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64x hypotf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __hypotf64x (_Float64x __x, _Float64x __y) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64x cbrtf64x (_Float64x __x) throw (); extern _Float64x __cbrtf64x (_Float64x __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64x ceilf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __ceilf64x (_Float64x __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern _Float64x fabsf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __fabsf64x (_Float64x __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern _Float64x floorf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __floorf64x (_Float64x __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern _Float64x fmodf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __fmodf64x (_Float64x __x, _Float64x __y) throw ();
#pragma line 196 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern _Float64x copysignf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern _Float64x __copysignf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64x nanf64x (const char *__tagb) throw (); extern _Float64x __nanf64x (const char *__tagb) throw ();
#pragma line 217 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern _Float64x j0f64x (_Float64x) throw (); extern _Float64x __j0f64x (_Float64x) throw ();
extern _Float64x j1f64x (_Float64x) throw (); extern _Float64x __j1f64x (_Float64x) throw ();
extern _Float64x jnf64x (int, _Float64x) throw (); extern _Float64x __jnf64x (int, _Float64x) throw ();
extern _Float64x y0f64x (_Float64x) throw (); extern _Float64x __y0f64x (_Float64x) throw ();
extern _Float64x y1f64x (_Float64x) throw (); extern _Float64x __y1f64x (_Float64x) throw ();
extern _Float64x ynf64x (int, _Float64x) throw (); extern _Float64x __ynf64x (int, _Float64x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64x erff64x (_Float64x) throw (); extern _Float64x __erff64x (_Float64x) throw ();
extern _Float64x erfcf64x (_Float64x) throw (); extern _Float64x __erfcf64x (_Float64x) throw ();
extern _Float64x lgammaf64x (_Float64x) throw (); extern _Float64x __lgammaf64x (_Float64x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64x tgammaf64x (_Float64x) throw (); extern _Float64x __tgammaf64x (_Float64x) throw ();
#pragma line 249 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern _Float64x lgammaf64x_r (_Float64x, int *__signgamp) throw (); extern _Float64x __lgammaf64x_r (_Float64x, int *__signgamp) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64x rintf64x (_Float64x __x) throw (); extern _Float64x __rintf64x (_Float64x __x) throw ();
#pragma empty_line
#pragma empty_line
extern _Float64x nextafterf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __nextafterf64x (_Float64x __x, _Float64x __y) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64x nextdownf64x (_Float64x __x) throw (); extern _Float64x __nextdownf64x (_Float64x __x) throw ();
#pragma empty_line
extern _Float64x nextupf64x (_Float64x __x) throw (); extern _Float64x __nextupf64x (_Float64x __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64x remainderf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __remainderf64x (_Float64x __x, _Float64x __y) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64x scalbnf64x (_Float64x __x, int __n) throw (); extern _Float64x __scalbnf64x (_Float64x __x, int __n) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int ilogbf64x (_Float64x __x) throw (); extern int __ilogbf64x (_Float64x __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long int llogbf64x (_Float64x __x) throw (); extern long int __llogbf64x (_Float64x __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64x scalblnf64x (_Float64x __x, long int __n) throw (); extern _Float64x __scalblnf64x (_Float64x __x, long int __n) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64x nearbyintf64x (_Float64x __x) throw (); extern _Float64x __nearbyintf64x (_Float64x __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64x roundf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __roundf64x (_Float64x __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64x truncf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __truncf64x (_Float64x __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64x remquof64x (_Float64x __x, _Float64x __y, int *__quo) throw (); extern _Float64x __remquof64x (_Float64x __x, _Float64x __y, int *__quo) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long int lrintf64x (_Float64x __x) throw (); extern long int __lrintf64x (_Float64x __x) throw ();
__extension__
extern long long int llrintf64x (_Float64x __x) throw (); extern long long int __llrintf64x (_Float64x __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern long int lroundf64x (_Float64x __x) throw (); extern long int __lroundf64x (_Float64x __x) throw ();
__extension__
extern long long int llroundf64x (_Float64x __x) throw (); extern long long int __llroundf64x (_Float64x __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64x fdimf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __fdimf64x (_Float64x __x, _Float64x __y) throw ();
#pragma empty_line
#pragma empty_line
extern _Float64x fmaxf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern _Float64x __fmaxf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern _Float64x fminf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern _Float64x __fminf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern _Float64x fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) throw (); extern _Float64x __fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern _Float64x roundevenf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __roundevenf64x (_Float64x __x) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __intmax_t fromfpf64x (_Float64x __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpf64x (_Float64x __x, int __round, unsigned int __width) throw ()
;
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __uintmax_t ufromfpf64x (_Float64x __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpf64x (_Float64x __x, int __round, unsigned int __width) throw ()
;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __intmax_t fromfpxf64x (_Float64x __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxf64x (_Float64x __x, int __round, unsigned int __width) throw ()
;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __uintmax_t ufromfpxf64x (_Float64x __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxf64x (_Float64x __x, int __round, unsigned int __width) throw ()
;
#pragma empty_line
#pragma empty_line
extern _Float64x fmaxmagf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern _Float64x __fmaxmagf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern _Float64x fminmagf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern _Float64x __fminmagf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
extern int canonicalizef64x (_Float64x *__cx, const _Float64x *__x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int totalorderf64x (const _Float64x *__x, const _Float64x *__y) throw ()
#pragma empty_line
__attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
extern int totalordermagf64x (const _Float64x *__x, const _Float64x *__y) throw ()
#pragma empty_line
__attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
extern _Float64x getpayloadf64x (const _Float64x *__x) throw (); extern _Float64x __getpayloadf64x (const _Float64x *__x) throw ();
#pragma empty_line
#pragma empty_line
extern int setpayloadf64x (_Float64x *__x, _Float64x __payload) throw ();
#pragma empty_line
#pragma empty_line
extern int setpayloadsigf64x (_Float64x *__x, _Float64x __payload) throw ();
#pragma line 458 "/usr/include/math.h" 2 3 4
#pragma line 503 "/usr/include/math.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4
#pragma line 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4
extern float fadd (double __x, double __y) throw ();
#pragma empty_line
#pragma empty_line
extern float fdiv (double __x, double __y) throw ();
#pragma empty_line
#pragma empty_line
extern float fmul (double __x, double __y) throw ();
#pragma empty_line
#pragma empty_line
extern float fsub (double __x, double __y) throw ();
#pragma line 504 "/usr/include/math.h" 2 3 4
#pragma line 517 "/usr/include/math.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4
#pragma line 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4
extern float faddl (long double __x, long double __y) throw ();
#pragma empty_line
#pragma empty_line
extern float fdivl (long double __x, long double __y) throw ();
#pragma empty_line
#pragma empty_line
extern float fmull (long double __x, long double __y) throw ();
#pragma empty_line
#pragma empty_line
extern float fsubl (long double __x, long double __y) throw ();
#pragma line 518 "/usr/include/math.h" 2 3 4
#pragma line 537 "/usr/include/math.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4
#pragma line 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4
extern double daddl (long double __x, long double __y) throw ();
#pragma empty_line
#pragma empty_line
extern double ddivl (long double __x, long double __y) throw ();
#pragma empty_line
#pragma empty_line
extern double dmull (long double __x, long double __y) throw ();
#pragma empty_line
#pragma empty_line
extern double dsubl (long double __x, long double __y) throw ();
#pragma line 538 "/usr/include/math.h" 2 3 4
#pragma line 616 "/usr/include/math.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4
#pragma line 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4
extern _Float32 f32addf32x (_Float32x __x, _Float32x __y) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32 f32divf32x (_Float32x __x, _Float32x __y) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32 f32mulf32x (_Float32x __x, _Float32x __y) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32 f32subf32x (_Float32x __x, _Float32x __y) throw ();
#pragma line 617 "/usr/include/math.h" 2 3 4
#pragma line 626 "/usr/include/math.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4
#pragma line 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4
extern _Float32 f32addf64 (_Float64 __x, _Float64 __y) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32 f32divf64 (_Float64 __x, _Float64 __y) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32 f32mulf64 (_Float64 __x, _Float64 __y) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32 f32subf64 (_Float64 __x, _Float64 __y) throw ();
#pragma line 627 "/usr/include/math.h" 2 3 4
#pragma line 636 "/usr/include/math.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4
#pragma line 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4
extern _Float32 f32addf64x (_Float64x __x, _Float64x __y) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32 f32divf64x (_Float64x __x, _Float64x __y) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32 f32mulf64x (_Float64x __x, _Float64x __y) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32 f32subf64x (_Float64x __x, _Float64x __y) throw ();
#pragma line 637 "/usr/include/math.h" 2 3 4
#pragma line 646 "/usr/include/math.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4
#pragma line 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4
extern _Float32 f32addf128 (_Float128 __x, _Float128 __y) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32 f32divf128 (_Float128 __x, _Float128 __y) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32 f32mulf128 (_Float128 __x, _Float128 __y) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32 f32subf128 (_Float128 __x, _Float128 __y) throw ();
#pragma line 647 "/usr/include/math.h" 2 3 4
#pragma line 666 "/usr/include/math.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4
#pragma line 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4
extern _Float32x f32xaddf64 (_Float64 __x, _Float64 __y) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32x f32xdivf64 (_Float64 __x, _Float64 __y) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32x f32xmulf64 (_Float64 __x, _Float64 __y) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32x f32xsubf64 (_Float64 __x, _Float64 __y) throw ();
#pragma line 667 "/usr/include/math.h" 2 3 4
#pragma line 676 "/usr/include/math.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4
#pragma line 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4
extern _Float32x f32xaddf64x (_Float64x __x, _Float64x __y) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32x f32xdivf64x (_Float64x __x, _Float64x __y) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32x f32xmulf64x (_Float64x __x, _Float64x __y) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32x f32xsubf64x (_Float64x __x, _Float64x __y) throw ();
#pragma line 677 "/usr/include/math.h" 2 3 4
#pragma line 686 "/usr/include/math.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4
#pragma line 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4
extern _Float32x f32xaddf128 (_Float128 __x, _Float128 __y) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32x f32xdivf128 (_Float128 __x, _Float128 __y) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32x f32xmulf128 (_Float128 __x, _Float128 __y) throw ();
#pragma empty_line
#pragma empty_line
extern _Float32x f32xsubf128 (_Float128 __x, _Float128 __y) throw ();
#pragma line 687 "/usr/include/math.h" 2 3 4
#pragma line 706 "/usr/include/math.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4
#pragma line 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4
extern _Float64 f64addf64x (_Float64x __x, _Float64x __y) throw ();
#pragma empty_line
#pragma empty_line
extern _Float64 f64divf64x (_Float64x __x, _Float64x __y) throw ();
#pragma empty_line
#pragma empty_line
extern _Float64 f64mulf64x (_Float64x __x, _Float64x __y) throw ();
#pragma empty_line
#pragma empty_line
extern _Float64 f64subf64x (_Float64x __x, _Float64x __y) throw ();
#pragma line 707 "/usr/include/math.h" 2 3 4
#pragma line 716 "/usr/include/math.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4
#pragma line 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4
extern _Float64 f64addf128 (_Float128 __x, _Float128 __y) throw ();
#pragma empty_line
#pragma empty_line
extern _Float64 f64divf128 (_Float128 __x, _Float128 __y) throw ();
#pragma empty_line
#pragma empty_line
extern _Float64 f64mulf128 (_Float128 __x, _Float128 __y) throw ();
#pragma empty_line
#pragma empty_line
extern _Float64 f64subf128 (_Float128 __x, _Float128 __y) throw ();
#pragma line 717 "/usr/include/math.h" 2 3 4
#pragma line 736 "/usr/include/math.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4
#pragma line 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4
extern _Float64x f64xaddf128 (_Float128 __x, _Float128 __y) throw ();
#pragma empty_line
#pragma empty_line
extern _Float64x f64xdivf128 (_Float128 __x, _Float128 __y) throw ();
#pragma empty_line
#pragma empty_line
extern _Float64x f64xmulf128 (_Float128 __x, _Float128 __y) throw ();
#pragma empty_line
#pragma empty_line
extern _Float64x f64xsubf128 (_Float128 __x, _Float128 __y) throw ();
#pragma line 737 "/usr/include/math.h" 2 3 4
#pragma line 773 "/usr/include/math.h" 3 4
extern int signgam;
#pragma line 853 "/usr/include/math.h" 3 4
enum
{
FP_NAN =
#pragma empty_line
0,
FP_INFINITE =
#pragma empty_line
1,
FP_ZERO =
#pragma empty_line
2,
FP_SUBNORMAL =
#pragma empty_line
3,
FP_NORMAL =
#pragma empty_line
4
};
#pragma line 973 "/usr/include/math.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/iscanonical.h" 1 3 4
#pragma line 23 "/usr/include/x86_64-linux-gnu/bits/iscanonical.h" 3 4
extern int __iscanonicall (long double __x)
throw () __attribute__ ((__const__));
#pragma line 46 "/usr/include/x86_64-linux-gnu/bits/iscanonical.h" 3 4
extern "C++" {
inline int iscanonical (float __val) { return ((void) (__typeof (__val)) (__val), 1); }
inline int iscanonical (double __val) { return ((void) (__typeof (__val)) (__val), 1); }
inline int iscanonical (long double __val) { return __iscanonicall (__val); }
#pragma empty_line
inline int iscanonical (_Float128 __val) { return ((void) (__typeof (__val)) (__val), 1); }
#pragma empty_line
}
#pragma line 974 "/usr/include/math.h" 2 3 4
#pragma line 985 "/usr/include/math.h" 3 4
extern "C++" {
inline int issignaling (float __val) { return __issignalingf (__val); }
inline int issignaling (double __val) { return __issignaling (__val); }
inline int
issignaling (long double __val)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
return __issignalingl (__val);
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline int issignaling (_Float128 __val) { return __issignalingf128 (__val); }
#pragma empty_line
}
#pragma line 1016 "/usr/include/math.h" 3 4
extern "C++" {
#pragma line 1047 "/usr/include/math.h" 3 4
template <class __T> inline bool
iszero (__T __val)
{
return __val == 0;
}
#pragma empty_line
}
#pragma line 1278 "/usr/include/math.h" 3 4
extern "C++" {
template<typename> struct __iseqsig_type;
#pragma empty_line
template<> struct __iseqsig_type<float>
{
static int __call (float __x, float __y) throw ()
{
return __iseqsigf (__x, __y);
}
};
#pragma empty_line
template<> struct __iseqsig_type<double>
{
static int __call (double __x, double __y) throw ()
{
return __iseqsig (__x, __y);
}
};
#pragma empty_line
template<> struct __iseqsig_type<long double>
{
static int __call (long double __x, long double __y) throw ()
{
#pragma empty_line
return __iseqsigl (__x, __y);
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<> struct __iseqsig_type<_Float128>
{
static int __call (_Float128 __x, _Float128 __y) throw ()
{
return __iseqsigf128 (__x, __y);
}
};
#pragma empty_line
#pragma empty_line
template<typename _T1, typename _T2>
inline int
iseqsig (_T1 __x, _T2 __y) throw ()
{
#pragma empty_line
typedef decltype (((__x) + (__y) + 0.0f)) _T3;
#pragma empty_line
#pragma empty_line
#pragma empty_line
return __iseqsig_type<_T3>::__call (__x, __y);
}
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 46 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cmath" 2 3
#pragma line 77 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cmath" 3
extern "C++"
{
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline constexpr double
abs(double __x)
{ return __builtin_fabs(__x); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline constexpr float
abs(float __x)
{ return __builtin_fabsf(__x); }
#pragma empty_line
inline constexpr long double
abs(long double __x)
{ return __builtin_fabsl(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
abs(_Tp __x)
{ return __builtin_fabs(__x); }
#pragma empty_line
using ::acos;
#pragma empty_line
#pragma empty_line
inline constexpr float
acos(float __x)
{ return __builtin_acosf(__x); }
#pragma empty_line
inline constexpr long double
acos(long double __x)
{ return __builtin_acosl(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
acos(_Tp __x)
{ return __builtin_acos(__x); }
#pragma empty_line
using ::asin;
#pragma empty_line
#pragma empty_line
inline constexpr float
asin(float __x)
{ return __builtin_asinf(__x); }
#pragma empty_line
inline constexpr long double
asin(long double __x)
{ return __builtin_asinl(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
asin(_Tp __x)
{ return __builtin_asin(__x); }
#pragma empty_line
using ::atan;
#pragma empty_line
#pragma empty_line
inline constexpr float
atan(float __x)
{ return __builtin_atanf(__x); }
#pragma empty_line
inline constexpr long double
atan(long double __x)
{ return __builtin_atanl(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
atan(_Tp __x)
{ return __builtin_atan(__x); }
#pragma empty_line
using ::atan2;
#pragma empty_line
#pragma empty_line
inline constexpr float
atan2(float __y, float __x)
{ return __builtin_atan2f(__y, __x); }
#pragma empty_line
inline constexpr long double
atan2(long double __y, long double __x)
{ return __builtin_atan2l(__y, __x); }
#pragma empty_line
#pragma empty_line
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));
}
#pragma empty_line
using ::ceil;
#pragma empty_line
#pragma empty_line
inline constexpr float
ceil(float __x)
{ return __builtin_ceilf(__x); }
#pragma empty_line
inline constexpr long double
ceil(long double __x)
{ return __builtin_ceill(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
ceil(_Tp __x)
{ return __builtin_ceil(__x); }
#pragma empty_line
using ::cos;
#pragma empty_line
#pragma empty_line
inline constexpr float
cos(float __x)
{ return __builtin_cosf(__x); }
#pragma empty_line
inline constexpr long double
cos(long double __x)
{ return __builtin_cosl(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
cos(_Tp __x)
{ return __builtin_cos(__x); }
#pragma empty_line
using ::cosh;
#pragma empty_line
#pragma empty_line
inline constexpr float
cosh(float __x)
{ return __builtin_coshf(__x); }
#pragma empty_line
inline constexpr long double
cosh(long double __x)
{ return __builtin_coshl(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
cosh(_Tp __x)
{ return __builtin_cosh(__x); }
#pragma empty_line
using ::exp;
#pragma empty_line
#pragma empty_line
inline constexpr float
exp(float __x)
{ return __builtin_expf(__x); }
#pragma empty_line
inline constexpr long double
exp(long double __x)
{ return __builtin_expl(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
exp(_Tp __x)
{ return __builtin_exp(__x); }
#pragma empty_line
using ::fabs;
#pragma empty_line
#pragma empty_line
inline constexpr float
fabs(float __x)
{ return __builtin_fabsf(__x); }
#pragma empty_line
inline constexpr long double
fabs(long double __x)
{ return __builtin_fabsl(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
fabs(_Tp __x)
{ return __builtin_fabs(__x); }
#pragma empty_line
using ::floor;
#pragma empty_line
#pragma empty_line
inline constexpr float
floor(float __x)
{ return __builtin_floorf(__x); }
#pragma empty_line
inline constexpr long double
floor(long double __x)
{ return __builtin_floorl(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
floor(_Tp __x)
{ return __builtin_floor(__x); }
#pragma empty_line
using ::fmod;
#pragma empty_line
#pragma empty_line
inline constexpr float
fmod(float __x, float __y)
{ return __builtin_fmodf(__x, __y); }
#pragma empty_line
inline constexpr long double
fmod(long double __x, long double __y)
{ return __builtin_fmodl(__x, __y); }
#pragma empty_line
#pragma empty_line
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));
}
#pragma empty_line
using ::frexp;
#pragma empty_line
#pragma empty_line
inline float
frexp(float __x, int* __exp)
{ return __builtin_frexpf(__x, __exp); }
#pragma empty_line
inline long double
frexp(long double __x, int* __exp)
{ return __builtin_frexpl(__x, __exp); }
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
using ::ldexp;
#pragma empty_line
#pragma empty_line
inline constexpr float
ldexp(float __x, int __exp)
{ return __builtin_ldexpf(__x, __exp); }
#pragma empty_line
inline constexpr long double
ldexp(long double __x, int __exp)
{ return __builtin_ldexpl(__x, __exp); }
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
using ::log;
#pragma empty_line
#pragma empty_line
inline constexpr float
log(float __x)
{ return __builtin_logf(__x); }
#pragma empty_line
inline constexpr long double
log(long double __x)
{ return __builtin_logl(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
log(_Tp __x)
{ return __builtin_log(__x); }
#pragma empty_line
using ::log10;
#pragma empty_line
#pragma empty_line
inline constexpr float
log10(float __x)
{ return __builtin_log10f(__x); }
#pragma empty_line
inline constexpr long double
log10(long double __x)
{ return __builtin_log10l(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
log10(_Tp __x)
{ return __builtin_log10(__x); }
#pragma empty_line
using ::modf;
#pragma empty_line
#pragma empty_line
inline float
modf(float __x, float* __iptr)
{ return __builtin_modff(__x, __iptr); }
#pragma empty_line
inline long double
modf(long double __x, long double* __iptr)
{ return __builtin_modfl(__x, __iptr); }
#pragma empty_line
#pragma empty_line
using ::pow;
#pragma empty_line
#pragma empty_line
inline constexpr float
pow(float __x, float __y)
{ return __builtin_powf(__x, __y); }
#pragma empty_line
inline constexpr long double
pow(long double __x, long double __y)
{ return __builtin_powl(__x, __y); }
#pragma line 435 "/home/justin/jhai/Xilinx/Vivado/2018.3/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));
}
#pragma empty_line
using ::sin;
#pragma empty_line
#pragma empty_line
inline constexpr float
sin(float __x)
{ return __builtin_sinf(__x); }
#pragma empty_line
inline constexpr long double
sin(long double __x)
{ return __builtin_sinl(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
sin(_Tp __x)
{ return __builtin_sin(__x); }
#pragma empty_line
using ::sinh;
#pragma empty_line
#pragma empty_line
inline constexpr float
sinh(float __x)
{ return __builtin_sinhf(__x); }
#pragma empty_line
inline constexpr long double
sinh(long double __x)
{ return __builtin_sinhl(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
sinh(_Tp __x)
{ return __builtin_sinh(__x); }
#pragma empty_line
using ::sqrt;
#pragma empty_line
#pragma empty_line
inline constexpr float
sqrt(float __x)
{ return __builtin_sqrtf(__x); }
#pragma empty_line
inline constexpr long double
sqrt(long double __x)
{ return __builtin_sqrtl(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
sqrt(_Tp __x)
{ return __builtin_sqrt(__x); }
#pragma empty_line
using ::tan;
#pragma empty_line
#pragma empty_line
inline constexpr float
tan(float __x)
{ return __builtin_tanf(__x); }
#pragma empty_line
inline constexpr long double
tan(long double __x)
{ return __builtin_tanl(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
tan(_Tp __x)
{ return __builtin_tan(__x); }
#pragma empty_line
using ::tanh;
#pragma empty_line
#pragma empty_line
inline constexpr float
tanh(float __x)
{ return __builtin_tanhf(__x); }
#pragma empty_line
inline constexpr long double
tanh(long double __x)
{ return __builtin_tanhl(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
tanh(_Tp __x)
{ return __builtin_tanh(__x); }
#pragma empty_line
#pragma empty_line
}
#pragma line 559 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cmath" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
constexpr int
fpclassify(float __x)
{ return __builtin_fpclassify(0, 1, 4,
3, 2, __x); }
#pragma empty_line
constexpr int
fpclassify(double __x)
{ return __builtin_fpclassify(0, 1, 4,
3, 2, __x); }
#pragma empty_line
constexpr int
fpclassify(long double __x)
{ return __builtin_fpclassify(0, 1, 4,
3, 2, __x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
int>::__type
fpclassify(_Tp __x)
{ return __x != 0 ? 4 : 2; }
#pragma empty_line
#pragma empty_line
constexpr bool
isfinite(float __x)
{ return __builtin_isfinite(__x); }
#pragma empty_line
constexpr bool
isfinite(double __x)
{ return __builtin_isfinite(__x); }
#pragma empty_line
constexpr bool
isfinite(long double __x)
{ return __builtin_isfinite(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
bool>::__type
isfinite(_Tp __x)
{ return true; }
#pragma empty_line
#pragma empty_line
constexpr bool
isinf(float __x)
{ return __builtin_isinf(__x); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
constexpr bool
isinf(double __x)
{ return __builtin_isinf(__x); }
#pragma empty_line
#pragma empty_line
constexpr bool
isinf(long double __x)
{ return __builtin_isinf(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
bool>::__type
isinf(_Tp __x)
{ return false; }
#pragma empty_line
#pragma empty_line
constexpr bool
isnan(float __x)
{ return __builtin_isnan(__x); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
constexpr bool
isnan(double __x)
{ return __builtin_isnan(__x); }
#pragma empty_line
#pragma empty_line
constexpr bool
isnan(long double __x)
{ return __builtin_isnan(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
bool>::__type
isnan(_Tp __x)
{ return false; }
#pragma empty_line
#pragma empty_line
constexpr bool
isnormal(float __x)
{ return __builtin_isnormal(__x); }
#pragma empty_line
constexpr bool
isnormal(double __x)
{ return __builtin_isnormal(__x); }
#pragma empty_line
constexpr bool
isnormal(long double __x)
{ return __builtin_isnormal(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
bool>::__type
isnormal(_Tp __x)
{ return __x != 0 ? true : false; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
constexpr bool
signbit(float __x)
{ return __builtin_signbit(__x); }
#pragma empty_line
constexpr bool
signbit(double __x)
{ return __builtin_signbit(__x); }
#pragma empty_line
constexpr bool
signbit(long double __x)
{ return __builtin_signbit(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
bool>::__type
signbit(_Tp __x)
{ return __x < 0 ? true : false; }
#pragma empty_line
#pragma empty_line
constexpr bool
isgreater(float __x, float __y)
{ return __builtin_isgreater(__x, __y); }
#pragma empty_line
constexpr bool
isgreater(double __x, double __y)
{ return __builtin_isgreater(__x, __y); }
#pragma empty_line
constexpr bool
isgreater(long double __x, long double __y)
{ return __builtin_isgreater(__x, __y); }
#pragma empty_line
#pragma empty_line
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));
}
#pragma empty_line
#pragma empty_line
constexpr bool
isgreaterequal(float __x, float __y)
{ return __builtin_isgreaterequal(__x, __y); }
#pragma empty_line
constexpr bool
isgreaterequal(double __x, double __y)
{ return __builtin_isgreaterequal(__x, __y); }
#pragma empty_line
constexpr bool
isgreaterequal(long double __x, long double __y)
{ return __builtin_isgreaterequal(__x, __y); }
#pragma empty_line
#pragma empty_line
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));
}
#pragma empty_line
#pragma empty_line
constexpr bool
isless(float __x, float __y)
{ return __builtin_isless(__x, __y); }
#pragma empty_line
constexpr bool
isless(double __x, double __y)
{ return __builtin_isless(__x, __y); }
#pragma empty_line
constexpr bool
isless(long double __x, long double __y)
{ return __builtin_isless(__x, __y); }
#pragma empty_line
#pragma empty_line
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));
}
#pragma empty_line
#pragma empty_line
constexpr bool
islessequal(float __x, float __y)
{ return __builtin_islessequal(__x, __y); }
#pragma empty_line
constexpr bool
islessequal(double __x, double __y)
{ return __builtin_islessequal(__x, __y); }
#pragma empty_line
constexpr bool
islessequal(long double __x, long double __y)
{ return __builtin_islessequal(__x, __y); }
#pragma empty_line
#pragma empty_line
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));
}
#pragma empty_line
#pragma empty_line
constexpr bool
islessgreater(float __x, float __y)
{ return __builtin_islessgreater(__x, __y); }
#pragma empty_line
constexpr bool
islessgreater(double __x, double __y)
{ return __builtin_islessgreater(__x, __y); }
#pragma empty_line
constexpr bool
islessgreater(long double __x, long double __y)
{ return __builtin_islessgreater(__x, __y); }
#pragma empty_line
#pragma empty_line
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));
}
#pragma empty_line
#pragma empty_line
constexpr bool
isunordered(float __x, float __y)
{ return __builtin_isunordered(__x, __y); }
#pragma empty_line
constexpr bool
isunordered(double __x, double __y)
{ return __builtin_isunordered(__x, __y); }
#pragma empty_line
constexpr bool
isunordered(long double __x, long double __y)
{ return __builtin_isunordered(__x, __y); }
#pragma empty_line
#pragma empty_line
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));
}
#pragma line 956 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cmath" 3
#pragma empty_line
}
#pragma line 1072 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cmath" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
using ::double_t;
using ::float_t;
#pragma empty_line
#pragma empty_line
using ::acosh;
using ::acoshf;
using ::acoshl;
#pragma empty_line
using ::asinh;
using ::asinhf;
using ::asinhl;
#pragma empty_line
using ::atanh;
using ::atanhf;
using ::atanhl;
#pragma empty_line
using ::cbrt;
using ::cbrtf;
using ::cbrtl;
#pragma empty_line
using ::copysign;
using ::copysignf;
using ::copysignl;
#pragma empty_line
using ::erf;
using ::erff;
using ::erfl;
#pragma empty_line
using ::erfc;
using ::erfcf;
using ::erfcl;
#pragma empty_line
using ::exp2;
using ::exp2f;
using ::exp2l;
#pragma empty_line
using ::expm1;
using ::expm1f;
using ::expm1l;
#pragma empty_line
using ::fdim;
using ::fdimf;
using ::fdiml;
#pragma empty_line
using ::fma;
using ::fmaf;
using ::fmal;
#pragma empty_line
using ::fmax;
using ::fmaxf;
using ::fmaxl;
#pragma empty_line
using ::fmin;
using ::fminf;
using ::fminl;
#pragma empty_line
using ::hypot;
using ::hypotf;
using ::hypotl;
#pragma empty_line
using ::ilogb;
using ::ilogbf;
using ::ilogbl;
#pragma empty_line
using ::lgamma;
using ::lgammaf;
using ::lgammal;
#pragma empty_line
using ::llrint;
using ::llrintf;
using ::llrintl;
#pragma empty_line
using ::llround;
using ::llroundf;
using ::llroundl;
#pragma empty_line
using ::log1p;
using ::log1pf;
using ::log1pl;
#pragma empty_line
using ::log2;
using ::log2f;
using ::log2l;
#pragma empty_line
using ::logb;
using ::logbf;
using ::logbl;
#pragma empty_line
using ::lrint;
using ::lrintf;
using ::lrintl;
#pragma empty_line
using ::lround;
using ::lroundf;
using ::lroundl;
#pragma empty_line
using ::nan;
using ::nanf;
using ::nanl;
#pragma empty_line
using ::nearbyint;
using ::nearbyintf;
using ::nearbyintl;
#pragma empty_line
using ::nextafter;
using ::nextafterf;
using ::nextafterl;
#pragma empty_line
using ::nexttoward;
using ::nexttowardf;
using ::nexttowardl;
#pragma empty_line
using ::remainder;
using ::remainderf;
using ::remainderl;
#pragma empty_line
using ::remquo;
using ::remquof;
using ::remquol;
#pragma empty_line
using ::rint;
using ::rintf;
using ::rintl;
#pragma empty_line
using ::round;
using ::roundf;
using ::roundl;
#pragma empty_line
using ::scalbln;
using ::scalblnf;
using ::scalblnl;
#pragma empty_line
using ::scalbn;
using ::scalbnf;
using ::scalbnl;
#pragma empty_line
using ::tgamma;
using ::tgammaf;
using ::tgammal;
#pragma empty_line
using ::trunc;
using ::truncf;
using ::truncl;
#pragma empty_line
#pragma empty_line
#pragma empty_line
constexpr float
acosh(float __x)
{ return __builtin_acoshf(__x); }
#pragma empty_line
constexpr long double
acosh(long double __x)
{ return __builtin_acoshl(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
acosh(_Tp __x)
{ return __builtin_acosh(__x); }
#pragma empty_line
#pragma empty_line
constexpr float
asinh(float __x)
{ return __builtin_asinhf(__x); }
#pragma empty_line
constexpr long double
asinh(long double __x)
{ return __builtin_asinhl(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
asinh(_Tp __x)
{ return __builtin_asinh(__x); }
#pragma empty_line
#pragma empty_line
constexpr float
atanh(float __x)
{ return __builtin_atanhf(__x); }
#pragma empty_line
constexpr long double
atanh(long double __x)
{ return __builtin_atanhl(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
atanh(_Tp __x)
{ return __builtin_atanh(__x); }
#pragma empty_line
#pragma empty_line
constexpr float
cbrt(float __x)
{ return __builtin_cbrtf(__x); }
#pragma empty_line
constexpr long double
cbrt(long double __x)
{ return __builtin_cbrtl(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
cbrt(_Tp __x)
{ return __builtin_cbrt(__x); }
#pragma empty_line
#pragma empty_line
constexpr float
copysign(float __x, float __y)
{ return __builtin_copysignf(__x, __y); }
#pragma empty_line
constexpr long double
copysign(long double __x, long double __y)
{ return __builtin_copysignl(__x, __y); }
#pragma empty_line
#pragma empty_line
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));
}
#pragma empty_line
#pragma empty_line
constexpr float
erf(float __x)
{ return __builtin_erff(__x); }
#pragma empty_line
constexpr long double
erf(long double __x)
{ return __builtin_erfl(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
erf(_Tp __x)
{ return __builtin_erf(__x); }
#pragma empty_line
#pragma empty_line
constexpr float
erfc(float __x)
{ return __builtin_erfcf(__x); }
#pragma empty_line
constexpr long double
erfc(long double __x)
{ return __builtin_erfcl(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
erfc(_Tp __x)
{ return __builtin_erfc(__x); }
#pragma empty_line
#pragma empty_line
constexpr float
exp2(float __x)
{ return __builtin_exp2f(__x); }
#pragma empty_line
constexpr long double
exp2(long double __x)
{ return __builtin_exp2l(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
exp2(_Tp __x)
{ return __builtin_exp2(__x); }
#pragma empty_line
#pragma empty_line
constexpr float
expm1(float __x)
{ return __builtin_expm1f(__x); }
#pragma empty_line
constexpr long double
expm1(long double __x)
{ return __builtin_expm1l(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
expm1(_Tp __x)
{ return __builtin_expm1(__x); }
#pragma empty_line
#pragma empty_line
constexpr float
fdim(float __x, float __y)
{ return __builtin_fdimf(__x, __y); }
#pragma empty_line
constexpr long double
fdim(long double __x, long double __y)
{ return __builtin_fdiml(__x, __y); }
#pragma empty_line
#pragma empty_line
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));
}
#pragma empty_line
#pragma empty_line
constexpr float
fma(float __x, float __y, float __z)
{ return __builtin_fmaf(__x, __y, __z); }
#pragma empty_line
constexpr long double
fma(long double __x, long double __y, long double __z)
{ return __builtin_fmal(__x, __y, __z); }
#pragma empty_line
#pragma empty_line
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));
}
#pragma empty_line
#pragma empty_line
constexpr float
fmax(float __x, float __y)
{ return __builtin_fmaxf(__x, __y); }
#pragma empty_line
constexpr long double
fmax(long double __x, long double __y)
{ return __builtin_fmaxl(__x, __y); }
#pragma empty_line
#pragma empty_line
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));
}
#pragma empty_line
#pragma empty_line
constexpr float
fmin(float __x, float __y)
{ return __builtin_fminf(__x, __y); }
#pragma empty_line
constexpr long double
fmin(long double __x, long double __y)
{ return __builtin_fminl(__x, __y); }
#pragma empty_line
#pragma empty_line
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));
}
#pragma empty_line
#pragma empty_line
constexpr float
hypot(float __x, float __y)
{ return __builtin_hypotf(__x, __y); }
#pragma empty_line
constexpr long double
hypot(long double __x, long double __y)
{ return __builtin_hypotl(__x, __y); }
#pragma empty_line
#pragma empty_line
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));
}
#pragma empty_line
#pragma empty_line
constexpr int
ilogb(float __x)
{ return __builtin_ilogbf(__x); }
#pragma empty_line
constexpr int
ilogb(long double __x)
{ return __builtin_ilogbl(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
int>::__type
ilogb(_Tp __x)
{ return __builtin_ilogb(__x); }
#pragma empty_line
#pragma empty_line
constexpr float
lgamma(float __x)
{ return __builtin_lgammaf(__x); }
#pragma empty_line
constexpr long double
lgamma(long double __x)
{ return __builtin_lgammal(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
lgamma(_Tp __x)
{ return __builtin_lgamma(__x); }
#pragma empty_line
#pragma empty_line
constexpr long long
llrint(float __x)
{ return __builtin_llrintf(__x); }
#pragma empty_line
constexpr long long
llrint(long double __x)
{ return __builtin_llrintl(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
long long>::__type
llrint(_Tp __x)
{ return __builtin_llrint(__x); }
#pragma empty_line
#pragma empty_line
constexpr long long
llround(float __x)
{ return __builtin_llroundf(__x); }
#pragma empty_line
constexpr long long
llround(long double __x)
{ return __builtin_llroundl(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
long long>::__type
llround(_Tp __x)
{ return __builtin_llround(__x); }
#pragma empty_line
#pragma empty_line
constexpr float
log1p(float __x)
{ return __builtin_log1pf(__x); }
#pragma empty_line
constexpr long double
log1p(long double __x)
{ return __builtin_log1pl(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
log1p(_Tp __x)
{ return __builtin_log1p(__x); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
constexpr float
log2(float __x)
{ return __builtin_log2f(__x); }
#pragma empty_line
constexpr long double
log2(long double __x)
{ return __builtin_log2l(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
log2(_Tp __x)
{ return __builtin_log2(__x); }
#pragma empty_line
#pragma empty_line
constexpr float
logb(float __x)
{ return __builtin_logbf(__x); }
#pragma empty_line
constexpr long double
logb(long double __x)
{ return __builtin_logbl(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
logb(_Tp __x)
{ return __builtin_logb(__x); }
#pragma empty_line
#pragma empty_line
constexpr long
lrint(float __x)
{ return __builtin_lrintf(__x); }
#pragma empty_line
constexpr long
lrint(long double __x)
{ return __builtin_lrintl(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
long>::__type
lrint(_Tp __x)
{ return __builtin_lrint(__x); }
#pragma empty_line
#pragma empty_line
constexpr long
lround(float __x)
{ return __builtin_lroundf(__x); }
#pragma empty_line
constexpr long
lround(long double __x)
{ return __builtin_lroundl(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
long>::__type
lround(_Tp __x)
{ return __builtin_lround(__x); }
#pragma empty_line
#pragma empty_line
constexpr float
nearbyint(float __x)
{ return __builtin_nearbyintf(__x); }
#pragma empty_line
constexpr long double
nearbyint(long double __x)
{ return __builtin_nearbyintl(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
nearbyint(_Tp __x)
{ return __builtin_nearbyint(__x); }
#pragma empty_line
#pragma empty_line
constexpr float
nextafter(float __x, float __y)
{ return __builtin_nextafterf(__x, __y); }
#pragma empty_line
constexpr long double
nextafter(long double __x, long double __y)
{ return __builtin_nextafterl(__x, __y); }
#pragma empty_line
#pragma empty_line
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));
}
#pragma empty_line
#pragma empty_line
constexpr float
nexttoward(float __x, long double __y)
{ return __builtin_nexttowardf(__x, __y); }
#pragma empty_line
constexpr long double
nexttoward(long double __x, long double __y)
{ return __builtin_nexttowardl(__x, __y); }
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
constexpr float
remainder(float __x, float __y)
{ return __builtin_remainderf(__x, __y); }
#pragma empty_line
constexpr long double
remainder(long double __x, long double __y)
{ return __builtin_remainderl(__x, __y); }
#pragma empty_line
#pragma empty_line
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));
}
#pragma empty_line
#pragma empty_line
inline float
remquo(float __x, float __y, int* __pquo)
{ return __builtin_remquof(__x, __y, __pquo); }
#pragma empty_line
inline long double
remquo(long double __x, long double __y, int* __pquo)
{ return __builtin_remquol(__x, __y, __pquo); }
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
constexpr float
rint(float __x)
{ return __builtin_rintf(__x); }
#pragma empty_line
constexpr long double
rint(long double __x)
{ return __builtin_rintl(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
rint(_Tp __x)
{ return __builtin_rint(__x); }
#pragma empty_line
#pragma empty_line
constexpr float
round(float __x)
{ return __builtin_roundf(__x); }
#pragma empty_line
constexpr long double
round(long double __x)
{ return __builtin_roundl(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
round(_Tp __x)
{ return __builtin_round(__x); }
#pragma empty_line
#pragma empty_line
constexpr float
scalbln(float __x, long __ex)
{ return __builtin_scalblnf(__x, __ex); }
#pragma empty_line
constexpr long double
scalbln(long double __x, long __ex)
{ return __builtin_scalblnl(__x, __ex); }
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
constexpr float
scalbn(float __x, int __ex)
{ return __builtin_scalbnf(__x, __ex); }
#pragma empty_line
constexpr long double
scalbn(long double __x, int __ex)
{ return __builtin_scalbnl(__x, __ex); }
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
constexpr float
tgamma(float __x)
{ return __builtin_tgammaf(__x); }
#pragma empty_line
constexpr long double
tgamma(long double __x)
{ return __builtin_tgammal(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
tgamma(_Tp __x)
{ return __builtin_tgamma(__x); }
#pragma empty_line
#pragma empty_line
constexpr float
trunc(float __x)
{ return __builtin_truncf(__x); }
#pragma empty_line
constexpr long double
trunc(long double __x)
{ return __builtin_truncl(__x); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
trunc(_Tp __x)
{ return __builtin_trunc(__x); }
#pragma empty_line
#pragma empty_line
}
#pragma line 1797 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cmath" 3
}
#pragma line 610 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_common.h" 2
#pragma line 630 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_common.h"
#pragma empty_line
#pragma line 630 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_common.h"
template <int _AP_W, bool _AP_S, bool _AP_C = _AP_W <= 64>
class ap_private;
#pragma empty_line
template <int _AP_W, bool _AP_S>
struct ssdm_int_sim {
#pragma empty_line
ap_private<_AP_W, _AP_S> V;
ssdm_int_sim() {}
};
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 1
#pragma line 63 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 90 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h" 1
#pragma line 31 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h"
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cmath" 1 3
#pragma line 39 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cmath" 3
#pragma empty_line
#pragma line 40 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cmath" 3
#pragma line 32 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h" 2
#pragma line 43 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h"
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstddef" 1 3
#pragma line 42 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstddef" 3
#pragma empty_line
#pragma line 43 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstddef" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include/stddef.h" 1 3 4
#pragma line 51 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstddef" 2 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 53 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstddef" 3
namespace std
{
#pragma empty_line
using ::max_align_t;
}
#pragma line 44 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h" 2
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_fpo.h" 1
#pragma line 59 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_fpo.h"
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/math.h" 1 3
#pragma line 36 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/math.h" 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cmath" 1 3
#pragma line 39 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cmath" 3
#pragma empty_line
#pragma line 40 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cmath" 3
#pragma line 37 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/math.h" 2 3
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
#pragma line 60 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_fpo.h" 2
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/assert.h" 1 3 4
#pragma line 63 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_fpo.h" 2
#pragma line 186 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_fpo.h"
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/floating_point_v7_0_bitacc_cmodel.h" 1
#pragma line 115 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/floating_point_v7_0_bitacc_cmodel.h"
#pragma empty_line
#pragma line 115 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include/stdbool.h" 1 3 4
#pragma line 126 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/floating_point_v7_0_bitacc_cmodel.h" 2
#pragma line 143 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/floating_point_v7_0_bitacc_cmodel.h"
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/gmp.h" 1
#pragma line 27 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/gmp.h"
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdio" 1 3
#pragma line 39 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdio" 3
#pragma empty_line
#pragma line 40 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdio" 3
#pragma line 28 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/gmp.h" 2
#pragma line 201 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/gmp.h"
typedef unsigned long int mp_limb_t;
typedef long int mp_limb_signed_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef unsigned long int mp_bitcnt_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef struct
{
int _mp_alloc;
#pragma empty_line
int _mp_size;
#pragma empty_line
#pragma empty_line
mp_limb_t *_mp_d;
} __mpz_struct;
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __mpz_struct mpz_t[1];
#pragma empty_line
typedef mp_limb_t * mp_ptr;
typedef const mp_limb_t * mp_srcptr;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef long int mp_size_t;
typedef long int mp_exp_t;
#pragma empty_line
#pragma empty_line
typedef struct
{
__mpz_struct _mp_num;
__mpz_struct _mp_den;
} __mpq_struct;
#pragma empty_line
typedef __mpq_struct mpq_t[1];
#pragma empty_line
typedef struct
{
int _mp_prec;
#pragma empty_line
#pragma empty_line
#pragma empty_line
int _mp_size;
#pragma empty_line
#pragma empty_line
mp_exp_t _mp_exp;
mp_limb_t *_mp_d;
} __mpf_struct;
#pragma empty_line
typedef __mpf_struct mpf_t[1];
#pragma empty_line
#pragma empty_line
typedef enum
{
GMP_RAND_ALG_DEFAULT = 0,
GMP_RAND_ALG_LC = GMP_RAND_ALG_DEFAULT
} gmp_randalg_t;
#pragma empty_line
#pragma empty_line
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];
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
#pragma line 532 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/gmp.h"
extern "C" {
using std::FILE;
#pragma empty_line
#pragma empty_line
#pragma empty_line
void __gmp_set_memory_functions (void *(*) (size_t), void *(*) (void *, size_t, size_t), void (*) (void *, size_t))
#pragma empty_line
throw ();
#pragma empty_line
#pragma empty_line
void __gmp_get_memory_functions (void *(**) (size_t), void *(**) (void *, size_t, size_t), void (**) (void *, size_t))
#pragma empty_line
throw ();
#pragma empty_line
#pragma empty_line
extern const int __gmp_bits_per_limb;
#pragma empty_line
#pragma empty_line
extern int __gmp_errno;
#pragma empty_line
#pragma empty_line
extern const char * const __gmp_version;
#pragma empty_line
#pragma empty_line
extern const char * const __mpir_version;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
void __gmp_randinit_default (gmp_randstate_t);
#pragma empty_line
#pragma empty_line
void __gmp_randinit_lc_2exp (gmp_randstate_t, mpz_srcptr, unsigned long int, mp_bitcnt_t)
#pragma empty_line
;
#pragma empty_line
#pragma empty_line
int __gmp_randinit_lc_2exp_size (gmp_randstate_t, mp_bitcnt_t);
#pragma empty_line
#pragma empty_line
void __gmp_randinit_mt (gmp_randstate_t);
#pragma empty_line
#pragma empty_line
void __gmp_randinit_set (gmp_randstate_t, const __gmp_randstate_struct *);
#pragma empty_line
#pragma empty_line
void __gmp_randseed (gmp_randstate_t, mpz_srcptr);
#pragma empty_line
#pragma empty_line
void __gmp_randseed_ui (gmp_randstate_t, unsigned long int);
#pragma empty_line
#pragma empty_line
void __gmp_randclear (gmp_randstate_t);
#pragma empty_line
#pragma empty_line
unsigned long __gmp_urandomb_ui (gmp_randstate_t, unsigned long);
#pragma empty_line
#pragma empty_line
unsigned long __gmp_urandomm_ui (gmp_randstate_t, unsigned long);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
int __gmp_asprintf (char **, const char *, ...);
#pragma empty_line
#pragma empty_line
#pragma empty_line
int __gmp_fprintf (FILE *, const char *, ...);
#pragma line 615 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/gmp.h"
int __gmp_printf (const char *, ...);
#pragma empty_line
#pragma empty_line
int __gmp_snprintf (char *, size_t, const char *, ...);
#pragma empty_line
#pragma empty_line
int __gmp_sprintf (char *, const char *, ...);
#pragma line 653 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/gmp.h"
int __gmp_fscanf (FILE *, const char *, ...);
#pragma empty_line
#pragma empty_line
#pragma empty_line
int __gmp_scanf (const char *, ...);
#pragma empty_line
#pragma empty_line
int __gmp_sscanf (const char *, const char *, ...);
#pragma line 684 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/gmp.h"
void *__gmpz_realloc (mpz_ptr, mp_size_t);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
void __gmpz_abs (mpz_ptr, mpz_srcptr);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
void __gmpz_add (mpz_ptr, mpz_srcptr, mpz_srcptr);
#pragma empty_line
#pragma empty_line
#pragma empty_line
void __gmpz_add_ui (mpz_ptr, mpz_srcptr, unsigned long int);
#pragma empty_line
#pragma empty_line
void __gmpz_addmul (mpz_ptr, mpz_srcptr, mpz_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpz_addmul_ui (mpz_ptr, mpz_srcptr, unsigned long int);
#pragma empty_line
#pragma empty_line
void __gmpz_and (mpz_ptr, mpz_srcptr, mpz_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpz_array_init (mpz_ptr, mp_size_t, mp_size_t);
#pragma empty_line
#pragma empty_line
void __gmpz_bin_ui (mpz_ptr, mpz_srcptr, unsigned long int);
#pragma empty_line
#pragma empty_line
void __gmpz_bin_uiui (mpz_ptr, unsigned long int, unsigned long int);
#pragma empty_line
#pragma empty_line
void __gmpz_cdiv_q (mpz_ptr, mpz_srcptr, mpz_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpz_cdiv_q_2exp (mpz_ptr, mpz_srcptr, unsigned long);
#pragma empty_line
#pragma empty_line
unsigned long int __gmpz_cdiv_q_ui (mpz_ptr, mpz_srcptr, unsigned long int);
#pragma empty_line
#pragma empty_line
void __gmpz_cdiv_qr (mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr);
#pragma empty_line
#pragma empty_line
unsigned long int __gmpz_cdiv_qr_ui (mpz_ptr, mpz_ptr, mpz_srcptr, unsigned long int);
#pragma empty_line
#pragma empty_line
void __gmpz_cdiv_r (mpz_ptr, mpz_srcptr, mpz_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpz_cdiv_r_2exp (mpz_ptr, mpz_srcptr, mp_bitcnt_t);
#pragma empty_line
#pragma empty_line
unsigned long int __gmpz_cdiv_r_ui (mpz_ptr, mpz_srcptr, unsigned long int);
#pragma empty_line
#pragma empty_line
unsigned long int __gmpz_cdiv_ui (mpz_srcptr, unsigned long int) __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
void __gmpz_clear (mpz_ptr);
#pragma empty_line
#pragma empty_line
void __gmpz_clears (mpz_ptr, ...);
#pragma empty_line
#pragma empty_line
void __gmpz_clrbit (mpz_ptr, mp_bitcnt_t);
#pragma empty_line
#pragma empty_line
int __gmpz_cmp (mpz_srcptr, mpz_srcptr) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
int __gmpz_cmp_d (mpz_srcptr, double) __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
int __gmpz_cmp_si (mpz_srcptr, signed long int) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
int __gmpz_cmp_ui (mpz_srcptr, unsigned long int) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
int __gmpz_cmpabs (mpz_srcptr, mpz_srcptr) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
int __gmpz_cmpabs_d (mpz_srcptr, double) __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
int __gmpz_cmpabs_ui (mpz_srcptr, unsigned long int) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
void __gmpz_com (mpz_ptr, mpz_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpz_combit (mpz_ptr, mp_bitcnt_t);
#pragma empty_line
#pragma empty_line
int __gmpz_congruent_p (mpz_srcptr, mpz_srcptr, mpz_srcptr) __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
int __gmpz_congruent_2exp_p (mpz_srcptr, mpz_srcptr, mp_bitcnt_t) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
int __gmpz_congruent_ui_p (mpz_srcptr, unsigned long, unsigned long) __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
void __gmpz_divexact (mpz_ptr, mpz_srcptr, mpz_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpz_divexact_ui (mpz_ptr, mpz_srcptr, unsigned long);
#pragma empty_line
#pragma empty_line
int __gmpz_divisible_p (mpz_srcptr, mpz_srcptr) __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
int __gmpz_divisible_ui_p (mpz_srcptr, unsigned long) __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
int __gmpz_divisible_2exp_p (mpz_srcptr, mp_bitcnt_t) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
void __gmpz_dump (mpz_srcptr);
#pragma empty_line
#pragma empty_line
void *__gmpz_export (void *, size_t *, int, size_t, int, size_t, mpz_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpz_fac_ui (mpz_ptr, unsigned long int);
#pragma empty_line
#pragma empty_line
void __gmpz_fdiv_q (mpz_ptr, mpz_srcptr, mpz_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpz_fdiv_q_2exp (mpz_ptr, mpz_srcptr, mp_bitcnt_t);
#pragma empty_line
#pragma empty_line
unsigned long int __gmpz_fdiv_q_ui (mpz_ptr, mpz_srcptr, unsigned long int);
#pragma empty_line
#pragma empty_line
void __gmpz_fdiv_qr (mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr);
#pragma empty_line
#pragma empty_line
unsigned long int __gmpz_fdiv_qr_ui (mpz_ptr, mpz_ptr, mpz_srcptr, unsigned long int);
#pragma empty_line
#pragma empty_line
void __gmpz_fdiv_r (mpz_ptr, mpz_srcptr, mpz_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpz_fdiv_r_2exp (mpz_ptr, mpz_srcptr, mp_bitcnt_t);
#pragma empty_line
#pragma empty_line
unsigned long int __gmpz_fdiv_r_ui (mpz_ptr, mpz_srcptr, unsigned long int);
#pragma empty_line
#pragma empty_line
unsigned long int __gmpz_fdiv_ui (mpz_srcptr, unsigned long int) __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
void __gmpz_fib_ui (mpz_ptr, unsigned long int);
#pragma empty_line
#pragma empty_line
void __gmpz_fib2_ui (mpz_ptr, mpz_ptr, unsigned long int);
#pragma empty_line
#pragma empty_line
int __gmpz_fits_sint_p (mpz_srcptr) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
int __gmpz_fits_slong_p (mpz_srcptr) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
int __gmpz_fits_sshort_p (mpz_srcptr) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
int __gmpz_fits_uint_p (mpz_srcptr) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
int __gmpz_fits_ulong_p (mpz_srcptr) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
int __gmpz_fits_ushort_p (mpz_srcptr) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
void __gmpz_gcd (mpz_ptr, mpz_srcptr, mpz_srcptr);
#pragma empty_line
#pragma empty_line
unsigned long int __gmpz_gcd_ui (mpz_ptr, mpz_srcptr, unsigned long int);
#pragma empty_line
#pragma empty_line
void __gmpz_gcdext (mpz_ptr, mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr);
#pragma empty_line
#pragma empty_line
double __gmpz_get_d (mpz_srcptr) __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
double __gmpz_get_d_2exp (signed long int *, mpz_srcptr);
#pragma empty_line
#pragma empty_line
long int __gmpz_get_si (mpz_srcptr) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
char *__gmpz_get_str (char *, int, mpz_srcptr);
#pragma empty_line
#pragma empty_line
#pragma empty_line
unsigned long int __gmpz_get_ui (mpz_srcptr) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
mp_limb_t __gmpz_getlimbn (mpz_srcptr, mp_size_t) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
mp_bitcnt_t __gmpz_hamdist (mpz_srcptr, mpz_srcptr) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
void __gmpz_import (mpz_ptr, size_t, int, size_t, int, size_t, const void *);
#pragma empty_line
#pragma empty_line
void __gmpz_init (mpz_ptr);
#pragma empty_line
#pragma empty_line
void __gmpz_init2 (mpz_ptr, mp_bitcnt_t);
#pragma empty_line
#pragma empty_line
void __gmpz_inits (mpz_ptr, ...);
#pragma empty_line
#pragma empty_line
void __gmpz_init_set (mpz_ptr, mpz_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpz_init_set_d (mpz_ptr, double);
#pragma empty_line
#pragma empty_line
void __gmpz_init_set_si (mpz_ptr, signed long int);
#pragma empty_line
#pragma empty_line
int __gmpz_init_set_str (mpz_ptr, const char *, int);
#pragma empty_line
#pragma empty_line
void __gmpz_init_set_ui (mpz_ptr, unsigned long int);
#pragma empty_line
#pragma empty_line
#pragma empty_line
size_t __gmpz_inp_raw (mpz_ptr, FILE *);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
size_t __gmpz_inp_str (mpz_ptr, FILE *, int);
#pragma empty_line
#pragma empty_line
#pragma empty_line
int __gmpz_invert (mpz_ptr, mpz_srcptr, mpz_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpz_ior (mpz_ptr, mpz_srcptr, mpz_srcptr);
#pragma empty_line
#pragma empty_line
int __gmpz_jacobi (mpz_srcptr, mpz_srcptr) __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
int __gmpz_kronecker_si (mpz_srcptr, long) __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
int __gmpz_kronecker_ui (mpz_srcptr, unsigned long) __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
int __gmpz_si_kronecker (long, mpz_srcptr) __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
int __gmpz_ui_kronecker (unsigned long, mpz_srcptr) __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
void __gmpz_lcm (mpz_ptr, mpz_srcptr, mpz_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpz_lcm_ui (mpz_ptr, mpz_srcptr, unsigned long);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
void __gmpz_lucnum_ui (mpz_ptr, unsigned long int);
#pragma empty_line
#pragma empty_line
void __gmpz_lucnum2_ui (mpz_ptr, mpz_ptr, unsigned long int);
#pragma empty_line
#pragma empty_line
int __gmpz_millerrabin (mpz_srcptr, int) __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
void __gmpz_mod (mpz_ptr, mpz_srcptr, mpz_srcptr);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
void __gmpz_mul (mpz_ptr, mpz_srcptr, mpz_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpz_mul_2exp (mpz_ptr, mpz_srcptr, mp_bitcnt_t);
#pragma empty_line
#pragma empty_line
#pragma empty_line
void __gmpz_mul_si (mpz_ptr, mpz_srcptr, long int);
#pragma empty_line
#pragma empty_line
#pragma empty_line
void __gmpz_mul_ui (mpz_ptr, mpz_srcptr, unsigned long int);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
void __gmpz_neg (mpz_ptr, mpz_srcptr);
#pragma empty_line
#pragma empty_line
#pragma empty_line
void __gmpz_nextprime (mpz_ptr, mpz_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpz_next_likely_prime (mpz_ptr, mpz_srcptr,gmp_randstate_t);
#pragma empty_line
#pragma empty_line
#pragma empty_line
size_t __gmpz_out_raw (FILE *, mpz_srcptr);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
size_t __gmpz_out_str (FILE *, int, mpz_srcptr);
#pragma empty_line
#pragma empty_line
#pragma empty_line
int __gmpz_perfect_power_p (mpz_srcptr) __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
int __gmpz_perfect_square_p (mpz_srcptr) __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
mp_bitcnt_t __gmpz_popcount (mpz_srcptr) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
void __gmpz_pow_ui (mpz_ptr, mpz_srcptr, unsigned long int);
#pragma empty_line
#pragma empty_line
void __gmpz_powm (mpz_ptr, mpz_srcptr, mpz_srcptr, mpz_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpz_powm_ui (mpz_ptr, mpz_srcptr, unsigned long int, mpz_srcptr);
#pragma empty_line
#pragma empty_line
int __gmpz_probab_prime_p (mpz_srcptr, int) __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
int __gmpz_probable_prime_p (mpz_srcptr,gmp_randstate_t, int,unsigned long);
#pragma empty_line
#pragma empty_line
int __gmpz_likely_prime_p (mpz_srcptr,gmp_randstate_t, unsigned long);
#pragma empty_line
#pragma empty_line
void __gmpz_realloc2 (mpz_ptr, mp_bitcnt_t);
#pragma empty_line
#pragma empty_line
unsigned long int __gmpz_remove (mpz_ptr, mpz_srcptr, mpz_srcptr);
#pragma empty_line
#pragma empty_line
int __gmpz_root (mpz_ptr, mpz_srcptr, unsigned long int);
#pragma empty_line
#pragma empty_line
void __gmpz_nthroot (mpz_ptr, mpz_srcptr, unsigned long int);
#pragma empty_line
#pragma empty_line
void __gmpz_rootrem (mpz_ptr,mpz_ptr, mpz_srcptr, unsigned long int);
#pragma empty_line
#pragma empty_line
void __gmpz_rrandomb (mpz_ptr, gmp_randstate_t, mp_bitcnt_t);
#pragma empty_line
#pragma empty_line
mp_bitcnt_t __gmpz_scan0 (mpz_srcptr, mp_bitcnt_t) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
mp_bitcnt_t __gmpz_scan1 (mpz_srcptr, mp_bitcnt_t) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
void __gmpz_set (mpz_ptr, mpz_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpz_set_d (mpz_ptr, double);
#pragma empty_line
#pragma empty_line
void __gmpz_set_f (mpz_ptr, mpf_srcptr);
#pragma empty_line
#pragma empty_line
#pragma empty_line
void __gmpz_set_q (mpz_ptr, mpq_srcptr);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
void __gmpz_set_si (mpz_ptr, signed long int);
#pragma empty_line
#pragma empty_line
int __gmpz_set_str (mpz_ptr, const char *, int);
#pragma empty_line
#pragma empty_line
#pragma empty_line
void __gmpz_set_ui (mpz_ptr, unsigned long int);
#pragma empty_line
#pragma empty_line
void __gmpz_setbit (mpz_ptr, mp_bitcnt_t);
#pragma empty_line
#pragma empty_line
#pragma empty_line
size_t __gmpz_size (mpz_srcptr) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
size_t __gmpz_sizeinbase (mpz_srcptr, int) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
void __gmpz_sqrt (mpz_ptr, mpz_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpz_sqrtrem (mpz_ptr, mpz_ptr, mpz_srcptr);
#pragma empty_line
#pragma empty_line
#pragma empty_line
void __gmpz_sub (mpz_ptr, mpz_srcptr, mpz_srcptr);
#pragma empty_line
#pragma empty_line
#pragma empty_line
void __gmpz_sub_ui (mpz_ptr, mpz_srcptr, unsigned long int);
#pragma empty_line
#pragma empty_line
#pragma empty_line
void __gmpz_ui_sub (mpz_ptr, unsigned long int, mpz_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpz_submul (mpz_ptr, mpz_srcptr, mpz_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpz_submul_ui (mpz_ptr, mpz_srcptr, unsigned long int);
#pragma empty_line
#pragma empty_line
void __gmpz_swap (mpz_ptr, mpz_ptr) throw ();
#pragma empty_line
#pragma empty_line
unsigned long int __gmpz_tdiv_ui (mpz_srcptr, unsigned long int) __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
void __gmpz_tdiv_q (mpz_ptr, mpz_srcptr, mpz_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpz_tdiv_q_2exp (mpz_ptr, mpz_srcptr, mp_bitcnt_t);
#pragma empty_line
#pragma empty_line
unsigned long int __gmpz_tdiv_q_ui (mpz_ptr, mpz_srcptr, unsigned long int);
#pragma empty_line
#pragma empty_line
void __gmpz_tdiv_qr (mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr);
#pragma empty_line
#pragma empty_line
unsigned long int __gmpz_tdiv_qr_ui (mpz_ptr, mpz_ptr, mpz_srcptr, unsigned long int);
#pragma empty_line
#pragma empty_line
void __gmpz_tdiv_r (mpz_ptr, mpz_srcptr, mpz_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpz_tdiv_r_2exp (mpz_ptr, mpz_srcptr, mp_bitcnt_t);
#pragma empty_line
#pragma empty_line
unsigned long int __gmpz_tdiv_r_ui (mpz_ptr, mpz_srcptr, unsigned long int);
#pragma empty_line
#pragma empty_line
int __gmpz_tstbit (mpz_srcptr, mp_bitcnt_t) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
void __gmpz_ui_pow_ui (mpz_ptr, unsigned long int, unsigned long int);
#pragma empty_line
#pragma empty_line
void __gmpz_urandomb (mpz_ptr, gmp_randstate_t, mp_bitcnt_t);
#pragma empty_line
#pragma empty_line
void __gmpz_urandomm (mpz_ptr, gmp_randstate_t, mpz_srcptr);
#pragma empty_line
#pragma empty_line
#pragma empty_line
void __gmpz_xor (mpz_ptr, mpz_srcptr, mpz_srcptr);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
void __gmpq_abs (mpq_ptr, mpq_srcptr);
#pragma empty_line
#pragma empty_line
#pragma empty_line
void __gmpq_add (mpq_ptr, mpq_srcptr, mpq_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpq_canonicalize (mpq_ptr);
#pragma empty_line
#pragma empty_line
void __gmpq_clear (mpq_ptr);
#pragma empty_line
#pragma empty_line
void __gmpq_clears (mpq_ptr, ...);
#pragma empty_line
#pragma empty_line
int __gmpq_cmp (mpq_srcptr, mpq_srcptr) __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
int __gmpq_cmp_si (mpq_srcptr, long, unsigned long) __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
int __gmpq_cmp_ui (mpq_srcptr, unsigned long int, unsigned long int) __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
void __gmpq_div (mpq_ptr, mpq_srcptr, mpq_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpq_div_2exp (mpq_ptr, mpq_srcptr, mp_bitcnt_t);
#pragma empty_line
#pragma empty_line
int __gmpq_equal (mpq_srcptr, mpq_srcptr) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
void __gmpq_get_num (mpz_ptr, mpq_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpq_get_den (mpz_ptr, mpq_srcptr);
#pragma empty_line
#pragma empty_line
double __gmpq_get_d (mpq_srcptr) __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
char *__gmpq_get_str (char *, int, mpq_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpq_init (mpq_ptr);
#pragma empty_line
#pragma empty_line
void __gmpq_inits (mpq_ptr, ...);
#pragma empty_line
#pragma empty_line
#pragma empty_line
size_t __gmpq_inp_str (mpq_ptr, FILE *, int);
#pragma empty_line
#pragma empty_line
#pragma empty_line
void __gmpq_inv (mpq_ptr, mpq_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpq_mul (mpq_ptr, mpq_srcptr, mpq_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpq_mul_2exp (mpq_ptr, mpq_srcptr, mp_bitcnt_t);
#pragma empty_line
#pragma empty_line
#pragma empty_line
void __gmpq_neg (mpq_ptr, mpq_srcptr);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
size_t __gmpq_out_str (FILE *, int, mpq_srcptr);
#pragma empty_line
#pragma empty_line
#pragma empty_line
void __gmpq_set (mpq_ptr, mpq_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpq_set_d (mpq_ptr, double);
#pragma empty_line
#pragma empty_line
void __gmpq_set_den (mpq_ptr, mpz_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpq_set_f (mpq_ptr, mpf_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpq_set_num (mpq_ptr, mpz_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpq_set_si (mpq_ptr, signed long int, unsigned long int);
#pragma empty_line
#pragma empty_line
int __gmpq_set_str (mpq_ptr, const char *, int);
#pragma empty_line
#pragma empty_line
void __gmpq_set_ui (mpq_ptr, unsigned long int, unsigned long int);
#pragma empty_line
#pragma empty_line
void __gmpq_set_z (mpq_ptr, mpz_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpq_sub (mpq_ptr, mpq_srcptr, mpq_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpq_swap (mpq_ptr, mpq_ptr) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
void __gmpf_abs (mpf_ptr, mpf_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpf_add (mpf_ptr, mpf_srcptr, mpf_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpf_add_ui (mpf_ptr, mpf_srcptr, unsigned long int);
#pragma empty_line
void __gmpf_ceil (mpf_ptr, mpf_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpf_clear (mpf_ptr);
#pragma empty_line
#pragma empty_line
void __gmpf_clears (mpf_ptr, ...);
#pragma empty_line
#pragma empty_line
int __gmpf_cmp (mpf_srcptr, mpf_srcptr) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
int __gmpf_cmp_d (mpf_srcptr, double) __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
int __gmpf_cmp_si (mpf_srcptr, signed long int) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
int __gmpf_cmp_ui (mpf_srcptr, unsigned long int) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
void __gmpf_div (mpf_ptr, mpf_srcptr, mpf_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpf_div_2exp (mpf_ptr, mpf_srcptr, mp_bitcnt_t);
#pragma empty_line
#pragma empty_line
void __gmpf_div_ui (mpf_ptr, mpf_srcptr, unsigned long int);
#pragma empty_line
#pragma empty_line
void __gmpf_dump (mpf_srcptr);
#pragma empty_line
#pragma empty_line
int __gmpf_eq (mpf_srcptr, mpf_srcptr, unsigned long int) __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
int __gmpf_fits_sint_p (mpf_srcptr) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
int __gmpf_fits_slong_p (mpf_srcptr) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
int __gmpf_fits_sshort_p (mpf_srcptr) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
int __gmpf_fits_uint_p (mpf_srcptr) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
int __gmpf_fits_ulong_p (mpf_srcptr) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
int __gmpf_fits_ushort_p (mpf_srcptr) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
void __gmpf_floor (mpf_ptr, mpf_srcptr);
#pragma empty_line
#pragma empty_line
double __gmpf_get_d (mpf_srcptr) __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
double __gmpf_get_d_2exp (signed long int *, mpf_srcptr);
#pragma empty_line
#pragma empty_line
mp_bitcnt_t __gmpf_get_default_prec (void) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
mp_bitcnt_t __gmpf_get_prec (mpf_srcptr) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
long __gmpf_get_si (mpf_srcptr) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
char *__gmpf_get_str (char *, mp_exp_t *, int, size_t, mpf_srcptr);
#pragma empty_line
#pragma empty_line
unsigned long __gmpf_get_ui (mpf_srcptr) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
void __gmpf_init (mpf_ptr);
#pragma empty_line
#pragma empty_line
void __gmpf_init2 (mpf_ptr, mp_bitcnt_t);
#pragma empty_line
#pragma empty_line
void __gmpf_inits (mpf_ptr, ...);
#pragma empty_line
#pragma empty_line
void __gmpf_init_set (mpf_ptr, mpf_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpf_init_set_d (mpf_ptr, double);
#pragma empty_line
#pragma empty_line
void __gmpf_init_set_si (mpf_ptr, signed long int);
#pragma empty_line
#pragma empty_line
int __gmpf_init_set_str (mpf_ptr, const char *, int);
#pragma empty_line
#pragma empty_line
void __gmpf_init_set_ui (mpf_ptr, unsigned long int);
#pragma empty_line
#pragma empty_line
#pragma empty_line
size_t __gmpf_inp_str (mpf_ptr, FILE *, int);
#pragma empty_line
#pragma empty_line
#pragma empty_line
int __gmpf_integer_p (mpf_srcptr) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
void __gmpf_mul (mpf_ptr, mpf_srcptr, mpf_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpf_mul_2exp (mpf_ptr, mpf_srcptr, mp_bitcnt_t);
#pragma empty_line
#pragma empty_line
void __gmpf_mul_ui (mpf_ptr, mpf_srcptr, unsigned long int);
#pragma empty_line
#pragma empty_line
void __gmpf_neg (mpf_ptr, mpf_srcptr);
#pragma empty_line
#pragma empty_line
#pragma empty_line
size_t __gmpf_out_str (FILE *, int, size_t, mpf_srcptr);
#pragma empty_line
#pragma empty_line
#pragma empty_line
void __gmpf_pow_ui (mpf_ptr, mpf_srcptr, unsigned long int);
#pragma empty_line
#pragma empty_line
void __gmpf_random2 (mpf_ptr, mp_size_t, mp_exp_t);
#pragma empty_line
#pragma empty_line
void __gmpf_rrandomb (mpf_ptr, gmp_randstate_t, mp_size_t, mp_exp_t);
#pragma empty_line
#pragma empty_line
void __gmpf_reldiff (mpf_ptr, mpf_srcptr, mpf_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpf_set (mpf_ptr, mpf_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpf_set_d (mpf_ptr, double);
#pragma empty_line
#pragma empty_line
void __gmpf_set_default_prec (mp_bitcnt_t) throw ();
#pragma empty_line
#pragma empty_line
void __gmpf_set_prec (mpf_ptr, mp_bitcnt_t);
#pragma empty_line
#pragma empty_line
void __gmpf_set_prec_raw (mpf_ptr, mp_bitcnt_t) throw ();
#pragma empty_line
#pragma empty_line
void __gmpf_set_q (mpf_ptr, mpq_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpf_set_si (mpf_ptr, signed long int);
#pragma empty_line
#pragma empty_line
int __gmpf_set_str (mpf_ptr, const char *, int);
#pragma empty_line
#pragma empty_line
void __gmpf_set_ui (mpf_ptr, unsigned long int);
#pragma empty_line
#pragma empty_line
void __gmpf_set_z (mpf_ptr, mpz_srcptr);
#pragma empty_line
#pragma empty_line
size_t __gmpf_size (mpf_srcptr) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
void __gmpf_sqrt (mpf_ptr, mpf_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpf_sqrt_ui (mpf_ptr, unsigned long int);
#pragma empty_line
#pragma empty_line
void __gmpf_sub (mpf_ptr, mpf_srcptr, mpf_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpf_sub_ui (mpf_ptr, mpf_srcptr, unsigned long int);
#pragma empty_line
#pragma empty_line
void __gmpf_swap (mpf_ptr, mpf_ptr) throw ();
#pragma empty_line
#pragma empty_line
void __gmpf_trunc (mpf_ptr, mpf_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpf_ui_div (mpf_ptr, unsigned long int, mpf_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpf_ui_sub (mpf_ptr, unsigned long int, mpf_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpf_urandomb (mpf_t, gmp_randstate_t, mp_bitcnt_t);
#pragma line 1516 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/gmp.h"
mp_limb_t __gmpn_add (mp_ptr, mp_srcptr, mp_size_t, mp_srcptr,mp_size_t);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
mp_limb_t __gmpn_add_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
mp_limb_t __gmpn_add_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
#pragma empty_line
#pragma empty_line
mp_limb_t __gmpn_addmul_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t);
#pragma empty_line
#pragma empty_line
mp_limb_t __gmpn_bdivmod (mp_ptr, mp_ptr, mp_size_t, mp_srcptr, mp_size_t, unsigned long int);
#pragma empty_line
#pragma empty_line
mp_limb_t __gmpn_divrem (mp_ptr, mp_size_t, mp_ptr, mp_size_t, mp_srcptr, mp_size_t);
#pragma empty_line
#pragma empty_line
int __gmpn_mulmod_2expp1 (mp_ptr, mp_srcptr, mp_srcptr,int,unsigned long, mp_ptr);
#pragma empty_line
#pragma empty_line
void __gmpn_mulmod_2expm1 (mp_ptr, mp_ptr, mp_ptr,unsigned long, mp_ptr);
#pragma empty_line
#pragma empty_line
#pragma empty_line
int __gmpn_cmp (mp_srcptr, mp_srcptr, mp_size_t) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
mp_limb_t __gmpn_divexact_by3c (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
mp_limb_t __gmpn_divrem_1 (mp_ptr, mp_size_t, mp_srcptr, mp_size_t, mp_limb_t);
#pragma empty_line
#pragma empty_line
mp_limb_t __gmpn_divrem_2 (mp_ptr, mp_size_t, mp_ptr, mp_size_t, mp_srcptr);
#pragma empty_line
#pragma empty_line
void __gmpn_invert (mp_ptr xp, mp_srcptr ap, mp_size_t n);
#pragma empty_line
#pragma empty_line
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)
;
#pragma empty_line
#pragma empty_line
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)
;
#pragma empty_line
#pragma empty_line
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)
;
#pragma empty_line
#pragma empty_line
mp_limb_t __gmpn_inv_divappr_q_n (mp_ptr qp, mp_ptr np, mp_srcptr dp, mp_size_t n, mp_srcptr dip)
;
#pragma empty_line
#pragma empty_line
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)
;
#pragma empty_line
#pragma empty_line
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)
;
#pragma empty_line
#pragma empty_line
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)
;
#pragma empty_line
#pragma empty_line
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)
;
#pragma empty_line
#pragma empty_line
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)
;
#pragma empty_line
#pragma empty_line
mp_limb_t __gmpn_inv_div_qr_n (mp_ptr qp, mp_ptr np, mp_srcptr dp, mp_size_t dn, mp_srcptr dinv)
;
#pragma empty_line
#pragma empty_line
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)
;
#pragma empty_line
#pragma empty_line
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)
;
#pragma empty_line
#pragma empty_line
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)
;
#pragma empty_line
#pragma empty_line
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)
;
#pragma empty_line
#pragma empty_line
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)
;
#pragma empty_line
#pragma empty_line
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)
;
#pragma empty_line
#pragma empty_line
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)
;
#pragma empty_line
#pragma empty_line
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)
;
#pragma empty_line
#pragma empty_line
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)
;
#pragma empty_line
#pragma empty_line
void __gmpn_tdiv_q (mp_ptr qp, mp_srcptr np, mp_size_t nn, mp_srcptr dp, mp_size_t dn)
;
#pragma empty_line
#pragma empty_line
void __gmpn_divexact (mp_ptr qp, mp_srcptr np, mp_size_t nn, mp_srcptr dp, mp_size_t dn)
;
#pragma empty_line
#pragma empty_line
void __gmpn_redc_1 (mp_ptr, mp_ptr, mp_srcptr, mp_size_t, mp_limb_t);
#pragma empty_line
#pragma empty_line
mp_size_t __gmpn_gcd (mp_ptr, mp_ptr, mp_size_t, mp_ptr, mp_size_t);
#pragma empty_line
#pragma empty_line
mp_limb_t __gmpn_gcd_1 (mp_srcptr, mp_size_t, mp_limb_t) __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
mp_size_t __gmpn_gcdext (mp_ptr, mp_ptr, mp_size_t *, mp_ptr, mp_size_t, mp_ptr, mp_size_t);
#pragma empty_line
#pragma empty_line
size_t __gmpn_get_str (unsigned char *, int, mp_ptr, mp_size_t);
#pragma empty_line
#pragma empty_line
mp_bitcnt_t __gmpn_hamdist (mp_srcptr, mp_srcptr, mp_size_t) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
mp_limb_t __gmpn_lshift (mp_ptr, mp_srcptr, mp_size_t, unsigned int);
#pragma empty_line
#pragma empty_line
mp_limb_t __gmpn_mod_1 (mp_srcptr, mp_size_t, mp_limb_t) __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
mp_limb_t __gmpn_mul (mp_ptr, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t);
#pragma empty_line
#pragma empty_line
mp_limb_t __gmpn_mul_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t);
#pragma empty_line
#pragma empty_line
void __gmpn_mul_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
#pragma empty_line
#pragma empty_line
void __gmpn_sqr (mp_ptr, mp_srcptr, mp_size_t);
#pragma empty_line
#pragma empty_line
#pragma empty_line
mp_limb_t __gmpn_neg_n (mp_ptr, mp_srcptr, mp_size_t);
#pragma empty_line
#pragma empty_line
#pragma empty_line
void __gmpn_com_n (mp_ptr, mp_srcptr, mp_size_t);
#pragma empty_line
#pragma empty_line
int __gmpn_perfect_square_p (mp_srcptr, mp_size_t) __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
mp_bitcnt_t __gmpn_popcount (mp_srcptr, mp_size_t) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
mp_size_t __gmpn_pow_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t, mp_ptr);
#pragma empty_line
#pragma empty_line
#pragma empty_line
mp_limb_t __gmpn_preinv_mod_1 (mp_srcptr, mp_size_t, mp_limb_t, mp_limb_t) __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
void __gmpn_random (mp_ptr, mp_size_t);
#pragma empty_line
#pragma empty_line
void __gmpn_random2 (mp_ptr, mp_size_t);
#pragma empty_line
#pragma empty_line
void __gmpn_urandomb (mp_ptr, gmp_randstate_t, unsigned long);
#pragma empty_line
#pragma empty_line
void __gmpn_urandomm (mp_ptr, gmp_randstate_t, mp_srcptr, mp_size_t);
#pragma empty_line
#pragma empty_line
void __gmpn_randomb (mp_ptr, gmp_randstate_t, mp_size_t);
#pragma empty_line
#pragma empty_line
void __gmpn_rrandom (mp_ptr, gmp_randstate_t, mp_size_t);
#pragma empty_line
#pragma empty_line
mp_limb_t __gmpn_rshift (mp_ptr, mp_srcptr, mp_size_t, unsigned int);
#pragma empty_line
#pragma empty_line
mp_bitcnt_t __gmpn_scan0 (mp_srcptr, mp_bitcnt_t) __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
mp_bitcnt_t __gmpn_scan1 (mp_srcptr, mp_bitcnt_t) __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
mp_size_t __gmpn_set_str (mp_ptr, const unsigned char *, size_t, int);
#pragma empty_line
#pragma empty_line
mp_size_t __gmpn_sqrtrem (mp_ptr, mp_ptr, mp_srcptr, mp_size_t);
#pragma empty_line
#pragma empty_line
#pragma empty_line
mp_limb_t __gmpn_sub (mp_ptr, mp_srcptr, mp_size_t, mp_srcptr,mp_size_t);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
mp_limb_t __gmpn_sub_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
mp_limb_t __gmpn_sub_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
#pragma empty_line
#pragma empty_line
mp_limb_t __gmpn_submul_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t);
#pragma empty_line
#pragma empty_line
void __gmpn_tdiv_qr (mp_ptr, mp_ptr, mp_size_t, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t);
#pragma empty_line
#pragma empty_line
void __gmpn_and_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
#pragma empty_line
void __gmpn_andn_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
#pragma empty_line
void __gmpn_nand_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
#pragma empty_line
void __gmpn_ior_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
#pragma empty_line
void __gmpn_iorn_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
#pragma empty_line
void __gmpn_nior_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
#pragma empty_line
void __gmpn_xor_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
#pragma empty_line
void __gmpn_xnor_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
#pragma empty_line
#pragma empty_line
void __gmpn_copyi (mp_ptr, mp_srcptr, mp_size_t);
#pragma empty_line
void __gmpn_copyd (mp_ptr, mp_srcptr, mp_size_t);
#pragma empty_line
void __gmpn_zero (mp_ptr, mp_size_t);
#pragma line 1799 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/gmp.h"
extern __inline__ __attribute__((__gnu_inline__)) void
__gmpz_abs (mpz_ptr __gmp_w, mpz_srcptr __gmp_u)
{
if (__gmp_w != __gmp_u)
__gmpz_set (__gmp_w, __gmp_u);
__gmp_w->_mp_size = ((__gmp_w->_mp_size) >= 0 ? (__gmp_w->_mp_size) : -(__gmp_w->_mp_size));
}
#pragma line 1823 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/gmp.h"
extern __inline__ __attribute__((__gnu_inline__))
#pragma empty_line
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)));;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __inline__ __attribute__((__gnu_inline__))
#pragma empty_line
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)));;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __inline__ __attribute__((__gnu_inline__))
#pragma empty_line
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)));;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __inline__ __attribute__((__gnu_inline__))
#pragma empty_line
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];
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
return (unsigned long)(__gmp_n != 0 ? __gmp_l : 0);
#pragma line 1879 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/gmp.h"
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __inline__ __attribute__((__gnu_inline__))
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __inline__ __attribute__((__gnu_inline__))
#pragma empty_line
int
__gmpz_perfect_square_p (mpz_srcptr __gmp_a)
{
mp_size_t __gmp_asize;
int __gmp_result;
#pragma empty_line
__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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __inline__ __attribute__((__gnu_inline__))
#pragma empty_line
mp_bitcnt_t
__gmpz_popcount (mpz_srcptr __gmp_u) throw ()
{
mp_size_t __gmp_usize;
mp_bitcnt_t __gmp_result;
#pragma empty_line
__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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __inline__ __attribute__((__gnu_inline__))
#pragma empty_line
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)));
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __inline__ __attribute__((__gnu_inline__))
#pragma empty_line
size_t
__gmpz_size (mpz_srcptr __gmp_z) throw ()
{
return ((__gmp_z->_mp_size) >= 0 ? (__gmp_z->_mp_size) : -(__gmp_z->_mp_size));
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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));
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma line 2220 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/gmp.h"
extern __inline__ __attribute__((__gnu_inline__))
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __inline__ __attribute__((__gnu_inline__))
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __inline__ __attribute__((__gnu_inline__))
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __inline__ __attribute__((__gnu_inline__))
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern __inline__ __attribute__((__gnu_inline__))
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 2328 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/gmp.h"
std::ostream& operator<< (std::ostream &, mpz_srcptr);
std::ostream& operator<< (std::ostream &, mpq_srcptr);
std::ostream& operator<< (std::ostream &, mpf_srcptr);
std::istream& operator>> (std::istream &, mpz_ptr);
std::istream& operator>> (std::istream &, mpq_ptr);
std::istream& operator>> (std::istream &, mpf_ptr);
#pragma line 2348 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/gmp.h"
typedef __mpz_struct MP_INT;
typedef __mpq_struct MP_RAT;
#pragma line 2358 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/gmp.h"
enum
{
GMP_ERROR_NONE = 0,
GMP_ERROR_UNSUPPORTED_ARGUMENT = 1,
GMP_ERROR_DIVISION_BY_ZERO = 2,
GMP_ERROR_SQRT_OF_NEGATIVE = 4,
GMP_ERROR_INVALID_ARGUMENT = 8
};
#pragma line 144 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/floating_point_v7_0_bitacc_cmodel.h" 2
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/mpfr.h" 1
#pragma line 73 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 95 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/mpfr.h"
typedef enum {
MPFR_RNDN=0,
MPFR_RNDZ,
MPFR_RNDU,
MPFR_RNDD,
MPFR_RNDA,
MPFR_RNDF,
MPFR_RNDNA=-1
} mpfr_rnd_t;
#pragma line 130 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/mpfr.h"
typedef long mpfr_prec_t;
typedef unsigned long mpfr_uprec_t;
#pragma line 143 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/mpfr.h"
typedef int mpfr_sign_t;
#pragma empty_line
#pragma empty_line
typedef mp_exp_t mpfr_exp_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef struct {
mpfr_prec_t _mpfr_prec;
mpfr_sign_t _mpfr_sign;
mpfr_exp_t _mpfr_exp;
mp_limb_t *_mpfr_d;
} __mpfr_struct;
#pragma line 179 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/mpfr.h"
typedef __mpfr_struct mpfr_t[1];
typedef __mpfr_struct *mpfr_ptr;
typedef const __mpfr_struct *mpfr_srcptr;
#pragma line 192 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/mpfr.h"
typedef enum {
MPFR_NAN_KIND = 0,
MPFR_INF_KIND = 1, MPFR_ZERO_KIND = 2, MPFR_REGULAR_KIND = 3
} mpfr_kind_t;
#pragma line 241 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/mpfr.h"
extern "C" {
#pragma empty_line
#pragma empty_line
const char * mpfr_get_version (void);
const char * mpfr_get_patches (void);
int mpfr_buildopt_tls_p (void);
int mpfr_buildopt_decimal_p (void);
#pragma empty_line
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);
#pragma empty_line
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);
#pragma empty_line
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);
#pragma empty_line
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);
#pragma empty_line
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);
#pragma empty_line
int
mpfr_check_range (mpfr_ptr, int, mpfr_rnd_t);
#pragma empty_line
void mpfr_init2 (mpfr_ptr, mpfr_prec_t);
void mpfr_init (mpfr_ptr);
void mpfr_clear (mpfr_ptr);
#pragma empty_line
void
mpfr_inits2 (mpfr_prec_t, mpfr_ptr, ...) __attribute__ ((sentinel));
void
mpfr_inits (mpfr_ptr, ...) __attribute__ ((sentinel));
void
mpfr_clears (mpfr_ptr, ...) __attribute__ ((sentinel));
#pragma empty_line
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);
#pragma empty_line
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);
#pragma empty_line
int mpfr_set_d (mpfr_ptr, double, mpfr_rnd_t);
int mpfr_set_flt (mpfr_ptr, float, mpfr_rnd_t);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
#pragma line 364 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
#pragma empty_line
#pragma empty_line
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);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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)
;
#pragma empty_line
void mpfr_free_str (char *);
#pragma empty_line
int mpfr_urandom (mpfr_ptr, gmp_randstate_t, mpfr_rnd_t)
;
int mpfr_urandomb (mpfr_ptr, gmp_randstate_t);
#pragma empty_line
void mpfr_nextabove (mpfr_ptr);
void mpfr_nextbelow (mpfr_ptr);
void mpfr_nexttoward (mpfr_ptr, mpfr_srcptr);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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)
;
#pragma empty_line
int __gmpfr_fprintf (FILE*, const char*, ...)
;
#pragma empty_line
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*, ...)
;
#pragma line 444 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
;
#pragma empty_line
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)
;
#pragma empty_line
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)
;
#pragma empty_line
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)
;
#pragma empty_line
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)
;
#pragma empty_line
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)
;
#pragma empty_line
int mpfr_sqr (mpfr_ptr, mpfr_srcptr,mpfr_rnd_t);
#pragma empty_line
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);
#pragma empty_line
int mpfr_agm (mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t)
;
#pragma empty_line
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)
;
#pragma empty_line
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);
#pragma empty_line
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);
#pragma empty_line
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)
;
#pragma empty_line
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)
;
#pragma empty_line
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);
#pragma empty_line
void mpfr_extract (mpz_ptr, mpfr_srcptr, unsigned int)
;
void mpfr_swap (mpfr_ptr, mpfr_ptr);
void mpfr_dump (mpfr_srcptr);
#pragma empty_line
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);
#pragma empty_line
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);
#pragma empty_line
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)
;
#pragma empty_line
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);
#pragma empty_line
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);
#pragma empty_line
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)
;
#pragma empty_line
int mpfr_ai (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t);
#pragma empty_line
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)
;
#pragma empty_line
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);
#pragma empty_line
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);
#pragma empty_line
int mpfr_cmp_f (mpfr_srcptr, mpf_srcptr);
#pragma empty_line
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)
;
#pragma empty_line
void mpfr_free_cache (void);
#pragma empty_line
int mpfr_subnormalize (mpfr_ptr, int, mpfr_rnd_t)
;
#pragma empty_line
int mpfr_strtofr (mpfr_ptr, const char *, char **, int, mpfr_rnd_t)
;
#pragma empty_line
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);
#pragma empty_line
#pragma empty_line
}
#pragma line 149 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/floating_point_v7_0_bitacc_cmodel.h" 2
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef long xip_fpo_prec_t;
#pragma empty_line
#pragma empty_line
typedef int xip_fpo_sign_t;
#pragma empty_line
#pragma empty_line
typedef long xip_fpo_exp_t;
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
typedef __xip_fpo_struct xip_fpo_t[1];
typedef __xip_fpo_fix_struct xip_fpo_fix_t[1];
#pragma empty_line
#pragma empty_line
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;
#pragma line 197 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/floating_point_v7_0_bitacc_cmodel.h"
typedef int xip_fpo_exc_t;
#pragma empty_line
#pragma empty_line
extern "C" {
#pragma empty_line
#pragma empty_line
typedef struct xil_fpo_accum_state xil_fpo_accum_state;
#pragma empty_line
#pragma empty_line
const char * xip_fpo_get_version (void);
#pragma empty_line
#pragma empty_line
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);
#pragma empty_line
#pragma empty_line
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);
#pragma empty_line
#pragma empty_line
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);
#pragma empty_line
#pragma empty_line
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);
#pragma empty_line
#pragma empty_line
}
#pragma line 187 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_fpo.h" 2
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/gmp.h" 1
#pragma line 188 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_fpo.h" 2
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/mpfr.h" 1
#pragma line 189 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_fpo.h" 2
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline float xil_fpo_add_flt(float a, float b)
{
float res_flt = 0.0f;
#pragma empty_line
#pragma empty_line
xip_fpo_add_flt(&res_flt, a, b);
return res_flt;
}
#pragma empty_line
inline double xil_fpo_add_d(double a, double b)
{
double res_d = 0.0;
#pragma empty_line
#pragma empty_line
xip_fpo_add_d(&res_d, a, b);
return res_d;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline float xil_fpo_sub_flt(float a, float b)
{
float res_flt = 0.0f;
#pragma empty_line
#pragma empty_line
xip_fpo_sub_flt(&res_flt, a, b);
return res_flt;
}
#pragma empty_line
inline double xil_fpo_sub_d(double a, double b)
{
double res_d = 0.0;
#pragma empty_line
#pragma empty_line
xip_fpo_sub_d(&res_d, a, b);
return res_d;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline float xil_fpo_mul_flt(float a, float b)
{
float res_flt = 0.0f;
#pragma empty_line
#pragma empty_line
xip_fpo_mul_flt(&res_flt, a, b);
return res_flt;
}
#pragma empty_line
inline double xil_fpo_mul_d(double a, double b)
{
double res_d = 0.0;
#pragma empty_line
#pragma empty_line
xip_fpo_mul_d(&res_d, a, b);
return res_d;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline float xil_fpo_div_flt(float a, float b)
{
float res_flt = 0.0f;
#pragma empty_line
#pragma empty_line
xip_fpo_div_flt(&res_flt, a, b);
return res_flt;
}
#pragma empty_line
inline double xil_fpo_div_d(double a, double b)
{
double res_d = 0.0;
#pragma empty_line
#pragma empty_line
xip_fpo_div_d(&res_d, a, b);
return res_d;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline float xil_fpo_rec_flt(float a)
{
float res_flt = 0.0f;
#pragma empty_line
#pragma empty_line
xip_fpo_rec_flt(&res_flt, a);
return res_flt;
}
#pragma empty_line
inline double xil_fpo_rec_d(double a)
{
double res_d = 0.0;
#pragma empty_line
#pragma empty_line
xip_fpo_rec_d(&res_d, a);
return res_d;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline float xil_fpo_sqrt_flt(float a)
{
#pragma empty_line
float res_flt = 0.0f;
#pragma empty_line
#pragma empty_line
xip_fpo_sqrt_flt(&res_flt, a);
#pragma empty_line
return res_flt;
}
#pragma empty_line
inline double xil_fpo_sqrt_d(double a)
{
double res_d = 0.0;
#pragma empty_line
#pragma empty_line
xip_fpo_sqrt_d(&res_d, a);
#pragma empty_line
return res_d;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline float xil_fpo_recsqrt_flt(float a)
{
float res_flt = 0.0f;
#pragma empty_line
#pragma empty_line
xip_fpo_recsqrt_flt(&res_flt, a);
return res_flt;
}
#pragma empty_line
inline double xil_fpo_recsqrt_d(double a)
{
double res_d = 0.0;
#pragma empty_line
#pragma empty_line
xip_fpo_recsqrt_d(&res_d, a);
return res_d;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline float xil_fpo_abs_flt(float a)
{
float res_flt = 0.0f;
#pragma empty_line
xip_fpo_abs_flt(&res_flt, a);
return res_flt;
}
#pragma empty_line
inline double xil_fpo_abs_d(double a)
{
double res_d = 0.0;
#pragma empty_line
xip_fpo_abs_d(&res_d, a);
return res_d;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline float xil_fpo_log_flt(float a)
{
float res_flt = 0.0f;
#pragma empty_line
#pragma empty_line
xip_fpo_log_flt(&res_flt, a);
return res_flt;
}
#pragma empty_line
inline double xil_fpo_log_d(double a)
{
double res_d = 0.0;
#pragma empty_line
#pragma empty_line
xip_fpo_log_d(&res_d, a);
return res_d;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline float xil_fpo_exp_flt(float a)
{
float res_flt = 0.0f;
#pragma empty_line
#pragma empty_line
xip_fpo_exp_flt(&res_flt, a);
return res_flt;
}
#pragma empty_line
inline double xil_fpo_exp_d(double a)
{
double res_d = 0.0;
#pragma empty_line
#pragma empty_line
xip_fpo_exp_d(&res_d, a);
return res_d;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline int xil_fpo_unordered_flt(float a, float b)
{
int res_int = 0;
#pragma empty_line
#pragma empty_line
xip_fpo_unordered_flt(&res_int, a, b);
return res_int;
}
#pragma empty_line
inline int xil_fpo_unordered_d(double a, double b)
{
int res_int = 0;
#pragma empty_line
#pragma empty_line
xip_fpo_unordered_d(&res_int, a, b);
return res_int;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline int xil_fpo_equal_flt(float a, float b)
{
int res_int = 0;
#pragma empty_line
#pragma empty_line
xip_fpo_equal_flt(&res_int, a, b);
return res_int;
}
#pragma empty_line
inline int xil_fpo_equal_d(double a, double b)
{
int res_int = 0;
#pragma empty_line
#pragma empty_line
xip_fpo_equal_d(&res_int, a, b);
return res_int;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline int xil_fpo_less_flt(float a, float b)
{
int res_int = 0;
#pragma empty_line
#pragma empty_line
xip_fpo_less_flt(&res_int, a, b);
return res_int;
}
#pragma empty_line
inline int xil_fpo_less_d(double a, double b)
{
int res_int = 0;
#pragma empty_line
#pragma empty_line
xip_fpo_less_d(&res_int, a, b);
return res_int;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline int xil_fpo_lessequal_flt(float a, float b)
{
int res_int = 0;
#pragma empty_line
#pragma empty_line
xip_fpo_lessequal_flt(&res_int, a, b);
return res_int;
}
#pragma empty_line
inline int xil_fpo_lessequal_d(double a, double b)
{
int res_int = 0;
#pragma empty_line
#pragma empty_line
xip_fpo_lessequal_d(&res_int, a, b);
return res_int;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline int xil_fpo_greater_flt(float a, float b)
{
int res_int = 0;
#pragma empty_line
#pragma empty_line
xip_fpo_greater_flt(&res_int, a, b);
return res_int;
}
#pragma empty_line
inline int xil_fpo_greater_d(double a, double b)
{
int res_int = 0;
#pragma empty_line
#pragma empty_line
xip_fpo_greater_d(&res_int, a, b);
return res_int;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline int xil_fpo_greaterequal_flt(float a, float b)
{
int res_int = 0;
#pragma empty_line
#pragma empty_line
xip_fpo_greaterequal_flt(&res_int, a, b);
return res_int;
}
#pragma empty_line
inline int xil_fpo_greaterequal_d(double a, double b)
{
int res_int = 0;
#pragma empty_line
#pragma empty_line
xip_fpo_greaterequal_d(&res_int, a, b);
return res_int;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline int xil_fpo_notequal_flt(float a, float b)
{
int res_int = 0;
#pragma empty_line
#pragma empty_line
xip_fpo_notequal_flt(&res_int, a, b);
return res_int;
}
#pragma empty_line
inline int xil_fpo_notequal_d(double a, double b)
{
int res_int = 0;
#pragma empty_line
xip_fpo_notequal_d(&res_int, a, b);
return res_int;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline int xil_fpo_condcode_flt(float a, float b)
{
int res_int = 0;
#pragma empty_line
#pragma empty_line
xip_fpo_condcode_flt(&res_int, a, b);
return res_int;
}
#pragma empty_line
inline int xil_fpo_condcode_d(double a, double b)
{
int res_int = 0;
#pragma empty_line
#pragma empty_line
xip_fpo_condcode_d(&res_int, a, b);
return res_int;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline int xil_fpo_flttofix_int_flt(float a)
{
int res_int = 0;
#pragma empty_line
#pragma empty_line
xip_fpo_flttofix_int_flt(&res_int, a);
return res_int;
}
#pragma empty_line
inline int xil_fpo_flttofix_int_d(double a)
{
int res_int = 0;
#pragma empty_line
#pragma empty_line
xip_fpo_flttofix_int_d(&res_int, a);
return res_int;
}
#pragma empty_line
inline float xil_fpo_fixtoflt_flt_int(int a)
{
float res_flt = 0.0f;
#pragma empty_line
#pragma empty_line
xip_fpo_fixtoflt_flt_int(&res_flt, a);
return res_flt;
}
#pragma empty_line
inline double xil_fpo_fixtoflt_d_int(int a)
{
double res_d = 0.0;
#pragma empty_line
#pragma empty_line
xip_fpo_fixtoflt_d_int(&res_d, a);
return res_d;
}
#pragma empty_line
inline float xil_fpo_flttoflt_flt_flt(float a)
{
float res_flt = 0.0f;
#pragma empty_line
#pragma empty_line
xip_fpo_flttoflt_flt_flt(&res_flt, a);
return res_flt;
}
#pragma empty_line
inline float xil_fpo_flttoflt_flt_d(double a)
{
float res_flt = 0.0f;
#pragma empty_line
#pragma empty_line
xip_fpo_flttoflt_flt_d(&res_flt, a);
return res_flt;
}
#pragma empty_line
inline double xil_fpo_flttoflt_d_flt(float a)
{
double res_d = 0.0;
#pragma empty_line
#pragma empty_line
xip_fpo_flttoflt_d_flt(&res_d, a);
return res_d;
}
#pragma empty_line
inline double xil_fpo_flttoflt_d_d(double a)
{
double res_d = 0.0;
#pragma empty_line
#pragma empty_line
xip_fpo_flttoflt_d_d(&res_d, a);
return res_d;
}
#pragma line 45 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h" 2
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_decl.h" 1
#pragma line 48 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h" 2
#pragma line 129 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h"
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/utility" 1 3
#pragma line 58 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/utility" 3
#pragma empty_line
#pragma line 59 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/utility" 3
#pragma line 69 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/utility" 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_relops.h" 1 3
#pragma line 67 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_relops.h" 3
#pragma empty_line
#pragma line 67 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_relops.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
namespace rel_ops
{
#pragma empty_line
#pragma line 85 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 98 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma line 111 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 124 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
}
#pragma line 70 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/utility" 2 3
#pragma line 78 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/utility" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct tuple_size;
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct tuple_size<const _Tp>
: integral_constant<size_t, tuple_size<_Tp>::value> { };
#pragma empty_line
template<typename _Tp>
struct tuple_size<volatile _Tp>
: integral_constant<size_t, tuple_size<_Tp>::value> { };
#pragma empty_line
template<typename _Tp>
struct tuple_size<const volatile _Tp>
: integral_constant<size_t, tuple_size<_Tp>::value> { };
#pragma empty_line
#pragma empty_line
template<std::size_t __i, typename _Tp>
struct tuple_element;
#pragma empty_line
#pragma empty_line
template<std::size_t __i, typename _Tp>
using __tuple_element_t = typename tuple_element<__i, _Tp>::type;
#pragma empty_line
template<std::size_t __i, typename _Tp>
struct tuple_element<__i, const _Tp>
{
typedef typename add_const<__tuple_element_t<__i, _Tp>>::type type;
};
#pragma empty_line
template<std::size_t __i, typename _Tp>
struct tuple_element<__i, volatile _Tp>
{
typedef typename add_volatile<__tuple_element_t<__i, _Tp>>::type type;
};
#pragma empty_line
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;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<std::size_t __i, typename _Tp>
using tuple_element_t = typename tuple_element<__i, _Tp>::type;
#pragma empty_line
#pragma empty_line
template<typename>
struct __is_tuple_like_impl : false_type
{ };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _T1, typename _T2>
struct __is_tuple_like_impl<std::pair<_T1, _T2>> : true_type
{ };
#pragma empty_line
#pragma empty_line
template<class _Tp1, class _Tp2>
struct tuple_size<std::pair<_Tp1, _Tp2>>
: public integral_constant<std::size_t, 2> { };
#pragma empty_line
#pragma empty_line
template<class _Tp1, class _Tp2>
struct tuple_element<0, std::pair<_Tp1, _Tp2>>
{ typedef _Tp1 type; };
#pragma empty_line
#pragma empty_line
template<class _Tp1, class _Tp2>
struct tuple_element<1, std::pair<_Tp1, _Tp2>>
{ typedef _Tp2 type; };
#pragma empty_line
template<std::size_t _Int>
struct __pair_get;
#pragma empty_line
template<>
struct __pair_get<0>
{
template<typename _Tp1, typename _Tp2>
static constexpr _Tp1&
__get(std::pair<_Tp1, _Tp2>& __pair) noexcept
{ return __pair.first; }
#pragma empty_line
template<typename _Tp1, typename _Tp2>
static constexpr _Tp1&&
__move_get(std::pair<_Tp1, _Tp2>&& __pair) noexcept
{ return std::forward<_Tp1>(__pair.first); }
#pragma empty_line
template<typename _Tp1, typename _Tp2>
static constexpr const _Tp1&
__const_get(const std::pair<_Tp1, _Tp2>& __pair) noexcept
{ return __pair.first; }
};
#pragma empty_line
template<>
struct __pair_get<1>
{
template<typename _Tp1, typename _Tp2>
static constexpr _Tp2&
__get(std::pair<_Tp1, _Tp2>& __pair) noexcept
{ return __pair.second; }
#pragma empty_line
template<typename _Tp1, typename _Tp2>
static constexpr _Tp2&&
__move_get(std::pair<_Tp1, _Tp2>&& __pair) noexcept
{ return std::forward<_Tp2>(__pair.second); }
#pragma empty_line
template<typename _Tp1, typename _Tp2>
static constexpr const _Tp2&
__const_get(const std::pair<_Tp1, _Tp2>& __pair) noexcept
{ return __pair.second; }
};
#pragma empty_line
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); }
#pragma empty_line
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)); }
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template <typename _Tp, typename _Up>
constexpr _Tp&
get(pair<_Tp, _Up>& __p) noexcept
{ return __p.first; }
#pragma empty_line
template <typename _Tp, typename _Up>
constexpr const _Tp&
get(const pair<_Tp, _Up>& __p) noexcept
{ return __p.first; }
#pragma empty_line
template <typename _Tp, typename _Up>
constexpr _Tp&&
get(pair<_Tp, _Up>&& __p) noexcept
{ return std::move(__p.first); }
#pragma empty_line
template <typename _Tp, typename _Up>
constexpr _Tp&
get(pair<_Up, _Tp>& __p) noexcept
{ return __p.second; }
#pragma empty_line
template <typename _Tp, typename _Up>
constexpr const _Tp&
get(const pair<_Up, _Tp>& __p) noexcept
{ return __p.second; }
#pragma empty_line
template <typename _Tp, typename _Up>
constexpr _Tp&&
get(pair<_Up, _Tp>&& __p) noexcept
{ return std::move(__p.second); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template <typename _Tp, typename _Up = _Tp>
inline _Tp
exchange(_Tp& __obj, _Up&& __new_val)
{ return std::__exchange(__obj, std::forward<_Up>(__new_val)); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<size_t... _Indexes> struct _Index_tuple { };
#pragma empty_line
#pragma empty_line
template<typename _Itup1, typename _Itup2> struct _Itup_cat;
#pragma empty_line
template<size_t... _Ind1, size_t... _Ind2>
struct _Itup_cat<_Index_tuple<_Ind1...>, _Index_tuple<_Ind2...>>
{
using __type = _Index_tuple<_Ind1..., (_Ind2 + sizeof...(_Ind1))...>;
};
#pragma empty_line
#pragma empty_line
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>
{ };
#pragma empty_line
template<>
struct _Build_index_tuple<1>
{
typedef _Index_tuple<0> __type;
};
#pragma empty_line
template<>
struct _Build_index_tuple<0>
{
typedef _Index_tuple<> __type;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp, _Tp... _Idx>
struct integer_sequence
{
typedef _Tp value_type;
static constexpr size_t size() { return sizeof...(_Idx); }
};
#pragma empty_line
template<typename _Tp, _Tp _Num,
typename _ISeq = typename _Build_index_tuple<_Num>::__type>
struct _Make_integer_sequence;
#pragma empty_line
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" );
#pragma empty_line
typedef integer_sequence<_Tp, static_cast<_Tp>(_Idx)...> __type;
};
#pragma empty_line
#pragma empty_line
template<typename _Tp, _Tp _Num>
using make_integer_sequence
= typename _Make_integer_sequence<_Tp, _Num>::__type;
#pragma empty_line
#pragma empty_line
template<size_t... _Idx>
using index_sequence = integer_sequence<size_t, _Idx...>;
#pragma empty_line
#pragma empty_line
template<size_t _Num>
using make_index_sequence = make_integer_sequence<size_t, _Num>;
#pragma empty_line
#pragma empty_line
template<typename... _Types>
using index_sequence_for = make_index_sequence<sizeof...(_Types)>;
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 130 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h" 2
#pragma line 210 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h"
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/algorithm" 1 3
#pragma line 58 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/algorithm" 3
#pragma empty_line
#pragma line 59 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/algorithm" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 1 3
#pragma line 59 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 1 3
#pragma line 39 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 3
#pragma empty_line
#pragma line 40 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 3
#pragma line 60 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 2 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/algorithmfwd.h" 1 3
#pragma line 33 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/algorithmfwd.h" 3
#pragma empty_line
#pragma line 34 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/algorithmfwd.h" 3
#pragma line 42 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/algorithmfwd.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma line 194 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
#pragma empty_line
template<typename _IIter, typename _Predicate>
bool
any_of(_IIter, _IIter, _Predicate);
#pragma empty_line
#pragma empty_line
template<typename _FIter, typename _Tp>
bool
binary_search(_FIter, _FIter, const _Tp&);
#pragma empty_line
template<typename _FIter, typename _Tp, typename _Compare>
bool
binary_search(_FIter, _FIter, const _Tp&, _Compare);
#pragma empty_line
template<typename _IIter, typename _OIter>
_OIter
copy(_IIter, _IIter, _OIter);
#pragma empty_line
template<typename _BIter1, typename _BIter2>
_BIter2
copy_backward(_BIter1, _BIter1, _BIter2);
#pragma empty_line
#pragma empty_line
template<typename _IIter, typename _OIter, typename _Predicate>
_OIter
copy_if(_IIter, _IIter, _OIter, _Predicate);
#pragma empty_line
template<typename _IIter, typename _Size, typename _OIter>
_OIter
copy_n(_IIter, _Size, _OIter);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _FIter, typename _Tp>
pair<_FIter, _FIter>
equal_range(_FIter, _FIter, const _Tp&);
#pragma empty_line
template<typename _FIter, typename _Tp, typename _Compare>
pair<_FIter, _FIter>
equal_range(_FIter, _FIter, const _Tp&, _Compare);
#pragma empty_line
template<typename _FIter, typename _Tp>
void
fill(_FIter, _FIter, const _Tp&);
#pragma empty_line
template<typename _OIter, typename _Size, typename _Tp>
_OIter
fill_n(_OIter, _Size, const _Tp&);
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _FIter1, typename _FIter2>
_FIter1
find_end(_FIter1, _FIter1, _FIter2, _FIter2);
#pragma empty_line
template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
_FIter1
find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _IIter, typename _Predicate>
_IIter
find_if_not(_IIter, _IIter, _Predicate);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _IIter1, typename _IIter2>
bool
includes(_IIter1, _IIter1, _IIter2, _IIter2);
#pragma empty_line
template<typename _IIter1, typename _IIter2, typename _Compare>
bool
includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
#pragma empty_line
template<typename _BIter>
void
inplace_merge(_BIter, _BIter, _BIter);
#pragma empty_line
template<typename _BIter, typename _Compare>
void
inplace_merge(_BIter, _BIter, _BIter, _Compare);
#pragma empty_line
#pragma empty_line
template<typename _RAIter>
bool
is_heap(_RAIter, _RAIter);
#pragma empty_line
template<typename _RAIter, typename _Compare>
bool
is_heap(_RAIter, _RAIter, _Compare);
#pragma empty_line
template<typename _RAIter>
_RAIter
is_heap_until(_RAIter, _RAIter);
#pragma empty_line
template<typename _RAIter, typename _Compare>
_RAIter
is_heap_until(_RAIter, _RAIter, _Compare);
#pragma empty_line
template<typename _IIter, typename _Predicate>
bool
is_partitioned(_IIter, _IIter, _Predicate);
#pragma empty_line
template<typename _FIter1, typename _FIter2>
bool
is_permutation(_FIter1, _FIter1, _FIter2);
#pragma empty_line
template<typename _FIter1, typename _FIter2,
typename _BinaryPredicate>
bool
is_permutation(_FIter1, _FIter1, _FIter2, _BinaryPredicate);
#pragma empty_line
template<typename _FIter>
bool
is_sorted(_FIter, _FIter);
#pragma empty_line
template<typename _FIter, typename _Compare>
bool
is_sorted(_FIter, _FIter, _Compare);
#pragma empty_line
template<typename _FIter>
_FIter
is_sorted_until(_FIter, _FIter);
#pragma empty_line
template<typename _FIter, typename _Compare>
_FIter
is_sorted_until(_FIter, _FIter, _Compare);
#pragma empty_line
#pragma empty_line
template<typename _FIter1, typename _FIter2>
void
iter_swap(_FIter1, _FIter2);
#pragma empty_line
template<typename _FIter, typename _Tp>
_FIter
lower_bound(_FIter, _FIter, const _Tp&);
#pragma empty_line
template<typename _FIter, typename _Tp, typename _Compare>
_FIter
lower_bound(_FIter, _FIter, const _Tp&, _Compare);
#pragma empty_line
template<typename _RAIter>
void
make_heap(_RAIter, _RAIter);
#pragma empty_line
template<typename _RAIter, typename _Compare>
void
make_heap(_RAIter, _RAIter, _Compare);
#pragma empty_line
template<typename _Tp>
constexpr
const _Tp&
max(const _Tp&, const _Tp&);
#pragma empty_line
template<typename _Tp, typename _Compare>
constexpr
const _Tp&
max(const _Tp&, const _Tp&, _Compare);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
constexpr
const _Tp&
min(const _Tp&, const _Tp&);
#pragma empty_line
template<typename _Tp, typename _Compare>
constexpr
const _Tp&
min(const _Tp&, const _Tp&, _Compare);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
constexpr
pair<const _Tp&, const _Tp&>
minmax(const _Tp&, const _Tp&);
#pragma empty_line
template<typename _Tp, typename _Compare>
constexpr
pair<const _Tp&, const _Tp&>
minmax(const _Tp&, const _Tp&, _Compare);
#pragma empty_line
template<typename _FIter>
constexpr
pair<_FIter, _FIter>
minmax_element(_FIter, _FIter);
#pragma empty_line
template<typename _FIter, typename _Compare>
constexpr
pair<_FIter, _FIter>
minmax_element(_FIter, _FIter, _Compare);
#pragma empty_line
template<typename _Tp>
constexpr
_Tp
min(initializer_list<_Tp>);
#pragma empty_line
template<typename _Tp, typename _Compare>
constexpr
_Tp
min(initializer_list<_Tp>, _Compare);
#pragma empty_line
template<typename _Tp>
constexpr
_Tp
max(initializer_list<_Tp>);
#pragma empty_line
template<typename _Tp, typename _Compare>
constexpr
_Tp
max(initializer_list<_Tp>, _Compare);
#pragma empty_line
template<typename _Tp>
constexpr
pair<_Tp, _Tp>
minmax(initializer_list<_Tp>);
#pragma empty_line
template<typename _Tp, typename _Compare>
constexpr
pair<_Tp, _Tp>
minmax(initializer_list<_Tp>, _Compare);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _BIter>
bool
next_permutation(_BIter, _BIter);
#pragma empty_line
template<typename _BIter, typename _Compare>
bool
next_permutation(_BIter, _BIter, _Compare);
#pragma empty_line
#pragma empty_line
template<typename _IIter, typename _Predicate>
bool
none_of(_IIter, _IIter, _Predicate);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _IIter, typename _RAIter>
_RAIter
partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter);
#pragma empty_line
template<typename _IIter, typename _RAIter, typename _Compare>
_RAIter
partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _IIter, typename _OIter1,
typename _OIter2, typename _Predicate>
pair<_OIter1, _OIter2>
partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate);
#pragma empty_line
template<typename _FIter, typename _Predicate>
_FIter
partition_point(_FIter, _FIter, _Predicate);
#pragma empty_line
#pragma empty_line
template<typename _RAIter>
void
pop_heap(_RAIter, _RAIter);
#pragma empty_line
template<typename _RAIter, typename _Compare>
void
pop_heap(_RAIter, _RAIter, _Compare);
#pragma empty_line
template<typename _BIter>
bool
prev_permutation(_BIter, _BIter);
#pragma empty_line
template<typename _BIter, typename _Compare>
bool
prev_permutation(_BIter, _BIter, _Compare);
#pragma empty_line
template<typename _RAIter>
void
push_heap(_RAIter, _RAIter);
#pragma empty_line
template<typename _RAIter, typename _Compare>
void
push_heap(_RAIter, _RAIter, _Compare);
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _FIter, typename _Tp>
_FIter
remove(_FIter, _FIter, const _Tp&);
#pragma empty_line
template<typename _FIter, typename _Predicate>
_FIter
remove_if(_FIter, _FIter, _Predicate);
#pragma empty_line
template<typename _IIter, typename _OIter, typename _Tp>
_OIter
remove_copy(_IIter, _IIter, _OIter, const _Tp&);
#pragma empty_line
template<typename _IIter, typename _OIter, typename _Predicate>
_OIter
remove_copy_if(_IIter, _IIter, _OIter, _Predicate);
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _IIter, typename _OIter, typename _Tp>
_OIter
replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&);
#pragma empty_line
template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp>
_OIter
replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&);
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _BIter>
void
reverse(_BIter, _BIter);
#pragma empty_line
template<typename _BIter, typename _OIter>
_OIter
reverse_copy(_BIter, _BIter, _OIter);
#pragma empty_line
inline namespace _V2
{
template<typename _FIter>
_FIter
rotate(_FIter, _FIter, _FIter);
}
#pragma empty_line
template<typename _FIter, typename _OIter>
_OIter
rotate_copy(_FIter, _FIter, _FIter, _OIter);
#pragma line 552 "/home/justin/jhai/Xilinx/Vivado/2018.3/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&&);
#pragma empty_line
#pragma empty_line
template<typename _RAIter>
void
sort_heap(_RAIter, _RAIter);
#pragma empty_line
template<typename _RAIter, typename _Compare>
void
sort_heap(_RAIter, _RAIter, _Compare);
#pragma empty_line
template<typename _BIter, typename _Predicate>
_BIter
stable_partition(_BIter, _BIter, _Predicate);
#pragma line 581 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _FIter>
_FIter
unique(_FIter, _FIter);
#pragma empty_line
template<typename _FIter, typename _BinaryPredicate>
_FIter
unique(_FIter, _FIter, _BinaryPredicate);
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _FIter, typename _Tp>
_FIter
upper_bound(_FIter, _FIter, const _Tp&);
#pragma empty_line
template<typename _FIter, typename _Tp, typename _Compare>
_FIter
upper_bound(_FIter, _FIter, const _Tp&, _Compare);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _FIter>
_FIter
adjacent_find(_FIter, _FIter);
#pragma empty_line
template<typename _FIter, typename _BinaryPredicate>
_FIter
adjacent_find(_FIter, _FIter, _BinaryPredicate);
#pragma empty_line
template<typename _IIter, typename _Tp>
typename iterator_traits<_IIter>::difference_type
count(_IIter, _IIter, const _Tp&);
#pragma empty_line
template<typename _IIter, typename _Predicate>
typename iterator_traits<_IIter>::difference_type
count_if(_IIter, _IIter, _Predicate);
#pragma empty_line
template<typename _IIter1, typename _IIter2>
bool
equal(_IIter1, _IIter1, _IIter2);
#pragma empty_line
template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
bool
equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
#pragma empty_line
template<typename _IIter, typename _Tp>
_IIter
find(_IIter, _IIter, const _Tp&);
#pragma empty_line
template<typename _FIter1, typename _FIter2>
_FIter1
find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);
#pragma empty_line
template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
_FIter1
find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
#pragma empty_line
template<typename _IIter, typename _Predicate>
_IIter
find_if(_IIter, _IIter, _Predicate);
#pragma empty_line
template<typename _IIter, typename _Funct>
_Funct
for_each(_IIter, _IIter, _Funct);
#pragma empty_line
template<typename _FIter, typename _Generator>
void
generate(_FIter, _FIter, _Generator);
#pragma empty_line
template<typename _OIter, typename _Size, typename _Generator>
_OIter
generate_n(_OIter, _Size, _Generator);
#pragma empty_line
template<typename _IIter1, typename _IIter2>
bool
lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);
#pragma empty_line
template<typename _IIter1, typename _IIter2, typename _Compare>
bool
lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
#pragma empty_line
template<typename _FIter>
constexpr
_FIter
max_element(_FIter, _FIter);
#pragma empty_line
template<typename _FIter, typename _Compare>
constexpr
_FIter
max_element(_FIter, _FIter, _Compare);
#pragma empty_line
template<typename _IIter1, typename _IIter2, typename _OIter>
_OIter
merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
#pragma empty_line
template<typename _IIter1, typename _IIter2, typename _OIter,
typename _Compare>
_OIter
merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
#pragma empty_line
template<typename _FIter>
constexpr
_FIter
min_element(_FIter, _FIter);
#pragma empty_line
template<typename _FIter, typename _Compare>
constexpr
_FIter
min_element(_FIter, _FIter, _Compare);
#pragma empty_line
template<typename _IIter1, typename _IIter2>
pair<_IIter1, _IIter2>
mismatch(_IIter1, _IIter1, _IIter2);
#pragma empty_line
template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
pair<_IIter1, _IIter2>
mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
#pragma empty_line
template<typename _RAIter>
void
nth_element(_RAIter, _RAIter, _RAIter);
#pragma empty_line
template<typename _RAIter, typename _Compare>
void
nth_element(_RAIter, _RAIter, _RAIter, _Compare);
#pragma empty_line
template<typename _RAIter>
void
partial_sort(_RAIter, _RAIter, _RAIter);
#pragma empty_line
template<typename _RAIter, typename _Compare>
void
partial_sort(_RAIter, _RAIter, _RAIter, _Compare);
#pragma empty_line
template<typename _BIter, typename _Predicate>
_BIter
partition(_BIter, _BIter, _Predicate);
#pragma empty_line
template<typename _RAIter>
void
random_shuffle(_RAIter, _RAIter);
#pragma empty_line
template<typename _RAIter, typename _Generator>
void
random_shuffle(_RAIter, _RAIter,
#pragma empty_line
_Generator&&);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _FIter, typename _Tp>
void
replace(_FIter, _FIter, const _Tp&, const _Tp&);
#pragma empty_line
template<typename _FIter, typename _Predicate, typename _Tp>
void
replace_if(_FIter, _FIter, _Predicate, const _Tp&);
#pragma empty_line
template<typename _FIter1, typename _FIter2>
_FIter1
search(_FIter1, _FIter1, _FIter2, _FIter2);
#pragma empty_line
template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
_FIter1
search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
#pragma empty_line
template<typename _FIter, typename _Size, typename _Tp>
_FIter
search_n(_FIter, _FIter, _Size, const _Tp&);
#pragma empty_line
template<typename _FIter, typename _Size, typename _Tp,
typename _BinaryPredicate>
_FIter
search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);
#pragma empty_line
template<typename _IIter1, typename _IIter2, typename _OIter>
_OIter
set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
#pragma empty_line
template<typename _IIter1, typename _IIter2, typename _OIter,
typename _Compare>
_OIter
set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
#pragma empty_line
template<typename _IIter1, typename _IIter2, typename _OIter>
_OIter
set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
#pragma empty_line
template<typename _IIter1, typename _IIter2, typename _OIter,
typename _Compare>
_OIter
set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
#pragma empty_line
template<typename _IIter1, typename _IIter2, typename _OIter>
_OIter
set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
#pragma empty_line
template<typename _IIter1, typename _IIter2, typename _OIter,
typename _Compare>
_OIter
set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2,
_OIter, _Compare);
#pragma empty_line
template<typename _IIter1, typename _IIter2, typename _OIter>
_OIter
set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
#pragma empty_line
template<typename _IIter1, typename _IIter2, typename _OIter,
typename _Compare>
_OIter
set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
#pragma empty_line
template<typename _RAIter>
void
sort(_RAIter, _RAIter);
#pragma empty_line
template<typename _RAIter, typename _Compare>
void
sort(_RAIter, _RAIter, _Compare);
#pragma empty_line
template<typename _RAIter>
void
stable_sort(_RAIter, _RAIter);
#pragma empty_line
template<typename _RAIter, typename _Compare>
void
stable_sort(_RAIter, _RAIter, _Compare);
#pragma empty_line
template<typename _IIter, typename _OIter, typename _UnaryOperation>
_OIter
transform(_IIter, _IIter, _OIter, _UnaryOperation);
#pragma empty_line
template<typename _IIter1, typename _IIter2, typename _OIter,
typename _BinaryOperation>
_OIter
transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);
#pragma empty_line
template<typename _IIter, typename _OIter>
_OIter
unique_copy(_IIter, _IIter, _OIter);
#pragma empty_line
template<typename _IIter, typename _OIter, typename _BinaryPredicate>
_OIter
unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);
#pragma empty_line
#pragma empty_line
}
#pragma line 61 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 2 3
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_tempbuf.h" 1 3
#pragma line 62 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_tempbuf.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma line 83 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
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);
}
#pragma line 110 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _ForwardIterator, typename _Tp>
class _Temporary_buffer
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
public:
typedef _Tp value_type;
typedef value_type* pointer;
typedef pointer iterator;
typedef ptrdiff_t size_type;
#pragma empty_line
protected:
size_type _M_original_len;
size_type _M_len;
pointer _M_buffer;
#pragma empty_line
public:
#pragma empty_line
size_type
size() const
{ return _M_len; }
#pragma empty_line
#pragma empty_line
size_type
requested_size() const
{ return _M_original_len; }
#pragma empty_line
#pragma empty_line
iterator
begin()
{ return _M_buffer; }
#pragma empty_line
#pragma empty_line
iterator
end()
{ return _M_buffer + _M_len; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
_Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last);
#pragma empty_line
~_Temporary_buffer()
{
std::_Destroy(_M_buffer, _M_buffer + _M_len);
std::return_temporary_buffer(_M_buffer);
}
#pragma empty_line
private:
#pragma empty_line
_Temporary_buffer(const _Temporary_buffer&);
#pragma empty_line
void
operator=(const _Temporary_buffer&);
};
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
_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;
}
}
};
#pragma empty_line
template<>
struct __uninitialized_construct_buf_dispatch<true>
{
template<typename _Pointer, typename _ForwardIterator>
static void
__ucr(_Pointer, _Pointer, _ForwardIterator) { }
};
#pragma line 229 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
std::__uninitialized_construct_buf_dispatch<
__has_trivial_constructor(_ValueType)>::
__ucr(__first, __last, __seed);
}
#pragma empty_line
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;
}
}
#pragma empty_line
#pragma empty_line
}
#pragma line 63 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 2 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/uniform_int_dist.h" 1 3
#pragma line 35 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/uniform_int_dist.h" 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/limits" 1 3
#pragma line 40 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/limits" 3
#pragma empty_line
#pragma line 41 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/limits" 3
#pragma line 158 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/limits" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
enum float_round_style
{
round_indeterminate = -1,
round_toward_zero = 0,
round_to_nearest = 1,
round_toward_infinity = 2,
round_toward_neg_infinity = 3
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
enum float_denorm_style
{
#pragma empty_line
denorm_indeterminate = -1,
#pragma empty_line
denorm_absent = 0,
#pragma empty_line
denorm_present = 1
};
#pragma line 202 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/limits" 3
struct __numeric_limits_base
{
#pragma empty_line
#pragma empty_line
static constexpr bool is_specialized = false;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static constexpr int digits = 0;
#pragma empty_line
#pragma empty_line
static constexpr int digits10 = 0;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static constexpr int max_digits10 = 0;
#pragma empty_line
#pragma empty_line
#pragma empty_line
static constexpr bool is_signed = false;
#pragma empty_line
#pragma empty_line
static constexpr bool is_integer = false;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static constexpr bool is_exact = false;
#pragma empty_line
#pragma empty_line
#pragma empty_line
static constexpr int radix = 0;
#pragma empty_line
#pragma empty_line
#pragma empty_line
static constexpr int min_exponent = 0;
#pragma empty_line
#pragma empty_line
#pragma empty_line
static constexpr int min_exponent10 = 0;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static constexpr int max_exponent = 0;
#pragma empty_line
#pragma empty_line
#pragma empty_line
static constexpr int max_exponent10 = 0;
#pragma empty_line
#pragma empty_line
static constexpr bool has_infinity = false;
#pragma empty_line
#pragma empty_line
#pragma empty_line
static constexpr bool has_quiet_NaN = false;
#pragma empty_line
#pragma empty_line
#pragma empty_line
static constexpr bool has_signaling_NaN = false;
#pragma empty_line
#pragma empty_line
static constexpr float_denorm_style has_denorm = denorm_absent;
#pragma empty_line
#pragma empty_line
#pragma empty_line
static constexpr bool has_denorm_loss = false;
#pragma empty_line
#pragma empty_line
#pragma empty_line
static constexpr bool is_iec559 = false;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static constexpr bool is_bounded = false;
#pragma line 288 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/limits" 3
static constexpr bool is_modulo = false;
#pragma empty_line
#pragma empty_line
static constexpr bool traps = false;
#pragma empty_line
#pragma empty_line
static constexpr bool tinyness_before = false;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static constexpr float_round_style round_style =
round_toward_zero;
};
#pragma line 314 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/limits" 3
template<typename _Tp>
struct numeric_limits : public __numeric_limits_base
{
#pragma empty_line
#pragma empty_line
static constexpr _Tp
min() noexcept { return _Tp(); }
#pragma empty_line
#pragma empty_line
static constexpr _Tp
max() noexcept { return _Tp(); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static constexpr _Tp
lowest() noexcept { return _Tp(); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static constexpr _Tp
epsilon() noexcept { return _Tp(); }
#pragma empty_line
#pragma empty_line
static constexpr _Tp
round_error() noexcept { return _Tp(); }
#pragma empty_line
#pragma empty_line
static constexpr _Tp
infinity() noexcept { return _Tp(); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
static constexpr _Tp
quiet_NaN() noexcept { return _Tp(); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
static constexpr _Tp
signaling_NaN() noexcept { return _Tp(); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static constexpr _Tp
denorm_min() noexcept { return _Tp(); }
};
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct numeric_limits<const _Tp>
: public numeric_limits<_Tp> { };
#pragma empty_line
template<typename _Tp>
struct numeric_limits<volatile _Tp>
: public numeric_limits<_Tp> { };
#pragma empty_line
template<typename _Tp>
struct numeric_limits<const volatile _Tp>
: public numeric_limits<_Tp> { };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<>
struct numeric_limits<bool>
{
static constexpr bool is_specialized = true;
#pragma empty_line
static constexpr bool
min() noexcept { return false; }
#pragma empty_line
static constexpr bool
max() noexcept { return true; }
#pragma empty_line
#pragma empty_line
static constexpr bool
lowest() noexcept { return min(); }
#pragma empty_line
static constexpr int digits = 1;
static constexpr int digits10 = 0;
#pragma empty_line
static constexpr int max_digits10 = 0;
#pragma empty_line
static constexpr bool is_signed = false;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
#pragma empty_line
static constexpr bool
epsilon() noexcept { return false; }
#pragma empty_line
static constexpr bool
round_error() noexcept { return false; }
#pragma empty_line
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
#pragma empty_line
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;
#pragma empty_line
static constexpr bool
infinity() noexcept { return false; }
#pragma empty_line
static constexpr bool
quiet_NaN() noexcept { return false; }
#pragma empty_line
static constexpr bool
signaling_NaN() noexcept { return false; }
#pragma empty_line
static constexpr bool
denorm_min() noexcept { return false; }
#pragma empty_line
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
#pragma empty_line
#pragma empty_line
template<>
struct numeric_limits<char>
{
static constexpr bool is_specialized = true;
#pragma empty_line
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); }
#pragma empty_line
static constexpr char
max() noexcept { return (((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0); }
#pragma empty_line
#pragma empty_line
static constexpr char
lowest() noexcept { return min(); }
#pragma empty_line
#pragma empty_line
static constexpr int digits = (sizeof(char) * 8 - ((char)(-1) < 0));
static constexpr int digits10 = ((sizeof(char) * 8 - ((char)(-1) < 0)) * 643L / 2136);
#pragma empty_line
static constexpr int max_digits10 = 0;
#pragma empty_line
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;
#pragma empty_line
static constexpr char
epsilon() noexcept { return 0; }
#pragma empty_line
static constexpr char
round_error() noexcept { return 0; }
#pragma empty_line
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
#pragma empty_line
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;
#pragma empty_line
static constexpr
char infinity() noexcept { return char(); }
#pragma empty_line
static constexpr char
quiet_NaN() noexcept { return char(); }
#pragma empty_line
static constexpr char
signaling_NaN() noexcept { return char(); }
#pragma empty_line
static constexpr char
denorm_min() noexcept { return static_cast<char>(0); }
#pragma empty_line
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = !is_signed;
#pragma empty_line
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
#pragma empty_line
#pragma empty_line
template<>
struct numeric_limits<signed char>
{
static constexpr bool is_specialized = true;
#pragma empty_line
static constexpr signed char
min() noexcept { return -0x7f - 1; }
#pragma empty_line
static constexpr signed char
max() noexcept { return 0x7f; }
#pragma empty_line
#pragma empty_line
static constexpr signed char
lowest() noexcept { return min(); }
#pragma empty_line
#pragma empty_line
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);
#pragma empty_line
static constexpr int max_digits10 = 0;
#pragma empty_line
static constexpr bool is_signed = true;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
#pragma empty_line
static constexpr signed char
epsilon() noexcept { return 0; }
#pragma empty_line
static constexpr signed char
round_error() noexcept { return 0; }
#pragma empty_line
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
#pragma empty_line
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;
#pragma empty_line
static constexpr signed char
infinity() noexcept { return static_cast<signed char>(0); }
#pragma empty_line
static constexpr signed char
quiet_NaN() noexcept { return static_cast<signed char>(0); }
#pragma empty_line
static constexpr signed char
signaling_NaN() noexcept
{ return static_cast<signed char>(0); }
#pragma empty_line
static constexpr signed char
denorm_min() noexcept
{ return static_cast<signed char>(0); }
#pragma empty_line
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
#pragma empty_line
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
#pragma empty_line
#pragma empty_line
template<>
struct numeric_limits<unsigned char>
{
static constexpr bool is_specialized = true;
#pragma empty_line
static constexpr unsigned char
min() noexcept { return 0; }
#pragma empty_line
static constexpr unsigned char
max() noexcept { return 0x7f * 2U + 1; }
#pragma empty_line
#pragma empty_line
static constexpr unsigned char
lowest() noexcept { return min(); }
#pragma empty_line
#pragma empty_line
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);
#pragma empty_line
static constexpr int max_digits10 = 0;
#pragma empty_line
static constexpr bool is_signed = false;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
#pragma empty_line
static constexpr unsigned char
epsilon() noexcept { return 0; }
#pragma empty_line
static constexpr unsigned char
round_error() noexcept { return 0; }
#pragma empty_line
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
#pragma empty_line
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;
#pragma empty_line
static constexpr unsigned char
infinity() noexcept
{ return static_cast<unsigned char>(0); }
#pragma empty_line
static constexpr unsigned char
quiet_NaN() noexcept
{ return static_cast<unsigned char>(0); }
#pragma empty_line
static constexpr unsigned char
signaling_NaN() noexcept
{ return static_cast<unsigned char>(0); }
#pragma empty_line
static constexpr unsigned char
denorm_min() noexcept
{ return static_cast<unsigned char>(0); }
#pragma empty_line
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = true;
#pragma empty_line
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
#pragma empty_line
#pragma empty_line
template<>
struct numeric_limits<wchar_t>
{
static constexpr bool is_specialized = true;
#pragma empty_line
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); }
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
static constexpr wchar_t
lowest() noexcept { return min(); }
#pragma empty_line
#pragma empty_line
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);
#pragma empty_line
static constexpr int max_digits10 = 0;
#pragma empty_line
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;
#pragma empty_line
static constexpr wchar_t
epsilon() noexcept { return 0; }
#pragma empty_line
static constexpr wchar_t
round_error() noexcept { return 0; }
#pragma empty_line
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
#pragma empty_line
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;
#pragma empty_line
static constexpr wchar_t
infinity() noexcept { return wchar_t(); }
#pragma empty_line
static constexpr wchar_t
quiet_NaN() noexcept { return wchar_t(); }
#pragma empty_line
static constexpr wchar_t
signaling_NaN() noexcept { return wchar_t(); }
#pragma empty_line
static constexpr wchar_t
denorm_min() noexcept { return wchar_t(); }
#pragma empty_line
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = !is_signed;
#pragma empty_line
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<>
struct numeric_limits<char16_t>
{
static constexpr bool is_specialized = true;
#pragma empty_line
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); }
#pragma empty_line
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); }
#pragma empty_line
static constexpr char16_t
lowest() noexcept { return min(); }
#pragma empty_line
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;
#pragma empty_line
static constexpr char16_t
epsilon() noexcept { return 0; }
#pragma empty_line
static constexpr char16_t
round_error() noexcept { return 0; }
#pragma empty_line
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
#pragma empty_line
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;
#pragma empty_line
static constexpr char16_t
infinity() noexcept { return char16_t(); }
#pragma empty_line
static constexpr char16_t
quiet_NaN() noexcept { return char16_t(); }
#pragma empty_line
static constexpr char16_t
signaling_NaN() noexcept { return char16_t(); }
#pragma empty_line
static constexpr char16_t
denorm_min() noexcept { return char16_t(); }
#pragma empty_line
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = !is_signed;
#pragma empty_line
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style = round_toward_zero;
};
#pragma empty_line
#pragma empty_line
template<>
struct numeric_limits<char32_t>
{
static constexpr bool is_specialized = true;
#pragma empty_line
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); }
#pragma empty_line
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); }
#pragma empty_line
static constexpr char32_t
lowest() noexcept { return min(); }
#pragma empty_line
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;
#pragma empty_line
static constexpr char32_t
epsilon() noexcept { return 0; }
#pragma empty_line
static constexpr char32_t
round_error() noexcept { return 0; }
#pragma empty_line
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
#pragma empty_line
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;
#pragma empty_line
static constexpr char32_t
infinity() noexcept { return char32_t(); }
#pragma empty_line
static constexpr char32_t
quiet_NaN() noexcept { return char32_t(); }
#pragma empty_line
static constexpr char32_t
signaling_NaN() noexcept { return char32_t(); }
#pragma empty_line
static constexpr char32_t
denorm_min() noexcept { return char32_t(); }
#pragma empty_line
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = !is_signed;
#pragma empty_line
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style = round_toward_zero;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<>
struct numeric_limits<short>
{
static constexpr bool is_specialized = true;
#pragma empty_line
static constexpr short
min() noexcept { return -0x7fff - 1; }
#pragma empty_line
static constexpr short
max() noexcept { return 0x7fff; }
#pragma empty_line
#pragma empty_line
static constexpr short
lowest() noexcept { return min(); }
#pragma empty_line
#pragma empty_line
static constexpr int digits = (sizeof(short) * 8 - ((short)(-1) < 0));
static constexpr int digits10 = ((sizeof(short) * 8 - ((short)(-1) < 0)) * 643L / 2136);
#pragma empty_line
static constexpr int max_digits10 = 0;
#pragma empty_line
static constexpr bool is_signed = true;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
#pragma empty_line
static constexpr short
epsilon() noexcept { return 0; }
#pragma empty_line
static constexpr short
round_error() noexcept { return 0; }
#pragma empty_line
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
#pragma empty_line
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;
#pragma empty_line
static constexpr short
infinity() noexcept { return short(); }
#pragma empty_line
static constexpr short
quiet_NaN() noexcept { return short(); }
#pragma empty_line
static constexpr short
signaling_NaN() noexcept { return short(); }
#pragma empty_line
static constexpr short
denorm_min() noexcept { return short(); }
#pragma empty_line
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
#pragma empty_line
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
#pragma empty_line
#pragma empty_line
template<>
struct numeric_limits<unsigned short>
{
static constexpr bool is_specialized = true;
#pragma empty_line
static constexpr unsigned short
min() noexcept { return 0; }
#pragma empty_line
static constexpr unsigned short
max() noexcept { return 0x7fff * 2U + 1; }
#pragma empty_line
#pragma empty_line
static constexpr unsigned short
lowest() noexcept { return min(); }
#pragma empty_line
#pragma empty_line
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);
#pragma empty_line
static constexpr int max_digits10 = 0;
#pragma empty_line
static constexpr bool is_signed = false;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
#pragma empty_line
static constexpr unsigned short
epsilon() noexcept { return 0; }
#pragma empty_line
static constexpr unsigned short
round_error() noexcept { return 0; }
#pragma empty_line
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
#pragma empty_line
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;
#pragma empty_line
static constexpr unsigned short
infinity() noexcept
{ return static_cast<unsigned short>(0); }
#pragma empty_line
static constexpr unsigned short
quiet_NaN() noexcept
{ return static_cast<unsigned short>(0); }
#pragma empty_line
static constexpr unsigned short
signaling_NaN() noexcept
{ return static_cast<unsigned short>(0); }
#pragma empty_line
static constexpr unsigned short
denorm_min() noexcept
{ return static_cast<unsigned short>(0); }
#pragma empty_line
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = true;
#pragma empty_line
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
#pragma empty_line
#pragma empty_line
template<>
struct numeric_limits<int>
{
static constexpr bool is_specialized = true;
#pragma empty_line
static constexpr int
min() noexcept { return -0x7fffffff - 1; }
#pragma empty_line
static constexpr int
max() noexcept { return 0x7fffffff; }
#pragma empty_line
#pragma empty_line
static constexpr int
lowest() noexcept { return min(); }
#pragma empty_line
#pragma empty_line
static constexpr int digits = (sizeof(int) * 8 - ((int)(-1) < 0));
static constexpr int digits10 = ((sizeof(int) * 8 - ((int)(-1) < 0)) * 643L / 2136);
#pragma empty_line
static constexpr int max_digits10 = 0;
#pragma empty_line
static constexpr bool is_signed = true;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
#pragma empty_line
static constexpr int
epsilon() noexcept { return 0; }
#pragma empty_line
static constexpr int
round_error() noexcept { return 0; }
#pragma empty_line
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
#pragma empty_line
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;
#pragma empty_line
static constexpr int
infinity() noexcept { return static_cast<int>(0); }
#pragma empty_line
static constexpr int
quiet_NaN() noexcept { return static_cast<int>(0); }
#pragma empty_line
static constexpr int
signaling_NaN() noexcept { return static_cast<int>(0); }
#pragma empty_line
static constexpr int
denorm_min() noexcept { return static_cast<int>(0); }
#pragma empty_line
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
#pragma empty_line
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
#pragma empty_line
#pragma empty_line
template<>
struct numeric_limits<unsigned int>
{
static constexpr bool is_specialized = true;
#pragma empty_line
static constexpr unsigned int
min() noexcept { return 0; }
#pragma empty_line
static constexpr unsigned int
max() noexcept { return 0x7fffffff * 2U + 1; }
#pragma empty_line
#pragma empty_line
static constexpr unsigned int
lowest() noexcept { return min(); }
#pragma empty_line
#pragma empty_line
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);
#pragma empty_line
static constexpr int max_digits10 = 0;
#pragma empty_line
static constexpr bool is_signed = false;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
#pragma empty_line
static constexpr unsigned int
epsilon() noexcept { return 0; }
#pragma empty_line
static constexpr unsigned int
round_error() noexcept { return 0; }
#pragma empty_line
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
#pragma empty_line
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;
#pragma empty_line
static constexpr unsigned int
infinity() noexcept { return static_cast<unsigned int>(0); }
#pragma empty_line
static constexpr unsigned int
quiet_NaN() noexcept
{ return static_cast<unsigned int>(0); }
#pragma empty_line
static constexpr unsigned int
signaling_NaN() noexcept
{ return static_cast<unsigned int>(0); }
#pragma empty_line
static constexpr unsigned int
denorm_min() noexcept
{ return static_cast<unsigned int>(0); }
#pragma empty_line
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = true;
#pragma empty_line
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
#pragma empty_line
#pragma empty_line
template<>
struct numeric_limits<long>
{
static constexpr bool is_specialized = true;
#pragma empty_line
static constexpr long
min() noexcept { return -0x7fffffffffffffffL - 1; }
#pragma empty_line
static constexpr long
max() noexcept { return 0x7fffffffffffffffL; }
#pragma empty_line
#pragma empty_line
static constexpr long
lowest() noexcept { return min(); }
#pragma empty_line
#pragma empty_line
static constexpr int digits = (sizeof(long) * 8 - ((long)(-1) < 0));
static constexpr int digits10 = ((sizeof(long) * 8 - ((long)(-1) < 0)) * 643L / 2136);
#pragma empty_line
static constexpr int max_digits10 = 0;
#pragma empty_line
static constexpr bool is_signed = true;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
#pragma empty_line
static constexpr long
epsilon() noexcept { return 0; }
#pragma empty_line
static constexpr long
round_error() noexcept { return 0; }
#pragma empty_line
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
#pragma empty_line
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;
#pragma empty_line
static constexpr long
infinity() noexcept { return static_cast<long>(0); }
#pragma empty_line
static constexpr long
quiet_NaN() noexcept { return static_cast<long>(0); }
#pragma empty_line
static constexpr long
signaling_NaN() noexcept { return static_cast<long>(0); }
#pragma empty_line
static constexpr long
denorm_min() noexcept { return static_cast<long>(0); }
#pragma empty_line
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
#pragma empty_line
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
#pragma empty_line
#pragma empty_line
template<>
struct numeric_limits<unsigned long>
{
static constexpr bool is_specialized = true;
#pragma empty_line
static constexpr unsigned long
min() noexcept { return 0; }
#pragma empty_line
static constexpr unsigned long
max() noexcept { return 0x7fffffffffffffffL * 2UL + 1; }
#pragma empty_line
#pragma empty_line
static constexpr unsigned long
lowest() noexcept { return min(); }
#pragma empty_line
#pragma empty_line
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);
#pragma empty_line
static constexpr int max_digits10 = 0;
#pragma empty_line
static constexpr bool is_signed = false;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
#pragma empty_line
static constexpr unsigned long
epsilon() noexcept { return 0; }
#pragma empty_line
static constexpr unsigned long
round_error() noexcept { return 0; }
#pragma empty_line
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
#pragma empty_line
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;
#pragma empty_line
static constexpr unsigned long
infinity() noexcept
{ return static_cast<unsigned long>(0); }
#pragma empty_line
static constexpr unsigned long
quiet_NaN() noexcept
{ return static_cast<unsigned long>(0); }
#pragma empty_line
static constexpr unsigned long
signaling_NaN() noexcept
{ return static_cast<unsigned long>(0); }
#pragma empty_line
static constexpr unsigned long
denorm_min() noexcept
{ return static_cast<unsigned long>(0); }
#pragma empty_line
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = true;
#pragma empty_line
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
#pragma empty_line
#pragma empty_line
template<>
struct numeric_limits<long long>
{
static constexpr bool is_specialized = true;
#pragma empty_line
static constexpr long long
min() noexcept { return -0x7fffffffffffffffLL - 1; }
#pragma empty_line
static constexpr long long
max() noexcept { return 0x7fffffffffffffffLL; }
#pragma empty_line
#pragma empty_line
static constexpr long long
lowest() noexcept { return min(); }
#pragma empty_line
#pragma empty_line
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);
#pragma empty_line
static constexpr int max_digits10 = 0;
#pragma empty_line
static constexpr bool is_signed = true;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
#pragma empty_line
static constexpr long long
epsilon() noexcept { return 0; }
#pragma empty_line
static constexpr long long
round_error() noexcept { return 0; }
#pragma empty_line
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
#pragma empty_line
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;
#pragma empty_line
static constexpr long long
infinity() noexcept { return static_cast<long long>(0); }
#pragma empty_line
static constexpr long long
quiet_NaN() noexcept { return static_cast<long long>(0); }
#pragma empty_line
static constexpr long long
signaling_NaN() noexcept
{ return static_cast<long long>(0); }
#pragma empty_line
static constexpr long long
denorm_min() noexcept { return static_cast<long long>(0); }
#pragma empty_line
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
#pragma empty_line
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
#pragma empty_line
#pragma empty_line
template<>
struct numeric_limits<unsigned long long>
{
static constexpr bool is_specialized = true;
#pragma empty_line
static constexpr unsigned long long
min() noexcept { return 0; }
#pragma empty_line
static constexpr unsigned long long
max() noexcept { return 0x7fffffffffffffffLL * 2ULL + 1; }
#pragma empty_line
#pragma empty_line
static constexpr unsigned long long
lowest() noexcept { return min(); }
#pragma empty_line
#pragma empty_line
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);
#pragma empty_line
static constexpr int max_digits10 = 0;
#pragma empty_line
static constexpr bool is_signed = false;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
#pragma empty_line
static constexpr unsigned long long
epsilon() noexcept { return 0; }
#pragma empty_line
static constexpr unsigned long long
round_error() noexcept { return 0; }
#pragma empty_line
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
#pragma empty_line
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;
#pragma empty_line
static constexpr unsigned long long
infinity() noexcept
{ return static_cast<unsigned long long>(0); }
#pragma empty_line
static constexpr unsigned long long
quiet_NaN() noexcept
{ return static_cast<unsigned long long>(0); }
#pragma empty_line
static constexpr unsigned long long
signaling_NaN() noexcept
{ return static_cast<unsigned long long>(0); }
#pragma empty_line
static constexpr unsigned long long
denorm_min() noexcept
{ return static_cast<unsigned long long>(0); }
#pragma empty_line
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = true;
#pragma empty_line
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
#pragma line 1569 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; };
#pragma line 1592 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/limits" 3
template<>
struct numeric_limits<float>
{
static constexpr bool is_specialized = true;
#pragma empty_line
static constexpr float
min() noexcept { return 1.17549435082228750797e-38F; }
#pragma empty_line
static constexpr float
max() noexcept { return 3.40282346638528859812e+38F; }
#pragma empty_line
#pragma empty_line
static constexpr float
lowest() noexcept { return -3.40282346638528859812e+38F; }
#pragma empty_line
#pragma empty_line
static constexpr int digits = 24;
static constexpr int digits10 = 6;
#pragma empty_line
static constexpr int max_digits10
= (2 + (24) * 643L / 2136);
#pragma empty_line
static constexpr bool is_signed = true;
static constexpr bool is_integer = false;
static constexpr bool is_exact = false;
static constexpr int radix = 2;
#pragma empty_line
static constexpr float
epsilon() noexcept { return 1.19209289550781250000e-7F; }
#pragma empty_line
static constexpr float
round_error() noexcept { return 0.5F; }
#pragma empty_line
static constexpr int min_exponent = (-125);
static constexpr int min_exponent10 = (-37);
static constexpr int max_exponent = 128;
static constexpr int max_exponent10 = 38;
#pragma empty_line
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;
#pragma empty_line
static constexpr float
infinity() noexcept { return __builtin_huge_valf(); }
#pragma empty_line
static constexpr float
quiet_NaN() noexcept { return __builtin_nanf(""); }
#pragma empty_line
static constexpr float
signaling_NaN() noexcept { return __builtin_nansf(""); }
#pragma empty_line
static constexpr float
denorm_min() noexcept { return 1.40129846432481707092e-45F; }
#pragma empty_line
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;
#pragma empty_line
static constexpr bool traps = false;
static constexpr bool tinyness_before
= false;
static constexpr float_round_style round_style
= round_to_nearest;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<>
struct numeric_limits<double>
{
static constexpr bool is_specialized = true;
#pragma empty_line
static constexpr double
min() noexcept { return double(2.22507385850720138309e-308L); }
#pragma empty_line
static constexpr double
max() noexcept { return double(1.79769313486231570815e+308L); }
#pragma empty_line
#pragma empty_line
static constexpr double
lowest() noexcept { return -double(1.79769313486231570815e+308L); }
#pragma empty_line
#pragma empty_line
static constexpr int digits = 53;
static constexpr int digits10 = 15;
#pragma empty_line
static constexpr int max_digits10
= (2 + (53) * 643L / 2136);
#pragma empty_line
static constexpr bool is_signed = true;
static constexpr bool is_integer = false;
static constexpr bool is_exact = false;
static constexpr int radix = 2;
#pragma empty_line
static constexpr double
epsilon() noexcept { return double(2.22044604925031308085e-16L); }
#pragma empty_line
static constexpr double
round_error() noexcept { return 0.5; }
#pragma empty_line
static constexpr int min_exponent = (-1021);
static constexpr int min_exponent10 = (-307);
static constexpr int max_exponent = 1024;
static constexpr int max_exponent10 = 308;
#pragma empty_line
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;
#pragma empty_line
static constexpr double
infinity() noexcept { return __builtin_huge_val(); }
#pragma empty_line
static constexpr double
quiet_NaN() noexcept { return __builtin_nan(""); }
#pragma empty_line
static constexpr double
signaling_NaN() noexcept { return __builtin_nans(""); }
#pragma empty_line
static constexpr double
denorm_min() noexcept { return double(4.94065645841246544177e-324L); }
#pragma empty_line
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;
#pragma empty_line
static constexpr bool traps = false;
static constexpr bool tinyness_before
= false;
static constexpr float_round_style round_style
= round_to_nearest;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<>
struct numeric_limits<long double>
{
static constexpr bool is_specialized = true;
#pragma empty_line
static constexpr long double
min() noexcept { return 3.36210314311209350626e-4932L; }
#pragma empty_line
static constexpr long double
max() noexcept { return 1.18973149535723176502e+4932L; }
#pragma empty_line
#pragma empty_line
static constexpr long double
lowest() noexcept { return -1.18973149535723176502e+4932L; }
#pragma empty_line
#pragma empty_line
static constexpr int digits = 64;
static constexpr int digits10 = 18;
#pragma empty_line
static constexpr int max_digits10
= (2 + (64) * 643L / 2136);
#pragma empty_line
static constexpr bool is_signed = true;
static constexpr bool is_integer = false;
static constexpr bool is_exact = false;
static constexpr int radix = 2;
#pragma empty_line
static constexpr long double
epsilon() noexcept { return 1.08420217248550443401e-19L; }
#pragma empty_line
static constexpr long double
round_error() noexcept { return 0.5L; }
#pragma empty_line
static constexpr int min_exponent = (-16381);
static constexpr int min_exponent10 = (-4931);
static constexpr int max_exponent = 16384;
static constexpr int max_exponent10 = 4932;
#pragma empty_line
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;
#pragma empty_line
static constexpr long double
infinity() noexcept { return __builtin_huge_vall(); }
#pragma empty_line
static constexpr long double
quiet_NaN() noexcept { return __builtin_nanl(""); }
#pragma empty_line
static constexpr long double
signaling_NaN() noexcept { return __builtin_nansl(""); }
#pragma empty_line
static constexpr long double
denorm_min() noexcept { return 3.64519953188247460253e-4951L; }
#pragma empty_line
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;
#pragma empty_line
static constexpr bool traps = false;
static constexpr bool tinyness_before =
false;
static constexpr float_round_style round_style =
round_to_nearest;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 36 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/uniform_int_dist.h" 2 3
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
namespace __detail
{
#pragma empty_line
template<typename _Tp>
inline bool
_Power_of_2(_Tp __x)
{
return ((__x - 1) & __x) == 0;
};
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _IntType = int>
class uniform_int_distribution
{
static_assert(std::is_integral<_IntType>::value,
"template argument not an integral type");
#pragma empty_line
public:
#pragma empty_line
typedef _IntType result_type;
#pragma empty_line
struct param_type
{
typedef uniform_int_distribution<_IntType> distribution_type;
#pragma empty_line
explicit
param_type(_IntType __a = 0,
_IntType __b = std::numeric_limits<_IntType>::max())
: _M_a(__a), _M_b(__b)
{
;
}
#pragma empty_line
result_type
a() const
{ return _M_a; }
#pragma empty_line
result_type
b() const
{ return _M_b; }
#pragma empty_line
friend bool
operator==(const param_type& __p1, const param_type& __p2)
{ return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
#pragma empty_line
private:
_IntType _M_a;
_IntType _M_b;
};
#pragma empty_line
public:
#pragma empty_line
#pragma empty_line
#pragma empty_line
explicit
uniform_int_distribution(_IntType __a = 0,
_IntType __b = std::numeric_limits<_IntType>::max())
: _M_param(__a, __b)
{ }
#pragma empty_line
explicit
uniform_int_distribution(const param_type& __p)
: _M_param(__p)
{ }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
void
reset() { }
#pragma empty_line
result_type
a() const
{ return _M_param.a(); }
#pragma empty_line
result_type
b() const
{ return _M_param.b(); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
param_type
param() const
{ return _M_param; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
void
param(const param_type& __param)
{ _M_param = __param; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
result_type
min() const
{ return this->a(); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
result_type
max() const
{ return this->b(); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
{ return this->operator()(__urng, _M_param); }
#pragma empty_line
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p);
#pragma empty_line
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
{ this->__generate(__f, __t, __urng, _M_param); }
#pragma empty_line
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
{ this->__generate_impl(__f, __t, __urng, __p); }
#pragma empty_line
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
{ this->__generate_impl(__f, __t, __urng, __p); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
friend bool
operator==(const uniform_int_distribution& __d1,
const uniform_int_distribution& __d2)
{ return __d1._M_param == __d2._M_param; }
#pragma empty_line
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
#pragma empty_line
param_type _M_param;
};
#pragma empty_line
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;
#pragma empty_line
const __uctype __urngmin = __urng.min();
const __uctype __urngmax = __urng.max();
const __uctype __urngrange = __urngmax - __urngmin;
const __uctype __urange
= __uctype(__param.b()) - __uctype(__param.a());
#pragma empty_line
__uctype __ret;
#pragma empty_line
if (__urngrange > __urange)
{
#pragma empty_line
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)
{
#pragma line 260 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
return __ret + __param.a();
}
#pragma empty_line
#pragma empty_line
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)
{
#pragma empty_line
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;
#pragma empty_line
const __uctype __urngmin = __urng.min();
const __uctype __urngmax = __urng.max();
const __uctype __urngrange = __urngmax - __urngmin;
const __uctype __urange
= __uctype(__param.b()) - __uctype(__param.a());
#pragma empty_line
__uctype __ret;
#pragma empty_line
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
{
#pragma empty_line
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)
{
#pragma line 344 "/home/justin/jhai/Xilinx/Vivado/2018.3/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();
}
#pragma empty_line
#pragma empty_line
}
#pragma line 67 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 2 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
for (; __trip_count > 0; --__trip_count)
{
if (__pred(__first))
return __first;
++__first;
#pragma empty_line
if (__pred(__first))
return __first;
++__first;
#pragma empty_line
if (__pred(__first))
return __first;
++__first;
#pragma empty_line
if (__pred(__first))
return __first;
++__first;
}
#pragma empty_line
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;
}
}
#pragma empty_line
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));
}
#pragma empty_line
#pragma empty_line
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));
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma line 202 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
if (__first1 == __last1 || __first2 == __last2)
return __first1;
#pragma empty_line
#pragma empty_line
_ForwardIterator2 __p1(__first2);
if (++__p1 == __last2)
return std::__find_if(__first1, __last1,
__gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2));
#pragma empty_line
#pragma empty_line
_ForwardIterator2 __p;
_ForwardIterator1 __current = __first1;
#pragma empty_line
for (;;)
{
__first1 =
std::__find_if(__first1, __last1,
__gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2));
#pragma empty_line
if (__first1 == __last1)
return __last1;
#pragma empty_line
__p = __p1;
__current = __first1;
if (++__current == __last1)
return __last1;
#pragma empty_line
while (__predicate(__current, __p))
{
if (++__p == __last2)
return __first1;
if (++__current == __last1)
return __last1;
}
++__first1;
}
return __first1;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
_DistanceType __tailSize = __last - __first;
_DistanceType __remainder = __count;
#pragma empty_line
while (__remainder <= __tailSize)
{
__first += __remainder;
__tailSize -= __remainder;
#pragma empty_line
#pragma empty_line
_RandomAccessIter __backTrack = __first;
while (__unary_pred(--__backTrack))
{
if (--__remainder == 0)
return (__first - __count);
}
__remainder = __count + 1 - (__first - __backTrack);
}
return __last;
}
#pragma empty_line
template<typename _ForwardIterator, typename _Integer,
typename _UnaryPredicate>
_ForwardIterator
__search_n(_ForwardIterator __first, _ForwardIterator __last,
_Integer __count,
_UnaryPredicate __unary_pred)
{
if (__count <= 0)
return __first;
#pragma empty_line
if (__count == 1)
return std::__find_if(__first, __last, __unary_pred);
#pragma empty_line
return std::__search_n_aux(__first, __last, __count, __unary_pred,
std::__iterator_category(__first));
}
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
_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;
}
}
}
#pragma empty_line
#pragma empty_line
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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1;
typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2;
#pragma empty_line
_RevIterator1 __rlast1(__first1);
_RevIterator2 __rlast2(__first2);
_RevIterator1 __rresult = std::__search(_RevIterator1(__last1), __rlast1,
_RevIterator2(__last2), __rlast2,
__comp);
#pragma empty_line
if (__rresult == __rlast1)
return __last1;
else
{
_BidirectionalIterator1 __result = __rresult.base();
std::advance(__result, -std::distance(__first2, __last2));
return __result;
}
}
#pragma line 423 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
#pragma empty_line
return std::__find_end(__first1, __last1, __first2, __last2,
std::__iterator_category(__first1),
std::__iterator_category(__first2),
__gnu_cxx::__ops::__iter_equal_to_iter());
}
#pragma line 471 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
#pragma empty_line
return std::__find_end(__first1, __last1, __first2, __last2,
std::__iterator_category(__first1),
std::__iterator_category(__first2),
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
#pragma line 506 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 523 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 541 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 556 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
return std::__find_if_not(__first, __last,
__gnu_cxx::__ops::__pred_iter(__pred));
}
#pragma line 580 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
}
#pragma line 598 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
typedef typename iterator_traits<_ForwardIterator>::difference_type
_DistanceType;
#pragma empty_line
_DistanceType __len = std::distance(__first, __last);
_DistanceType __half;
_ForwardIterator __middle;
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
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;
}
#pragma line 665 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
return std::__remove_copy_if(__first, __last, __result,
__gnu_cxx::__ops::__iter_equals_val(__value));
}
#pragma line 697 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
return std::__remove_copy_if(__first, __last, __result,
__gnu_cxx::__ops::__pred_iter(__pred));
}
#pragma line 731 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
for (; __first != __last; ++__first)
if (__pred(*__first))
{
*__result = *__first;
++__result;
}
return __result;
}
#pragma empty_line
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;
}
#pragma empty_line
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); }
#pragma line 794 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
return std::__copy_n(__first, __n, __result,
std::__iterator_category(__first));
}
#pragma line 822 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
for (; __first != __last; ++__first)
if (__pred(*__first))
{
*__out_true = *__first;
++__out_true;
}
else
{
*__out_false = *__first;
++__out_false;
}
#pragma empty_line
return pair<_OutputIterator1, _OutputIterator2>(__out_true, __out_false);
}
#pragma empty_line
#pragma empty_line
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;
}
#pragma line 891 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
return std::__remove_if(__first, __last,
__gnu_cxx::__ops::__iter_equals_val(__value));
}
#pragma line 924 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
return std::__remove_if(__first, __last,
__gnu_cxx::__ops::__pred_iter(__pred));
}
#pragma empty_line
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;
}
#pragma empty_line
template<typename _ForwardIterator, typename _BinaryPredicate>
_ForwardIterator
__unique(_ForwardIterator __first, _ForwardIterator __last,
_BinaryPredicate __binary_pred)
{
#pragma empty_line
__first = std::__adjacent_find(__first, __last, __binary_pred);
if (__first == __last)
return __last;
#pragma empty_line
#pragma empty_line
_ForwardIterator __dest = __first;
++__first;
while (++__first != __last)
if (!__binary_pred(__dest, __first))
*++__dest = std::move(*__first);
return ++__dest;
}
#pragma line 990 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
return std::__unique(__first, __last,
__gnu_cxx::__ops::__iter_equal_to_iter());
}
#pragma line 1020 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
return std::__unique(__first, __last,
__gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
_ForwardIterator __next = __first;
*__result = *__first;
while (++__next != __last)
if (!__binary_pred(__first, __next))
{
__first = __next;
*++__result = *__first;
}
return ++__result;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
*__result = *__first;
while (++__first != __last)
if (!__binary_pred(__result, __first))
*++__result = *__first;
return ++__result;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
}
#pragma line 1175 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
std::__reverse(__first, __last, std::__iterator_category(__first));
}
#pragma line 1202 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
while (__first != __last)
{
--__last;
*__result = *__last;
++__result;
}
return __result;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _EuclideanRingElement>
_EuclideanRingElement
__gcd(_EuclideanRingElement __m, _EuclideanRingElement __n)
{
while (__n != 0)
{
_EuclideanRingElement __t = __m % __n;
__m = __n;
__n = __t;
}
return __m;
}
#pragma empty_line
inline namespace _V2
{
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
_ForwardIterator __first2 = __middle;
do
{
std::iter_swap(__first, __first2);
++__first;
++__first2;
if (__first == __middle)
__middle = __first2;
}
while (__first2 != __last);
#pragma empty_line
_ForwardIterator __ret = __first;
#pragma empty_line
__first2 = __middle;
#pragma empty_line
while (__first2 != __last)
{
std::iter_swap(__first, __first2);
++__first;
++__first2;
if (__first == __middle)
__middle = __first2;
else if (__first2 == __last)
__first2 = __middle;
}
return __ret;
}
#pragma empty_line
#pragma empty_line
template<typename _BidirectionalIterator>
_BidirectionalIterator
__rotate(_BidirectionalIterator __first,
_BidirectionalIterator __middle,
_BidirectionalIterator __last,
bidirectional_iterator_tag)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
if (__first == __middle)
return __last;
else if (__last == __middle)
return __first;
#pragma empty_line
std::__reverse(__first, __middle, bidirectional_iterator_tag());
std::__reverse(__middle, __last, bidirectional_iterator_tag());
#pragma empty_line
while (__first != __middle && __middle != __last)
{
std::iter_swap(__first, --__last);
++__first;
}
#pragma empty_line
if (__first == __middle)
{
std::__reverse(__middle, __last, bidirectional_iterator_tag());
return __last;
}
else
{
std::__reverse(__first, __middle, bidirectional_iterator_tag());
return __first;
}
}
#pragma empty_line
#pragma empty_line
template<typename _RandomAccessIterator>
_RandomAccessIterator
__rotate(_RandomAccessIterator __first,
_RandomAccessIterator __middle,
_RandomAccessIterator __last,
random_access_iterator_tag)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
if (__first == __middle)
return __last;
else if (__last == __middle)
return __first;
#pragma empty_line
typedef typename iterator_traits<_RandomAccessIterator>::difference_type
_Distance;
typedef typename iterator_traits<_RandomAccessIterator>::value_type
_ValueType;
#pragma empty_line
_Distance __n = __last - __first;
_Distance __k = __middle - __first;
#pragma empty_line
if (__k == __n - __k)
{
std::swap_ranges(__first, __middle, __middle);
return __middle;
}
#pragma empty_line
_RandomAccessIterator __p = __first;
_RandomAccessIterator __ret = __first + (__last - __middle);
#pragma empty_line
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);
}
}
}
#pragma line 1429 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
#pragma empty_line
return std::__rotate(__first, __middle, __last,
std::__iterator_category(__first));
}
#pragma empty_line
}
#pragma line 1466 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
#pragma empty_line
return std::copy(__first, __middle,
std::copy(__middle, __last, __result));
}
#pragma empty_line
#pragma empty_line
template<typename _ForwardIterator, typename _Predicate>
_ForwardIterator
__partition(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred, forward_iterator_tag)
{
if (__first == __last)
return __first;
#pragma empty_line
while (__pred(*__first))
if (++__first == __last)
return __first;
#pragma empty_line
_ForwardIterator __next = __first;
#pragma empty_line
while (++__next != __last)
if (__pred(*__next))
{
std::iter_swap(__first, __next);
++__first;
}
#pragma empty_line
return __first;
}
#pragma empty_line
#pragma empty_line
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;
}
}
#pragma line 1543 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
if (__len <= __buffer_size)
{
_ForwardIterator __result1 = __first;
_Pointer __result2 = __buffer;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
*__result2 = std::move(*__first);
++__result2;
++__first;
for (; __first != __last; ++__first)
if (__pred(__first))
{
*__result1 = std::move(*__first);
++__result1;
}
else
{
*__result2 = std::move(*__first);
++__result2;
}
#pragma empty_line
std::move(__buffer, __result2, __result1);
return __result1;
}
#pragma empty_line
_ForwardIterator __middle = __first;
std::advance(__middle, __len / 2);
_ForwardIterator __left_split =
std::__stable_partition_adaptive(__first, __middle, __pred,
__len / 2, __buffer,
__buffer_size);
#pragma empty_line
#pragma empty_line
#pragma empty_line
_Distance __right_len = __len - __len / 2;
_ForwardIterator __right_split =
std::__find_if_not_n(__middle, __right_len, __pred);
#pragma empty_line
if (__right_len)
__right_split =
std::__stable_partition_adaptive(__right_split, __last, __pred,
__right_len,
__buffer, __buffer_size);
#pragma empty_line
std::rotate(__left_split, __middle, __right_split);
std::advance(__left_split, std::distance(__middle, __right_split));
return __left_split;
}
#pragma empty_line
template<typename _ForwardIterator, typename _Predicate>
_ForwardIterator
__stable_partition(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred)
{
__first = std::__find_if_not(__first, __last, __pred);
#pragma empty_line
if (__first == __last)
return __first;
#pragma empty_line
typedef typename iterator_traits<_ForwardIterator>::value_type
_ValueType;
typedef typename iterator_traits<_ForwardIterator>::difference_type
_DistanceType;
#pragma empty_line
_Temporary_buffer<_ForwardIterator, _ValueType> __buf(__first, __last);
return
std::__stable_partition_adaptive(__first, __last, __pred,
_DistanceType(__buf.requested_size()),
__buf.begin(),
_DistanceType(__buf.size()));
}
#pragma line 1646 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
return std::__stable_partition(__first, __last,
__gnu_cxx::__ops::__pred_iter(__pred));
}
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma line 1732 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma line 1746 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
;
#pragma empty_line
return std::__partial_sort_copy(__first, __last,
__result_first, __result_last,
__gnu_cxx::__ops::__iter_less_iter());
}
#pragma line 1781 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma line 1797 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stl_algo.h" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
;
#pragma empty_line
return std::__partial_sort_copy(__first, __last,
__result_first, __result_last,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
template<typename _RandomAccessIterator, typename _Compare>
void
__insertion_sort(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
{
if (__first == __last) return;
#pragma empty_line
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));
}
}
#pragma empty_line
#pragma empty_line
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));
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
enum { _S_threshold = 16 };
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
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;
}
}
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
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;
}
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
}
}
#pragma empty_line
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);
#pragma empty_line
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);
}
#pragma line 2018 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
return std::__lower_bound(__first, __last, __val,
__gnu_cxx::__ops::__iter_comp_val(__comp));
}
#pragma empty_line
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;
#pragma empty_line
_DistanceType __len = std::distance(__first, __last);
#pragma empty_line
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;
}
#pragma line 2072 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
return std::__upper_bound(__first, __last, __val,
__gnu_cxx::__ops::__val_less_iter());
}
#pragma line 2102 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
return std::__upper_bound(__first, __last, __val,
__gnu_cxx::__ops::__val_comp_iter(__comp));
}
#pragma empty_line
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;
#pragma empty_line
_DistanceType __len = std::distance(__first, __last);
#pragma empty_line
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);
}
#pragma line 2173 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
#pragma empty_line
return std::__equal_range(__first, __last, __val,
__gnu_cxx::__ops::__iter_less_val(),
__gnu_cxx::__ops::__val_less_iter());
}
#pragma line 2209 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
;
#pragma empty_line
return std::__equal_range(__first, __last, __val,
__gnu_cxx::__ops::__iter_comp_val(__comp),
__gnu_cxx::__ops::__val_comp_iter(__comp));
}
#pragma line 2242 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
#pragma empty_line
_ForwardIterator __i
= std::__lower_bound(__first, __last, __val,
__gnu_cxx::__ops::__iter_less_val());
return __i != __last && !(__val < *__i);
}
#pragma line 2275 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
;
#pragma empty_line
_ForwardIterator __i
= std::__lower_bound(__first, __last, __val,
__gnu_cxx::__ops::__iter_comp_val(__comp));
return __i != __last && !bool(__comp(__val, *__i));
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
--__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;
}
}
}
#pragma empty_line
#pragma empty_line
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;
}
}
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
_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);
}
}
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
if (__len1 + __len2 == 2)
{
if (__comp(__middle, __first))
std::iter_swap(__first, __middle);
return;
}
#pragma empty_line
_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);
}
#pragma empty_line
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);
}
#pragma empty_line
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;
#pragma empty_line
if (__first == __middle || __middle == __last)
return;
#pragma empty_line
const _DistanceType __len1 = std::distance(__first, __middle);
const _DistanceType __len2 = std::distance(__middle, __last);
#pragma empty_line
typedef _Temporary_buffer<_BidirectionalIterator, _ValueType> _TmpBuf;
_TmpBuf __buf(__first, __last);
#pragma empty_line
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);
}
#pragma line 2569 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
;
#pragma empty_line
std::__inplace_merge(__first, __middle, __last,
__gnu_cxx::__ops::__iter_less_iter());
}
#pragma line 2610 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
;
#pragma empty_line
std::__inplace_merge(__first, __middle, __last,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
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))
#pragma empty_line
;
}
#pragma empty_line
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;
#pragma empty_line
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);
#pragma empty_line
std::__move_merge(__first, __first + __step_size,
__first + __step_size, __last, __result, __comp);
}
#pragma empty_line
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);
}
#pragma empty_line
enum { _S_chunk_size = 7 };
#pragma empty_line
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;
#pragma empty_line
const _Distance __len = __last - __first;
const _Pointer __buffer_last = __buffer + __len;
#pragma empty_line
_Distance __step_size = _S_chunk_size;
std::__chunk_insertion_sort(__first, __last, __step_size, __comp);
#pragma empty_line
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;
}
}
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
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);
}
#pragma line 2782 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma empty_line
return __first2 == __last2;
}
#pragma line 2821 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
;
;
#pragma empty_line
return std::__includes(__first1, __last1, __first2, __last2,
__gnu_cxx::__ops::__iter_less_iter());
}
#pragma line 2865 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
;
;
#pragma empty_line
return std::__includes(__first1, __last1, __first2, __last2,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
#pragma line 2900 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
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;
}
}
}
#pragma line 2949 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
#pragma empty_line
return std::__next_permutation
(__first, __last, __gnu_cxx::__ops::__iter_less_iter());
}
#pragma line 2981 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
#pragma empty_line
return std::__next_permutation
(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));
}
#pragma empty_line
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;
#pragma empty_line
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;
}
}
}
#pragma line 3049 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
#pragma empty_line
return std::__prev_permutation(__first, __last,
__gnu_cxx::__ops::__iter_less_iter());
}
#pragma line 3081 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
#pragma empty_line
return std::__prev_permutation(__first, __last,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma line 3131 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
return std::__replace_copy_if(__first, __last, __result,
__gnu_cxx::__ops::__iter_equals_val(__old_value),
__new_value);
}
#pragma line 3165 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
return std::__replace_copy_if(__first, __last, __result,
__gnu_cxx::__ops::__pred_iter(__pred),
__new_value);
}
#pragma empty_line
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;
}
#pragma line 3204 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma line 3218 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma empty_line
template<typename _ForwardIterator, typename _Compare>
_ForwardIterator
__is_sorted_until(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
{
if (__first == __last)
return __last;
#pragma empty_line
_ForwardIterator __next = __first;
for (++__next; __next != __last; __first = __next, (void)++__next)
if (__comp(__next, __first))
return __next;
return __next;
}
#pragma line 3247 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
#pragma empty_line
return std::__is_sorted_until(__first, __last,
__gnu_cxx::__ops::__iter_less_iter());
}
#pragma line 3271 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
#pragma empty_line
return std::__is_sorted_until(__first, __last,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
#pragma line 3296 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
return __b < __a ? pair<const _Tp&, const _Tp&>(__b, __a)
: pair<const _Tp&, const _Tp&>(__a, __b);
}
#pragma line 3317 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
}
#pragma empty_line
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);
#pragma empty_line
_ForwardIterator __min{}, __max{};
if (__comp(__next, __first))
{
__min = __next;
__max = __first;
}
else
{
__min = __first;
__max = __next;
}
#pragma empty_line
__first = __next;
++__first;
#pragma empty_line
while (__first != __last)
{
__next = __first;
if (++__next == __last)
{
if (__comp(__first, __min))
__min = __first;
else if (!__comp(__first, __max))
__max = __first;
break;
}
#pragma empty_line
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;
}
#pragma empty_line
__first = __next;
++__first;
}
#pragma empty_line
return std::make_pair(__min, __max);
}
#pragma line 3397 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
#pragma empty_line
return std::__minmax_element(__first, __last,
__gnu_cxx::__ops::__iter_less_iter());
}
#pragma line 3425 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
#pragma empty_line
return std::__minmax_element(__first, __last,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
#pragma empty_line
#pragma empty_line
template<typename _Tp>
constexpr
inline _Tp
min(initializer_list<_Tp> __l)
{ return *std::min_element(__l.begin(), __l.end()); }
#pragma empty_line
template<typename _Tp, typename _Compare>
constexpr
inline _Tp
min(initializer_list<_Tp> __l, _Compare __comp)
{ return *std::min_element(__l.begin(), __l.end(), __comp); }
#pragma empty_line
template<typename _Tp>
constexpr
inline _Tp
max(initializer_list<_Tp> __l)
{ return *std::max_element(__l.begin(), __l.end()); }
#pragma empty_line
template<typename _Tp, typename _Compare>
constexpr
inline _Tp
max(initializer_list<_Tp> __l, _Compare __comp)
{ return *std::max_element(__l.begin(), __l.end(), __comp); }
#pragma empty_line
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);
}
#pragma empty_line
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);
}
#pragma empty_line
template<typename _ForwardIterator1, typename _ForwardIterator2,
typename _BinaryPredicate>
bool
__is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _BinaryPredicate __pred)
{
#pragma empty_line
#pragma empty_line
for (; __first1 != __last1; ++__first1, (void)++__first2)
if (!__pred(__first1, __first2))
break;
#pragma empty_line
if (__first1 == __last1)
return true;
#pragma empty_line
#pragma empty_line
#pragma empty_line
_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;
#pragma empty_line
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;
}
#pragma line 3537 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
return std::__is_permutation(__first1, __last1, __first2,
__gnu_cxx::__ops::__iter_equal_to_iter());
}
#pragma line 3568 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
return std::__is_permutation(__first1, __last1, __first2,
__gnu_cxx::__ops::__iter_comp_iter(__pred));
}
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
for (; __first1 != __last1 && __first2 != __last2;
++__first1, (void)++__first2)
if (!__pred(__first1, __first2))
break;
#pragma empty_line
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;
}
#pragma empty_line
for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan)
{
if (__scan != std::__find_if(__first1, __scan,
__gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)))
continue;
#pragma empty_line
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;
}
#pragma line 3661 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
;
;
#pragma empty_line
return
std::__is_permutation(__first1, __last1, __first2, __last2,
__gnu_cxx::__ops::__iter_equal_to_iter());
}
#pragma line 3688 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
;
;
#pragma empty_line
return std::__is_permutation(__first1, __last1, __first2, __last2,
__gnu_cxx::__ops::__iter_comp_iter(__pred));
}
#pragma line 3716 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
if (__first == __last)
return;
#pragma empty_line
typedef typename iterator_traits<_RandomAccessIterator>::difference_type
_DistanceType;
#pragma empty_line
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;
#pragma empty_line
for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
std::iter_swap(__i, __first + __d(__g, __p_type(0, __i - __first)));
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 3761 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
;
for (; __first != __last; ++__first)
__f(*__first);
return std::move(__f);
}
#pragma line 3782 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
return std::__find_if(__first, __last,
__gnu_cxx::__ops::__iter_equals_val(__val));
}
#pragma line 3806 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
return std::__find_if(__first, __last,
__gnu_cxx::__ops::__pred_iter(__pred));
}
#pragma line 3837 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
#pragma empty_line
for (; __first1 != __last1; ++__first1)
for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
if (*__first1 == *__iter)
return __first1;
return __last1;
}
#pragma line 3877 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
#pragma empty_line
for (; __first1 != __last1; ++__first1)
for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
if (__comp(*__first1, *__iter))
return __first1;
return __last1;
}
#pragma line 3909 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
return std::__adjacent_find(__first, __last,
__gnu_cxx::__ops::__iter_equal_to_iter());
}
#pragma line 3934 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
return std::__adjacent_find(__first, __last,
__gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
}
#pragma line 3959 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
return std::__count_if(__first, __last,
__gnu_cxx::__ops::__iter_equals_val(__value));
}
#pragma line 3982 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
return std::__count_if(__first, __last,
__gnu_cxx::__ops::__pred_iter(__pred));
}
#pragma line 4022 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
#pragma empty_line
return std::__search(__first1, __last1, __first2, __last2,
__gnu_cxx::__ops::__iter_equal_to_iter());
}
#pragma line 4061 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
#pragma empty_line
return std::__search(__first1, __last1, __first2, __last2,
__gnu_cxx::__ops::__iter_comp_iter(__predicate));
}
#pragma line 4096 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
return std::__search_n(__first, __last, __count,
__gnu_cxx::__ops::__iter_equals_val(__val));
}
#pragma line 4129 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
return std::__search_n(__first, __last, __count,
__gnu_cxx::__ops::__iter_comp_val(__binary_pred, __val));
}
#pragma line 4163 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
for (; __first != __last; ++__first, (void)++__result)
*__result = __unary_op(*__first);
return __result;
}
#pragma line 4200 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
for (; __first1 != __last1; ++__first1, (void)++__first2, ++__result)
*__result = __binary_op(*__first1, *__first2);
return __result;
}
#pragma line 4233 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
for (; __first != __last; ++__first)
if (*__first == __old_value)
*__first = __new_value;
}
#pragma line 4265 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
for (; __first != __last; ++__first)
if (__pred(*__first))
*__first = __new_value;
}
#pragma line 4297 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
for (; __first != __last; ++__first)
*__first = __gen();
}
#pragma line 4328 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
for (__decltype(__n + 0) __niter = __n;
__niter > 0; --__niter, ++__first)
*__first = __gen();
return __first;
}
#pragma line 4364 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
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));
}
#pragma line 4404 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
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));
}
#pragma line 4437 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
if (__first != __last)
for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
{
#pragma empty_line
_RandomAccessIterator __j = __first
+ std::rand() % ((__i - __first) + 1);
if (__i != __j)
std::iter_swap(__i, __j);
}
}
#pragma line 4472 "/home/justin/jhai/Xilinx/Vivado/2018.3/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,
#pragma empty_line
_RandomNumberGenerator&& __rand)
#pragma empty_line
#pragma empty_line
#pragma empty_line
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
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);
}
}
#pragma line 4512 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
return std::__partition(__first, __last, __pred,
std::__iterator_category(__first));
}
#pragma line 4545 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
;
#pragma empty_line
std::__partial_sort(__first, __middle, __last,
__gnu_cxx::__ops::__iter_less_iter());
}
#pragma line 4583 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
;
#pragma empty_line
std::__partial_sort(__first, __middle, __last,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
#pragma line 4619 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
;
#pragma empty_line
if (__first == __last || __nth == __last)
return;
#pragma empty_line
std::__introselect(__first, __nth, __last,
std::__lg(__last - __first) * 2,
__gnu_cxx::__ops::__iter_less_iter());
}
#pragma line 4658 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
;
#pragma empty_line
if (__first == __last || __nth == __last)
return;
#pragma empty_line
std::__introselect(__first, __nth, __last,
std::__lg(__last - __first) * 2,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
#pragma line 4695 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
#pragma empty_line
std::__sort(__first, __last, __gnu_cxx::__ops::__iter_less_iter());
}
#pragma line 4725 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
#pragma empty_line
std::__sort(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));
}
#pragma empty_line
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));
}
#pragma line 4786 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
;
;
#pragma empty_line
return std::__merge(__first1, __last1,
__first2, __last2, __result,
__gnu_cxx::__ops::__iter_less_iter());
}
#pragma line 4836 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
;
;
#pragma empty_line
return std::__merge(__first1, __last1,
__first2, __last2, __result,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
#pragma empty_line
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;
#pragma empty_line
typedef _Temporary_buffer<_RandomAccessIterator, _ValueType> _TmpBuf;
_TmpBuf __buf(__first, __last);
#pragma empty_line
if (__buf.begin() == 0)
std::__inplace_stable_sort(__first, __last, __comp);
else
std::__stable_sort_adaptive(__first, __last, __buf.begin(),
_DistanceType(__buf.size()), __comp);
}
#pragma line 4900 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
#pragma empty_line
std::__stable_sort(__first, __last,
__gnu_cxx::__ops::__iter_less_iter());
}
#pragma line 4934 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
#pragma empty_line
std::__stable_sort(__first, __last,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
#pragma empty_line
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));
}
#pragma line 5002 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
;
;
#pragma empty_line
return std::__set_union(__first1, __last1,
__first2, __last2, __result,
__gnu_cxx::__ops::__iter_less_iter());
}
#pragma line 5051 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
;
;
#pragma empty_line
return std::__set_union(__first1, __last1,
__first2, __last2, __result,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
#pragma empty_line
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;
}
#pragma line 5121 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
;
;
#pragma empty_line
return std::__set_intersection(__first1, __last1,
__first2, __last2, __result,
__gnu_cxx::__ops::__iter_less_iter());
}
#pragma line 5169 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
;
;
#pragma empty_line
return std::__set_intersection(__first1, __last1,
__first2, __last2, __result,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
#pragma empty_line
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);
}
#pragma line 5241 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
;
;
#pragma empty_line
return std::__set_difference(__first1, __last1,
__first2, __last2, __result,
__gnu_cxx::__ops::__iter_less_iter());
}
#pragma line 5291 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
;
;
#pragma empty_line
return std::__set_difference(__first1, __last1,
__first2, __last2, __result,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
#pragma empty_line
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));
}
#pragma line 5369 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
;
;
#pragma empty_line
return std::__set_symmetric_difference(__first1, __last1,
__first2, __last2, __result,
__gnu_cxx::__ops::__iter_less_iter());
}
#pragma line 5419 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
;
;
#pragma empty_line
return std::__set_symmetric_difference(__first1, __last1,
__first2, __last2, __result,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
#pragma empty_line
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;
}
#pragma line 5472 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
#pragma empty_line
return std::__min_element(__first, __last,
__gnu_cxx::__ops::__iter_less_iter());
}
#pragma line 5497 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
#pragma empty_line
return std::__min_element(__first, __last,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
#pragma empty_line
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;
}
#pragma line 5536 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
#pragma empty_line
return std::__max_element(__first, __last,
__gnu_cxx::__ops::__iter_less_iter());
}
#pragma line 5561 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
;
#pragma empty_line
return std::__max_element(__first, __last,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}
#pragma empty_line
#pragma empty_line
}
#pragma line 63 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/algorithm" 2 3
#pragma line 211 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h" 2
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/climits" 1 3
#pragma line 39 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/climits" 3
#pragma empty_line
#pragma line 40 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/climits" 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include-fixed/limits.h" 1 3 4
#pragma line 43 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/climits" 2 3
#pragma line 214 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h" 2
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstring" 1 3
#pragma line 39 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstring" 3
#pragma empty_line
#pragma line 40 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstring" 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/string.h" 1 3 4
#pragma line 26 "/usr/include/string.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4
#pragma line 27 "/usr/include/string.h" 2 3 4
#pragma empty_line
extern "C" {
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include/stddef.h" 1 3 4
#pragma line 34 "/usr/include/string.h" 2 3 4
#pragma line 43 "/usr/include/string.h" 3 4
extern void *memcpy (void *__restrict __dest, const void *__restrict __src,
size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
extern void *memmove (void *__dest, const void *__src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern void *memccpy (void *__restrict __dest, const void *__restrict __src,
int __c, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern void *memset (void *__s, int __c, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
extern int memcmp (const void *__s1, const void *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
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)));
#pragma line 89 "/usr/include/string.h" 3 4
}
#pragma line 99 "/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)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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)));
#pragma line 122 "/usr/include/string.h" 3 4
extern char *strcpy (char *__restrict __dest, const char *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
extern char *strncpy (char *__restrict __dest,
const char *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
extern char *strcat (char *__restrict __dest, const char *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
extern char *strncat (char *__restrict __dest, const char *__restrict __src,
size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
extern int strcmp (const char *__s1, const char *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
extern int strncmp (const char *__s1, const char *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
extern int strcoll (const char *__s1, const char *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
extern size_t strxfrm (char *__restrict __dest,
const char *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (2)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int strcoll_l (const char *__s1, const char *__s2, locale_t __l)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
#pragma empty_line
#pragma empty_line
extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n,
locale_t __l) throw () __attribute__ ((__nonnull__ (2, 4)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern char *strdup (const char *__s)
throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern char *strndup (const char *__string, size_t __n)
throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
#pragma line 204 "/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)));
#pragma line 224 "/usr/include/string.h" 3 4
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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)));
#pragma line 251 "/usr/include/string.h" 3 4
}
#pragma line 261 "/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)));
#pragma line 273 "/usr/include/string.h" 3 4
extern size_t strcspn (const char *__s, const char *__reject)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
extern size_t strspn (const char *__s, const char *__accept)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
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)));
#pragma line 301 "/usr/include/string.h" 3 4
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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)));
#pragma line 328 "/usr/include/string.h" 3 4
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern char *strtok (char *__restrict __s, const char *__restrict __delim)
throw () __attribute__ ((__nonnull__ (2)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern char *__strtok_r (char *__restrict __s,
const char *__restrict __delim,
char **__restrict __save_ptr)
throw () __attribute__ ((__nonnull__ (2, 3)));
#pragma empty_line
extern char *strtok_r (char *__restrict __s, const char *__restrict __delim,
char **__restrict __save_ptr)
throw () __attribute__ ((__nonnull__ (2, 3)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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)));
#pragma line 369 "/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)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
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)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern size_t strlen (const char *__s)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern size_t strnlen (const char *__string, size_t __maxlen)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern char *strerror (int __errnum) throw ();
#pragma line 421 "/usr/include/string.h" 3 4
extern char *strerror_r (int __errnum, char *__buf, size_t __buflen)
throw () __attribute__ ((__nonnull__ (2))) ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern char *strerror_l (int __errnum, locale_t __l) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/strings.h" 1 3 4
#pragma line 23 "/usr/include/strings.h" 3 4
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/lib/gcc/x86_64-pc-linux-gnu/6.2.0/include/stddef.h" 1 3 4
#pragma line 24 "/usr/include/strings.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern "C" {
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int bcmp (const void *__s1, const void *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
extern void bcopy (const void *__src, void *__dest, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
extern void bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
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)));
#pragma line 66 "/usr/include/strings.h" 3 4
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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)));
#pragma line 94 "/usr/include/strings.h" 3 4
}
#pragma line 104 "/usr/include/strings.h" 3 4
extern int ffs (int __i) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int ffsl (long int __l) throw () __attribute__ ((__const__));
__extension__ extern int ffsll (long long int __ll)
throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int strcasecmp (const char *__s1, const char *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
extern int strncasecmp (const char *__s1, const char *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int strcasecmp_l (const char *__s1, const char *__s2, locale_t __loc)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int strncasecmp_l (const char *__s1, const char *__s2,
size_t __n, locale_t __loc)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4)));
#pragma empty_line
#pragma empty_line
}
#pragma line 433 "/usr/include/string.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern void explicit_bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern char *strsep (char **__restrict __stringp,
const char *__restrict __delim)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern char *strsignal (int __sig) throw ();
#pragma empty_line
#pragma empty_line
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)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
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)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int strverscmp (const char *__s1, const char *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
extern char *strfry (char *__string) throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
extern void *memfrob (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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)));
#pragma line 499 "/usr/include/string.h" 3 4
}
#pragma line 43 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstring" 2 3
#pragma line 71 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstring" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
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;
#pragma line 120 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstring" 3
#pragma empty_line
}
#pragma line 216 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h" 2
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/functional" 1 3
#pragma line 46 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/functional" 3
#pragma empty_line
#pragma line 47 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/functional" 3
#pragma line 55 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/functional" 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/tuple" 1 3
#pragma line 32 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/tuple" 3
#pragma empty_line
#pragma line 33 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/tuple" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/array" 1 3
#pragma line 32 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/array" 3
#pragma empty_line
#pragma line 33 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/array" 3
#pragma line 43 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/array" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
template<typename _Tp, std::size_t _Nm>
struct __array_traits
{
typedef _Tp _Type[_Nm];
#pragma empty_line
static constexpr _Tp&
_S_ref(const _Type& __t, std::size_t __n) noexcept
{ return const_cast<_Tp&>(__t[__n]); }
#pragma empty_line
static constexpr _Tp*
_S_ptr(const _Type& __t) noexcept
{ return const_cast<_Tp*>(__t); }
};
#pragma empty_line
template<typename _Tp>
struct __array_traits<_Tp, 0>
{
struct _Type { };
#pragma empty_line
static constexpr _Tp&
_S_ref(const _Type&, std::size_t) noexcept
{ return *static_cast<_Tp*>(nullptr); }
#pragma empty_line
static constexpr _Tp*
_S_ptr(const _Type&) noexcept
{ return nullptr; }
};
#pragma line 89 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
#pragma empty_line
typedef std::__array_traits<_Tp, _Nm> _AT_Type;
typename _AT_Type::_Type _M_elems;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
void
fill(const value_type& __u)
{ std::fill_n(begin(), size(), __u); }
#pragma empty_line
void
swap(array& __other)
noexcept(__is_nothrow_swappable<_Tp>::value)
{ std::swap_ranges(begin(), end(), __other.begin()); }
#pragma empty_line
#pragma empty_line
iterator
begin() noexcept
{ return iterator(data()); }
#pragma empty_line
const_iterator
begin() const noexcept
{ return const_iterator(data()); }
#pragma empty_line
iterator
end() noexcept
{ return iterator(data() + _Nm); }
#pragma empty_line
const_iterator
end() const noexcept
{ return const_iterator(data() + _Nm); }
#pragma empty_line
reverse_iterator
rbegin() noexcept
{ return reverse_iterator(end()); }
#pragma empty_line
const_reverse_iterator
rbegin() const noexcept
{ return const_reverse_iterator(end()); }
#pragma empty_line
reverse_iterator
rend() noexcept
{ return reverse_iterator(begin()); }
#pragma empty_line
const_reverse_iterator
rend() const noexcept
{ return const_reverse_iterator(begin()); }
#pragma empty_line
const_iterator
cbegin() const noexcept
{ return const_iterator(data()); }
#pragma empty_line
const_iterator
cend() const noexcept
{ return const_iterator(data() + _Nm); }
#pragma empty_line
const_reverse_iterator
crbegin() const noexcept
{ return const_reverse_iterator(end()); }
#pragma empty_line
const_reverse_iterator
crend() const noexcept
{ return const_reverse_iterator(begin()); }
#pragma empty_line
#pragma empty_line
constexpr size_type
size() const noexcept { return _Nm; }
#pragma empty_line
constexpr size_type
max_size() const noexcept { return _Nm; }
#pragma empty_line
constexpr bool
empty() const noexcept { return size() == 0; }
#pragma empty_line
#pragma empty_line
reference
operator[](size_type __n) noexcept
{ return _AT_Type::_S_ref(_M_elems, __n); }
#pragma empty_line
constexpr const_reference
operator[](size_type __n) const noexcept
{ return _AT_Type::_S_ref(_M_elems, __n); }
#pragma empty_line
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);
}
#pragma empty_line
constexpr const_reference
at(size_type __n) const
{
#pragma empty_line
#pragma empty_line
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));
}
#pragma empty_line
reference
front() noexcept
{ return *begin(); }
#pragma empty_line
constexpr const_reference
front() const noexcept
{ return _AT_Type::_S_ref(_M_elems, 0); }
#pragma empty_line
reference
back() noexcept
{ return _Nm ? *(end() - 1) : *end(); }
#pragma empty_line
constexpr const_reference
back() const noexcept
{
return _Nm ? _AT_Type::_S_ref(_M_elems, _Nm - 1)
: _AT_Type::_S_ref(_M_elems, 0);
}
#pragma empty_line
pointer
data() noexcept
{ return _AT_Type::_S_ptr(_M_elems); }
#pragma empty_line
const_pointer
data() const noexcept
{ return _AT_Type::_S_ptr(_M_elems); }
};
#pragma empty_line
#pragma empty_line
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()); }
#pragma empty_line
template<typename _Tp, std::size_t _Nm>
inline bool
operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
{ return !(__one == __two); }
#pragma empty_line
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());
}
#pragma empty_line
template<typename _Tp, std::size_t _Nm>
inline bool
operator>(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
{ return __two < __one; }
#pragma empty_line
template<typename _Tp, std::size_t _Nm>
inline bool
operator<=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
{ return !(__one > __two); }
#pragma empty_line
template<typename _Tp, std::size_t _Nm>
inline bool
operator>=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
{ return !(__one < __two); }
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
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);
}
#pragma empty_line
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));
}
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
class tuple_size;
#pragma empty_line
#pragma empty_line
template<typename _Tp, std::size_t _Nm>
struct tuple_size<std::array<_Tp, _Nm>>
: public integral_constant<std::size_t, _Nm> { };
#pragma empty_line
#pragma empty_line
template<std::size_t _Int, typename _Tp>
class tuple_element;
#pragma empty_line
#pragma empty_line
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;
};
#pragma empty_line
template<typename _Tp, std::size_t _Nm>
struct __is_tuple_like_impl<std::array<_Tp, _Nm>> : true_type
{ };
#pragma empty_line
#pragma empty_line
}
#pragma line 40 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/tuple" 2 3
#pragma empty_line
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<std::size_t _Idx, typename _Head, bool _IsEmptyNotFinal>
struct _Head_base;
#pragma empty_line
template<std::size_t _Idx, typename _Head>
struct _Head_base<_Idx, _Head, true>
: public _Head
{
constexpr _Head_base()
: _Head() { }
#pragma empty_line
constexpr _Head_base(const _Head& __h)
: _Head(__h) { }
#pragma empty_line
constexpr _Head_base(const _Head_base&) = default;
constexpr _Head_base(_Head_base&&) = default;
#pragma empty_line
template<typename _UHead>
constexpr _Head_base(_UHead&& __h)
: _Head(std::forward<_UHead>(__h)) { }
#pragma empty_line
_Head_base(allocator_arg_t, __uses_alloc0)
: _Head() { }
#pragma empty_line
template<typename _Alloc>
_Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
: _Head(allocator_arg, *__a._M_a) { }
#pragma empty_line
template<typename _Alloc>
_Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a)
: _Head(*__a._M_a) { }
#pragma empty_line
template<typename _UHead>
_Head_base(__uses_alloc0, _UHead&& __uhead)
: _Head(std::forward<_UHead>(__uhead)) { }
#pragma empty_line
template<typename _Alloc, typename _UHead>
_Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
: _Head(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) { }
#pragma empty_line
template<typename _Alloc, typename _UHead>
_Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
: _Head(std::forward<_UHead>(__uhead), *__a._M_a) { }
#pragma empty_line
static constexpr _Head&
_M_head(_Head_base& __b) noexcept { return __b; }
#pragma empty_line
static constexpr const _Head&
_M_head(const _Head_base& __b) noexcept { return __b; }
};
#pragma empty_line
template<std::size_t _Idx, typename _Head>
struct _Head_base<_Idx, _Head, false>
{
constexpr _Head_base()
: _M_head_impl() { }
#pragma empty_line
constexpr _Head_base(const _Head& __h)
: _M_head_impl(__h) { }
#pragma empty_line
constexpr _Head_base(const _Head_base&) = default;
constexpr _Head_base(_Head_base&&) = default;
#pragma empty_line
template<typename _UHead>
constexpr _Head_base(_UHead&& __h)
: _M_head_impl(std::forward<_UHead>(__h)) { }
#pragma empty_line
_Head_base(allocator_arg_t, __uses_alloc0)
: _M_head_impl() { }
#pragma empty_line
template<typename _Alloc>
_Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
: _M_head_impl(allocator_arg, *__a._M_a) { }
#pragma empty_line
template<typename _Alloc>
_Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a)
: _M_head_impl(*__a._M_a) { }
#pragma empty_line
template<typename _UHead>
_Head_base(__uses_alloc0, _UHead&& __uhead)
: _M_head_impl(std::forward<_UHead>(__uhead)) { }
#pragma empty_line
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))
{ }
#pragma empty_line
template<typename _Alloc, typename _UHead>
_Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
: _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { }
#pragma empty_line
static constexpr _Head&
_M_head(_Head_base& __b) noexcept { return __b._M_head_impl; }
#pragma empty_line
static constexpr const _Head&
_M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; }
#pragma empty_line
_Head _M_head_impl;
};
#pragma line 158 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/tuple" 3
template<std::size_t _Idx, typename... _Elements>
struct _Tuple_impl;
#pragma empty_line
template<typename _Tp>
struct __is_empty_non_tuple : is_empty<_Tp> { };
#pragma empty_line
#pragma empty_line
template<typename _El0, typename... _El>
struct __is_empty_non_tuple<tuple<_El0, _El...>> : false_type { };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
using __empty_not_final
= typename conditional<__is_final(_Tp), false_type,
__is_empty_non_tuple<_Tp>>::type;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
typedef _Head_base<_Idx, _Head, __empty_not_final<_Head>::value> _Base;
#pragma empty_line
static constexpr _Head&
_M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
#pragma empty_line
static constexpr const _Head&
_M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
#pragma empty_line
static constexpr _Inherited&
_M_tail(_Tuple_impl& __t) noexcept { return __t; }
#pragma empty_line
static constexpr const _Inherited&
_M_tail(const _Tuple_impl& __t) noexcept { return __t; }
#pragma empty_line
constexpr _Tuple_impl()
: _Inherited(), _Base() { }
#pragma empty_line
explicit
constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail)
: _Inherited(__tail...), _Base(__head) { }
#pragma empty_line
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)) { }
#pragma empty_line
constexpr _Tuple_impl(const _Tuple_impl&) = default;
#pragma empty_line
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))) { }
#pragma empty_line
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)) { }
#pragma empty_line
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))) { }
#pragma empty_line
template<typename _Alloc>
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
: _Inherited(__tag, __a),
_Base(__tag, __use_alloc<_Head>(__a)) { }
#pragma empty_line
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) { }
#pragma empty_line
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)) { }
#pragma empty_line
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)) { }
#pragma empty_line
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))) { }
#pragma empty_line
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)) { }
#pragma empty_line
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))) { }
#pragma empty_line
_Tuple_impl&
operator=(const _Tuple_impl& __in)
{
_M_head(*this) = _M_head(__in);
_M_tail(*this) = _M_tail(__in);
return *this;
}
#pragma empty_line
_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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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));
}
};
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
typedef _Head_base<_Idx, _Head, __empty_not_final<_Head>::value> _Base;
#pragma empty_line
static constexpr _Head&
_M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
#pragma empty_line
static constexpr const _Head&
_M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
#pragma empty_line
constexpr _Tuple_impl()
: _Base() { }
#pragma empty_line
explicit
constexpr _Tuple_impl(const _Head& __head)
: _Base(__head) { }
#pragma empty_line
template<typename _UHead>
explicit
constexpr _Tuple_impl(_UHead&& __head)
: _Base(std::forward<_UHead>(__head)) { }
#pragma empty_line
constexpr _Tuple_impl(const _Tuple_impl&) = default;
#pragma empty_line
constexpr
_Tuple_impl(_Tuple_impl&& __in)
noexcept(is_nothrow_move_constructible<_Head>::value)
: _Base(std::forward<_Head>(_M_head(__in))) { }
#pragma empty_line
template<typename _UHead>
constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UHead>& __in)
: _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in)) { }
#pragma empty_line
template<typename _UHead>
constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead>&& __in)
: _Base(std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
{ }
#pragma empty_line
template<typename _Alloc>
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
: _Base(__tag, __use_alloc<_Head>(__a)) { }
#pragma empty_line
template<typename _Alloc>
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
const _Head& __head)
: _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { }
#pragma empty_line
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)) { }
#pragma empty_line
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)) { }
#pragma empty_line
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))) { }
#pragma empty_line
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)) { }
#pragma empty_line
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)))
{ }
#pragma empty_line
_Tuple_impl&
operator=(const _Tuple_impl& __in)
{
_M_head(*this) = _M_head(__in);
return *this;
}
#pragma empty_line
_Tuple_impl&
operator=(_Tuple_impl&& __in)
noexcept(is_nothrow_move_assignable<_Head>::value)
{
_M_head(*this) = std::forward<_Head>(_M_head(__in));
return *this;
}
#pragma empty_line
template<typename _UHead>
_Tuple_impl&
operator=(const _Tuple_impl<_Idx, _UHead>& __in)
{
_M_head(*this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in);
return *this;
}
#pragma empty_line
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;
}
#pragma empty_line
protected:
void
_M_swap(_Tuple_impl& __in)
noexcept(__is_nothrow_swappable<_Head>::value)
{
using std::swap;
swap(_M_head(*this), _M_head(__in));
}
};
#pragma empty_line
template<typename... _Elements>
class tuple;
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<bool, typename... _Elements>
struct _TC
{
template<typename... _UElements>
static constexpr bool _ConstructibleTuple()
{
return __and_<is_constructible<_Elements, const _UElements&>...>::value;
}
#pragma empty_line
template<typename... _UElements>
static constexpr bool _ImplicitlyConvertibleTuple()
{
return __and_<is_convertible<const _UElements&, _Elements>...>::value;
}
#pragma empty_line
template<typename... _UElements>
static constexpr bool _MoveConstructibleTuple()
{
return __and_<is_constructible<_Elements, _UElements&&>...>::value;
}
#pragma empty_line
template<typename... _UElements>
static constexpr bool _ImplicitlyMoveConvertibleTuple()
{
return __and_<is_convertible<_UElements&&, _Elements>...>::value;
}
#pragma empty_line
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;
}
};
#pragma empty_line
template<typename... _Elements>
struct _TC<false, _Elements...>
{
template<typename... _UElements>
static constexpr bool _ConstructibleTuple()
{
return false;
}
#pragma empty_line
template<typename... _UElements>
static constexpr bool _ImplicitlyConvertibleTuple()
{
return false;
}
#pragma empty_line
template<typename... _UElements>
static constexpr bool _MoveConstructibleTuple()
{
return false;
}
#pragma empty_line
template<typename... _UElements>
static constexpr bool _ImplicitlyMoveConvertibleTuple()
{
return false;
}
#pragma empty_line
template<typename... _UElements>
static constexpr bool _NonNestedTuple()
{
return true;
}
template<typename... _UElements>
static constexpr bool _NotSameTuple()
{
return true;
}
};
#pragma empty_line
#pragma empty_line
template<typename... _Elements>
class tuple : public _Tuple_impl<0, _Elements...>
{
typedef _Tuple_impl<0, _Elements...> _Inherited;
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
};
#pragma empty_line
public:
template<typename _Dummy = void,
typename enable_if<_TC2<_Dummy>::
_ImplicitlyDefaultConstructibleTuple(),
bool>::type = true>
constexpr tuple()
: _Inherited() { }
#pragma empty_line
template<typename _Dummy = void,
typename enable_if<_TC2<_Dummy>::
_DefaultConstructibleTuple()
&&
!_TC2<_Dummy>::
_ImplicitlyDefaultConstructibleTuple(),
bool>::type = false>
explicit constexpr tuple()
: _Inherited() { }
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Dummy> using _TCC =
_TC<is_same<_Dummy, void>::value,
_Elements...>;
#pragma empty_line
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...) { }
#pragma empty_line
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...) { }
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename... _UElements> using _TMC =
_TC<(sizeof...(_Elements) == sizeof...(_UElements)),
_Elements...>;
#pragma empty_line
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)...) { }
#pragma empty_line
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)...) { }
#pragma empty_line
constexpr tuple(const tuple&) = default;
#pragma empty_line
constexpr tuple(tuple&&) = default;
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Dummy> using _TNTC =
_TC<is_same<_Dummy, void>::value && sizeof...(_Elements) == 1,
_Elements...>;
#pragma empty_line
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))
{ }
#pragma empty_line
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))
{ }
#pragma empty_line
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)) { }
#pragma empty_line
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)) { }
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Alloc>
tuple(allocator_arg_t __tag, const _Alloc& __a)
: _Inherited(__tag, __a) { }
#pragma empty_line
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...) { }
#pragma empty_line
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...) { }
#pragma empty_line
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)...)
{ }
#pragma empty_line
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)...)
{ }
#pragma empty_line
template<typename _Alloc>
tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
: _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
#pragma empty_line
template<typename _Alloc>
tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
: _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
#pragma empty_line
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))
{ }
#pragma empty_line
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))
{ }
#pragma empty_line
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))
{ }
#pragma empty_line
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))
{ }
#pragma empty_line
tuple&
operator=(const tuple& __in)
{
static_cast<_Inherited&>(*this) = __in;
return *this;
}
#pragma empty_line
tuple&
operator=(tuple&& __in)
noexcept(is_nothrow_move_assignable<_Inherited>::value)
{
static_cast<_Inherited&>(*this) = std::move(__in);
return *this;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
void
swap(tuple& __in)
noexcept(noexcept(__in._M_swap(__in)))
{ _Inherited::_M_swap(__in); }
};
#pragma empty_line
#pragma empty_line
template<>
class tuple<>
{
public:
void swap(tuple&) noexcept { }
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _T1, typename _T2>
class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2>
{
typedef _Tuple_impl<0, _T1, _T2> _Inherited;
#pragma empty_line
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>
#pragma empty_line
constexpr tuple()
: _Inherited() { }
#pragma empty_line
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>
#pragma empty_line
explicit constexpr tuple()
: _Inherited() { }
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Dummy> using _TCC =
_TC<is_same<_Dummy, void>::value, _T1, _T2>;
#pragma empty_line
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) { }
#pragma empty_line
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) { }
#pragma empty_line
#pragma empty_line
#pragma empty_line
using _TMC = _TC<true, _T1, _T2>;
#pragma empty_line
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)) { }
#pragma empty_line
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)) { }
#pragma empty_line
constexpr tuple(const tuple&) = default;
#pragma empty_line
constexpr tuple(tuple&&) = default;
#pragma empty_line
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)) { }
#pragma empty_line
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)) { }
#pragma empty_line
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)) { }
#pragma empty_line
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)) { }
#pragma empty_line
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) { }
#pragma empty_line
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) { }
#pragma empty_line
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)) { }
#pragma empty_line
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)) { }
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Alloc>
tuple(allocator_arg_t __tag, const _Alloc& __a)
: _Inherited(__tag, __a) { }
#pragma empty_line
template<typename _Alloc, typename _Dummy = void,
typename enable_if<
_TCC<_Dummy>::template
_ConstructibleTuple<_T1, _T2>()
&& _TCC<_Dummy>::template
_ImplicitlyConvertibleTuple<_T1, _T2>(),
bool>::type=true>
#pragma empty_line
tuple(allocator_arg_t __tag, const _Alloc& __a,
const _T1& __a1, const _T2& __a2)
: _Inherited(__tag, __a, __a1, __a2) { }
#pragma empty_line
template<typename _Alloc, typename _Dummy = void,
typename enable_if<
_TCC<_Dummy>::template
_ConstructibleTuple<_T1, _T2>()
&& !_TCC<_Dummy>::template
_ImplicitlyConvertibleTuple<_T1, _T2>(),
bool>::type=false>
#pragma empty_line
explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
const _T1& __a1, const _T2& __a2)
: _Inherited(__tag, __a, __a1, __a2) { }
#pragma empty_line
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)) { }
#pragma empty_line
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)) { }
#pragma empty_line
template<typename _Alloc>
tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
: _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
#pragma empty_line
template<typename _Alloc>
tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
: _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
#pragma empty_line
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))
{ }
#pragma empty_line
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))
{ }
#pragma empty_line
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))
{ }
#pragma empty_line
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))
{ }
#pragma empty_line
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) { }
#pragma empty_line
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) { }
#pragma empty_line
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)) { }
#pragma empty_line
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)) { }
#pragma empty_line
tuple&
operator=(const tuple& __in)
{
static_cast<_Inherited&>(*this) = __in;
return *this;
}
#pragma empty_line
tuple&
operator=(tuple&& __in)
noexcept(is_nothrow_move_assignable<_Inherited>::value)
{
static_cast<_Inherited&>(*this) = std::move(__in);
return *this;
}
#pragma empty_line
template<typename _U1, typename _U2>
tuple&
operator=(const tuple<_U1, _U2>& __in)
{
static_cast<_Inherited&>(*this) = __in;
return *this;
}
#pragma empty_line
template<typename _U1, typename _U2>
tuple&
operator=(tuple<_U1, _U2>&& __in)
{
static_cast<_Inherited&>(*this) = std::move(__in);
return *this;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
void
swap(tuple& __in)
noexcept(noexcept(__in._M_swap(__in)))
{ _Inherited::_M_swap(__in); }
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<std::size_t __i, typename _Head, typename... _Tail>
struct tuple_element<__i, tuple<_Head, _Tail...> >
: tuple_element<__i - 1, tuple<_Tail...> > { };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Head, typename... _Tail>
struct tuple_element<0, tuple<_Head, _Tail...> >
{
typedef _Head type;
};
#pragma empty_line
#pragma empty_line
template<typename... _Elements>
struct tuple_size<tuple<_Elements...>>
: public integral_constant<std::size_t, sizeof...(_Elements)> { };
#pragma empty_line
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); }
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
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));
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
template <typename _Tp, typename... _Types>
constexpr _Tp&
get(tuple<_Types...>& __t) noexcept
{ return std::__get_helper2<_Tp>(__t); }
#pragma empty_line
#pragma empty_line
template <typename _Tp, typename... _Types>
constexpr _Tp&&
get(tuple<_Types...>&& __t) noexcept
{ return std::forward<_Tp&&>(std::__get_helper2<_Tp>(__t)); }
#pragma empty_line
#pragma empty_line
template <typename _Tp, typename... _Types>
constexpr const _Tp&
get(const tuple<_Types...>& __t) noexcept
{ return std::__get_helper2<_Tp>(__t); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
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));
}
};
#pragma empty_line
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; }
#pragma empty_line
static constexpr bool
__less(const _Tp&, const _Up&) { return false; }
};
#pragma empty_line
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);
}
#pragma empty_line
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);
}
#pragma empty_line
template<typename... _TElements, typename... _UElements>
constexpr bool
operator!=(const tuple<_TElements...>& __t,
const tuple<_UElements...>& __u)
{ return !(__t == __u); }
#pragma empty_line
template<typename... _TElements, typename... _UElements>
constexpr bool
operator>(const tuple<_TElements...>& __t,
const tuple<_UElements...>& __u)
{ return __u < __t; }
#pragma empty_line
template<typename... _TElements, typename... _UElements>
constexpr bool
operator<=(const tuple<_TElements...>& __t,
const tuple<_UElements...>& __u)
{ return !(__u < __t); }
#pragma empty_line
template<typename... _TElements, typename... _UElements>
constexpr bool
operator>=(const tuple<_TElements...>& __t,
const tuple<_UElements...>& __u)
{ return !(__t < __u); }
#pragma empty_line
#pragma empty_line
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)...);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename... _Elements>
constexpr tuple<_Elements&&...>
forward_as_tuple(_Elements&&... __args) noexcept
{ return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); }
#pragma empty_line
template<typename... _Tps>
struct __is_tuple_like_impl<tuple<_Tps...>> : true_type
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct __is_tuple_like
: public __is_tuple_like_impl<typename std::remove_cv
<typename std::remove_reference<_Tp>::type>::type>::type
{ };
#pragma empty_line
template<size_t, typename, typename, size_t>
struct __make_tuple_impl;
#pragma empty_line
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>
{ };
#pragma empty_line
template<std::size_t _Nm, typename _Tuple, typename... _Tp>
struct __make_tuple_impl<_Nm, tuple<_Tp...>, _Tuple, _Nm>
{
typedef tuple<_Tp...> __type;
};
#pragma empty_line
template<typename _Tuple>
struct __do_make_tuple
: __make_tuple_impl<0, tuple<>, _Tuple, std::tuple_size<_Tuple>::value>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tuple>
struct __make_tuple
: public __do_make_tuple<typename std::remove_cv
<typename std::remove_reference<_Tuple>::type>::type>
{ };
#pragma empty_line
#pragma empty_line
template<typename...>
struct __combine_tuples;
#pragma empty_line
template<>
struct __combine_tuples<>
{
typedef tuple<> __type;
};
#pragma empty_line
template<typename... _Ts>
struct __combine_tuples<tuple<_Ts...>>
{
typedef tuple<_Ts...> __type;
};
#pragma empty_line
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;
};
#pragma empty_line
#pragma empty_line
template<typename... _Tpls>
struct __tuple_cat_result
{
typedef typename __combine_tuples
<typename __make_tuple<_Tpls>::__type...>::__type __type;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename...>
struct __make_1st_indices;
#pragma empty_line
template<>
struct __make_1st_indices<>
{
typedef std::_Index_tuple<> __type;
};
#pragma empty_line
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;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Ret, typename _Indices, typename... _Tpls>
struct __tuple_concater;
#pragma empty_line
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))...);
}
};
#pragma empty_line
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)...);
}
};
#pragma empty_line
#pragma empty_line
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)...);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename... _Elements>
constexpr tuple<_Elements&...>
tie(_Elements&... __args) noexcept
{ return tuple<_Elements&...>(__args...); }
#pragma empty_line
#pragma empty_line
template<typename... _Elements>
inline void
swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y)
noexcept(noexcept(__x.swap(__y)))
{ __x.swap(__y); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
struct _Swallow_assign
{
template<class _Tp>
const _Swallow_assign&
operator=(const _Tp&) const
{ return *this; }
};
#pragma empty_line
const _Swallow_assign ignore{};
#pragma empty_line
#pragma empty_line
template<typename... _Types, typename _Alloc>
struct uses_allocator<tuple<_Types...>, _Alloc> : true_type { };
#pragma empty_line
#pragma empty_line
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())
{ }
#pragma empty_line
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))...)
{ }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 56 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/functional" 2 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
template<typename _MemberPointer>
class _Mem_fn;
template<typename _Tp, typename _Class>
_Mem_fn<_Tp _Class::*>
mem_fn(_Tp _Class::*) noexcept;
#pragma empty_line
#pragma empty_line
template<typename _Functor, typename = __void_t<>>
struct _Maybe_get_result_type
{ };
#pragma empty_line
template<typename _Functor>
struct _Maybe_get_result_type<_Functor,
__void_t<typename _Functor::result_type>>
{ typedef typename _Functor::result_type result_type; };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Functor>
struct _Weak_result_type_impl
: _Maybe_get_result_type<_Functor>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes...)>
{ typedef _Res result_type; };
#pragma empty_line
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes......)>
{ typedef _Res result_type; };
#pragma empty_line
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes...) const>
{ typedef _Res result_type; };
#pragma empty_line
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes......) const>
{ typedef _Res result_type; };
#pragma empty_line
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes...) volatile>
{ typedef _Res result_type; };
#pragma empty_line
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes......) volatile>
{ typedef _Res result_type; };
#pragma empty_line
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes...) const volatile>
{ typedef _Res result_type; };
#pragma empty_line
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes......) const volatile>
{ typedef _Res result_type; };
#pragma empty_line
#pragma empty_line
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(&)(_ArgTypes...)>
{ typedef _Res result_type; };
#pragma empty_line
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(&)(_ArgTypes......)>
{ typedef _Res result_type; };
#pragma empty_line
#pragma empty_line
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(*)(_ArgTypes...)>
{ typedef _Res result_type; };
#pragma empty_line
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(*)(_ArgTypes......)>
{ typedef _Res result_type; };
#pragma empty_line
#pragma empty_line
template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)>
{ typedef _Res result_type; };
#pragma empty_line
template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......)>
{ typedef _Res result_type; };
#pragma empty_line
#pragma empty_line
template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) const>
{ typedef _Res result_type; };
#pragma empty_line
template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) const>
{ typedef _Res result_type; };
#pragma empty_line
#pragma empty_line
template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) volatile>
{ typedef _Res result_type; };
#pragma empty_line
template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) volatile>
{ typedef _Res result_type; };
#pragma empty_line
#pragma empty_line
template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)
const volatile>
{ typedef _Res result_type; };
#pragma empty_line
template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......)
const volatile>
{ typedef _Res result_type; };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Functor>
struct _Weak_result_type
: _Weak_result_type_impl<typename remove_cv<_Functor>::type>
{ };
#pragma empty_line
template<typename _Tp, typename _Up = typename decay<_Tp>::type>
struct _Unwrap
{
using type = _Tp&&;
#pragma empty_line
#pragma empty_line
static constexpr _Tp&&
_S_fwd(_Tp& __t) noexcept { return static_cast<_Tp&&>(__t); }
};
#pragma empty_line
template<typename _Tp, typename _Up>
struct _Unwrap<_Tp, reference_wrapper<_Up>>
{
using type = _Up&;
#pragma empty_line
#pragma empty_line
static _Up&
_S_fwd(const _Tp& __t) noexcept { __t.get(); }
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
inline typename _Unwrap<_Tp>::type
__invfwd(typename remove_reference<_Tp>::type& __t) noexcept
{ return _Unwrap<_Tp>::_S_fwd(__t); }
#pragma empty_line
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)...); }
#pragma empty_line
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)...); }
#pragma empty_line
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)...);
}
#pragma empty_line
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; }
#pragma empty_line
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; }
#pragma empty_line
#pragma empty_line
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)...);
}
#pragma line 281 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct _Reference_wrapper_base_impl<false, false, _Tp>
: _Weak_result_type<_Tp>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct _Reference_wrapper_base_impl<true, false, _Tp>
: _Weak_result_type<_Tp>
{
typedef typename _Tp::argument_type argument_type;
};
#pragma empty_line
#pragma empty_line
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;
};
#pragma empty_line
#pragma empty_line
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;
};
#pragma empty_line
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 { };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res(_T1)>
: unary_function<_T1, _Res>
{ };
#pragma empty_line
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res(_T1) const>
: unary_function<_T1, _Res>
{ };
#pragma empty_line
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res(_T1) volatile>
: unary_function<_T1, _Res>
{ };
#pragma empty_line
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res(_T1) const volatile>
: unary_function<_T1, _Res>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res(_T1, _T2)>
: binary_function<_T1, _T2, _Res>
{ };
#pragma empty_line
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res(_T1, _T2) const>
: binary_function<_T1, _T2, _Res>
{ };
#pragma empty_line
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res(_T1, _T2) volatile>
: binary_function<_T1, _T2, _Res>
{ };
#pragma empty_line
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res(_T1, _T2) const volatile>
: binary_function<_T1, _T2, _Res>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res(*)(_T1)>
: unary_function<_T1, _Res>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res(*)(_T1, _T2)>
: binary_function<_T1, _T2, _Res>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res (_T1::*)()>
: unary_function<_T1*, _Res>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res (_T1::*)(_T2)>
: binary_function<_T1*, _T2, _Res>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res (_T1::*)() const>
: unary_function<const _T1*, _Res>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const>
: binary_function<const _T1*, _T2, _Res>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res (_T1::*)() volatile>
: unary_function<volatile _T1*, _Res>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res (_T1::*)(_T2) volatile>
: binary_function<volatile _T1*, _T2, _Res>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res (_T1::*)() const volatile>
: unary_function<const volatile _T1*, _Res>
{ };
#pragma empty_line
#pragma empty_line
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const volatile>
: binary_function<const volatile _T1*, _T2, _Res>
{ };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
class reference_wrapper
: public _Reference_wrapper_base<typename remove_cv<_Tp>::type>
{
_Tp* _M_data;
#pragma empty_line
public:
typedef _Tp type;
#pragma empty_line
reference_wrapper(_Tp& __indata) noexcept
: _M_data(std::__addressof(__indata))
{ }
#pragma empty_line
reference_wrapper(_Tp&&) = delete;
#pragma empty_line
reference_wrapper(const reference_wrapper&) = default;
#pragma empty_line
reference_wrapper&
operator=(const reference_wrapper&) = default;
#pragma empty_line
operator _Tp&() const noexcept
{ return this->get(); }
#pragma empty_line
_Tp&
get() const noexcept
{ return *_M_data; }
#pragma empty_line
template<typename... _Args>
typename result_of<_Tp&(_Args&&...)>::type
operator()(_Args&&... __args) const
{
return std::__invoke(get(), std::forward<_Args>(__args)...);
}
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
inline reference_wrapper<_Tp>
ref(_Tp& __t) noexcept
{ return reference_wrapper<_Tp>(__t); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
inline reference_wrapper<const _Tp>
cref(const _Tp& __t) noexcept
{ return reference_wrapper<const _Tp>(__t); }
#pragma empty_line
template<typename _Tp>
void ref(const _Tp&&) = delete;
#pragma empty_line
template<typename _Tp>
void cref(const _Tp&&) = delete;
#pragma empty_line
#pragma empty_line
template<typename _Tp>
inline reference_wrapper<_Tp>
ref(reference_wrapper<_Tp> __t) noexcept
{ return ref(__t.get()); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
inline reference_wrapper<const _Tp>
cref(reference_wrapper<_Tp> __t) noexcept
{ return cref(__t.get()); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename... _Types>
struct _Pack : integral_constant<size_t, sizeof...(_Types)>
{ };
#pragma empty_line
template<typename _From, typename _To, bool = _From::value == _To::value>
struct _AllConvertible : false_type
{ };
#pragma empty_line
template<typename... _From, typename... _To>
struct _AllConvertible<_Pack<_From...>, _Pack<_To...>, true>
: __and_<is_convertible<_From, _To>...>
{ };
#pragma empty_line
template<typename _Tp1, typename _Tp2>
using _NotSame = __not_<is_same<typename std::decay<_Tp1>::type,
typename std::decay<_Tp2>::type>>;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Res, typename... _ArgTypes>
struct _Maybe_unary_or_binary_function { };
#pragma empty_line
#pragma empty_line
template<typename _Res, typename _T1>
struct _Maybe_unary_or_binary_function<_Res, _T1>
: std::unary_function<_T1, _Res> { };
#pragma empty_line
#pragma empty_line
template<typename _Res, typename _T1, typename _T2>
struct _Maybe_unary_or_binary_function<_Res, _T1, _T2>
: std::binary_function<_T1, _T2, _Res> { };
#pragma empty_line
template<typename _Signature>
struct _Mem_fn_traits;
#pragma empty_line
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)>;
};
#pragma line 578 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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>;
#pragma empty_line
using _Arity = typename _Traits::__arity;
using _Varargs = typename _Traits::__vararg;
#pragma empty_line
template<typename _Func, typename... _BoundArgs>
friend struct _Bind_check_arity;
#pragma empty_line
_MemFunPtr _M_pmf;
#pragma empty_line
public:
#pragma empty_line
using result_type = typename _Traits::__result_type;
#pragma empty_line
explicit constexpr
_Mem_fn_base(_MemFunPtr __pmf) noexcept : _M_pmf(__pmf) { }
#pragma empty_line
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)...); }
};
#pragma empty_line
#pragma empty_line
template<typename _MemObjPtr>
class _Mem_fn_base<_MemObjPtr, false>
{
using _Arity = integral_constant<size_t, 0>;
using _Varargs = false_type;
#pragma empty_line
template<typename _Func, typename... _BoundArgs>
friend struct _Bind_check_arity;
#pragma empty_line
_MemObjPtr _M_pm;
#pragma empty_line
public:
explicit constexpr
_Mem_fn_base(_MemObjPtr __pm) noexcept : _M_pm(__pm) { }
#pragma empty_line
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)); }
};
#pragma empty_line
template<typename _Res, typename _Class>
struct _Mem_fn<_Res _Class::*>
: _Mem_fn_base<_Res _Class::*>
{
using _Mem_fn_base<_Res _Class::*>::_Mem_fn_base;
};
#pragma line 654 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
}
#pragma line 669 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/functional" 3
template<typename _Tp>
struct is_bind_expression
: public false_type { };
#pragma line 680 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/functional" 3
template<typename _Tp>
struct is_placeholder
: public integral_constant<int, 0>
{ };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<int _Num> struct _Placeholder { };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace placeholders
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<int _Num>
struct is_placeholder<_Placeholder<_Num> >
: public integral_constant<int, _Num>
{ };
#pragma empty_line
template<int _Num>
struct is_placeholder<const _Placeholder<_Num> >
: public integral_constant<int, _Num>
{ };
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
#pragma line 770 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
class _Mu<reference_wrapper<_Tp>, false, false>
{
public:
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _CVRef, typename _Tuple>
_Tp&
operator()(_CVRef& __arg, _Tuple&) const volatile
{ return __arg.get(); }
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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>()...))
{
#pragma empty_line
typedef typename _Build_index_tuple<sizeof...(_Args)>::__type
_Indexes;
return this->__call(__arg, __tuple, _Indexes());
}
#pragma empty_line
private:
#pragma empty_line
#pragma empty_line
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))...);
}
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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));
}
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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); }
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct _Maybe_wrap_member_pointer
{
typedef _Tp type;
#pragma empty_line
static constexpr const _Tp&
__do_wrap(const _Tp& __x)
{ return __x; }
#pragma empty_line
static constexpr _Tp&&
__do_wrap(_Tp&& __x)
{ return static_cast<_Tp&&>(__x); }
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename _Class>
struct _Maybe_wrap_member_pointer<_Tp _Class::*>
{
typedef _Mem_fn<_Tp _Class::*> type;
#pragma empty_line
static constexpr type
__do_wrap(_Tp _Class::* __pm)
{ return type(__pm); }
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<>
struct _Maybe_wrap_member_pointer<void>
{
typedef void type;
};
#pragma empty_line
#pragma empty_line
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)); }
#pragma empty_line
#pragma empty_line
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)); }
#pragma empty_line
#pragma empty_line
template<typename _Signature>
struct _Bind;
#pragma empty_line
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;
#pragma empty_line
_Functor _M_f;
tuple<_Bound_args...> _M_bound_args;
#pragma empty_line
#pragma empty_line
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)...);
}
#pragma empty_line
#pragma empty_line
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)...);
}
#pragma empty_line
#pragma empty_line
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)...);
}
#pragma empty_line
#pragma empty_line
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)...);
}
#pragma empty_line
public:
template<typename... _Args>
explicit _Bind(const _Functor& __f, _Args&&... __args)
: _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
{ }
#pragma empty_line
template<typename... _Args>
explicit _Bind(_Functor&& __f, _Args&&... __args)
: _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...)
{ }
#pragma empty_line
_Bind(const _Bind&) = default;
#pragma empty_line
_Bind(_Bind&& __b)
: _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args))
{ }
#pragma empty_line
#pragma empty_line
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());
}
#pragma empty_line
#pragma empty_line
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());
}
#pragma empty_line
#pragma empty_line
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());
}
#pragma empty_line
#pragma empty_line
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());
}
};
#pragma empty_line
#pragma empty_line
template<typename _Result, typename _Signature>
struct _Bind_result;
#pragma empty_line
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;
#pragma empty_line
_Functor _M_f;
tuple<_Bound_args...> _M_bound_args;
#pragma empty_line
#pragma empty_line
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> { };
#pragma empty_line
#pragma empty_line
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)...);
}
#pragma empty_line
#pragma empty_line
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)...);
}
#pragma empty_line
#pragma empty_line
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)...);
}
#pragma empty_line
#pragma empty_line
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)...);
}
#pragma empty_line
#pragma empty_line
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)...);
}
#pragma empty_line
#pragma empty_line
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)...);
}
#pragma empty_line
#pragma empty_line
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)...);
}
#pragma empty_line
#pragma empty_line
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)...);
}
#pragma empty_line
public:
typedef _Result result_type;
#pragma empty_line
template<typename... _Args>
explicit _Bind_result(const _Functor& __f, _Args&&... __args)
: _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
{ }
#pragma empty_line
template<typename... _Args>
explicit _Bind_result(_Functor&& __f, _Args&&... __args)
: _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...)
{ }
#pragma empty_line
_Bind_result(const _Bind_result&) = default;
#pragma empty_line
_Bind_result(_Bind_result&& __b)
: _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args))
{ }
#pragma empty_line
#pragma empty_line
template<typename... _Args>
result_type
operator()(_Args&&... __args)
{
return this->__call<_Result>(
std::forward_as_tuple(std::forward<_Args>(__args)...),
_Bound_indexes());
}
#pragma empty_line
#pragma empty_line
template<typename... _Args>
result_type
operator()(_Args&&... __args) const
{
return this->__call<_Result>(
std::forward_as_tuple(std::forward<_Args>(__args)...),
_Bound_indexes());
}
#pragma empty_line
#pragma empty_line
template<typename... _Args>
result_type
operator()(_Args&&... __args) volatile
{
return this->__call<_Result>(
std::forward_as_tuple(std::forward<_Args>(__args)...),
_Bound_indexes());
}
#pragma empty_line
#pragma empty_line
template<typename... _Args>
result_type
operator()(_Args&&... __args) const volatile
{
return this->__call<_Result>(
std::forward_as_tuple(std::forward<_Args>(__args)...),
_Bound_indexes());
}
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Signature>
struct is_bind_expression<_Bind<_Signature> >
: public true_type { };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Signature>
struct is_bind_expression<const _Bind<_Signature> >
: public true_type { };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Signature>
struct is_bind_expression<volatile _Bind<_Signature> >
: public true_type { };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Signature>
struct is_bind_expression<const volatile _Bind<_Signature>>
: public true_type { };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Result, typename _Signature>
struct is_bind_expression<_Bind_result<_Result, _Signature>>
: public true_type { };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Result, typename _Signature>
struct is_bind_expression<const _Bind_result<_Result, _Signature>>
: public true_type { };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Result, typename _Signature>
struct is_bind_expression<volatile _Bind_result<_Result, _Signature>>
: public true_type { };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Result, typename _Signature>
struct is_bind_expression<const volatile _Bind_result<_Result, _Signature>>
: public true_type { };
#pragma empty_line
template<typename _Func, typename... _BoundArgs>
struct _Bind_check_arity { };
#pragma empty_line
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");
};
#pragma empty_line
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");
};
#pragma empty_line
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");
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename _Tp2 = typename decay<_Tp>::type>
using __is_socketlike = __or_<is_integral<_Tp2>, is_enum<_Tp2>>;
#pragma empty_line
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;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Func, typename... _BoundArgs>
struct _Bind_helper<true, _Func, _BoundArgs...>
{ };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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)...);
}
#pragma empty_line
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;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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)...);
}
#pragma empty_line
template<typename _Signature>
struct _Bind_simple;
#pragma empty_line
template<typename _Callable, typename... _Args>
struct _Bind_simple<_Callable(_Args...)>
{
typedef typename result_of<_Callable(_Args...)>::type result_type;
#pragma empty_line
template<typename _Tp, typename... _Up>
explicit
_Bind_simple(_Tp&& __f, _Up&&... __args)
: _M_bound(std::forward<_Tp>(__f), std::forward<_Up>(__args)...)
{ }
#pragma empty_line
_Bind_simple(const _Bind_simple&) = default;
_Bind_simple(_Bind_simple&&) = default;
#pragma empty_line
result_type
operator()()
{
typedef typename _Build_index_tuple<sizeof...(_Args)>::__type _Indices;
return _M_invoke(_Indices());
}
#pragma empty_line
private:
template<std::size_t... _Indices>
typename result_of<_Callable(_Args...)>::type
_M_invoke(_Index_tuple<_Indices...>)
{
#pragma empty_line
#pragma empty_line
return std::forward<_Callable>(std::get<0>(_M_bound))(
std::forward<_Args>(std::get<_Indices+1>(_M_bound))...);
}
#pragma empty_line
std::tuple<_Callable, _Args...> _M_bound;
};
#pragma empty_line
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;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
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)...);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
class bad_function_call : public std::exception
{
public:
virtual ~bad_function_call() noexcept;
#pragma empty_line
const char* what() const noexcept;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct __is_location_invariant
: is_trivially_copyable<_Tp>::type
{ };
#pragma empty_line
class _Undefined_class;
#pragma empty_line
union _Nocopy_types
{
void* _M_object;
const void* _M_const_object;
void (*_M_function_pointer)();
void (_Undefined_class::*_M_member_pointer)();
};
#pragma empty_line
union _Any_data
{
void* _M_access() { return &_M_pod_data[0]; }
const void* _M_access() const { return &_M_pod_data[0]; }
#pragma empty_line
template<typename _Tp>
_Tp&
_M_access()
{ return *static_cast<_Tp*>(_M_access()); }
#pragma empty_line
template<typename _Tp>
const _Tp&
_M_access() const
{ return *static_cast<const _Tp*>(_M_access()); }
#pragma empty_line
_Nocopy_types _M_unused;
char _M_pod_data[sizeof(_Nocopy_types)];
};
#pragma empty_line
enum _Manager_operation
{
__get_type_info,
__get_functor_ptr,
__clone_functor,
__destroy_functor
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct _Simple_type_wrapper
{
_Simple_type_wrapper(_Tp __value) : __value(__value) { }
#pragma empty_line
_Tp __value;
};
#pragma empty_line
template<typename _Tp>
struct __is_location_invariant<_Simple_type_wrapper<_Tp> >
: __is_location_invariant<_Tp>
{ };
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Functor>
inline _Functor&
__callable_functor(_Functor& __f)
{ return __f; }
#pragma empty_line
template<typename _Member, typename _Class>
inline _Mem_fn<_Member _Class::*>
__callable_functor(_Member _Class::* &__p)
{ return std::mem_fn(__p); }
#pragma empty_line
template<typename _Member, typename _Class>
inline _Mem_fn<_Member _Class::*>
__callable_functor(_Member _Class::* const &__p)
{ return std::mem_fn(__p); }
#pragma empty_line
template<typename _Member, typename _Class>
inline _Mem_fn<_Member _Class::*>
__callable_functor(_Member _Class::* volatile &__p)
{ return std::mem_fn(__p); }
#pragma empty_line
template<typename _Member, typename _Class>
inline _Mem_fn<_Member _Class::*>
__callable_functor(_Member _Class::* const volatile &__p)
{ return std::mem_fn(__p); }
#pragma empty_line
template<typename _Signature>
class function;
#pragma empty_line
#pragma empty_line
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);
#pragma empty_line
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));
#pragma empty_line
typedef integral_constant<bool, __stored_locally> _Local_storage;
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
static void
_M_clone(_Any_data& __dest, const _Any_data& __source, true_type)
{
new (__dest._M_access()) _Functor(__source._M_access<_Functor>());
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
static void
_M_clone(_Any_data& __dest, const _Any_data& __source, false_type)
{
__dest._M_access<_Functor*>() =
new _Functor(*__source._M_access<_Functor*>());
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
static void
_M_destroy(_Any_data& __victim, true_type)
{
__victim._M_access<_Functor>().~_Functor();
}
#pragma empty_line
#pragma empty_line
static void
_M_destroy(_Any_data& __victim, false_type)
{
delete __victim._M_access<_Functor*>();
}
#pragma empty_line
public:
static bool
_M_manager(_Any_data& __dest, const _Any_data& __source,
_Manager_operation __op)
{
switch (__op)
{
#pragma empty_line
case __get_type_info:
__dest._M_access<const type_info*>() = &typeid(_Functor);
break;
#pragma empty_line
case __get_functor_ptr:
__dest._M_access<_Functor*>() = _M_get_pointer(__source);
break;
#pragma empty_line
case __clone_functor:
_M_clone(__dest, __source, _Local_storage());
break;
#pragma empty_line
case __destroy_functor:
_M_destroy(__dest, _Local_storage());
break;
}
return false;
}
#pragma empty_line
static void
_M_init_functor(_Any_data& __functor, _Functor&& __f)
{ _M_init_functor(__functor, std::move(__f), _Local_storage()); }
#pragma empty_line
template<typename _Signature>
static bool
_M_not_empty_function(const function<_Signature>& __f)
{ return static_cast<bool>(__f); }
#pragma empty_line
template<typename _Tp>
static bool
_M_not_empty_function(_Tp* __fp)
{ return __fp != nullptr; }
#pragma empty_line
template<typename _Class, typename _Tp>
static bool
_M_not_empty_function(_Tp _Class::* __mp)
{ return __mp != nullptr; }
#pragma empty_line
template<typename _Tp>
static bool
_M_not_empty_function(const _Tp&)
{ return true; }
#pragma empty_line
private:
static void
_M_init_functor(_Any_data& __functor, _Functor&& __f, true_type)
{ new (__functor._M_access()) _Functor(std::move(__f)); }
#pragma empty_line
static void
_M_init_functor(_Any_data& __functor, _Functor&& __f, false_type)
{ __functor._M_access<_Functor*>() = new _Functor(std::move(__f)); }
};
#pragma empty_line
template<typename _Functor>
class _Ref_manager : public _Base_manager<_Functor*>
{
typedef _Function_base::_Base_manager<_Functor*> _Base;
#pragma empty_line
public:
static bool
_M_manager(_Any_data& __dest, const _Any_data& __source,
_Manager_operation __op)
{
switch (__op)
{
#pragma empty_line
case __get_type_info:
__dest._M_access<const type_info*>() = &typeid(_Functor);
break;
#pragma empty_line
case __get_functor_ptr:
__dest._M_access<_Functor*>() = *_Base::_M_get_pointer(__source);
return is_const<_Functor>::value;
break;
#pragma empty_line
default:
_Base::_M_manager(__dest, __source, __op);
}
return false;
}
#pragma empty_line
static void
_M_init_functor(_Any_data& __functor, reference_wrapper<_Functor> __f)
{
_Base::_M_init_functor(__functor, std::__addressof(__f.get()));
}
};
#pragma empty_line
_Function_base() : _M_manager(nullptr) { }
#pragma empty_line
~_Function_base()
{
if (_M_manager)
_M_manager(_M_functor, _M_functor, __destroy_functor);
}
#pragma empty_line
#pragma empty_line
bool _M_empty() const { return !_M_manager; }
#pragma empty_line
typedef bool (*_Manager_type)(_Any_data&, const _Any_data&,
_Manager_operation);
#pragma empty_line
_Any_data _M_functor;
_Manager_type _M_manager;
};
#pragma empty_line
template<typename _Signature, typename _Functor>
class _Function_handler;
#pragma empty_line
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;
#pragma empty_line
public:
static _Res
_M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
{
return (*_Base::_M_get_pointer(__functor))(
std::forward<_ArgTypes>(__args)...);
}
};
#pragma empty_line
template<typename _Functor, typename... _ArgTypes>
class _Function_handler<void(_ArgTypes...), _Functor>
: public _Function_base::_Base_manager<_Functor>
{
typedef _Function_base::_Base_manager<_Functor> _Base;
#pragma empty_line
public:
static void
_M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
{
(*_Base::_M_get_pointer(__functor))(
std::forward<_ArgTypes>(__args)...);
}
};
#pragma empty_line
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;
#pragma empty_line
public:
static _Res
_M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
{
return std::__callable_functor(**_Base::_M_get_pointer(__functor))(
std::forward<_ArgTypes>(__args)...);
}
};
#pragma empty_line
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;
#pragma empty_line
public:
static void
_M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
{
std::__callable_functor(**_Base::_M_get_pointer(__functor))(
std::forward<_ArgTypes>(__args)...);
}
};
#pragma empty_line
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;
#pragma empty_line
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)...);
}
};
#pragma empty_line
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;
#pragma empty_line
public:
static bool
_M_manager(_Any_data& __dest, const _Any_data& __source,
_Manager_operation __op)
{
switch (__op)
{
#pragma empty_line
case __get_type_info:
__dest._M_access<const type_info*>() = &typeid(_Functor);
break;
#pragma empty_line
case __get_functor_ptr:
__dest._M_access<_Functor*>() =
&_Base::_M_get_pointer(__source)->__value;
break;
#pragma empty_line
default:
_Base::_M_manager(__dest, __source, __op);
}
return false;
}
#pragma empty_line
static void
_M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
{
std::mem_fn(_Base::_M_get_pointer(__functor)->__value)(
std::forward<_ArgTypes>(__args)...);
}
};
#pragma empty_line
template<typename _From, typename _To>
using __check_func_return_type
= __or_<is_void<_To>, is_same<_From, _To>, is_convertible<_From, _To>>;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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...);
#pragma empty_line
template<typename _Func,
typename _Res2 = typename result_of<_Func&(_ArgTypes...)>::type>
struct _Callable : __check_func_return_type<_Res2, _Res> { };
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct _Callable<function, _Tp> : false_type { };
#pragma empty_line
template<typename _Cond, typename _Tp>
using _Requires = typename enable_if<_Cond::value, _Tp>::type;
#pragma empty_line
public:
typedef _Res result_type;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
function() noexcept
: _Function_base() { }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
function(nullptr_t) noexcept
: _Function_base() { }
#pragma line 1888 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/functional" 3
function(const function& __x);
#pragma line 1897 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/functional" 3
function(function&& __x) : _Function_base()
{
__x.swap(*this);
}
#pragma line 1920 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
#pragma line 1937 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/functional" 3
function&
operator=(const function& __x)
{
function(__x).swap(*this);
return *this;
}
#pragma line 1955 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma line 1969 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma line 1997 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma empty_line
#pragma empty_line
template<typename _Functor>
function&
operator=(reference_wrapper<_Functor> __f) noexcept
{
function(__f).swap(*this);
return *this;
}
#pragma line 2023 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
}
#pragma line 2051 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/functional" 3
explicit operator bool() const noexcept
{ return !_M_empty(); }
#pragma line 2064 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/functional" 3
_Res operator()(_ArgTypes... __args) const;
#pragma line 2077 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/functional" 3
const type_info& target_type() const noexcept;
#pragma line 2088 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/functional" 3
template<typename _Functor> _Functor* target() noexcept;
#pragma empty_line
#pragma empty_line
template<typename _Functor> const _Functor* target() const noexcept;
#pragma empty_line
#pragma empty_line
private:
using _Invoker_type = _Res (*)(const _Any_data&, _ArgTypes&&...);
_Invoker_type _M_invoker;
};
#pragma empty_line
#pragma empty_line
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;
}
}
#pragma empty_line
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;
#pragma empty_line
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;
}
}
#pragma empty_line
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)...);
}
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma line 2200 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
#pragma empty_line
template<typename _Res, typename... _Args>
inline bool
operator==(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
{ return !static_cast<bool>(__f); }
#pragma line 2218 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
#pragma empty_line
template<typename _Res, typename... _Args>
inline bool
operator!=(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
{ return static_cast<bool>(__f); }
#pragma line 2236 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
#pragma empty_line
}
#pragma line 224 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h" 2
#pragma line 292 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h"
#pragma empty_line
#pragma line 292 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h"
class half;
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace detail
{
#pragma line 311 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; };
#pragma empty_line
#pragma empty_line
template<bool> struct bool_type {};
typedef bool_type<true> true_type;
typedef bool_type<false> false_type;
#pragma empty_line
#pragma empty_line
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 {};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef std::uint_least16_t uint16;
#pragma empty_line
#pragma empty_line
typedef std::uint_least32_t uint32;
#pragma empty_line
#pragma empty_line
typedef std::int_fast32_t int17;
#pragma line 350 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h"
struct binary_t {};
#pragma empty_line
#pragma empty_line
constexpr binary_t binary = binary_t();
#pragma empty_line
#pragma empty_line
#pragma empty_line
struct expr
{
#pragma empty_line
#pragma empty_line
explicit constexpr expr(float f) : value_(f) {}
#pragma empty_line
#pragma empty_line
#pragma empty_line
constexpr operator float() const { return value_; }
#pragma empty_line
private:
#pragma empty_line
float value_;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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; };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename T,typename U> struct result : enable<expr,T,U> {};
template<> struct result<half,half> { typedef half type; };
#pragma line 434 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h"
template<typename T> bool builtin_isinf(T arg)
{
#pragma empty_line
return std::isinf(arg);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename T> bool builtin_isnan(T arg)
{
#pragma empty_line
return std::isnan(arg);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename T> bool builtin_signbit(T arg)
{
#pragma empty_line
return std::signbit(arg);
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 484 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h"
template<std::float_round_style R> uint16 float2half_impl(float value, true_type)
{
#pragma empty_line
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'");
#pragma empty_line
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)
#pragma empty_line
& (((((static_cast<uint32>(1)<<(shift_table[bits>>23]-1))-1)&bits)!=0)|hbits)
#pragma empty_line
;
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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));
#pragma empty_line
hbits += (diff>0.5f) | ((diff==0.5f)&hbits);
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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)>());
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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
#pragma empty_line
& (((((1<<(exp-26))-1)&value)!=0)|bits)
#pragma empty_line
;
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline float half2float_impl(uint16 value, true_type)
{
#pragma empty_line
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'");
#pragma empty_line
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];
#pragma empty_line
#pragma empty_line
float out;
std::memcpy(&out, &bits, sizeof(float));
return out;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline float half2float(uint16 value)
{
return half2float_impl(value, bool_type<std::numeric_limits<float>::is_iec559&&sizeof(uint32)==sizeof(float)>());
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
return static_cast<T>((value&0x8000) ? -m : m);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<std::float_round_style R,typename T> T half2int(uint16 value) { return half2int_impl<R,1,T>(value); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename T> T half2int_up(uint16 value) { return half2int_impl<std::round_to_nearest,0,T>(value); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<std::float_round_style R> uint16 round_half(uint16 value) { return round_half_impl<R,1>(value); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline uint16 round_half_up(uint16 value) { return round_half_impl<std::round_to_nearest,0>(value); }
#pragma empty_line
#pragma empty_line
struct functions;
template<typename> struct unary_specialized;
template<typename,typename> struct binary_specialized;
template<typename,typename,std::float_round_style> struct half_caster;
}
#pragma line 979 "/home/justin/jhai/Xilinx/Vivado/2018.3/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>;
#pragma empty_line
friend struct std::hash<half>;
#pragma empty_line
#pragma empty_line
public:
#pragma empty_line
#pragma empty_line
#pragma empty_line
constexpr half() : data_() {}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
half(detail::expr rhs) : data_(detail::float2half<round_style>(rhs)) {
#pragma empty_line
xip_fpo_half_set_flt(rhs);
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
half(float rhs) : data_(detail::float2half<round_style>(rhs)) {
#pragma empty_line
xip_fpo_half_set_flt(rhs);
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
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();
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
operator float() const {
#pragma empty_line
#pragma empty_line
#pragma empty_line
return xip_fpo_half_get_flt();
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
half& operator=(detail::expr rhs) { return *this = static_cast<float>(rhs); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename T> typename detail::enable<half&,T>::type operator+=(T rhs) { return *this = *this + rhs; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename T> typename detail::enable<half&,T>::type operator-=(T rhs) { return *this = *this - rhs; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename T> typename detail::enable<half&,T>::type operator*=(T rhs) { return *this = *this * rhs; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename T> typename detail::enable<half&,T>::type operator/=(T rhs) { return *this = *this / rhs; }
#pragma line 1097 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h"
half& operator++() { return *this += 1.0f; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
half& operator--() { return *this -= 1.0f; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
half operator++(int) { half out(*this); ++*this; return out; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
half operator--(int) { half out(*this); --*this; return out; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
detail::uint16 get_bits() { return data_; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
void set_bits(detail::uint16 bits) { data_ = bits; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
}
}
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
private:
#pragma empty_line
static const std::float_round_style round_style = (std::float_round_style)(1);
#pragma empty_line
#pragma empty_line
#pragma empty_line
constexpr half(detail::binary_t, detail::uint16 bits) : data_(bits) {}
#pragma empty_line
#pragma empty_line
detail::uint16 data_;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma line 1248 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h"
namespace literal
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline half operator "" _h(long double value) { return half(static_cast<float>(value)); }
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace detail
{
#pragma empty_line
struct functions
{
#pragma line 1273 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 1289 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 1305 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 1321 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename charT,typename traits> static std::basic_ostream<charT,traits>& write(std::basic_ostream<charT,traits> &out, float arg) { return out << arg; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static expr fmod(float x, float y) { return expr(std::fmod(x, y)); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static expr remainder(float x, float y)
{
#pragma empty_line
return expr(std::remainder(x, y));
#pragma line 1381 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h"
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static expr remquo(float x, float y, int *quo)
{
#pragma empty_line
return expr(std::remquo(x, y, quo));
#pragma line 1428 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h"
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static expr fdim(float x, float y)
{
#pragma empty_line
return expr(std::fdim(x, y));
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
static expr maxmag(float x, float y)
{
if (fabs(y)>fabs(x)) return expr(y);
else return expr(x);
}
#pragma empty_line
static expr minmag(float x, float y)
{
if (fabs(y)<fabs(x)) return expr(y);
else return expr(x);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static expr fma(float x, float y, float z)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
return expr(x*y+z);
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
static half nanh(const char*) { return half(binary, 0x7FFF); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static expr exp(float arg) { return expr(std::exp(arg)); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static expr expm1(float arg)
{
#pragma empty_line
return expr(std::expm1(arg));
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static expr exp2(float arg)
{
#pragma empty_line
return expr(std::exp2(arg));
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static expr log(float arg) { return expr(std::log(arg)); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static expr log10(float arg) { return expr(std::log10(arg)); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static expr log1p(float arg)
{
#pragma empty_line
return expr(std::log1p(arg));
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static expr log2(float arg)
{
#pragma empty_line
return expr(std::log2(arg));
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
static expr logb(float arg)
{
#pragma empty_line
return expr(std::logb(arg));
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static expr sqrt(float arg) { return expr(std::sqrt(arg)); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static expr cbrt(float arg)
{
#pragma empty_line
return expr(std::cbrt(arg));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static expr hypot(float x, float y)
{
#pragma empty_line
return expr(std::hypot(x, y));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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)))); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static expr sin(float arg) { return expr(std::sin(arg)); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static expr cos(float arg) { return expr(std::cos(arg)); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static expr tan(float arg) { return expr(std::tan(arg)); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static expr asin(float arg) { return expr(std::asin(arg)); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static expr acos(float arg) { return expr(std::acos(arg)); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static expr atan(float arg) { return expr(std::atan(arg)); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static expr atan2(float x, float y) { return expr(std::atan2(x, y)); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static expr sinh(float arg) { return expr(std::sinh(arg)); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static expr cosh(float arg) { return expr(std::cosh(arg)); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static expr tanh(float arg) { return expr(std::tanh(arg)); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static expr asinh(float arg)
{
#pragma empty_line
return expr(std::asinh(arg));
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static expr acosh(float arg)
{
#pragma empty_line
return expr(std::acosh(arg));
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static expr atanh(float arg)
{
#pragma empty_line
return expr(std::atanh(arg));
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static expr erf(float arg)
{
#pragma empty_line
return expr(std::erf(arg));
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static expr erfc(float arg)
{
#pragma empty_line
return expr(std::erfc(arg));
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static expr lgamma(float arg)
{
#pragma empty_line
return expr(std::lgamma(arg));
#pragma line 1721 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h"
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static expr tgamma(float arg)
{
#pragma empty_line
return expr(std::tgamma(arg));
#pragma line 1748 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h"
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static half floor(half arg) { return half(binary, round_half<std::round_toward_neg_infinity>(arg.data_)); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static half ceil(half arg) { return half(binary, round_half<std::round_toward_infinity>(arg.data_)); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static half trunc(half arg) { return half(binary, round_half<std::round_toward_zero>(arg.data_)); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static half round(half arg) { return half(binary, round_half_up(arg.data_)); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static long lround(half arg) { return detail::half2int_up<long>(arg.data_); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static half rint(half arg) { return half(binary, round_half<half::round_style>(arg.data_)); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static long lrint(half arg) { return detail::half2int<half::round_style,long>(arg.data_); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static long long llround(half arg) { return detail::half2int_up<long long>(arg.data_); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static long long llrint(half arg) { return detail::half2int<half::round_style,long long>(arg.data_); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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)));
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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)));
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
m -= (m>>(1-e)) & 1;
#pragma empty_line
}
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);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static int ilogb(half arg)
{
int exp = arg.data_ & 0x7FFF;
if(!exp)
return
#pragma line 1894 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h" 3 4
(-2147483647 - 1)
#pragma line 1894 "/home/justin/jhai/Xilinx/Vivado/2018.3/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
#pragma line 1902 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h" 3 4
(-2147483647 - 1)
#pragma line 1902 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h"
;
return 0x7fffffff;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static half copysign(half x, half y) { return half(binary, x.data_^((x.data_^y.data_)&0x8000)); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static int fpclassify(half arg)
{
unsigned int abs = arg.data_ & 0x7FFF;
if(abs > 0x7C00)
return
#pragma line 1953 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h" 3 4
0
#pragma line 1953 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h"
;
if(abs == 0x7C00)
return
#pragma line 1955 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h" 3 4
1
#pragma line 1955 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h"
;
if(abs > 0x3FF)
return
#pragma line 1957 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h" 3 4
4
#pragma line 1957 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h"
;
return abs ?
#pragma line 1958 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h" 3 4
3
#pragma line 1958 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h"
:
#pragma line 1958 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h" 3 4
2
#pragma line 1958 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h"
;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static bool isfinite(half arg) { return (arg.data_&0x7C00) != 0x7C00; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static bool isinf(half arg) { return (arg.data_&0x7FFF) == 0x7C00; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static bool isnan(half arg) { return (arg.data_&0x7FFF) > 0x7C00; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static bool isnormal(half arg) { return ((arg.data_&0x7C00)!=0) & ((arg.data_&0x7C00)!=0x7C00); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static bool signbit(half arg) { return (arg.data_&0x8000) != 0; }
#pragma line 1999 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 2015 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 2032 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 2049 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 2066 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 2083 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static bool islessgreater(half x, half y)
{
if(isnan(x) || isnan(y))
return false;
#pragma empty_line
#pragma empty_line
#pragma empty_line
return isless(x, y) || isgreater(x, y);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static bool isunordered(half x, half y) { return isnan(x) || isnan(y); }
#pragma empty_line
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;
}
#pragma empty_line
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);
}
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename T> struct unary_specialized
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
static constexpr half negate(half arg) { return half(binary, arg.data_^0x8000); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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)); }
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename T,typename U> struct binary_specialized
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static expr fmin(float x, float y)
{
#pragma empty_line
return expr(std::fmin(x, y));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static expr fmax(float x, float y)
{
#pragma empty_line
return expr(std::fmax(x, y));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
};
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;
}
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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>
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef half type;
static half cast(U arg) { return cast_impl(arg, is_float<U>()); };
#pragma empty_line
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>
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef T type;
template<typename U> static T cast(U arg) { return cast_impl(arg, is_float<T>()); }
#pragma empty_line
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> {};
#pragma line 2269 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename T,typename U> typename enable<bool,T,U>::type operator!=(T x, U y) { return functions::isnotequal(x, y); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename T,typename U> typename enable<bool,T,U>::type operator<(T x, U y) { return functions::isless(x, y); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename T,typename U> typename enable<bool,T,U>::type operator>(T x, U y) { return functions::isgreater(x, y); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename T,typename U> typename enable<bool,T,U>::type operator<=(T x, U y) { return functions::islessequal(x, y); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename T,typename U> typename enable<bool,T,U>::type operator>=(T x, U y) { return functions::isgreaterequal(x, y); }
#pragma line 2317 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 2327 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 2337 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 2347 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename T> constexpr typename enable<T,T>::type operator+(T arg) { return arg; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename T> constexpr typename enable<T,T>::type operator-(T arg) { return unary_specialized<T>::negate(arg); }
#pragma line 2368 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename charT,typename traits> std::basic_istream<charT,traits>&
operator>>(std::basic_istream<charT,traits> &in, half &arg) { return functions::read(in, arg); }
#pragma line 2386 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline half fabs(half arg) { return unary_specialized<half>::fabs(arg); }
inline expr fabs(expr arg) { return unary_specialized<expr>::fabs(arg); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
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); }
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline half nanh(const char *arg) { return functions::nanh(arg); }
#pragma line 2504 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h"
inline expr exp(half arg) { return functions::exp(arg); }
inline expr exp(expr arg) { return functions::exp(arg); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline expr expm1(half arg) { return functions::expm1(arg); }
inline expr expm1(expr arg) { return functions::expm1(arg); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline expr exp2(half arg) { return functions::exp2(arg); }
inline expr exp2(expr arg) { return functions::exp2(arg); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline expr log(half arg) { return functions::log(arg); }
inline expr log(expr arg) { return functions::log(arg); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline expr log10(half arg) { return functions::log10(arg); }
inline expr log10(expr arg) { return functions::log10(arg); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline expr log1p(half arg) { return functions::log1p(arg); }
inline expr log1p(expr arg) { return functions::log1p(arg); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline expr log2(half arg) { return functions::log2(arg); }
inline expr log2(expr arg) { return functions::log2(arg); }
#pragma line 2560 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h"
inline half sqrt(half arg) { return math_function_1arg(xip_fpo_sqrt, arg); }
#pragma empty_line
inline expr sqrt(expr arg) { return functions::sqrt(arg); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline expr cbrt(half arg) { return functions::cbrt(arg); }
inline expr cbrt(expr arg) { return functions::cbrt(arg); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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); }
#pragma line 2605 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h"
inline expr sin(half arg) { return functions::sin(arg); }
inline expr sin(expr arg) { return functions::sin(arg); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline expr cos(half arg) { return functions::cos(arg); }
inline expr cos(expr arg) { return functions::cos(arg); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline expr tan(half arg) { return functions::tan(arg); }
inline expr tan(expr arg) { return functions::tan(arg); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline expr asin(half arg) { return functions::asin(arg); }
inline expr asin(expr arg) { return functions::asin(arg); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline expr acos(half arg) { return functions::acos(arg); }
inline expr acos(expr arg) { return functions::acos(arg); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline expr atan(half arg) { return functions::atan(arg); }
inline expr atan(expr arg) { return functions::atan(arg); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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); }
#pragma line 2661 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h"
inline expr sinh(half arg) { return functions::sinh(arg); }
inline expr sinh(expr arg) { return functions::sinh(arg); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline expr cosh(half arg) { return functions::cosh(arg); }
inline expr cosh(expr arg) { return functions::cosh(arg); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline expr tanh(half arg) { return functions::tanh(arg); }
inline expr tanh(expr arg) { return functions::tanh(arg); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline expr asinh(half arg) { return functions::asinh(arg); }
inline expr asinh(expr arg) { return functions::asinh(arg); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline expr acosh(half arg) { return functions::acosh(arg); }
inline expr acosh(expr arg) { return functions::acosh(arg); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline expr atanh(half arg) { return functions::atanh(arg); }
inline expr atanh(expr arg) { return functions::atanh(arg); }
#pragma line 2707 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h"
inline expr erf(half arg) { return functions::erf(arg); }
inline expr erf(expr arg) { return functions::erf(arg); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline expr erfc(half arg) { return functions::erfc(arg); }
inline expr erfc(expr arg) { return functions::erfc(arg); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline expr tgamma(half arg) { return functions::tgamma(arg); }
inline expr tgamma(expr arg) { return functions::tgamma(arg); }
#pragma line 2741 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h"
inline half ceil(half arg) { return functions::ceil(arg); }
inline half ceil(expr arg) { return functions::ceil(arg); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline half floor(half arg) { return functions::floor(arg); }
inline half floor(expr arg) { return functions::floor(arg); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline half trunc(half arg) { return functions::trunc(arg); }
inline half trunc(expr arg) { return functions::trunc(arg); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline half round(half arg) { return functions::round(arg); }
inline half round(expr arg) { return functions::round(arg); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline long lround(half arg) { return functions::lround(arg); }
inline long lround(expr arg) { return functions::lround(arg); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline half nearbyint(half arg) { return functions::rint(arg); }
inline half nearbyint(expr arg) { return functions::rint(arg); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline half rint(half arg) { return functions::rint(arg); }
inline half rint(expr arg) { return functions::rint(arg); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline long lrint(half arg) { return functions::lrint(arg); }
inline long lrint(expr arg) { return functions::lrint(arg); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline long long llround(half arg) { return functions::llround(arg); }
inline long long llround(expr arg) { return functions::llround(arg); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline long long llrint(half arg) { return functions::llrint(arg); }
inline long long llrint(expr arg) { return functions::llrint(arg); }
#pragma line 2817 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline half ldexp(half arg, int exp) { return functions::scalbln(arg, exp); }
inline half ldexp(expr arg, int exp) { return functions::scalbln(arg, exp); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline half modf(half arg, half *iptr) { return functions::modf(arg, iptr); }
inline half modf(expr arg, half *iptr) { return functions::modf(arg, iptr); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline half scalbn(half arg, int exp) { return functions::scalbln(arg, exp); }
inline half scalbn(expr arg, int exp) { return functions::scalbln(arg, exp); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline half scalbln(half arg, long exp) { return functions::scalbln(arg, exp); }
inline half scalbln(expr arg, long exp) { return functions::scalbln(arg, exp); }
#pragma line 2859 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h"
inline int ilogb(half arg) { return functions::ilogb(arg); }
inline int ilogb(expr arg) { return functions::ilogb(arg); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline half logb(half arg) { return functions::logb(arg); }
inline half logb(expr arg) { return functions::logb(arg); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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); }
#pragma line 2910 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h"
inline int fpclassify(half arg) { return functions::fpclassify(arg); }
inline int fpclassify(expr arg) { return functions::fpclassify(arg); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline bool isfinite(half arg) { return functions::isfinite(arg); }
inline bool isfinite(expr arg) { return functions::isfinite(arg); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline bool isinf(half arg) { return functions::isinf(arg); }
inline bool isinf(expr arg) { return functions::isinf(arg); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline bool isnan(half arg) { return functions::isnan(arg); }
inline bool isnan(expr arg) { return functions::isnan(arg); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline bool isnormal(half arg) { return functions::isnormal(arg); }
inline bool isnormal(expr arg) { return functions::isnormal(arg); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline bool signbit(half arg) { return functions::signbit(arg); }
inline bool signbit(expr arg) { return functions::signbit(arg); }
#pragma line 2963 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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); }
#pragma line 3040 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 3057 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
}
#pragma empty_line
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>>;
#pragma line 3135 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
using detail::half_cast;
#pragma empty_line
#pragma empty_line
namespace std
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<> struct numeric_limits<half> : public numeric_limits<float>
{
public:
#pragma empty_line
static constexpr bool is_signed = true;
#pragma empty_line
#pragma empty_line
static constexpr bool is_exact = false;
#pragma empty_line
#pragma empty_line
static constexpr bool is_modulo = false;
#pragma empty_line
#pragma empty_line
static constexpr bool is_iec559 = true;
#pragma empty_line
#pragma empty_line
static constexpr bool has_infinity = true;
#pragma empty_line
#pragma empty_line
static constexpr bool has_quiet_NaN = true;
#pragma empty_line
#pragma empty_line
static constexpr float_denorm_style has_denorm = denorm_present;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static constexpr float_round_style round_style = (std::numeric_limits<float>::round_style==
half::round_style) ? half::round_style : round_indeterminate;
#pragma empty_line
#pragma empty_line
static constexpr int digits = 11;
#pragma empty_line
#pragma empty_line
static constexpr int digits10 = 3;
#pragma empty_line
#pragma empty_line
static constexpr int max_digits10 = 5;
#pragma empty_line
#pragma empty_line
static constexpr int radix = 2;
#pragma empty_line
#pragma empty_line
static constexpr int min_exponent = -13;
#pragma empty_line
#pragma empty_line
static constexpr int min_exponent10 = -4;
#pragma empty_line
#pragma empty_line
static constexpr int max_exponent = 16;
#pragma empty_line
#pragma empty_line
static constexpr int max_exponent10 = 4;
#pragma empty_line
#pragma empty_line
static constexpr half min() noexcept { return half(detail::binary, 0x0400); }
#pragma empty_line
#pragma empty_line
static constexpr half lowest() noexcept { return half(detail::binary, 0xFBFF); }
#pragma empty_line
#pragma empty_line
static constexpr half max() noexcept { return half(detail::binary, 0x7BFF); }
#pragma empty_line
#pragma empty_line
static constexpr half epsilon() noexcept { return half(detail::binary, 0x1400); }
#pragma empty_line
#pragma empty_line
static constexpr half round_error() noexcept
{ return half(detail::binary, (round_style==std::round_to_nearest) ? 0x3800 : 0x3C00); }
#pragma empty_line
#pragma empty_line
static constexpr half infinity() noexcept { return half(detail::binary, 0x7C00); }
#pragma empty_line
#pragma empty_line
static constexpr half quiet_NaN() noexcept { return half(detail::binary, 0x7FFF); }
#pragma empty_line
#pragma empty_line
static constexpr half signaling_NaN() noexcept { return half(detail::binary, 0x7DFF); }
#pragma empty_line
#pragma empty_line
static constexpr half denorm_min() noexcept { return half(detail::binary, 0x0001); }
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<> struct hash<half>
{
#pragma empty_line
typedef half argument_type;
#pragma empty_line
#pragma empty_line
typedef size_t result_type;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
result_type operator()(argument_type arg) const
{ return hash<detail::uint16>()(static_cast<unsigned int>(arg.data_)&-(arg.data_!=0x8000)); }
};
#pragma empty_line
}
#pragma line 3274 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/hls_half.h"
extern half half_nan(const char *tagp);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern half half_atan(half t);
extern half half_atan2(half y, half x);
extern half half_copysign(half x, half y);
#pragma empty_line
extern half half_fabs(half x);
#pragma empty_line
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);
#pragma empty_line
extern half half_fmin(half x, half y);
#pragma empty_line
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);
#pragma empty_line
extern half half_ceil(half x);
#pragma empty_line
extern half half_trunc(half x);
#pragma empty_line
extern half half_round(half x);
#pragma empty_line
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);
#pragma empty_line
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);
#pragma line 91 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 2
#pragma line 101 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
namespace AESL_std {
template <class DataType>
DataType inline min(DataType a, DataType b) {
return (a >= b) ? b : a;
}
#pragma empty_line
template <class DataType>
DataType inline max(DataType a, DataType b) {
return (a >= b) ? a : b;
}
}
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/math.h" 1 3
#pragma line 115 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 2
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cassert" 1 3
#pragma line 41 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cassert" 3
#pragma empty_line
#pragma line 42 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cassert" 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/assert.h" 1 3 4
#pragma line 44 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cassert" 2 3
#pragma line 117 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 2
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 1 3
#pragma line 39 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 3
#pragma empty_line
#pragma line 40 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 3
#pragma line 118 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 2
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstring" 1 3
#pragma line 39 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstring" 3
#pragma empty_line
#pragma line 40 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstring" 3
#pragma line 119 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 2
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iomanip" 1 3
#pragma line 36 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iomanip" 3
#pragma empty_line
#pragma line 37 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iomanip" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/locale" 1 3
#pragma line 36 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/locale" 3
#pragma empty_line
#pragma line 37 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/locale" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 1 3
#pragma line 37 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
#pragma empty_line
#pragma line 38 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ctime" 1 3
#pragma line 39 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ctime" 3
#pragma empty_line
#pragma line 40 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ctime" 3
#pragma line 58 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ctime" 3
#pragma empty_line
#pragma line 58 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/ctime" 3
namespace std
{
using ::clock_t;
using ::time_t;
using ::tm;
#pragma empty_line
using ::clock;
using ::difftime;
using ::mktime;
using ::time;
using ::asctime;
using ::ctime;
using ::gmtime;
using ::localtime;
using ::strftime;
}
#pragma line 40 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 2 3
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma line 52 "/home/justin/jhai/Xilinx/Vivado/2018.3/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 };
};
#pragma empty_line
template<typename _CharT>
struct __timepunct_cache : public locale::facet
{
#pragma empty_line
static const _CharT* _S_timezones[14];
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
bool _M_allocated;
#pragma empty_line
__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)
{ }
#pragma empty_line
~__timepunct_cache();
#pragma empty_line
private:
__timepunct_cache&
operator=(const __timepunct_cache&);
#pragma empty_line
explicit
__timepunct_cache(const __timepunct_cache&);
};
#pragma empty_line
template<typename _CharT>
__timepunct_cache<_CharT>::~__timepunct_cache()
{
if (_M_allocated)
{
#pragma empty_line
}
}
#pragma empty_line
#pragma empty_line
template<>
const char*
__timepunct_cache<char>::_S_timezones[14];
#pragma empty_line
#pragma empty_line
template<>
const wchar_t*
__timepunct_cache<wchar_t>::_S_timezones[14];
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _CharT>
const _CharT* __timepunct_cache<_CharT>::_S_timezones[14];
#pragma empty_line
template<typename _CharT>
class __timepunct : public locale::facet
{
public:
#pragma empty_line
typedef _CharT __char_type;
typedef __timepunct_cache<_CharT> __cache_type;
#pragma empty_line
protected:
__cache_type* _M_data;
__c_locale _M_c_locale_timepunct;
const char* _M_name_timepunct;
#pragma empty_line
public:
#pragma empty_line
static locale::id id;
#pragma empty_line
explicit
__timepunct(size_t __refs = 0);
#pragma empty_line
explicit
__timepunct(__cache_type* __cache, size_t __refs = 0);
#pragma line 206 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
#pragma empty_line
#pragma empty_line
#pragma empty_line
void
_M_put(_CharT* __s, size_t __maxlen, const _CharT* __format,
const tm* __tm) const throw ();
#pragma empty_line
void
_M_date_formats(const _CharT** __date) const
{
#pragma empty_line
__date[0] = _M_data->_M_date_format;
__date[1] = _M_data->_M_date_era_format;
}
#pragma empty_line
void
_M_time_formats(const _CharT** __time) const
{
#pragma empty_line
__time[0] = _M_data->_M_time_format;
__time[1] = _M_data->_M_time_era_format;
}
#pragma empty_line
void
_M_date_time_formats(const _CharT** __dt) const
{
#pragma empty_line
__dt[0] = _M_data->_M_date_time_format;
__dt[1] = _M_data->_M_date_time_era_format;
}
#pragma empty_line
void
_M_am_pm_format(const _CharT* __ampm) const
{ __ampm = _M_data->_M_am_pm_format; }
#pragma empty_line
void
_M_am_pm(const _CharT** __ampm) const
{
__ampm[0] = _M_data->_M_am;
__ampm[1] = _M_data->_M_pm;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
protected:
virtual
~__timepunct();
#pragma empty_line
#pragma empty_line
void
_M_initialize_timepunct(__c_locale __cloc = 0);
};
#pragma empty_line
template<typename _CharT>
locale::id __timepunct<_CharT>::id;
#pragma empty_line
#pragma empty_line
template<>
void
__timepunct<char>::_M_initialize_timepunct(__c_locale __cloc);
#pragma empty_line
template<>
void
__timepunct<char>::_M_put(char*, size_t, const char*, const tm*) const throw ();
#pragma empty_line
#pragma empty_line
template<>
void
__timepunct<wchar_t>::_M_initialize_timepunct(__c_locale __cloc);
#pragma empty_line
template<>
void
__timepunct<wchar_t>::_M_put(wchar_t*, size_t, const wchar_t*,
const tm*) const throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/time_members.h" 1 3
#pragma line 37 "/home/justin/jhai/Xilinx/Vivado/2018.3/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")))
{
#pragma empty_line
#pragma empty_line
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(); }
#pragma empty_line
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(); }
#pragma empty_line
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();
#pragma empty_line
try
{ _M_initialize_timepunct(__cloc); }
catch(...)
{
if (_M_name_timepunct != _S_get_c_name())
delete [] _M_name_timepunct;
throw;
}
}
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
}
#pragma line 345 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 2 3
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
namespace __cxx11 {
#pragma line 365 "/home/justin/jhai/Xilinx/Vivado/2018.3/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:
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef _CharT char_type;
typedef _InIter iter_type;
#pragma empty_line
#pragma empty_line
#pragma empty_line
static locale::id id;
#pragma line 386 "/home/justin/jhai/Xilinx/Vivado/2018.3/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) { }
#pragma line 403 "/home/justin/jhai/Xilinx/Vivado/2018.3/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(); }
#pragma line 427 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 452 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 480 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 509 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 535 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 556 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
}
#pragma line 583 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
#pragma empty_line
protected:
#pragma empty_line
virtual
~time_get() { }
#pragma line 603 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
virtual dateorder
do_date_order() const;
#pragma line 621 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 640 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 659 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 678 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 697 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 720 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
virtual
#pragma empty_line
iter_type
do_get(iter_type __s, iter_type __end, ios_base& __f,
ios_base::iostate& __err, tm* __tm,
char __format, char __modifier) const;
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
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;
};
#pragma empty_line
template<typename _CharT, typename _InIter>
locale::id time_get<_CharT, _InIter>::id;
#pragma empty_line
#pragma empty_line
template<typename _CharT, typename _InIter>
class time_get_byname : public time_get<_CharT, _InIter>
{
public:
#pragma empty_line
typedef _CharT char_type;
typedef _InIter iter_type;
#pragma empty_line
explicit
time_get_byname(const char*, size_t __refs = 0)
: time_get<_CharT, _InIter>(__refs) { }
#pragma empty_line
#pragma empty_line
explicit
time_get_byname(const string& __s, size_t __refs = 0)
: time_get_byname(__s.c_str(), __refs) { }
#pragma empty_line
#pragma empty_line
protected:
virtual
~time_get_byname() { }
};
#pragma empty_line
}
#pragma line 794 "/home/justin/jhai/Xilinx/Vivado/2018.3/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:
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef _CharT char_type;
typedef _OutIter iter_type;
#pragma empty_line
#pragma empty_line
#pragma empty_line
static locale::id id;
#pragma line 815 "/home/justin/jhai/Xilinx/Vivado/2018.3/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) { }
#pragma line 834 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 854 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
protected:
#pragma empty_line
virtual
~time_put()
{ }
#pragma line 881 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
};
#pragma empty_line
template<typename _CharT, typename _OutIter>
locale::id time_put<_CharT, _OutIter>::id;
#pragma empty_line
#pragma empty_line
template<typename _CharT, typename _OutIter>
class time_put_byname : public time_put<_CharT, _OutIter>
{
public:
#pragma empty_line
typedef _CharT char_type;
typedef _OutIter iter_type;
#pragma empty_line
explicit
time_put_byname(const char*, size_t __refs = 0)
: time_put<_CharT, _OutIter>(__refs)
{ };
#pragma empty_line
#pragma empty_line
explicit
time_put_byname(const string& __s, size_t __refs = 0)
: time_put_byname(__s.c_str(), __refs) { }
#pragma empty_line
#pragma empty_line
protected:
virtual
~time_put_byname() { }
};
#pragma line 926 "/home/justin/jhai/Xilinx/Vivado/2018.3/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]; };
#pragma empty_line
static const pattern _S_default_pattern;
#pragma empty_line
enum
{
_S_minus,
_S_zero,
_S_end = 11
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
static const char* _S_atoms;
#pragma empty_line
#pragma empty_line
#pragma empty_line
__attribute__ ((__const__)) static pattern
_S_construct_pattern(char __precedes, char __space, char __posn) throw ();
};
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
_CharT _M_atoms[money_base::_S_end];
#pragma empty_line
bool _M_allocated;
#pragma empty_line
__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)
{ }
#pragma empty_line
~__moneypunct_cache();
#pragma empty_line
void
_M_cache(const locale& __loc);
#pragma empty_line
private:
__moneypunct_cache&
operator=(const __moneypunct_cache&);
#pragma empty_line
explicit
__moneypunct_cache(const __moneypunct_cache&);
};
#pragma empty_line
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;
}
}
#pragma empty_line
namespace __cxx11 {
#pragma line 1021 "/home/justin/jhai/Xilinx/Vivado/2018.3/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:
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;
#pragma empty_line
typedef __moneypunct_cache<_CharT, _Intl> __cache_type;
#pragma empty_line
private:
__cache_type* _M_data;
#pragma empty_line
public:
#pragma empty_line
#pragma empty_line
static const bool intl = _Intl;
#pragma empty_line
static locale::id id;
#pragma line 1050 "/home/justin/jhai/Xilinx/Vivado/2018.3/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(); }
#pragma line 1063 "/home/justin/jhai/Xilinx/Vivado/2018.3/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(); }
#pragma line 1078 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 1092 "/home/justin/jhai/Xilinx/Vivado/2018.3/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(); }
#pragma line 1105 "/home/justin/jhai/Xilinx/Vivado/2018.3/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(); }
#pragma line 1135 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
string
grouping() const
{ return this->do_grouping(); }
#pragma line 1148 "/home/justin/jhai/Xilinx/Vivado/2018.3/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(); }
#pragma line 1165 "/home/justin/jhai/Xilinx/Vivado/2018.3/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(); }
#pragma line 1182 "/home/justin/jhai/Xilinx/Vivado/2018.3/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(); }
#pragma line 1198 "/home/justin/jhai/Xilinx/Vivado/2018.3/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(); }
#pragma line 1234 "/home/justin/jhai/Xilinx/Vivado/2018.3/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(); }
#pragma empty_line
pattern
neg_format() const
{ return this->do_neg_format(); }
#pragma empty_line
#pragma empty_line
protected:
#pragma empty_line
virtual
~moneypunct();
#pragma line 1256 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma line 1268 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma line 1281 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma line 1294 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma line 1307 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma line 1320 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma line 1334 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma line 1348 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma line 1362 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma empty_line
#pragma empty_line
void
_M_initialize_moneypunct(__c_locale __cloc = 0,
const char* __name = 0);
};
#pragma empty_line
template<typename _CharT, bool _Intl>
locale::id moneypunct<_CharT, _Intl>::id;
#pragma empty_line
template<typename _CharT, bool _Intl>
const bool moneypunct<_CharT, _Intl>::intl;
#pragma empty_line
template<>
moneypunct<char, true>::~moneypunct();
#pragma empty_line
template<>
moneypunct<char, false>::~moneypunct();
#pragma empty_line
template<>
void
moneypunct<char, true>::_M_initialize_moneypunct(__c_locale, const char*);
#pragma empty_line
template<>
void
moneypunct<char, false>::_M_initialize_moneypunct(__c_locale, const char*);
#pragma empty_line
#pragma empty_line
template<>
moneypunct<wchar_t, true>::~moneypunct();
#pragma empty_line
template<>
moneypunct<wchar_t, false>::~moneypunct();
#pragma empty_line
template<>
void
moneypunct<wchar_t, true>::_M_initialize_moneypunct(__c_locale,
const char*);
#pragma empty_line
template<>
void
moneypunct<wchar_t, false>::_M_initialize_moneypunct(__c_locale,
const char*);
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _CharT, bool _Intl>
class moneypunct_byname : public moneypunct<_CharT, _Intl>
{
public:
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;
#pragma empty_line
static const bool intl = _Intl;
#pragma empty_line
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);
}
}
#pragma empty_line
#pragma empty_line
explicit
moneypunct_byname(const string& __s, size_t __refs = 0)
: moneypunct_byname(__s.c_str(), __refs) { }
#pragma empty_line
#pragma empty_line
protected:
virtual
~moneypunct_byname() { }
};
#pragma empty_line
template<typename _CharT, bool _Intl>
const bool moneypunct_byname<_CharT, _Intl>::intl;
#pragma empty_line
}
#pragma empty_line
namespace __cxx11 {
#pragma line 1465 "/home/justin/jhai/Xilinx/Vivado/2018.3/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:
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef _CharT char_type;
typedef _InIter iter_type;
typedef basic_string<_CharT> string_type;
#pragma empty_line
#pragma empty_line
#pragma empty_line
static locale::id id;
#pragma line 1487 "/home/justin/jhai/Xilinx/Vivado/2018.3/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) { }
#pragma line 1517 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 1548 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
protected:
#pragma empty_line
virtual
~money_get() { }
#pragma line 1572 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 1584 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 1596 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
};
#pragma empty_line
template<typename _CharT, typename _InIter>
locale::id money_get<_CharT, _InIter>::id;
#pragma line 1618 "/home/justin/jhai/Xilinx/Vivado/2018.3/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:
#pragma empty_line
#pragma empty_line
typedef _CharT char_type;
typedef _OutIter iter_type;
typedef basic_string<_CharT> string_type;
#pragma empty_line
#pragma empty_line
#pragma empty_line
static locale::id id;
#pragma line 1639 "/home/justin/jhai/Xilinx/Vivado/2018.3/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) { }
#pragma line 1659 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 1682 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
protected:
#pragma empty_line
virtual
~money_put() { }
#pragma line 1717 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 1741 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 1753 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
};
#pragma empty_line
template<typename _CharT, typename _OutIter>
locale::id money_put<_CharT, _OutIter>::id;
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
struct messages_base
{
typedef int catalog;
};
#pragma empty_line
namespace __cxx11 {
#pragma line 1796 "/home/justin/jhai/Xilinx/Vivado/2018.3/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:
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;
#pragma empty_line
#pragma empty_line
protected:
#pragma empty_line
#pragma empty_line
__c_locale _M_c_locale_messages;
const char* _M_name_messages;
#pragma empty_line
public:
#pragma empty_line
static locale::id id;
#pragma line 1824 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 3
explicit
messages(size_t __refs = 0);
#pragma line 1838 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
#pragma line 1851 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 1869 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 1887 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 1898 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
protected:
#pragma empty_line
virtual
~messages();
#pragma line 1918 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 1937 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
virtual void
do_close(catalog) const;
#pragma empty_line
#pragma empty_line
char*
_M_convert_to_char(const string_type& __msg) const
{
#pragma empty_line
return reinterpret_cast<char*>(const_cast<_CharT*>(__msg.c_str()));
}
#pragma empty_line
#pragma empty_line
string_type
_M_convert_from_char(char*) const
{
#pragma empty_line
return string_type();
}
};
#pragma empty_line
template<typename _CharT>
locale::id messages<_CharT>::id;
#pragma empty_line
#pragma empty_line
template<>
string
messages<char>::do_get(catalog, int, int, const string&) const;
#pragma empty_line
#pragma empty_line
template<>
wstring
messages<wchar_t>::do_get(catalog, int, int, const wstring&) const;
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _CharT>
class messages_byname : public messages<_CharT>
{
public:
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;
#pragma empty_line
explicit
messages_byname(const char* __s, size_t __refs = 0);
#pragma empty_line
#pragma empty_line
explicit
messages_byname(const string& __s, size_t __refs = 0)
: messages_byname(__s.c_str(), __refs) { }
#pragma empty_line
#pragma empty_line
protected:
virtual
~messages_byname()
{ }
};
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/messages_members.h" 1 3
#pragma line 36 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/messages_members.h" 3
#pragma line 1 "/usr/include/libintl.h" 1 3 4
#pragma line 34 "/usr/include/libintl.h" 3 4
extern "C" {
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern char *gettext (const char *__msgid)
throw () __attribute__ ((__format_arg__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
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)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
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)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern char *ngettext (const char *__msgid1, const char *__msgid2,
unsigned long int __n)
throw () __attribute__ ((__format_arg__ (1))) __attribute__ ((__format_arg__ (2)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
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)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
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)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern char *textdomain (const char *__domainname) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern char *bindtextdomain (const char *__domainname,
const char *__dirname) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern char *bind_textdomain_codeset (const char *__domainname,
const char *__codeset) throw ();
#pragma line 121 "/usr/include/libintl.h" 3 4
}
#pragma line 37 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/x86_64-pc-linux-gnu/bits/messages_members.h" 2 3
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
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())
{ }
#pragma empty_line
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();
#pragma empty_line
#pragma empty_line
_M_c_locale_messages = _S_clone_c_locale(__cloc);
}
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
template<typename _CharT>
typename messages<_CharT>::catalog
messages<_CharT>::do_open(const basic_string<char>& __s,
const locale&) const
{
#pragma empty_line
#pragma empty_line
textdomain(__s.c_str());
return 0;
}
#pragma empty_line
template<typename _CharT>
void
messages<_CharT>::do_close(catalog) const
{ }
#pragma empty_line
#pragma empty_line
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();
}
#pragma empty_line
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);
}
}
#pragma empty_line
#pragma empty_line
template<>
typename messages<char>::catalog
messages<char>::do_open(const basic_string<char>&,
const locale&) const;
#pragma empty_line
template<>
void
messages<char>::do_close(catalog) const;
#pragma empty_line
#pragma empty_line
template<>
typename messages<wchar_t>::catalog
messages<wchar_t>::do_open(const basic_string<char>&,
const locale&) const;
#pragma empty_line
template<>
void
messages<wchar_t>::do_close(catalog) const;
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 2009 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 2 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/codecvt.h" 1 3
#pragma line 39 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/codecvt.h" 3
#pragma empty_line
#pragma line 40 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/codecvt.h" 3
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
class codecvt_base
{
public:
enum result
{
ok,
partial,
error,
noconv
};
};
#pragma line 67 "/home/justin/jhai/Xilinx/Vivado/2018.3/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:
#pragma empty_line
typedef codecvt_base::result result;
typedef _InternT intern_type;
typedef _ExternT extern_type;
typedef _StateT state_type;
#pragma line 115 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
}
#pragma line 154 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 195 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
}
#pragma empty_line
int
encoding() const throw()
{ return this->do_encoding(); }
#pragma empty_line
bool
always_noconv() const throw()
{ return this->do_always_noconv(); }
#pragma empty_line
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); }
#pragma empty_line
int
max_length() const throw()
{ return this->do_max_length(); }
#pragma empty_line
protected:
explicit
__codecvt_abstract_base(size_t __refs = 0) : locale::facet(__refs) { }
#pragma empty_line
virtual
~__codecvt_abstract_base() { }
#pragma line 236 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
virtual result
do_unshift(state_type& __state, extern_type* __to,
extern_type* __to_end, extern_type*& __to_next) const = 0;
#pragma empty_line
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;
#pragma empty_line
virtual int
do_encoding() const throw() = 0;
#pragma empty_line
virtual bool
do_always_noconv() const throw() = 0;
#pragma empty_line
virtual int
do_length(state_type&, const extern_type* __from,
const extern_type* __end, size_t __max) const = 0;
#pragma empty_line
virtual int
do_max_length() const throw() = 0;
};
#pragma line 273 "/home/justin/jhai/Xilinx/Vivado/2018.3/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:
#pragma empty_line
typedef codecvt_base::result result;
typedef _InternT intern_type;
typedef _ExternT extern_type;
typedef _StateT state_type;
#pragma empty_line
protected:
__c_locale _M_c_locale_codecvt;
#pragma empty_line
public:
static locale::id id;
#pragma empty_line
explicit
codecvt(size_t __refs = 0)
: __codecvt_abstract_base<_InternT, _ExternT, _StateT> (__refs),
_M_c_locale_codecvt(0)
{ }
#pragma empty_line
explicit
codecvt(__c_locale __cloc, size_t __refs = 0);
#pragma empty_line
protected:
virtual
~codecvt() { }
#pragma empty_line
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;
#pragma empty_line
virtual result
do_unshift(state_type& __state, extern_type* __to,
extern_type* __to_end, extern_type*& __to_next) const;
#pragma empty_line
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;
#pragma empty_line
virtual int
do_encoding() const throw();
#pragma empty_line
virtual bool
do_always_noconv() const throw();
#pragma empty_line
virtual int
do_length(state_type&, const extern_type* __from,
const extern_type* __end, size_t __max) const;
#pragma empty_line
virtual int
do_max_length() const throw();
};
#pragma empty_line
template<typename _InternT, typename _ExternT, typename _StateT>
locale::id codecvt<_InternT, _ExternT, _StateT>::id;
#pragma empty_line
#pragma empty_line
template<>
class codecvt<char, char, mbstate_t>
: public __codecvt_abstract_base<char, char, mbstate_t>
{
friend class messages<char>;
#pragma empty_line
public:
#pragma empty_line
typedef char intern_type;
typedef char extern_type;
typedef mbstate_t state_type;
#pragma empty_line
protected:
__c_locale _M_c_locale_codecvt;
#pragma empty_line
public:
static locale::id id;
#pragma empty_line
explicit
codecvt(size_t __refs = 0);
#pragma empty_line
explicit
codecvt(__c_locale __cloc, size_t __refs = 0);
#pragma empty_line
protected:
virtual
~codecvt();
#pragma empty_line
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;
#pragma empty_line
virtual result
do_unshift(state_type& __state, extern_type* __to,
extern_type* __to_end, extern_type*& __to_next) const;
#pragma empty_line
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;
#pragma empty_line
virtual int
do_encoding() const throw();
#pragma empty_line
virtual bool
do_always_noconv() const throw();
#pragma empty_line
virtual int
do_length(state_type&, const extern_type* __from,
const extern_type* __end, size_t __max) const;
#pragma empty_line
virtual int
do_max_length() const throw();
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<>
class codecvt<wchar_t, char, mbstate_t>
: public __codecvt_abstract_base<wchar_t, char, mbstate_t>
{
friend class messages<wchar_t>;
#pragma empty_line
public:
#pragma empty_line
typedef wchar_t intern_type;
typedef char extern_type;
typedef mbstate_t state_type;
#pragma empty_line
protected:
__c_locale _M_c_locale_codecvt;
#pragma empty_line
public:
static locale::id id;
#pragma empty_line
explicit
codecvt(size_t __refs = 0);
#pragma empty_line
explicit
codecvt(__c_locale __cloc, size_t __refs = 0);
#pragma empty_line
protected:
virtual
~codecvt();
#pragma empty_line
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;
#pragma empty_line
virtual result
do_unshift(state_type& __state,
extern_type* __to, extern_type* __to_end,
extern_type*& __to_next) const;
#pragma empty_line
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;
#pragma empty_line
virtual
int do_encoding() const throw();
#pragma empty_line
virtual
bool do_always_noconv() const throw();
#pragma empty_line
virtual
int do_length(state_type&, const extern_type* __from,
const extern_type* __end, size_t __max) const;
#pragma empty_line
virtual int
do_max_length() const throw();
};
#pragma line 467 "/home/justin/jhai/Xilinx/Vivado/2018.3/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:
#pragma empty_line
typedef char16_t intern_type;
typedef char extern_type;
typedef mbstate_t state_type;
#pragma empty_line
public:
static locale::id id;
#pragma empty_line
explicit
codecvt(size_t __refs = 0)
: __codecvt_abstract_base<char16_t, char, mbstate_t>(__refs) { }
#pragma empty_line
protected:
virtual
~codecvt();
#pragma empty_line
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;
#pragma empty_line
virtual result
do_unshift(state_type& __state,
extern_type* __to, extern_type* __to_end,
extern_type*& __to_next) const;
#pragma empty_line
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;
#pragma empty_line
virtual
int do_encoding() const throw();
#pragma empty_line
virtual
bool do_always_noconv() const throw();
#pragma empty_line
virtual
int do_length(state_type&, const extern_type* __from,
const extern_type* __end, size_t __max) const;
#pragma empty_line
virtual int
do_max_length() const throw();
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<>
class codecvt<char32_t, char, mbstate_t>
: public __codecvt_abstract_base<char32_t, char, mbstate_t>
{
public:
#pragma empty_line
typedef char32_t intern_type;
typedef char extern_type;
typedef mbstate_t state_type;
#pragma empty_line
public:
static locale::id id;
#pragma empty_line
explicit
codecvt(size_t __refs = 0)
: __codecvt_abstract_base<char32_t, char, mbstate_t>(__refs) { }
#pragma empty_line
protected:
virtual
~codecvt();
#pragma empty_line
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;
#pragma empty_line
virtual result
do_unshift(state_type& __state,
extern_type* __to, extern_type* __to_end,
extern_type*& __to_next) const;
#pragma empty_line
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;
#pragma empty_line
virtual
int do_encoding() const throw();
#pragma empty_line
virtual
bool do_always_noconv() const throw();
#pragma empty_line
virtual
int do_length(state_type&, const extern_type* __from,
const extern_type* __end, size_t __max) const;
#pragma empty_line
virtual int
do_max_length() const throw();
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
}
}
#pragma empty_line
#pragma empty_line
explicit
codecvt_byname(const string& __s, size_t __refs = 0)
: codecvt_byname(__s.c_str(), __refs) { }
#pragma empty_line
#pragma empty_line
protected:
virtual
~codecvt_byname() { }
};
#pragma empty_line
#pragma empty_line
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) { }
#pragma empty_line
explicit
codecvt_byname(const string& __s, size_t __refs = 0)
: codecvt_byname(__s.c_str(), __refs) { }
#pragma empty_line
protected:
virtual
~codecvt_byname() { }
};
#pragma empty_line
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) { }
#pragma empty_line
explicit
codecvt_byname(const string& __s, size_t __refs = 0)
: codecvt_byname(__s.c_str(), __refs) { }
#pragma empty_line
protected:
virtual
~codecvt_byname() { }
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern template class codecvt_byname<char, char, mbstate_t>;
#pragma empty_line
extern template
const codecvt<char, char, mbstate_t>&
use_facet<codecvt<char, char, mbstate_t> >(const locale&);
#pragma empty_line
extern template
bool
has_facet<codecvt<char, char, mbstate_t> >(const locale&);
#pragma empty_line
#pragma empty_line
extern template class codecvt_byname<wchar_t, char, mbstate_t>;
#pragma empty_line
extern template
const codecvt<wchar_t, char, mbstate_t>&
use_facet<codecvt<wchar_t, char, mbstate_t> >(const locale&);
#pragma empty_line
extern template
bool
has_facet<codecvt<wchar_t, char, mbstate_t> >(const locale&);
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern template class codecvt_byname<char16_t, char, mbstate_t>;
extern template class codecvt_byname<char32_t, char, mbstate_t>;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 2012 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 2 3
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.tcc" 1 3
#pragma line 33 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.tcc" 3
#pragma empty_line
#pragma line 34 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.tcc" 3
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
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]);
}
};
#pragma empty_line
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);
#pragma empty_line
_M_decimal_point = __mp.decimal_point();
_M_thousands_sep = __mp.thousands_sep();
_M_frac_digits = __mp.frac_digits();
#pragma empty_line
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));
#pragma empty_line
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);
#pragma empty_line
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);
#pragma empty_line
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);
#pragma empty_line
_M_pos_format = __mp.pos_format();
_M_neg_format = __mp.neg_format();
#pragma empty_line
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);
#pragma empty_line
_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;
}
}
#pragma empty_line
namespace __cxx11 {
#pragma empty_line
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;
#pragma empty_line
const locale& __loc = __io._M_getloc();
const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
#pragma empty_line
__use_cache<__cache_type> __uc;
const __cache_type* __lc = __uc(__loc);
const char_type* __lit = __lc->_M_atoms;
#pragma empty_line
#pragma empty_line
bool __negative = false;
#pragma empty_line
size_type __sign_size = 0;
#pragma empty_line
const bool __mandatory_sign = (__lc->_M_positive_sign_size
&& __lc->_M_negative_sign_size);
#pragma empty_line
string __grouping_tmp;
if (__lc->_M_use_grouping)
__grouping_tmp.reserve(32);
#pragma empty_line
int __last_pos = 0;
#pragma empty_line
int __n = 0;
#pragma empty_line
bool __testvalid = true;
#pragma empty_line
bool __testdecfound = false;
#pragma empty_line
#pragma empty_line
string __res;
__res.reserve(32);
#pragma empty_line
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:
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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:
#pragma empty_line
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)
#pragma empty_line
#pragma empty_line
__negative = true;
else if (__mandatory_sign)
__testvalid = false;
break;
case money_base::value:
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
__last_pos = __n;
__n = 0;
__testdecfound = true;
}
else if (__lc->_M_use_grouping
&& __c == __lc->_M_thousands_sep
&& !__testdecfound)
{
if (__n)
{
#pragma empty_line
__grouping_tmp += static_cast<char>(__n);
__n = 0;
}
else
{
__testvalid = false;
break;
}
}
else
break;
}
if (__res.empty())
__testvalid = false;
break;
case money_base::space:
#pragma empty_line
if (__beg != __end && __ctype.is(ctype_base::space, *__beg))
++__beg;
else
__testvalid = false;
case money_base::none:
#pragma empty_line
if (__i != 3)
for (; __beg != __end
&& __ctype.is(ctype_base::space, *__beg); ++__beg);
break;
}
}
#pragma empty_line
#pragma empty_line
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);
#pragma empty_line
if (__i != __sign_size)
__testvalid = false;
}
#pragma empty_line
if (__testvalid)
{
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
if (__negative && __res[0] != '0')
__res.insert(__res.begin(), '-');
#pragma empty_line
#pragma empty_line
if (__grouping_tmp.size())
{
#pragma empty_line
__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;
}
#pragma empty_line
#pragma empty_line
if (__testdecfound && __n != __lc->_M_frac_digits)
__testvalid = false;
}
#pragma empty_line
#pragma empty_line
if (!__testvalid)
__err |= ios_base::failbit;
else
__units.swap(__res);
#pragma empty_line
#pragma empty_line
if (__beg == __end)
__err |= ios_base::eofbit;
return __beg;
}
#pragma line 367 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma empty_line
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;
#pragma empty_line
const locale& __loc = __io._M_getloc();
const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
#pragma empty_line
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;
}
#pragma empty_line
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;
#pragma empty_line
const locale& __loc = __io._M_getloc();
const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
#pragma empty_line
__use_cache<__cache_type> __uc;
const __cache_type* __lc = __uc(__loc);
const char_type* __lit = __lc->_M_atoms;
#pragma empty_line
#pragma empty_line
#pragma empty_line
const char_type* __beg = __digits.data();
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
size_type __len = __ctype.scan_not(ctype_base::digit, __beg,
__beg + __digits.size()) - __beg;
if (__len)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
string_type __value;
__value.reserve(2 * __len);
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
if (__lc->_M_frac_digits > 0)
{
__value += __lc->_M_decimal_point;
if (__paddec >= 0)
__value.append(__beg + __paddec, __lc->_M_frac_digits);
else
{
#pragma empty_line
__value.append(-__paddec, __lit[money_base::_S_zero]);
__value.append(__beg, __len);
}
}
#pragma empty_line
#pragma empty_line
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);
#pragma empty_line
string_type __res;
__res.reserve(2 * __len);
#pragma empty_line
const size_type __width = static_cast<size_type>(__io.width());
const bool __testipad = (__f == ios_base::internal
&& __len < __width);
#pragma empty_line
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:
#pragma empty_line
#pragma empty_line
#pragma empty_line
if (__sign_size)
__res += __sign[0];
break;
case money_base::value:
__res += __value;
break;
case money_base::space:
#pragma empty_line
#pragma empty_line
#pragma empty_line
if (__testipad)
__res.append(__width - __len, __fill);
else
__res += __fill;
break;
case money_base::none:
if (__testipad)
__res.append(__width - __len, __fill);
break;
}
}
#pragma empty_line
#pragma empty_line
if (__sign_size > 1)
__res.append(__sign + 1, __sign_size - 1);
#pragma empty_line
#pragma empty_line
__len = __res.size();
if (__width > __len)
{
if (__f == ios_base::left)
#pragma empty_line
__res.append(__width - __len, __fill);
else
#pragma empty_line
__res.insert(0, __width - __len, __fill);
__len = __width;
}
#pragma empty_line
#pragma empty_line
__s = std::__write(__s, __res.data(), __len);
}
__io.width(0);
return __s;
}
#pragma line 573 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
#pragma empty_line
#pragma empty_line
int __cs_size = 64;
char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
#pragma empty_line
#pragma empty_line
int __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
"%.*Lf", 0, __units);
#pragma empty_line
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);
}
#pragma line 605 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
}
#pragma empty_line
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); }
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _CharT, typename _InIter>
time_base::dateorder
time_get<_CharT, _InIter>::do_date_order() const
{ return time_base::no_order; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
#pragma empty_line
ios_base::iostate __tmperr = ios_base::goodbit;
size_t __i = 0;
for (; __beg != __end && __i < __len && !__tmperr; ++__i)
{
if (__ctype.narrow(__format[__i], 0) == '%')
{
#pragma empty_line
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':
#pragma empty_line
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':
#pragma empty_line
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':
#pragma empty_line
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':
#pragma empty_line
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':
#pragma empty_line
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':
#pragma empty_line
__beg = _M_extract_num(__beg, __end, __tm->tm_mday, 1, 31, 2,
__io, __tmperr);
break;
case 'e':
#pragma empty_line
#pragma empty_line
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':
#pragma empty_line
__cs = "%m/%d/%y";
__ctype.widen(__cs, __cs + 9, __wcs);
__beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
__tm, __wcs);
break;
case 'H':
#pragma empty_line
__beg = _M_extract_num(__beg, __end, __tm->tm_hour, 0, 23, 2,
__io, __tmperr);
break;
case 'I':
#pragma empty_line
__beg = _M_extract_num(__beg, __end, __tm->tm_hour, 1, 12, 2,
__io, __tmperr);
break;
case 'm':
#pragma empty_line
__beg = _M_extract_num(__beg, __end, __mem, 1, 12, 2,
__io, __tmperr);
if (!__tmperr)
__tm->tm_mon = __mem - 1;
break;
case 'M':
#pragma empty_line
__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':
#pragma empty_line
__cs = "%H:%M";
__ctype.widen(__cs, __cs + 6, __wcs);
__beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
__tm, __wcs);
break;
case 'S':
#pragma empty_line
#pragma empty_line
#pragma empty_line
__beg = _M_extract_num(__beg, __end, __tm->tm_sec, 0, 60, 2,
#pragma empty_line
#pragma empty_line
#pragma empty_line
__io, __tmperr);
break;
case 't':
if (__ctype.narrow(*__beg, 0) == '\t')
++__beg;
else
__tmperr |= ios_base::failbit;
break;
case 'T':
#pragma empty_line
__cs = "%H:%M:%S";
__ctype.widen(__cs, __cs + 9, __wcs);
__beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
__tm, __wcs);
break;
case 'x':
#pragma empty_line
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':
#pragma empty_line
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':
#pragma empty_line
case 'Y':
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__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':
#pragma empty_line
if (__ctype.is(ctype_base::upper, *__beg))
{
int __tmp;
__beg = _M_extract_name(__beg, __end, __tmp,
__timepunct_cache<_CharT>::_S_timezones,
14, __io, __tmperr);
#pragma empty_line
#pragma empty_line
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:
#pragma empty_line
__tmperr |= ios_base::failbit;
}
}
else
{
#pragma empty_line
if (__format[__i] == *__beg)
++__beg;
else
__tmperr |= ios_base::failbit;
}
}
#pragma empty_line
if (__tmperr || __i != __len)
__err |= ios_base::failbit;
#pragma empty_line
return __beg;
}
#pragma empty_line
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);
#pragma empty_line
#pragma empty_line
int __mult = __len == 2 ? 10 : (__len == 4 ? 1000 : 1);
#pragma empty_line
++__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;
#pragma empty_line
else if (__len == 4 && __i == 2)
__member = __value - 100;
else
__err |= ios_base::failbit;
#pragma empty_line
return __beg;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
while (__nmatches > 1)
{
#pragma empty_line
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;
}
#pragma empty_line
if (__nmatches == 1)
{
#pragma empty_line
++__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;
#pragma empty_line
if (__len == __pos)
__member = __matches[0];
else
__testvalid = false;
}
else
__testvalid = false;
if (!__testvalid)
__err |= ios_base::failbit;
#pragma empty_line
return __beg;
}
#pragma empty_line
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);
#pragma empty_line
int* __matches = static_cast<int*>(__builtin_alloca(2 * sizeof(int)
* __indexlen));
size_t __nmatches = 0;
size_t* __matches_lengths = 0;
size_t __pos = 0;
#pragma empty_line
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;
}
#pragma empty_line
if (__nmatches)
{
++__beg;
++__pos;
#pragma empty_line
__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]]);
}
#pragma empty_line
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;
}
#pragma empty_line
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;
#pragma empty_line
return __beg;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
#pragma empty_line
__beg = _M_extract_wday_or_month(__beg, __end, __tmpwday, __days, 7,
__io, __tmperr);
if (!__tmperr)
__tm->tm_wday = __tmpwday;
else
__err |= ios_base::failbit;
#pragma empty_line
if (__beg == __end)
__err |= ios_base::eofbit;
return __beg;
}
#pragma empty_line
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;
#pragma empty_line
__beg = _M_extract_wday_or_month(__beg, __end, __tmpmon, __months, 12,
__io, __tmperr);
if (!__tmperr)
__tm->tm_mon = __tmpmon;
else
__err |= ios_base::failbit;
#pragma empty_line
if (__beg == __end)
__err |= ios_base::eofbit;
return __beg;
}
#pragma empty_line
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;
#pragma empty_line
__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;
#pragma empty_line
if (__beg == __end)
__err |= ios_base::eofbit;
return __beg;
}
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
while (__s != __end &&
__ctype.is(ctype_base::space, *__s))
++__s;
}
#pragma empty_line
else if (__ctype.tolower(*__s) == __ctype.tolower(*__fmt) ||
__ctype.toupper(*__s) == __ctype.toupper(*__fmt))
{
++__s;
++__fmt;
}
else
{
__err = ios_base::failbit;
break;
}
}
return __s;
}
#pragma empty_line
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;
#pragma empty_line
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();
}
#pragma empty_line
__beg = _M_extract_via_format(__beg, __end, __io, __err, __tm, __fmt);
if (__beg == __end)
__err |= ios_base::eofbit;
return __beg;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
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);
#pragma empty_line
#pragma empty_line
#pragma empty_line
const size_t __maxlen = 128;
char_type __res[__maxlen];
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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();
}
#pragma empty_line
__tp._M_put(__res, __maxlen, __fmt, __tm);
#pragma empty_line
#pragma empty_line
return std::__write(__s, __res, char_traits<char_type>::length(__res));
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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>;
#pragma empty_line
extern template
const moneypunct<char, true>&
use_facet<moneypunct<char, true> >(const locale&);
#pragma empty_line
extern template
const moneypunct<char, false>&
use_facet<moneypunct<char, false> >(const locale&);
#pragma empty_line
extern template
const money_put<char>&
use_facet<money_put<char> >(const locale&);
#pragma empty_line
extern template
const money_get<char>&
use_facet<money_get<char> >(const locale&);
#pragma empty_line
extern template
const __timepunct<char>&
use_facet<__timepunct<char> >(const locale&);
#pragma empty_line
extern template
const time_put<char>&
use_facet<time_put<char> >(const locale&);
#pragma empty_line
extern template
const time_get<char>&
use_facet<time_get<char> >(const locale&);
#pragma empty_line
extern template
const messages<char>&
use_facet<messages<char> >(const locale&);
#pragma empty_line
extern template
bool
has_facet<moneypunct<char> >(const locale&);
#pragma empty_line
extern template
bool
has_facet<money_put<char> >(const locale&);
#pragma empty_line
extern template
bool
has_facet<money_get<char> >(const locale&);
#pragma empty_line
extern template
bool
has_facet<__timepunct<char> >(const locale&);
#pragma empty_line
extern template
bool
has_facet<time_put<char> >(const locale&);
#pragma empty_line
extern template
bool
has_facet<time_get<char> >(const locale&);
#pragma empty_line
extern template
bool
has_facet<messages<char> >(const locale&);
#pragma empty_line
#pragma empty_line
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>;
#pragma empty_line
extern template
const moneypunct<wchar_t, true>&
use_facet<moneypunct<wchar_t, true> >(const locale&);
#pragma empty_line
extern template
const moneypunct<wchar_t, false>&
use_facet<moneypunct<wchar_t, false> >(const locale&);
#pragma empty_line
extern template
const money_put<wchar_t>&
use_facet<money_put<wchar_t> >(const locale&);
#pragma empty_line
extern template
const money_get<wchar_t>&
use_facet<money_get<wchar_t> >(const locale&);
#pragma empty_line
extern template
const __timepunct<wchar_t>&
use_facet<__timepunct<wchar_t> >(const locale&);
#pragma empty_line
extern template
const time_put<wchar_t>&
use_facet<time_put<wchar_t> >(const locale&);
#pragma empty_line
extern template
const time_get<wchar_t>&
use_facet<time_get<wchar_t> >(const locale&);
#pragma empty_line
extern template
const messages<wchar_t>&
use_facet<messages<wchar_t> >(const locale&);
#pragma empty_line
extern template
bool
has_facet<moneypunct<wchar_t> >(const locale&);
#pragma empty_line
extern template
bool
has_facet<money_put<wchar_t> >(const locale&);
#pragma empty_line
extern template
bool
has_facet<money_get<wchar_t> >(const locale&);
#pragma empty_line
extern template
bool
has_facet<__timepunct<wchar_t> >(const locale&);
#pragma empty_line
extern template
bool
has_facet<time_put<wchar_t> >(const locale&);
#pragma empty_line
extern template
bool
has_facet<time_get<wchar_t> >(const locale&);
#pragma empty_line
extern template
bool
has_facet<messages<wchar_t> >(const locale&);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 2014 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_facets_nonio.h" 2 3
#pragma line 42 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/locale" 2 3
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_conv.h" 1 3
#pragma line 38 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_conv.h" 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/stringfwd.h" 1 3
#pragma line 39 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_conv.h" 2 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/allocator.h" 1 3
#pragma line 40 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_conv.h" 2 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/codecvt.h" 1 3
#pragma line 41 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_conv.h" 2 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/unique_ptr.h" 1 3
#pragma line 39 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/unique_ptr.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename> class auto_ptr;
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct default_delete
{
#pragma empty_line
constexpr default_delete() noexcept = default;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Up, typename = typename
enable_if<is_convertible<_Up*, _Tp*>::value>::type>
default_delete(const default_delete<_Up>&) noexcept { }
#pragma empty_line
#pragma empty_line
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;
}
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct default_delete<_Tp[]>
{
public:
#pragma empty_line
constexpr default_delete() noexcept = default;
#pragma line 99 "/home/justin/jhai/Xilinx/Vivado/2018.3/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 { }
#pragma empty_line
#pragma empty_line
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;
}
};
#pragma empty_line
#pragma empty_line
template <typename _Tp, typename _Dp = default_delete<_Tp> >
class unique_ptr
{
#pragma empty_line
class _Pointer
{
template<typename _Up>
static typename _Up::pointer __test(typename _Up::pointer*);
#pragma empty_line
template<typename _Up>
static _Tp* __test(...);
#pragma empty_line
typedef typename remove_reference<_Dp>::type _Del;
#pragma empty_line
public:
typedef decltype(__test<_Del>(0)) type;
};
#pragma empty_line
typedef std::tuple<typename _Pointer::type, _Dp> __tuple_type;
__tuple_type _M_t;
#pragma empty_line
public:
typedef typename _Pointer::type pointer;
typedef _Tp element_type;
typedef _Dp deleter_type;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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>>
>
>;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
constexpr unique_ptr() noexcept
: _M_t()
{ static_assert(!is_pointer<deleter_type>::value,
"constructed with null function pointer deleter"); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
explicit
unique_ptr(pointer __p) noexcept
: _M_t(__p, deleter_type())
{ static_assert(!is_pointer<deleter_type>::value,
"constructed with null function pointer deleter"); }
#pragma line 182 "/home/justin/jhai/Xilinx/Vivado/2018.3/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) { }
#pragma line 194 "/home/justin/jhai/Xilinx/Vivado/2018.3/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"); }
#pragma empty_line
#pragma empty_line
constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
unique_ptr(unique_ptr&& __u) noexcept
: _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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()))
{ }
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Up, typename = _Require<
is_convertible<_Up*, _Tp*>, is_same<_Dp, default_delete<_Tp>>>>
unique_ptr(auto_ptr<_Up>&& __u) noexcept;
#pragma empty_line
#pragma empty_line
#pragma empty_line
~unique_ptr() noexcept
{
auto& __ptr = std::get<0>(_M_t);
if (__ptr != nullptr)
get_deleter()(__ptr);
__ptr = pointer();
}
#pragma line 248 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma line 263 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma empty_line
#pragma empty_line
unique_ptr&
operator=(nullptr_t) noexcept
{
reset();
return *this;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typename add_lvalue_reference<element_type>::type
operator*() const
{
;
return *get();
}
#pragma empty_line
#pragma empty_line
pointer
operator->() const noexcept
{
;
return get();
}
#pragma empty_line
#pragma empty_line
pointer
get() const noexcept
{ return std::get<0>(_M_t); }
#pragma empty_line
#pragma empty_line
deleter_type&
get_deleter() noexcept
{ return std::get<1>(_M_t); }
#pragma empty_line
#pragma empty_line
const deleter_type&
get_deleter() const noexcept
{ return std::get<1>(_M_t); }
#pragma empty_line
#pragma empty_line
explicit operator bool() const noexcept
{ return get() == pointer() ? false : true; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
pointer
release() noexcept
{
pointer __p = get();
std::get<0>(_M_t) = pointer();
return __p;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
void
reset(pointer __p = pointer()) noexcept
{
using std::swap;
swap(std::get<0>(_M_t), __p);
if (__p != pointer())
get_deleter()(__p);
}
#pragma empty_line
#pragma empty_line
void
swap(unique_ptr& __u) noexcept
{
using std::swap;
swap(_M_t, __u._M_t);
}
#pragma empty_line
#pragma empty_line
unique_ptr(const unique_ptr&) = delete;
unique_ptr& operator=(const unique_ptr&) = delete;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename _Dp>
class unique_ptr<_Tp[], _Dp>
{
#pragma empty_line
class _Pointer
{
template<typename _Up>
static typename _Up::pointer __test(typename _Up::pointer*);
#pragma empty_line
template<typename _Up>
static _Tp* __test(...);
#pragma empty_line
typedef typename remove_reference<_Dp>::type _Del;
#pragma empty_line
public:
typedef decltype(__test<_Del>(0)) type;
};
#pragma empty_line
typedef std::tuple<typename _Pointer::type, _Dp> __tuple_type;
__tuple_type _M_t;
#pragma empty_line
template<typename _Up>
using __remove_cv = typename remove_cv<_Up>::type;
#pragma empty_line
#pragma empty_line
template<typename _Up>
using __is_derived_Tp
= __and_< is_base_of<_Tp, _Up>,
__not_<is_same<__remove_cv<_Tp>, __remove_cv<_Up>>> >;
#pragma empty_line
#pragma empty_line
public:
typedef typename _Pointer::type pointer;
typedef _Tp element_type;
typedef _Dp deleter_type;
#pragma empty_line
#pragma empty_line
#pragma empty_line
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>>>
>;
#pragma empty_line
#pragma empty_line
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(*)[]>
>
>
>;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
constexpr unique_ptr() noexcept
: _M_t()
{ static_assert(!std::is_pointer<deleter_type>::value,
"constructed with null function pointer deleter"); }
#pragma line 444 "/home/justin/jhai/Xilinx/Vivado/2018.3/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"); }
#pragma line 461 "/home/justin/jhai/Xilinx/Vivado/2018.3/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) { }
#pragma line 477 "/home/justin/jhai/Xilinx/Vivado/2018.3/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"); }
#pragma empty_line
#pragma empty_line
unique_ptr(unique_ptr&& __u) noexcept
: _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { }
#pragma empty_line
#pragma empty_line
constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }
#pragma empty_line
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()))
{ }
#pragma empty_line
#pragma empty_line
~unique_ptr()
{
auto& __ptr = std::get<0>(_M_t);
if (__ptr != nullptr)
get_deleter()(__ptr);
__ptr = pointer();
}
#pragma line 516 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma line 531 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma empty_line
#pragma empty_line
unique_ptr&
operator=(nullptr_t) noexcept
{
reset();
return *this;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typename std::add_lvalue_reference<element_type>::type
operator[](size_t __i) const
{
;
return get()[__i];
}
#pragma empty_line
#pragma empty_line
pointer
get() const noexcept
{ return std::get<0>(_M_t); }
#pragma empty_line
#pragma empty_line
deleter_type&
get_deleter() noexcept
{ return std::get<1>(_M_t); }
#pragma empty_line
#pragma empty_line
const deleter_type&
get_deleter() const noexcept
{ return std::get<1>(_M_t); }
#pragma empty_line
#pragma empty_line
explicit operator bool() const noexcept
{ return get() == pointer() ? false : true; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
pointer
release() noexcept
{
pointer __p = get();
std::get<0>(_M_t) = pointer();
return __p;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
void reset(nullptr_t = nullptr) noexcept
{
reset(pointer());
}
#pragma empty_line
#pragma empty_line
void
swap(unique_ptr& __u) noexcept
{
using std::swap;
swap(_M_t, __u._M_t);
}
#pragma empty_line
#pragma empty_line
unique_ptr(const unique_ptr&) = delete;
unique_ptr& operator=(const unique_ptr&) = delete;
};
#pragma empty_line
template<typename _Tp, typename _Dp>
inline void
swap(unique_ptr<_Tp, _Dp>& __x,
unique_ptr<_Tp, _Dp>& __y) noexcept
{ __x.swap(__y); }
#pragma empty_line
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(); }
#pragma empty_line
template<typename _Tp, typename _Dp>
inline bool
operator==(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
{ return !__x; }
#pragma empty_line
template<typename _Tp, typename _Dp>
inline bool
operator==(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
{ return !__x; }
#pragma empty_line
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(); }
#pragma empty_line
template<typename _Tp, typename _Dp>
inline bool
operator!=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
{ return (bool)__x; }
#pragma empty_line
template<typename _Tp, typename _Dp>
inline bool
operator!=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
{ return (bool)__x; }
#pragma empty_line
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());
}
#pragma empty_line
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); }
#pragma empty_line
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()); }
#pragma empty_line
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); }
#pragma empty_line
template<typename _Tp, typename _Dp>
inline bool
operator<=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
{ return !(nullptr < __x); }
#pragma empty_line
template<typename _Tp, typename _Dp>
inline bool
operator<=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
{ return !(__x < nullptr); }
#pragma empty_line
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); }
#pragma empty_line
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()); }
#pragma empty_line
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); }
#pragma empty_line
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); }
#pragma empty_line
template<typename _Tp, typename _Dp>
inline bool
operator>=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
{ return !(__x < nullptr); }
#pragma empty_line
template<typename _Tp, typename _Dp>
inline bool
operator>=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
{ return !(nullptr < __x); }
#pragma empty_line
#pragma empty_line
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());
}
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _Tp>
struct _MakeUniq
{ typedef unique_ptr<_Tp> __single_object; };
#pragma empty_line
template<typename _Tp>
struct _MakeUniq<_Tp[]>
{ typedef unique_ptr<_Tp[]> __array; };
#pragma empty_line
template<typename _Tp, size_t _Bound>
struct _MakeUniq<_Tp[_Bound]>
{ struct __invalid_type { }; };
#pragma empty_line
#pragma empty_line
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)...)); }
#pragma empty_line
#pragma empty_line
template<typename _Tp>
inline typename _MakeUniq<_Tp>::__array
make_unique(size_t __num)
{ return unique_ptr<_Tp>(new remove_extent_t<_Tp>[__num]()); }
#pragma empty_line
#pragma empty_line
template<typename _Tp, typename... _Args>
inline typename _MakeUniq<_Tp>::__invalid_type
make_unique(_Args&&...) = delete;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 42 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/locale_conv.h" 2 3
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
size_t __outchars = 0;
auto __next = __first;
const auto __maxlen = __cvt.max_length() + 1;
#pragma empty_line
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);
#pragma empty_line
if (__result == codecvt_base::error)
return false;
#pragma empty_line
if (__result == codecvt_base::noconv)
{
__outstr.assign(__first, __last);
__count = __last - __first;
}
else
{
__outstr.resize(__outchars);
__count = __next - __first;
}
#pragma empty_line
return true;
}
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace __cxx11 {
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
explicit
wstring_convert(_Codecvt* __pcvt = new _Codecvt()) : _M_cvt(__pcvt)
{
if (!_M_cvt)
__throw_logic_error("wstring_convert");
}
#pragma line 195 "/home/justin/jhai/Xilinx/Vivado/2018.3/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");
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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");
}
#pragma empty_line
~wstring_convert() = default;
#pragma empty_line
#pragma empty_line
#pragma empty_line
wstring_convert(const wstring_convert&) = delete;
wstring_convert& operator=(const wstring_convert&) = delete;
#pragma empty_line
#pragma empty_line
wide_string
from_bytes(char __byte)
{
char __bytes[2] = { __byte };
return from_bytes(__bytes, __bytes+1);
}
#pragma empty_line
wide_string
from_bytes(const char* __ptr)
{ return from_bytes(__ptr, __ptr+char_traits<char>::length(__ptr)); }
#pragma empty_line
wide_string
from_bytes(const byte_string& __str)
{
auto __ptr = __str.data();
return from_bytes(__ptr, __ptr + __str.size());
}
#pragma empty_line
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");
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
byte_string
to_bytes(_Elem __wchar)
{
_Elem __wchars[2] = { __wchar };
return to_bytes(__wchars, __wchars+1);
}
#pragma empty_line
byte_string
to_bytes(const _Elem* __ptr)
{
return to_bytes(__ptr, __ptr+wide_string::traits_type::length(__ptr));
}
#pragma empty_line
byte_string
to_bytes(const wide_string& __wstr)
{
auto __ptr = __wstr.data();
return to_bytes(__ptr, __ptr + __wstr.size());
}
#pragma empty_line
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");
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
size_t converted() const noexcept { return _M_count; }
#pragma empty_line
#pragma empty_line
state_type state() const { return _M_state; }
#pragma empty_line
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;
};
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
public:
typedef typename _Codecvt::state_type state_type;
#pragma line 333 "/home/justin/jhai/Xilinx/Vivado/2018.3/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");
#pragma empty_line
_M_always_noconv = _M_cvt->always_noconv();
#pragma empty_line
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);
}
}
#pragma empty_line
~wbuffer_convert() = default;
#pragma empty_line
#pragma empty_line
#pragma empty_line
wbuffer_convert(const wbuffer_convert&) = delete;
wbuffer_convert& operator=(const wbuffer_convert&) = delete;
#pragma empty_line
streambuf* rdbuf() const noexcept { return _M_buf; }
#pragma empty_line
streambuf*
rdbuf(streambuf *__bytebuf) noexcept
{
auto __prev = _M_buf;
_M_buf = __bytebuf;
return __prev;
}
#pragma empty_line
#pragma empty_line
state_type state() const noexcept { return _M_state; }
#pragma empty_line
protected:
int
sync()
{ return _M_buf && _M_conv_put() && _M_buf->pubsync() ? 0 : -1; }
#pragma empty_line
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);
}
#pragma empty_line
typename _Wide_streambuf::int_type
underflow()
{
if (!_M_buf)
return _Tr::eof();
#pragma empty_line
if (this->gptr() < this->egptr() || (_M_buf && _M_conv_get()))
return _Tr::to_int_type(*this->gptr());
else
return _Tr::eof();
}
#pragma empty_line
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;
}
#pragma empty_line
private:
#pragma empty_line
bool
_M_conv_get()
{
const streamsize __pb1 = this->gptr() - this->eback();
const streamsize __pb2 = _S_putback_length;
const streamsize __npb = std::min(__pb1, __pb2);
#pragma empty_line
_Tr::move(_M_get_area + _S_putback_length - __npb,
this->gptr() - __npb, __npb);
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
#pragma empty_line
_Elem* __outbuf = _M_get_area + _S_putback_length;
_Elem* __outnext = __outbuf;
const char* __bnext = _M_get_buf;
#pragma empty_line
codecvt_base::result __result;
if (_M_always_noconv)
__result = codecvt_base::noconv;
else
{
_Elem* __outend = _M_get_area + _S_buffer_length;
#pragma empty_line
__result = _M_cvt->in(_M_state,
__bnext, __bnext + __nbytes, __bnext,
__outbuf, __outend, __outnext);
}
#pragma empty_line
if (__result == codecvt_base::noconv)
{
#pragma empty_line
auto __get_buf = reinterpret_cast<const _Elem*>(_M_get_buf);
_Tr::copy(__outbuf, __get_buf, __nbytes);
_M_unconv = 0;
return true;
}
#pragma empty_line
if ((_M_unconv = _M_get_buf + __nbytes - __bnext))
char_traits<char>::move(_M_get_buf, __bnext, _M_unconv);
#pragma empty_line
this->setg(__outbuf, __outbuf, __outnext);
#pragma empty_line
return __result != codecvt_base::error;
}
#pragma empty_line
#pragma empty_line
bool
_M_put(...)
{ return false; }
#pragma empty_line
bool
_M_put(const char* __p, streamsize __n)
{
if (_M_buf->sputn(__p, __n) < __n)
return false;
}
#pragma empty_line
#pragma empty_line
bool
_M_conv_put()
{
_Elem* const __first = this->pbase();
const _Elem* const __last = this->pptr();
const streamsize __pending = __last - __first;
#pragma empty_line
if (_M_always_noconv)
return _M_put(__first, __pending);
#pragma empty_line
char __outbuf[2 * _S_buffer_length];
#pragma empty_line
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);
#pragma empty_line
if (!_M_put(__outbuf, __outnext - __outbuf))
return false;
}
while (__next != __last && __next != __start);
#pragma empty_line
if (__next != __last)
_Tr::move(__first, __next, __last - __next);
#pragma empty_line
this->pbump(__first - __next);
return __next != __first;
}
#pragma empty_line
streambuf* _M_buf;
unique_ptr<_Codecvt> _M_cvt;
state_type _M_state;
#pragma empty_line
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;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 44 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/locale" 2 3
#pragma line 44 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iomanip" 2 3
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/quoted_string.h" 1 3
#pragma line 33 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/quoted_string.h" 3
#pragma empty_line
#pragma line 34 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/bits/quoted_string.h" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
namespace __detail {
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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");
#pragma empty_line
_Quoted_string(_String __str, _CharT __del, _CharT __esc)
: _M_string(__str), _M_delim{__del}, _M_escape{__esc}
{ }
#pragma empty_line
_Quoted_string&
operator=(_Quoted_string&) = delete;
#pragma empty_line
_String _M_string;
_CharT _M_delim;
_CharT _M_escape;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
return __os << __ostr.str();
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
return __os << __ostr.str();
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
#pragma empty_line
return __is;
}
#pragma empty_line
#pragma empty_line
}
}
#pragma line 46 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iomanip" 2 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
struct _Resetiosflags { ios_base::fmtflags _M_mask; };
#pragma line 65 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iomanip" 3
inline _Resetiosflags
resetiosflags(ios_base::fmtflags __mask)
{ return { __mask }; }
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
struct _Setiosflags { ios_base::fmtflags _M_mask; };
#pragma line 95 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iomanip" 3
inline _Setiosflags
setiosflags(ios_base::fmtflags __mask)
{ return { __mask }; }
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
struct _Setbase { int _M_base; };
#pragma line 126 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iomanip" 3
inline _Setbase
setbase(int __base)
{ return { __base }; }
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
template<typename _CharT>
struct _Setfill { _CharT _M_c; };
#pragma line 163 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iomanip" 3
template<typename _CharT>
inline _Setfill<_CharT>
setfill(_CharT __c)
{ return { __c }; }
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
struct _Setprecision { int _M_n; };
#pragma line 194 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iomanip" 3
inline _Setprecision
setprecision(int __n)
{ return { __n }; }
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
struct _Setw { int _M_n; };
#pragma line 224 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/iomanip" 3
inline _Setw
setw(int __n)
{ return { __n }; }
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<typename _MoneyT>
struct _Get_money { _MoneyT& _M_mon; bool _M_intl; };
#pragma line 257 "/home/justin/jhai/Xilinx/Vivado/2018.3/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 }; }
#pragma empty_line
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;
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
template<typename _MoneyT>
struct _Put_money { const _MoneyT& _M_mon; bool _M_intl; };
#pragma line 304 "/home/justin/jhai/Xilinx/Vivado/2018.3/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 }; }
#pragma empty_line
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;
#pragma empty_line
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;
}
#pragma empty_line
template<typename _CharT>
struct _Put_time
{
const std::tm* _M_tmb;
const _CharT* _M_fmt;
};
#pragma line 356 "/home/justin/jhai/Xilinx/Vivado/2018.3/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 }; }
#pragma empty_line
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;
#pragma empty_line
const _CharT* const __fmt_end = __f._M_fmt +
_Traits::length(__f._M_fmt);
#pragma empty_line
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;
}
#pragma empty_line
template<typename _CharT>
struct _Get_time
{
std::tm* _M_tmb;
const _CharT* _M_fmt;
};
#pragma line 411 "/home/justin/jhai/Xilinx/Vivado/2018.3/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 }; }
#pragma empty_line
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;
#pragma empty_line
const _CharT* const __fmt_end = __f._M_fmt +
_Traits::length(__f._M_fmt);
#pragma empty_line
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;
}
#pragma line 459 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
}
#pragma empty_line
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);
}
#pragma empty_line
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);
}
#pragma line 496 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
#pragma empty_line
#pragma empty_line
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);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 120 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 2
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 124 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
namespace ap_private_ops {
#pragma empty_line
static inline uint32_t Hi_32(uint64_t Value) {
return static_cast<uint32_t>(Value >> 32);
}
#pragma empty_line
#pragma empty_line
static inline uint32_t Lo_32(uint64_t Value) {
return static_cast<uint32_t>(Value);
}
#pragma empty_line
template <int _AP_W>
inline bool isNegative(const ap_private<_AP_W, false>& a) {
return false;
}
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static inline unsigned CountLeadingZeros_32(uint32_t Value) {
unsigned Count;
#pragma empty_line
#pragma empty_line
#pragma empty_line
if (Value == 0) return 32;
#pragma empty_line
Count = __builtin_clz(Value);
#pragma line 175 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
return Count;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static inline unsigned CountLeadingZeros_64(uint64_t Value) {
unsigned Count;
#pragma empty_line
#pragma empty_line
#pragma empty_line
if (!Value) return 64;
#pragma empty_line
Count = __builtin_clzll(Value);
#pragma line 219 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
return Count;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static inline unsigned CountTrailingZeros_64(uint64_t Value) {
#pragma empty_line
return (Value != 0) ? __builtin_ctzll(Value) : 64;
#pragma line 237 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
static inline unsigned CountPopulation_64(uint64_t Value) {
#pragma empty_line
return __builtin_popcountll(Value);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
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;
}
#pragma empty_line
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";
}
}
#pragma empty_line
#pragma line 295 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 295 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
0 && "Invalid character in digit string"
#pragma line 295 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 295 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"0 && \"Invalid character in digit string\""
#pragma line 295 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 295, __extension__ __PRETTY_FUNCTION__))
#pragma line 295 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
return "";
}
#pragma empty_line
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";
}
}
#pragma empty_line
#pragma line 362 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 362 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
0 && "Invalid character in digit string"
#pragma line 362 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 362 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"0 && \"Invalid character in digit string\""
#pragma line 362 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 362, __extension__ __PRETTY_FUNCTION__))
#pragma line 362 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
return "";
}
#pragma empty_line
static inline uint32_t decode_digit(char cdigit, int radix) {
uint32_t digit = 0;
if (radix == 16) {
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
if (!(((cdigit) >= '0' && (cdigit) <= '9') || ((cdigit) >= 'a' && (cdigit) <= 'f') || ((cdigit) >= 'A' && (cdigit) <= 'F')))
#pragma line 373 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 373 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
0 && "Invalid hex digit in string"
#pragma line 373 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 373 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"0 && \"Invalid hex digit in string\""
#pragma line 373 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 373, __extension__ __PRETTY_FUNCTION__))
#pragma line 373 "/home/justin/jhai/Xilinx/Vivado/2018.3/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
#pragma empty_line
#pragma line 381 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 381 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
0 && "huh? we shouldn't get here"
#pragma line 381 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 381 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"0 && \"huh? we shouldn't get here\""
#pragma line 381 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 381, __extension__ __PRETTY_FUNCTION__))
#pragma line 381 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
} else if (((cdigit) >= '0' && (cdigit) <= '9')) {
digit = cdigit - '0';
} else {
#pragma empty_line
#pragma line 385 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 385 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
0 && "Invalid character in digit string"
#pragma line 385 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 385 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"0 && \"Invalid character in digit string\""
#pragma line 385 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 385, __extension__ __PRETTY_FUNCTION__))
#pragma line 385 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
}
#pragma empty_line
#pragma empty_line
return digit;
}
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
size_t startPos = 0;
#pragma empty_line
while (input[startPos] == ' ' && startPos < len) startPos++;
while (input[len - 1] == ' ' && startPos < len) len--;
#pragma empty_line
std::string val = input.substr(startPos, len - startPos);
#pragma empty_line
len = val.length();
startPos = 0;
#pragma empty_line
#pragma empty_line
#pragma empty_line
if (len < 2) {
if (radix == 0) radix = 10;
return val;
}
#pragma empty_line
bool isNegative = false;
std::string ans;
#pragma empty_line
#pragma empty_line
if (val[0] == '-') {
ans = "-";
++startPos;
isNegative = true;
} else if (val[0] == '+')
++startPos;
#pragma empty_line
if (len - startPos < 2) {
if (radix == 0) radix = 10;
return val;
}
#pragma empty_line
if (val.substr(startPos, 2) == "0x" || val.substr(startPos, 2) == "0X") {
#pragma empty_line
radix = 16;
startPos += 2;
} else if (val.substr(startPos, 2) == "0b" ||
val.substr(startPos, 2) == "0B") {
#pragma empty_line
radix = 2;
startPos += 2;
} else if (val.substr(startPos, 2) == "0o" ||
val.substr(startPos, 2) == "0O") {
#pragma empty_line
radix = 8;
startPos += 2;
} else if (radix == 0) {
radix = 10;
}
#pragma empty_line
int exp = 0;
if (radix == 10) {
#pragma empty_line
#pragma empty_line
size_t expPos = val.find('e');
bool has_exponent = true;
if (expPos == std::string::npos) expPos = val.find('E');
if (expPos == std::string::npos) {
#pragma empty_line
expPos = len;
has_exponent = false;
}
#pragma empty_line
#pragma empty_line
ans += val.substr(startPos, expPos - startPos);
if (has_exponent) {
#pragma empty_line
std::istringstream iss(val.substr(expPos + 1, len - expPos - 1));
iss >> exp;
}
} else {
#pragma empty_line
size_t expPos = val.find('p');
bool has_exponent = true;
if (expPos == std::string::npos) expPos = val.find('P');
if (expPos == std::string::npos) {
#pragma empty_line
expPos = len;
has_exponent = false;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 484 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 484 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
startPos <= expPos
#pragma line 484 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 484 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"startPos <= expPos"
#pragma line 484 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 484, __extension__ __PRETTY_FUNCTION__))
#pragma line 484 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
#pragma empty_line
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];
}
}
#pragma empty_line
radix = 2;
if (has_exponent) {
#pragma empty_line
std::istringstream iss(val.substr(expPos + 1, len - expPos - 1));
iss >> exp;
}
}
if (exp == 0) return ans;
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma line 643 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
static inline uint64_t mul_1(uint64_t dest[], const uint64_t x[], uint32_t len,
uint64_t y) {
#pragma empty_line
uint64_t ly = y & 0xffffffffULL, hy = (y) >> 32;
uint64_t carry = 0;
static const uint64_t two_power_32 = 1ULL << 32;
#pragma empty_line
for (uint32_t i = 0; i < len; ++i) {
#pragma empty_line
uint64_t lx = x[i] & 0xffffffffULL;
uint64_t hx = (x[i]) >> 32;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
uint8_t hasCarry = 0;
dest[i] = carry + lx * ly;
#pragma empty_line
hasCarry = (dest[i] < carry) ? 1 : 0;
carry = hx * ly + ((dest[i]) >> 32) + (hasCarry ? two_power_32 : 0);
#pragma empty_line
#pragma empty_line
hasCarry = (!carry && hasCarry) ? 1 : (!carry ? 2 : 0);
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static inline void mul(uint64_t dest[], const uint64_t x[], uint32_t xlen,
const uint64_t y[], uint32_t ylen, uint32_t destlen) {
#pragma empty_line
#pragma line 683 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 683 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
xlen > 0
#pragma line 683 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 683 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"xlen > 0"
#pragma line 683 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 683, __extension__ __PRETTY_FUNCTION__))
#pragma line 683 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
#pragma empty_line
#pragma line 684 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 684 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
ylen > 0
#pragma line 684 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 684 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"ylen > 0"
#pragma line 684 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 684, __extension__ __PRETTY_FUNCTION__))
#pragma line 684 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
#pragma empty_line
#pragma line 685 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 685 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
destlen >= xlen + ylen
#pragma line 685 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 685 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"destlen >= xlen + ylen"
#pragma line 685 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 685, __extension__ __PRETTY_FUNCTION__))
#pragma line 685 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static inline void KnuthDiv(uint32_t* u, uint32_t* v, uint32_t* q, uint32_t* r,
uint32_t m, uint32_t n) {
#pragma empty_line
#pragma line 720 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 720 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
u && "Must provide dividend"
#pragma line 720 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 720 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"u && \"Must provide dividend\""
#pragma line 720 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 720, __extension__ __PRETTY_FUNCTION__))
#pragma line 720 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
#pragma empty_line
#pragma line 721 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 721 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
v && "Must provide divisor"
#pragma line 721 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 721 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"v && \"Must provide divisor\""
#pragma line 721 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 721, __extension__ __PRETTY_FUNCTION__))
#pragma line 721 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
#pragma empty_line
#pragma line 722 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 722 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
q && "Must provide quotient"
#pragma line 722 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 722 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"q && \"Must provide quotient\""
#pragma line 722 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 722, __extension__ __PRETTY_FUNCTION__))
#pragma line 722 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
#pragma empty_line
#pragma line 723 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 723 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
u != v && u != q && v != q && "Must us different memory"
#pragma line 723 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 723 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"u != v && u != q && v != q && \"Must us different memory\""
#pragma line 723 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 723, __extension__ __PRETTY_FUNCTION__))
#pragma line 723 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
#pragma empty_line
#pragma line 724 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 724 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
n > 1 && "n must be > 1"
#pragma line 724 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 724 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"n > 1 && \"n must be > 1\""
#pragma line 724 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 724, __extension__ __PRETTY_FUNCTION__))
#pragma line 724 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
#pragma empty_line
#pragma empty_line
#pragma empty_line
uint64_t b = uint64_t(1) << 32;
#pragma line 746 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma line 771 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
int j = m;
do {
#pragma line 782 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
uint64_t dividend = ((uint64_t(u[j + n]) << 32) + u[j + n - 1]);
#pragma empty_line
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--;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
}
#pragma line 827 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
q[j] = (uint32_t)qp;
if (isNeg) {
#pragma empty_line
#pragma empty_line
#pragma empty_line
q[j]--;
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
} while (--j >= 0);
#pragma line 871 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
if (r) {
#pragma empty_line
#pragma empty_line
#pragma empty_line
if (shift) {
uint32_t carry = 0;
#pragma empty_line
for (int i = n - 1; i >= 0; i--) {
r[i] = ((u[i]) >> (shift)) | carry;
carry = (u[i]) << (32 - shift);
#pragma empty_line
}
} else {
for (int i = n - 1; i >= 0; i--) {
r[i] = u[i];
#pragma empty_line
}
}
#pragma empty_line
}
#pragma empty_line
}
#pragma empty_line
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) {
#pragma empty_line
#pragma line 899 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 899 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
lhsWords >= rhsWords && "Fractional result"
#pragma line 899 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 899 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"lhsWords >= rhsWords && \"Fractional result\""
#pragma line 899 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 899, __extension__ __PRETTY_FUNCTION__))
#pragma line 899 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
enum { APINT_BITS_PER_WORD = 64 };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
uint64_t mask = ~0ull >> (sizeof(uint32_t) * 8);
uint32_t n = rhsWords * 2;
uint32_t m = (lhsWords * 2) - n;
#pragma empty_line
#pragma empty_line
#pragma empty_line
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];
}
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
memset(__Q, 0, (m + n) * sizeof(uint32_t));
if (Remainder) memset(__R, 0, n * sizeof(uint32_t));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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--;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 968 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 968 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
n != 0 && "Divide by zero?"
#pragma line 968 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 968 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"n != 0 && \"Divide by zero?\""
#pragma line 968 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 968, __extension__ __PRETTY_FUNCTION__))
#pragma line 968 "/home/justin/jhai/Xilinx/Vivado/2018.3/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 {
#pragma empty_line
#pragma empty_line
KnuthDiv(__U, __V, __Q, __R, m, n);
}
#pragma empty_line
#pragma empty_line
if (Quotient) {
#pragma empty_line
if (Quotient->BitWidth != LHS.BitWidth) {
if (Quotient->isSingleWord()) Quotient->set_VAL(0);
} else
Quotient->clear();
#pragma empty_line
#pragma empty_line
#pragma empty_line
if (lhsWords == 1) {
uint64_t tmp =
uint64_t(__Q[0]) | ((uint64_t(__Q[1])) << (APINT_BITS_PER_WORD / 2));
Quotient->set_VAL(tmp);
} else {
#pragma empty_line
#pragma line 1010 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 1010 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
!Quotient->isSingleWord() && "Quotient ap_private not large enough"
#pragma line 1010 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 1010 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"!Quotient->isSingleWord() && \"Quotient ap_private not large enough\""
#pragma line 1010 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
,
"/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
#pragma line 1010 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
,
1011
#pragma line 1010 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, __extension__ __PRETTY_FUNCTION__))
#pragma empty_line
#pragma line 1011 "/home/justin/jhai/Xilinx/Vivado/2018.3/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();
}
#pragma empty_line
#pragma empty_line
if (Remainder) {
#pragma empty_line
if (Remainder->BitWidth != RHS.BitWidth) {
if (Remainder->isSingleWord()) Remainder->set_VAL(0);
} else
Remainder->clear();
#pragma empty_line
#pragma empty_line
#pragma empty_line
if (rhsWords == 1) {
uint64_t tmp =
uint64_t(__R[0]) | ((uint64_t(__R[1])) << (APINT_BITS_PER_WORD / 2));
Remainder->set_VAL(tmp);
} else {
#pragma empty_line
#pragma line 1035 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 1035 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
!Remainder->isSingleWord() && "Remainder ap_private not large enough"
#pragma line 1035 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 1035 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"!Remainder->isSingleWord() && \"Remainder ap_private not large enough\""
#pragma line 1035 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
,
"/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
#pragma line 1035 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
,
1036
#pragma line 1035 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, __extension__ __PRETTY_FUNCTION__))
#pragma empty_line
#pragma line 1036 "/home/justin/jhai/Xilinx/Vivado/2018.3/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();
}
#pragma empty_line
#pragma empty_line
if (__U != &SPACE[0]) {
delete[] __U;
delete[] __V;
delete[] __Q;
delete[] __R;
}
}
#pragma empty_line
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;
#pragma empty_line
#pragma line 1059 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 1059 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
lhsWords >= rhsWords && "Fractional result"
#pragma line 1059 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 1059 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"lhsWords >= rhsWords && \"Fractional result\""
#pragma line 1059 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 1059, __extension__ __PRETTY_FUNCTION__))
#pragma line 1059 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
enum { APINT_BITS_PER_WORD = 64 };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
uint64_t mask = ~0ull >> (sizeof(uint32_t) * 8);
uint32_t n = 2;
uint32_t m = (lhsWords * 2) - n;
#pragma empty_line
#pragma empty_line
#pragma empty_line
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];
}
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
memset(__V, 0, (n) * sizeof(uint32_t));
__V[0] = RHS & mask;
__V[1] = (RHS) >> (sizeof(uint32_t) * 8);
#pragma empty_line
#pragma empty_line
memset(__Q, 0, (m + n) * sizeof(uint32_t));
if (Remainder) memset(__R, 0, n * sizeof(uint32_t));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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--;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1125 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 1125 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
n != 0 && "Divide by zero?"
#pragma line 1125 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 1125 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"n != 0 && \"Divide by zero?\""
#pragma line 1125 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 1125, __extension__ __PRETTY_FUNCTION__))
#pragma line 1125 "/home/justin/jhai/Xilinx/Vivado/2018.3/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 {
#pragma empty_line
#pragma empty_line
KnuthDiv(__U, __V, __Q, __R, m, n);
}
#pragma empty_line
#pragma empty_line
if (Quotient) {
#pragma empty_line
if (Quotient->BitWidth != LHS.BitWidth) {
if (Quotient->isSingleWord()) Quotient->set_VAL(0);
} else
Quotient->clear();
#pragma empty_line
#pragma empty_line
#pragma empty_line
if (lhsWords == 1) {
uint64_t tmp =
uint64_t(__Q[0]) | ((uint64_t(__Q[1])) << (APINT_BITS_PER_WORD / 2));
Quotient->set_VAL(tmp);
} else {
#pragma empty_line
#pragma line 1167 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 1167 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
!Quotient->isSingleWord() && "Quotient ap_private not large enough"
#pragma line 1167 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 1167 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"!Quotient->isSingleWord() && \"Quotient ap_private not large enough\""
#pragma line 1167 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
,
"/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
#pragma line 1167 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
,
1168
#pragma line 1167 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, __extension__ __PRETTY_FUNCTION__))
#pragma empty_line
#pragma line 1168 "/home/justin/jhai/Xilinx/Vivado/2018.3/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();
}
#pragma empty_line
#pragma empty_line
if (Remainder) {
#pragma empty_line
if (Remainder->BitWidth != 64 ) {
if (Remainder->isSingleWord()) Remainder->set_VAL(0);
} else
Remainder->clear();
#pragma empty_line
#pragma empty_line
#pragma empty_line
if (rhsWords == 1) {
uint64_t tmp =
uint64_t(__R[0]) | ((uint64_t(__R[1])) << (APINT_BITS_PER_WORD / 2));
Remainder->set_VAL(tmp);
} else {
#pragma empty_line
#pragma line 1192 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 1192 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
!Remainder->isSingleWord() && "Remainder ap_private not large enough"
#pragma line 1192 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 1192 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"!Remainder->isSingleWord() && \"Remainder ap_private not large enough\""
#pragma line 1192 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
,
"/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
#pragma line 1192 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
,
1193
#pragma line 1192 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, __extension__ __PRETTY_FUNCTION__))
#pragma empty_line
#pragma line 1193 "/home/justin/jhai/Xilinx/Vivado/2018.3/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();
}
#pragma empty_line
#pragma empty_line
if (__U != &SPACE[0]) {
delete[] __U;
delete[] __V;
delete[] __Q;
delete[] __R;
}
}
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
enum {
MIN_INT_BITS = 1,
#pragma empty_line
MAX_INT_BITS = (1 << 23) - 1
#pragma empty_line
};
#pragma line 1280 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
typedef unsigned long long ap_ulong;
typedef signed long long ap_slong;
#pragma empty_line
template <int _AP_N8, bool _AP_S>
struct valtype;
#pragma empty_line
template <int _AP_N8>
struct valtype<_AP_N8, false> {
typedef uint64_t Type;
};
#pragma empty_line
template <int _AP_N8>
struct valtype<_AP_N8, true> {
typedef int64_t Type;
};
#pragma empty_line
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;
};
#pragma empty_line
template <bool enable>
struct ap_private_enable_if {};
template <>
struct ap_private_enable_if<true> {
static const bool isValid = true;
};
#pragma empty_line
#pragma empty_line
template <int _AP_W, bool _AP_S>
class ap_private<_AP_W, _AP_S, true> {
#pragma empty_line
const static bool valid = ap_private_enable_if<_AP_W <= 64>::isValid;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
enum {
BitWidth = _AP_W,
_AP_N = 1,
};
ValType VAL;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
void check_canary() {}
void set_canary() {}
#pragma empty_line
#pragma empty_line
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 {
#pragma empty_line
#pragma line 1411 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 1411 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
0 && "invalid usage"
#pragma line 1411 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 1411 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"0 && \"invalid usage\""
#pragma line 1411 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 1411, __extension__ __PRETTY_FUNCTION__))
#pragma line 1411 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
return 0;
}
inline ValType get_pVal(int i) const volatile { return VAL; }
inline uint64_t* get_pVal() const volatile {
#pragma empty_line
#pragma line 1416 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 1416 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
0 && "invalid usage"
#pragma line 1416 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 1416 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"0 && \"invalid usage\""
#pragma line 1416 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 1416, __extension__ __PRETTY_FUNCTION__))
#pragma line 1416 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
return 0;
}
inline void set_pVal(int i, uint64_t value) { VAL = (ValType)value; }
#pragma empty_line
inline uint32_t getBitWidth() const { return BitWidth; }
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
void operator=(const ap_private& RHS) volatile {
#pragma empty_line
VAL = RHS.get_VAL();
}
#pragma empty_line
ap_private& operator=(const ap_private& RHS) {
#pragma empty_line
VAL = RHS.get_VAL();
return *this;
}
#pragma empty_line
void operator=(const volatile ap_private& RHS) volatile {
#pragma empty_line
VAL = RHS.get_VAL();
}
#pragma empty_line
ap_private& operator=(const volatile ap_private& RHS) {
#pragma empty_line
VAL = RHS.get_VAL();
return *this;
}
#pragma empty_line
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;
}
#pragma line 1475 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma empty_line
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; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline ap_private& operator=(const char* s) {
ap_private tmp(s);
operator=(tmp);
return *this;
}
#pragma empty_line
private:
explicit inline ap_private(uint64_t* val) : VAL(val[0]) {
set_canary();
clearUnusedBits();
check_canary();
}
#pragma empty_line
inline bool isSingleWord() const { return true; }
#pragma empty_line
public:
inline void fromString(const char* strStart, uint32_t slen, uint8_t radix) {
bool isNeg = strStart[0] == '-';
if (isNeg) {
strStart++;
slen--;
}
#pragma empty_line
if (strStart[0] == '0' && (strStart[1] == 'b' || strStart[1] == 'B')) {
#pragma empty_line
do { if ((radix != 2)) { fprintf(
#pragma line 1519 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
stderr
#pragma line 1519 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
, "WARNING: " "%s seems to have base %d, but %d given.", strStart, 2, radix); fprintf(
#pragma line 1519 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
stderr
#pragma line 1519 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
, "\n"); } } while (0);
strStart += 2;
slen -=2;
} else if (strStart[0] == '0' && (strStart[1] == 'o' || strStart[1] == 'O')) {
#pragma empty_line
do { if ((radix != 8)) { fprintf(
#pragma line 1524 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
stderr
#pragma line 1524 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
, "WARNING: " "%s seems to have base %d, but %d given.", strStart, 8, radix); fprintf(
#pragma line 1524 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
stderr
#pragma line 1524 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
, "\n"); } } while (0);
strStart += 2;
slen -=2;
} else if (strStart[0] == '0' && (strStart[1] == 'x' || strStart[1] == 'X')) {
#pragma empty_line
do { if ((radix != 16)) { fprintf(
#pragma line 1529 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
stderr
#pragma line 1529 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
, "WARNING: " "%s seems to have base %d, but %d given.", strStart, 16, radix); fprintf(
#pragma line 1529 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
stderr
#pragma line 1529 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
, "\n"); } } while (0);
strStart += 2;
slen -=2;
} else if (strStart[0] == '0' && (strStart[1] == 'd' || strStart[1] == 'D')) {
#pragma empty_line
do { if ((radix != 10)) { fprintf(
#pragma line 1534 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
stderr
#pragma line 1534 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
, "WARNING: " "%s seems to have base %d, but %d given.", strStart, 10, radix); fprintf(
#pragma line 1534 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
stderr
#pragma line 1534 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
, "\n"); } } while (0);
strStart += 2;
slen -=2;
} else if (radix == 0) {
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1542 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 1542 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
(radix == 10 || radix == 8 || radix == 16 || radix == 2) && "Radix should be 2, 8, 10, or 16!"
#pragma line 1542 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 1542 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"(radix == 10 || radix == 8 || radix == 16 || radix == 2) && \"Radix should be 2, 8, 10, or 16!\""
#pragma line 1542 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
,
"/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
#pragma line 1542 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
,
1543
#pragma line 1542 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, __extension__ __PRETTY_FUNCTION__))
#pragma empty_line
#pragma line 1543 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
#pragma empty_line
#pragma line 1544 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 1544 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
strStart && "String is null?"
#pragma line 1544 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 1544 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"strStart && \"String is null?\""
#pragma line 1544 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 1544, __extension__ __PRETTY_FUNCTION__))
#pragma line 1544 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
#pragma empty_line
#pragma empty_line
uint64_t tmpVAL = VAL = 0;
#pragma empty_line
switch (radix) {
case 2:
#pragma empty_line
#pragma empty_line
for (; *strStart; ++strStart) {
#pragma empty_line
#pragma line 1554 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 1554 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
(*strStart == '0' || *strStart == '1') && ("Wrong binary number")
#pragma line 1554 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 1554 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"(*strStart == '0' || *strStart == '1') && (\"Wrong binary number\")"
#pragma line 1554 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
,
"/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
#pragma line 1554 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
,
1555
#pragma line 1554 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, __extension__ __PRETTY_FUNCTION__))
#pragma empty_line
#pragma line 1555 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
tmpVAL <<= 1;
tmpVAL |= (*strStart - '0');
}
break;
case 8:
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
sscanf(strStart, "%lo", &tmpVAL);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
break;
case 10:
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
sscanf(strStart, "%lu", &tmpVAL);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
break;
case 16:
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
sscanf(strStart, "%lx", &tmpVAL);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
break;
default:
#pragma empty_line
#pragma line 1594 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 1594 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
true && "Unknown radix"
#pragma line 1594 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 1594 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"true && \"Unknown radix\""
#pragma line 1594 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 1594, __extension__ __PRETTY_FUNCTION__))
#pragma line 1594 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
#pragma empty_line
}
VAL = isNeg ? (ValType)(-tmpVAL) : (ValType)(tmpVAL);
#pragma empty_line
clearUnusedBits();
}
#pragma empty_line
private:
inline ap_private(const std::string& val, uint8_t radix = 2) : VAL(0) {
#pragma empty_line
#pragma line 1604 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 1604 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
!val.empty() && "String empty?"
#pragma line 1604 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 1604 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"!val.empty() && \"String empty?\""
#pragma line 1604 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 1604, __extension__ __PRETTY_FUNCTION__))
#pragma line 1604 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
set_canary();
fromString(val.c_str(), val.size(), radix);
check_canary();
}
#pragma empty_line
inline ap_private(const char strStart[], uint32_t slen, uint8_t radix)
: VAL(0) {
set_canary();
fromString(strStart, slen, radix);
check_canary();
}
#pragma empty_line
inline ap_private(uint32_t numWords, const uint64_t bigVal[])
: VAL(bigVal[0]) {
set_canary();
clearUnusedBits();
check_canary();
}
#pragma empty_line
public:
inline ap_private() {
set_canary();
clearUnusedBits();
check_canary();
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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(); }
#pragma empty_line
#pragma empty_line
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();
}
#pragma empty_line
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();
}
#pragma empty_line
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('.');
#pragma empty_line
if (pos != std::string::npos) str = str.substr(pos);
#pragma empty_line
ap_private<_AP_W, _AP_S> ap_private_val(str, radix);
operator=(ap_private_val);
check_canary();
}
#pragma empty_line
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('.');
#pragma empty_line
if (pos != std::string::npos) str = str.substr(pos);
#pragma empty_line
ap_private<_AP_W, _AP_S> ap_private_val(str, radix);
operator=(ap_private_val);
check_canary();
}
#pragma empty_line
inline ~ap_private() { check_canary(); }
#pragma empty_line
inline bool isNegative() const {
static const uint64_t sign_mask = 1ULL << (_AP_W - 1);
return _AP_S && (sign_mask & VAL);
}
#pragma empty_line
inline bool isPositive() const { return !isNegative(); }
#pragma empty_line
inline bool isStrictlyPositive() const { return !isNegative() && VAL != 0; }
#pragma empty_line
inline bool isAllOnesValue() const { return (mask & VAL) == mask; }
#pragma empty_line
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();
}
#pragma empty_line
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();
}
#pragma empty_line
#pragma empty_line
const ap_private operator++(int) {
ap_private orig(*this);
VAL++;
clearUnusedBits();
return orig;
}
#pragma empty_line
#pragma empty_line
const ap_private operator++() {
++VAL;
clearUnusedBits();
return *this;
}
#pragma empty_line
#pragma empty_line
const ap_private operator--(int) {
ap_private orig(*this);
--VAL;
clearUnusedBits();
return orig;
}
#pragma empty_line
#pragma empty_line
const ap_private operator--() {
--VAL;
clearUnusedBits();
return *this;
}
#pragma empty_line
#pragma empty_line
inline ap_private<_AP_W + !_AP_S, true> operator~() const {
ap_private<_AP_W + !_AP_S, true> Result(*this);
Result.flip();
return Result;
}
#pragma empty_line
#pragma empty_line
inline typename RType<1, false>::minus operator-() const {
return ap_private<1, false>(0) - (*this);
}
#pragma empty_line
#pragma empty_line
inline bool operator!() const { return !VAL; }
#pragma empty_line
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;
}
#pragma empty_line
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));
}
#pragma empty_line
inline ap_private lshr(uint32_t shiftAmt) const {
return ap_private((shiftAmt == BitWidth)
? ap_private(0)
: ap_private((VAL & mask) >> (shiftAmt)));
}
#pragma empty_line
inline ap_private shl(uint32_t shiftAmt) const
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
{
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));
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
inline int64_t getSExtValue() const { return VAL; }
#pragma empty_line
#pragma empty_line
inline uint64_t getZExtValue() const { return VAL & mask; }
#pragma empty_line
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();
}
#pragma empty_line
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();
}
#pragma line 1863 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
inline void write(const ap_private<_AP_W, _AP_S>& op2) volatile {
*this = (op2);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline operator ValType() const { return get_VAL(); }
#pragma empty_line
inline int to_uchar() const { return (unsigned char)get_VAL(); }
#pragma empty_line
inline int to_char() const { return (signed char)get_VAL(); }
#pragma empty_line
inline int to_ushort() const { return (unsigned short)get_VAL(); }
#pragma empty_line
inline int to_short() const { return (short)get_VAL(); }
#pragma empty_line
inline int to_int() const {
#pragma empty_line
return (int)get_VAL();
}
#pragma empty_line
inline unsigned to_uint() const { return (unsigned)get_VAL(); }
#pragma empty_line
inline long to_long() const { return (long)get_VAL(); }
#pragma empty_line
inline unsigned long to_ulong() const { return (unsigned long)get_VAL(); }
#pragma empty_line
inline ap_slong to_int64() const { return (ap_slong)get_VAL(); }
#pragma empty_line
inline ap_ulong to_uint64() const { return (ap_ulong)get_VAL(); }
#pragma empty_line
inline double to_double() const {
if (isNegative())
return roundToDouble(true);
else
return roundToDouble(false);
}
#pragma empty_line
inline unsigned length() const { return _AP_W; }
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
}
#pragma empty_line
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;
}
}
#pragma empty_line
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;
}
}
#pragma empty_line
inline ap_private And(const ap_private& RHS) const {
return ap_private(VAL & RHS.get_VAL());
}
#pragma empty_line
inline ap_private Or(const ap_private& RHS) const {
return ap_private(VAL | RHS.get_VAL());
}
#pragma empty_line
inline ap_private Xor(const ap_private& RHS) const {
return ap_private(VAL ^ RHS.get_VAL());
}
#pragma empty_line
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;
}
}
#pragma empty_line
inline ap_private Mul(const ap_private& RHS) const {
return ap_private(VAL * RHS.get_VAL());
}
#pragma empty_line
inline ap_private Add(const ap_private& RHS) const {
return ap_private(VAL + RHS.get_VAL());
}
#pragma empty_line
inline ap_private Sub(const ap_private& RHS) const {
return ap_private(VAL - RHS.get_VAL());
}
#pragma empty_line
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;
}
#pragma empty_line
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));
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
inline ap_private<_AP_W, _AP_S>& set(uint32_t bitPosition) {
VAL |= (1ULL << (bitPosition));
clearUnusedBits();
return *this;
}
#pragma empty_line
inline void set() {
VAL = (ValType)~0ULL;
clearUnusedBits();
}
#pragma empty_line
template <int _AP_W3>
inline void set(const ap_private<_AP_W3, false>& val) {
operator=(ap_private<_AP_W3, _AP_S>(val));
}
#pragma empty_line
inline void set(const ap_private& val) { operator=(val); }
#pragma empty_line
inline void clearUnusedBits(void)
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
{
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));
}
#pragma empty_line
inline void clearUnusedBitsToZero(void) {
enum { excess_bits = (_AP_W % 64) ? 64 - _AP_W % 64 : 0 };
static uint64_t mask = ~0ULL >> (excess_bits);
VAL &= mask;
}
#pragma empty_line
inline ap_private udiv(const ap_private& RHS) const {
return ap_private((uint64_t)VAL / RHS.get_VAL());
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
template <bool _AP_S2>
inline ap_private urem(const ap_private<_AP_W, _AP_S2>& RHS) const {
#pragma empty_line
#pragma line 2169 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 2169 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
RHS.get_VAL() != 0 && "Divide by 0"
#pragma line 2169 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 2169 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"RHS.get_VAL() != 0 && \"Divide by 0\""
#pragma line 2169 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 2169, __extension__ __PRETTY_FUNCTION__))
#pragma line 2169 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
return ap_private(((uint64_t)VAL) % ((uint64_t)RHS.get_VAL()));
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
template <int _AP_W1, bool _AP_S1>
inline bool eq(const ap_private<_AP_W1, _AP_S1>& RHS) const {
return (*this) == RHS;
}
#pragma empty_line
template <int _AP_W1, bool _AP_S1>
inline bool ne(const ap_private<_AP_W1, _AP_S1>& RHS) const {
return !((*this) == RHS);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template <int _AP_W1, bool _AP_S1>
inline bool slt(const ap_private<_AP_W1, _AP_S1>& RHS) const
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
{
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);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template <int _AP_W1, bool _AP_S1>
inline bool ule(const ap_private<_AP_W1, _AP_S1>& RHS) const {
return ult(RHS) || eq(RHS);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template <int _AP_W1, bool _AP_S1>
inline bool sle(const ap_private<_AP_W1, _AP_S1>& RHS) const {
return slt(RHS) || eq(RHS);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template <int _AP_W1, bool _AP_S1>
inline bool ugt(const ap_private<_AP_W1, _AP_S1>& RHS) const {
return !ult(RHS) && !eq(RHS);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template <int _AP_W1, bool _AP_S1>
inline bool sgt(const ap_private<_AP_W1, _AP_S1>& RHS) const {
return !slt(RHS) && !eq(RHS);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template <int _AP_W1, bool _AP_S1>
inline bool uge(const ap_private<_AP_W1, _AP_S1>& RHS) const {
return !ult(RHS);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template <int _AP_W1, bool _AP_S1>
inline bool sge(const ap_private<_AP_W1, _AP_S1>& RHS) const {
return !slt(RHS);
}
#pragma empty_line
inline ap_private abs() const {
if (isNegative()) return -(*this);
return *this;
}
#pragma empty_line
inline ap_private<_AP_W, false> get() const {
ap_private<_AP_W, false> ret(*this);
return ret;
}
#pragma empty_line
inline static uint32_t getBitsNeeded(const char* str, uint32_t slen,
uint8_t radix) {
return _AP_W;
}
#pragma empty_line
inline uint32_t getActiveBits() const {
uint32_t bits = _AP_W - countLeadingZeros();
return bits ? bits : 1;
}
#pragma empty_line
inline double roundToDouble(bool isSigned = false) const {
return isSigned ? double((int64_t)VAL) : double((uint64_t)VAL);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
inline bool iszero() const { return isMinValue(); }
#pragma empty_line
inline bool to_bool() const { return !iszero(); }
#pragma empty_line
#pragma empty_line
inline bool sign() const {
if (isNegative()) return true;
return false;
}
#pragma empty_line
#pragma empty_line
inline void invert(int i) {
#pragma empty_line
#pragma line 2345 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 2345 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
i >= 0 && "Attempting to read bit with negative index"
#pragma line 2345 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 2345 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"i >= 0 && \"Attempting to read bit with negative index\""
#pragma line 2345 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 2345, __extension__ __PRETTY_FUNCTION__))
#pragma line 2345 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
#pragma empty_line
#pragma line 2346 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 2346 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
i < _AP_W && "Attempting to read bit beyond MSB"
#pragma line 2346 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 2346 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"i < _AP_W && \"Attempting to read bit beyond MSB\""
#pragma line 2346 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 2346, __extension__ __PRETTY_FUNCTION__))
#pragma line 2346 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
flip(i);
}
#pragma empty_line
#pragma empty_line
inline bool test(int i) const {
#pragma empty_line
#pragma line 2352 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 2352 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
i >= 0 && "Attempting to read bit with negative index"
#pragma line 2352 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 2352 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"i >= 0 && \"Attempting to read bit with negative index\""
#pragma line 2352 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 2352, __extension__ __PRETTY_FUNCTION__))
#pragma line 2352 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
#pragma empty_line
#pragma line 2353 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 2353 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
i < _AP_W && "Attempting to read bit beyond MSB"
#pragma line 2353 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 2353 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"i < _AP_W && \"Attempting to read bit beyond MSB\""
#pragma line 2353 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 2353, __extension__ __PRETTY_FUNCTION__))
#pragma line 2353 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
return operator[](i);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline void lrotate(int n) {
#pragma empty_line
#pragma line 2360 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 2360 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
n >= 0 && "Attempting to shift negative index"
#pragma line 2360 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 2360 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"n >= 0 && \"Attempting to shift negative index\""
#pragma line 2360 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 2360, __extension__ __PRETTY_FUNCTION__))
#pragma line 2360 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
#pragma empty_line
#pragma line 2361 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 2361 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
n < _AP_W && "Shift value larger than bit width"
#pragma line 2361 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 2361 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"n < _AP_W && \"Shift value larger than bit width\""
#pragma line 2361 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 2361, __extension__ __PRETTY_FUNCTION__))
#pragma line 2361 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
operator=(shl(n) | lshr(_AP_W - n));
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline void rrotate(int n) {
#pragma empty_line
#pragma line 2368 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 2368 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
n >= 0 && "Attempting to shift negative index"
#pragma line 2368 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 2368 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"n >= 0 && \"Attempting to shift negative index\""
#pragma line 2368 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 2368, __extension__ __PRETTY_FUNCTION__))
#pragma line 2368 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
#pragma empty_line
#pragma line 2369 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 2369 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
n < _AP_W && "Shift value larger than bit width"
#pragma line 2369 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 2369 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"n < _AP_W && \"Shift value larger than bit width\""
#pragma line 2369 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 2369, __extension__ __PRETTY_FUNCTION__))
#pragma line 2369 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
operator=(lshr(n) | shl(_AP_W - n));
}
#pragma empty_line
#pragma empty_line
inline void set(int i, bool v) {
#pragma empty_line
#pragma line 2375 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 2375 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
i >= 0 && "Attempting to write bit with negative index"
#pragma line 2375 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 2375 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"i >= 0 && \"Attempting to write bit with negative index\""
#pragma line 2375 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 2375, __extension__ __PRETTY_FUNCTION__))
#pragma line 2375 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
#pragma empty_line
#pragma line 2376 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 2376 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
i < _AP_W && "Attempting to write bit beyond MSB"
#pragma line 2376 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 2376 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"i < _AP_W && \"Attempting to write bit beyond MSB\""
#pragma line 2376 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 2376, __extension__ __PRETTY_FUNCTION__))
#pragma line 2376 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
v ? set(i) : clear(i);
}
#pragma empty_line
#pragma empty_line
inline void set_bit(int i, bool v) {
#pragma empty_line
#pragma line 2382 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 2382 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
i >= 0 && "Attempting to write bit with negative index"
#pragma line 2382 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 2382 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"i >= 0 && \"Attempting to write bit with negative index\""
#pragma line 2382 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 2382, __extension__ __PRETTY_FUNCTION__))
#pragma line 2382 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
#pragma empty_line
#pragma line 2383 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 2383 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
i < _AP_W && "Attempting to write bit beyond MSB"
#pragma line 2383 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 2383 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"i < _AP_W && \"Attempting to write bit beyond MSB\""
#pragma line 2383 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 2383, __extension__ __PRETTY_FUNCTION__))
#pragma line 2383 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
v ? set(i) : clear(i);
}
#pragma empty_line
#pragma empty_line
inline bool get_bit(int i) const {
#pragma empty_line
#pragma line 2389 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 2389 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
i >= 0 && "Attempting to read bit with negative index"
#pragma line 2389 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 2389 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"i >= 0 && \"Attempting to read bit with negative index\""
#pragma line 2389 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 2389, __extension__ __PRETTY_FUNCTION__))
#pragma line 2389 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
#pragma empty_line
#pragma line 2390 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 2390 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
i < _AP_W && "Attempting to read bit beyond MSB"
#pragma line 2390 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 2390 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"i < _AP_W && \"Attempting to read bit beyond MSB\""
#pragma line 2390 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 2390, __extension__ __PRETTY_FUNCTION__))
#pragma line 2390 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
return (((1ULL << i) & VAL) != 0);
}
#pragma empty_line
#pragma empty_line
inline ap_private& flip() {
VAL = (ValType)((~0ULL ^ VAL) & mask);
clearUnusedBits();
return *this;
}
#pragma empty_line
#pragma empty_line
inline ap_private& flip(uint32_t bitPosition) {
#pragma empty_line
#pragma line 2403 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 2403 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
bitPosition < BitWidth && "Out of the bit-width range!"
#pragma line 2403 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 2403 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"bitPosition < BitWidth && \"Out of the bit-width range!\""
#pragma line 2403 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 2403, __extension__ __PRETTY_FUNCTION__))
#pragma line 2403 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
set_bit(bitPosition, !get_bit(bitPosition));
return *this;
}
#pragma empty_line
#pragma empty_line
inline void b_not() { flip(); }
#pragma line 2428 "/home/justin/jhai/Xilinx/Vivado/2018.3/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));
}
#pragma empty_line
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;
}
#pragma line 2468 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma line 2486 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
}
#pragma line 2530 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
}
#pragma line 2586 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline bool operator!=(const ap_private<_AP_W2, _AP_S2>& op) const {
return !(*this == op);
}
#pragma empty_line
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);
#pragma empty_line
#pragma empty_line
if (_AP_S == _AP_S2)
return _AP_S ? lhs.sgt(rhs) : lhs.ugt(rhs);
else if (_AP_W < 32 && _AP_W2 < 32)
#pragma empty_line
return lhs.sgt(rhs);
else
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline bool operator<=(const ap_private<_AP_W2, _AP_S2>& op) const {
return !(*this > op);
}
#pragma empty_line
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);
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline bool operator>=(const ap_private<_AP_W2, _AP_S2>& op) const {
return !(*this < op);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline _private_range_ref<_AP_W, _AP_S> operator()(int Hi, int Lo) {
return _private_range_ref<_AP_W, _AP_S>(this, Hi, Lo);
}
#pragma empty_line
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);
}
#pragma empty_line
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);
}
#pragma empty_line
inline _private_range_ref<_AP_W, _AP_S> range(int Hi, int Lo) {
return _private_range_ref<_AP_W, _AP_S>(this, Hi, Lo);
}
#pragma empty_line
inline _private_bit_ref<_AP_W, _AP_S> operator[](int index) {
return _private_bit_ref<_AP_W, _AP_S>(*this, index);
}
#pragma empty_line
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());
}
#pragma empty_line
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);
}
#pragma empty_line
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());
}
#pragma empty_line
inline _private_bit_ref<_AP_W, _AP_S> bit(int index) {
return _private_bit_ref<_AP_W, _AP_S>(*this, index);
}
#pragma empty_line
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());
}
#pragma empty_line
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);
}
#pragma empty_line
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());
}
#pragma line 2911 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
inline bool and_reduce() const { return (VAL & mask) == mask; }
#pragma empty_line
inline bool nand_reduce() const { return (VAL & mask) != mask; }
#pragma empty_line
inline bool or_reduce() const { return (bool)VAL; }
#pragma empty_line
inline bool nor_reduce() const { return VAL == 0; }
#pragma empty_line
inline bool xor_reduce() const {
unsigned int i = countPopulation();
return (i % 2) ? true : false;
}
#pragma empty_line
inline bool xnor_reduce() const {
unsigned int i = countPopulation();
return (i % 2) ? false : true;
}
#pragma empty_line
inline std::string to_string(uint8_t radix = 2, bool sign = false) const {
return toString(radix, radix == 10 ? _AP_S : sign);
}
};
#pragma empty_line
template <int _AP_W, bool _AP_S>
std::string ap_private<_AP_W, _AP_S, true>::toString(uint8_t radix,
bool wantSigned) const {
#pragma empty_line
#pragma line 2937 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 2937 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
(radix == 10 || radix == 8 || radix == 16 || radix == 2) && "Radix should be 2, 8, 10, or 16!"
#pragma line 2937 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 2937 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"(radix == 10 || radix == 8 || radix == 16 || radix == 2) && \"Radix should be 2, 8, 10, or 16!\""
#pragma line 2937 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
,
"/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
#pragma line 2937 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
,
2938
#pragma line 2937 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, __extension__ __PRETTY_FUNCTION__))
#pragma empty_line
#pragma line 2938 "/home/justin/jhai/Xilinx/Vivado/2018.3/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) {
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
if (*this == (uint64_t)(0)) {
#pragma empty_line
#pragma empty_line
switch (radix) {
case 2:
result = "0b0";
break;
case 8:
result = "0o0";
break;
case 16:
result = "0x0";
break;
default:
#pragma empty_line
#pragma line 2962 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 2962 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"invalid radix" && 0
#pragma line 2962 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 2962 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"\"invalid radix\" && 0"
#pragma line 2962 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 2962, __extension__ __PRETTY_FUNCTION__))
#pragma line 2962 "/home/justin/jhai/Xilinx/Vivado/2018.3/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()) {
#pragma empty_line
#pragma empty_line
#pragma empty_line
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:
#pragma empty_line
#pragma line 2989 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 2989 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"invalid radix" && 0
#pragma line 2989 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 2989 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"\"invalid radix\" && 0"
#pragma line 2989 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 2989, __extension__ __PRETTY_FUNCTION__))
#pragma line 2989 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
}
insert_at += 2;
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
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()) {
#pragma empty_line
#pragma empty_line
#pragma empty_line
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());
#pragma empty_line
#pragma line 3033 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 3033 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
digit < radix && "divide failed"
#pragma line 3033 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 3033 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"digit < radix && \"divide failed\""
#pragma line 3033 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 3033, __extension__ __PRETTY_FUNCTION__))
#pragma line 3033 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
result.insert(insert_at, digits[digit]);
tmp = tmp2;
}
return result;
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
template <int _AP_W, bool _AP_S>
class ap_private<_AP_W, _AP_S, false> {
#pragma empty_line
const static bool valid = ap_private_enable_if<(_AP_W > 64)>::isValid;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
public:
enum { BitWidth = _AP_W, _AP_N = (_AP_W + 63) / 64 };
static const int width = _AP_W;
#pragma empty_line
private:
#pragma line 3065 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
inline ap_private(uint32_t numWords, const uint64_t bigVal[]) {
set_canary();
#pragma empty_line
#pragma line 3067 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 3067 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
bigVal && "Null pointer detected!"
#pragma line 3067 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 3067 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"bigVal && \"Null pointer detected!\""
#pragma line 3067 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 3067, __extension__ __PRETTY_FUNCTION__))
#pragma line 3067 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
{
#pragma empty_line
memset(pVal, 0, _AP_N * sizeof(uint64_t));
#pragma empty_line
#pragma empty_line
uint32_t words = AESL_std::min<uint32_t>(numWords, _AP_N);
#pragma empty_line
memcpy(pVal, bigVal, words * APINT_WORD_SIZE);
if (words >= _AP_W) clearUnusedBits();
#pragma empty_line
}
check_canary();
}
#pragma line 3090 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
inline ap_private(const std::string& val, uint8_t radix = 2) {
set_canary();
#pragma empty_line
#pragma line 3092 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 3092 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
!val.empty() && "The input string is empty."
#pragma line 3092 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 3092 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"!val.empty() && \"The input string is empty.\""
#pragma line 3092 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 3092, __extension__ __PRETTY_FUNCTION__))
#pragma line 3092 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
const char* c_str = val.c_str();
fromString(c_str, val.size(), radix);
check_canary();
}
#pragma line 3108 "/home/justin/jhai/Xilinx/Vivado/2018.3/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();
}
#pragma empty_line
inline void report() {
do { if ((_AP_W > ((1024 + 1023) / 1024) * 1024)) { fprintf(
#pragma line 3115 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
stderr
#pragma line 3115 "/home/justin/jhai/Xilinx/Vivado/2018.3/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(
#pragma line 3115 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
stderr
#pragma line 3115 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
, "\n"); abort(); } } while (0)
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
uint64_t pVal[_AP_N];
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline void check_canary() {}
inline void set_canary() {}
#pragma empty_line
#pragma empty_line
public:
typedef typename valtype<8, _AP_S>::Type ValType;
typedef ap_private<_AP_W, _AP_S> Type;
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
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;
};
#pragma empty_line
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; }
#pragma empty_line
#pragma empty_line
enum {
APINT_BITS_PER_WORD = sizeof(uint64_t) * 8,
APINT_WORD_SIZE = sizeof(uint64_t)
};
#pragma empty_line
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));
#pragma empty_line
public:
#pragma empty_line
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();
}
#pragma empty_line
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();
#pragma empty_line
report();
check_canary();
}
#pragma empty_line
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();
}
#pragma empty_line
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();
}
#pragma line 3272 "/home/justin/jhai/Xilinx/Vivado/2018.3/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();
}
#pragma empty_line
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();
}
#pragma empty_line
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();
}
#pragma empty_line
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();
}
#pragma empty_line
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();
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline ~ap_private() { check_canary(); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline ap_private() {
set_canary();
clearUnusedBits();
check_canary();
}
#pragma empty_line
inline ap_private(uint64_t* val, uint32_t bits = _AP_W) {
#pragma line 3335 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 3335 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
0
#pragma line 3335 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 3335 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"0"
#pragma line 3335 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 3335, __extension__ __PRETTY_FUNCTION__))
#pragma line 3335 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
; }
inline ap_private(const uint64_t* const val, uint32_t bits) {
#pragma line 3336 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 3336 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
0
#pragma line 3336 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 3336 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"0"
#pragma line 3336 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 3336, __extension__ __PRETTY_FUNCTION__))
#pragma line 3336 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
; }
#pragma line 3359 "/home/justin/jhai/Xilinx/Vivado/2018.3/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(); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline bool isSingleWord() const { return false; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
static inline uint32_t whichWord(uint32_t bitPosition) {
#pragma empty_line
return (bitPosition) >> 6;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static inline uint32_t whichBit(uint32_t bitPosition) {
#pragma empty_line
return bitPosition & 0x3f;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static inline uint64_t maskBit(uint32_t bitPosition) {
return 1ULL << (whichBit(bitPosition));
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline uint64_t getWord(uint32_t bitPosition) const {
return pVal[whichWord(bitPosition)];
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline void clearUnusedBits(void)
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
{
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]);
}
#pragma empty_line
inline void clearUnusedBitsToZero(void) { pVal[_AP_N - 1] &= mask; }
#pragma empty_line
inline void clearUnusedBitsToOne(void) { pVal[_AP_N - 1] |= mask; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline void fromString(const char* str, uint32_t slen, uint8_t radix) {
enum { numbits = _AP_W };
bool isNeg = str[0] == '-';
if (isNeg) {
str++;
slen--;
}
#pragma empty_line
if (str[0] == '0' && (str[1] == 'b' || str[1] == 'B')) {
#pragma empty_line
do { if ((radix != 2)) { fprintf(
#pragma line 3443 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
stderr
#pragma line 3443 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
, "WARNING: " "%s seems to have base %d, but %d given.", str, 2, radix); fprintf(
#pragma line 3443 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
stderr
#pragma line 3443 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
, "\n"); } } while (0);
str += 2;
slen -=2;
} else if (str[0] == '0' && (str[1] == 'o' || str[1] == 'O')) {
#pragma empty_line
do { if ((radix != 8)) { fprintf(
#pragma line 3448 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
stderr
#pragma line 3448 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
, "WARNING: " "%s seems to have base %d, but %d given.", str, 8, radix); fprintf(
#pragma line 3448 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
stderr
#pragma line 3448 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
, "\n"); } } while (0);
str += 2;
slen -=2;
} else if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X')) {
#pragma empty_line
do { if ((radix != 16)) { fprintf(
#pragma line 3453 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
stderr
#pragma line 3453 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
, "WARNING: " "%s seems to have base %d, but %d given.", str, 16, radix); fprintf(
#pragma line 3453 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
stderr
#pragma line 3453 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
, "\n"); } } while (0);
str += 2;
slen -=2;
} else if (str[0] == '0' && (str[1] == 'd' || str[1] == 'D')) {
#pragma empty_line
do { if ((radix != 10)) { fprintf(
#pragma line 3458 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
stderr
#pragma line 3458 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
, "WARNING: " "%s seems to have base %d, but %d given.", str, 10, radix); fprintf(
#pragma line 3458 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
stderr
#pragma line 3458 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
, "\n"); } } while (0);
str += 2;
slen -=2;
} else if (radix == 0) {
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 3466 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 3466 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
(radix == 10 || radix == 8 || radix == 16 || radix == 2) && "Radix should be 2, 8, 10, or 16!"
#pragma line 3466 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 3466 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"(radix == 10 || radix == 8 || radix == 16 || radix == 2) && \"Radix should be 2, 8, 10, or 16!\""
#pragma line 3466 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
,
"/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
#pragma line 3466 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
,
3467
#pragma line 3466 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, __extension__ __PRETTY_FUNCTION__))
#pragma empty_line
#pragma line 3467 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
#pragma empty_line
#pragma line 3468 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 3468 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
str && "String is null?"
#pragma line 3468 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 3468 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"str && \"String is null?\""
#pragma line 3468 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 3468, __extension__ __PRETTY_FUNCTION__))
#pragma line 3468 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
#pragma empty_line
#pragma empty_line
while (*str == '0' && *(str + 1) != '\0') {
str++;
slen--;
}
#pragma empty_line
#pragma line 3475 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 3475 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
(slen <= numbits || radix != 2) && "Insufficient bit width"
#pragma line 3475 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 3475 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"(slen <= numbits || radix != 2) && \"Insufficient bit width\""
#pragma line 3475 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 3475, __extension__ __PRETTY_FUNCTION__))
#pragma line 3475 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
#pragma empty_line
#pragma line 3476 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 3476 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
((slen - 1) * 3 <= numbits || radix != 8) && "Insufficient bit width"
#pragma line 3476 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 3476 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"((slen - 1) * 3 <= numbits || radix != 8) && \"Insufficient bit width\""
#pragma line 3476 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
,
"/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
#pragma line 3476 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
,
3477
#pragma line 3476 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, __extension__ __PRETTY_FUNCTION__))
#pragma empty_line
#pragma line 3477 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
#pragma empty_line
#pragma line 3478 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 3478 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
((slen - 1) * 4 <= numbits || radix != 16) && "Insufficient bit width"
#pragma line 3478 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 3478 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"((slen - 1) * 4 <= numbits || radix != 16) && \"Insufficient bit width\""
#pragma line 3478 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
,
"/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
#pragma line 3478 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
,
3479
#pragma line 3478 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, __extension__ __PRETTY_FUNCTION__))
#pragma empty_line
#pragma line 3479 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
#pragma empty_line
#pragma line 3480 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 3480 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
(((slen - 1) * 64) / 22 <= numbits || radix != 10) && "Insufficient bit width"
#pragma line 3480 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 3480 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"(((slen - 1) * 64) / 22 <= numbits || radix != 10) && \"Insufficient bit width\""
#pragma line 3480 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
,
"/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
#pragma line 3480 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
,
3481
#pragma line 3480 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, __extension__ __PRETTY_FUNCTION__))
#pragma empty_line
#pragma line 3481 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
#pragma empty_line
#pragma empty_line
memset(pVal, 0, _AP_N * sizeof(uint64_t));
#pragma empty_line
#pragma empty_line
uint32_t shift = (radix == 16 ? 4 : radix == 8 ? 3 : radix == 2 ? 1 : 0);
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
#pragma empty_line
#pragma empty_line
for (unsigned i = 0; i < slen; i++) {
#pragma empty_line
uint32_t digit = 0;
char cdigit = str[i];
if (radix == 16) {
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
if (!(((cdigit) >= '0' && (cdigit) <= '9') || ((cdigit) >= 'a' && (cdigit) <= 'f') || ((cdigit) >= 'A' && (cdigit) <= 'F')))
#pragma line 3506 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 3506 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
0 && "Invalid hex digit in string"
#pragma line 3506 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 3506 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"0 && \"Invalid hex digit in string\""
#pragma line 3506 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 3506, __extension__ __PRETTY_FUNCTION__))
#pragma line 3506 "/home/justin/jhai/Xilinx/Vivado/2018.3/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
#pragma empty_line
#pragma line 3514 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 3514 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
0 && "huh? we shouldn't get here"
#pragma line 3514 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 3514 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"0 && \"huh? we shouldn't get here\""
#pragma line 3514 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 3514, __extension__ __PRETTY_FUNCTION__))
#pragma line 3514 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
} else if (((cdigit) >= '0' && (cdigit) <= '9')) {
digit = cdigit - '0';
} else if (cdigit != '\0') {
#pragma empty_line
#pragma line 3518 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 3518 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
0 && "Invalid character in digit string"
#pragma line 3518 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 3518 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"0 && \"Invalid character in digit string\""
#pragma line 3518 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 3518, __extension__ __PRETTY_FUNCTION__))
#pragma line 3518 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
if (shift)
*this <<= shift;
else
*this *= apradix;
#pragma empty_line
#pragma empty_line
apdigit.set_VAL(digit);
*this += apdigit;
}
#pragma empty_line
if (isNeg) {
(*this)--;
this->flip();
}
clearUnusedBits();
}
#pragma empty_line
inline ap_private read() volatile { return *this; }
#pragma empty_line
inline void write(const ap_private& op2) volatile { *this = (op2); }
#pragma empty_line
inline operator ValType() const { return get_VAL(); }
#pragma empty_line
inline int to_uchar() const { return (unsigned char)get_VAL(); }
#pragma empty_line
inline int to_char() const { return (signed char)get_VAL(); }
#pragma empty_line
inline int to_ushort() const { return (unsigned short)get_VAL(); }
#pragma empty_line
inline int to_short() const { return (short)get_VAL(); }
#pragma empty_line
inline int to_int() const { return (int)get_VAL(); }
#pragma empty_line
inline unsigned to_uint() const { return (unsigned)get_VAL(); }
#pragma empty_line
inline long to_long() const { return (long)get_VAL(); }
#pragma empty_line
inline unsigned long to_ulong() const { return (unsigned long)get_VAL(); }
#pragma empty_line
inline ap_slong to_int64() const { return (ap_slong)get_VAL(); }
#pragma empty_line
inline ap_ulong to_uint64() const { return (ap_ulong)get_VAL(); }
#pragma empty_line
inline double to_double() const {
if (isNegative())
return roundToDouble(true);
else
return roundToDouble(false);
}
#pragma empty_line
inline unsigned length() const { return _AP_W; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
inline bool iszero() const { return isMinValue(); }
#pragma empty_line
inline bool to_bool() const { return !iszero(); }
#pragma empty_line
#pragma empty_line
inline bool sign() const {
if (isNegative()) return true;
return false;
}
#pragma empty_line
#pragma empty_line
inline void invert(int i) {
#pragma empty_line
#pragma line 3606 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 3606 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
i >= 0 && "Attempting to read bit with negative index"
#pragma line 3606 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 3606 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"i >= 0 && \"Attempting to read bit with negative index\""
#pragma line 3606 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 3606, __extension__ __PRETTY_FUNCTION__))
#pragma line 3606 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
#pragma empty_line
#pragma line 3607 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 3607 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
i < _AP_W && "Attempting to read bit beyond MSB"
#pragma line 3607 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 3607 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"i < _AP_W && \"Attempting to read bit beyond MSB\""
#pragma line 3607 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 3607, __extension__ __PRETTY_FUNCTION__))
#pragma line 3607 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
flip(i);
}
#pragma empty_line
#pragma empty_line
inline bool test(int i) const {
#pragma empty_line
#pragma line 3613 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 3613 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
i >= 0 && "Attempting to read bit with negative index"
#pragma line 3613 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 3613 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"i >= 0 && \"Attempting to read bit with negative index\""
#pragma line 3613 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 3613, __extension__ __PRETTY_FUNCTION__))
#pragma line 3613 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
#pragma empty_line
#pragma line 3614 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 3614 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
i < _AP_W && "Attempting to read bit beyond MSB"
#pragma line 3614 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 3614 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"i < _AP_W && \"Attempting to read bit beyond MSB\""
#pragma line 3614 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 3614, __extension__ __PRETTY_FUNCTION__))
#pragma line 3614 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
return operator[](i);
}
#pragma empty_line
#pragma empty_line
inline void set(int i, bool v) {
#pragma empty_line
#pragma line 3620 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 3620 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
i >= 0 && "Attempting to write bit with negative index"
#pragma line 3620 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 3620 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"i >= 0 && \"Attempting to write bit with negative index\""
#pragma line 3620 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 3620, __extension__ __PRETTY_FUNCTION__))
#pragma line 3620 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
#pragma empty_line
#pragma line 3621 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 3621 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
i < _AP_W && "Attempting to write bit beyond MSB"
#pragma line 3621 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 3621 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"i < _AP_W && \"Attempting to write bit beyond MSB\""
#pragma line 3621 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 3621, __extension__ __PRETTY_FUNCTION__))
#pragma line 3621 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
v ? set(i) : clear(i);
}
#pragma empty_line
#pragma empty_line
inline void set_bit(int i, bool v) {
#pragma empty_line
#pragma line 3627 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 3627 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
i >= 0 && "Attempting to write bit with negative index"
#pragma line 3627 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 3627 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"i >= 0 && \"Attempting to write bit with negative index\""
#pragma line 3627 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 3627, __extension__ __PRETTY_FUNCTION__))
#pragma line 3627 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
#pragma empty_line
#pragma line 3628 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 3628 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
i < _AP_W && "Attempting to write bit beyond MSB"
#pragma line 3628 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 3628 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"i < _AP_W && \"Attempting to write bit beyond MSB\""
#pragma line 3628 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 3628, __extension__ __PRETTY_FUNCTION__))
#pragma line 3628 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
v ? set(i) : clear(i);
}
#pragma empty_line
#pragma empty_line
inline ap_private& set(uint32_t bitPosition) {
pVal[whichWord(bitPosition)] |= maskBit(bitPosition);
clearUnusedBits();
return *this;
}
#pragma empty_line
inline void set() {
for (int i = 0; i < _AP_N; ++i) pVal[i] = ~0ULL;
clearUnusedBits();
}
#pragma empty_line
#pragma empty_line
inline bool get(int i) const {
#pragma empty_line
#pragma line 3646 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 3646 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
i >= 0 && "Attempting to read bit with negative index"
#pragma line 3646 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 3646 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"i >= 0 && \"Attempting to read bit with negative index\""
#pragma line 3646 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 3646, __extension__ __PRETTY_FUNCTION__))
#pragma line 3646 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
#pragma empty_line
#pragma line 3647 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 3647 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
i < _AP_W && "Attempting to read bit beyond MSB"
#pragma line 3647 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 3647 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"i < _AP_W && \"Attempting to read bit beyond MSB\""
#pragma line 3647 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 3647, __extension__ __PRETTY_FUNCTION__))
#pragma line 3647 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
return ((maskBit(i) & (pVal[whichWord(i)])) != 0);
}
#pragma empty_line
#pragma empty_line
inline bool get_bit(int i) const {
#pragma empty_line
#pragma line 3653 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 3653 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
i >= 0 && "Attempting to read bit with negative index"
#pragma line 3653 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 3653 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"i >= 0 && \"Attempting to read bit with negative index\""
#pragma line 3653 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 3653, __extension__ __PRETTY_FUNCTION__))
#pragma line 3653 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
#pragma empty_line
#pragma line 3654 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 3654 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
i < _AP_W && "Attempting to read bit beyond MSB"
#pragma line 3654 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 3654 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"i < _AP_W && \"Attempting to read bit beyond MSB\""
#pragma line 3654 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 3654, __extension__ __PRETTY_FUNCTION__))
#pragma line 3654 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
return ((maskBit(i) & (pVal[whichWord(i)])) != 0);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline void lrotate(int n) {
#pragma empty_line
#pragma line 3661 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 3661 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
n >= 0 && "Attempting to shift negative index"
#pragma line 3661 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 3661 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"n >= 0 && \"Attempting to shift negative index\""
#pragma line 3661 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 3661, __extension__ __PRETTY_FUNCTION__))
#pragma line 3661 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
#pragma empty_line
#pragma line 3662 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 3662 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
n < _AP_W && "Shift value larger than bit width"
#pragma line 3662 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 3662 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"n < _AP_W && \"Shift value larger than bit width\""
#pragma line 3662 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 3662, __extension__ __PRETTY_FUNCTION__))
#pragma line 3662 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
operator=(shl(n) | lshr(_AP_W - n));
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline void rrotate(int n) {
#pragma empty_line
#pragma line 3669 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 3669 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
n >= 0 && "Attempting to shift negative index"
#pragma line 3669 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 3669 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"n >= 0 && \"Attempting to shift negative index\""
#pragma line 3669 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 3669, __extension__ __PRETTY_FUNCTION__))
#pragma line 3669 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
#pragma empty_line
#pragma line 3670 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 3670 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
n < _AP_W && "Shift value larger than bit width"
#pragma line 3670 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 3670 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"n < _AP_W && \"Shift value larger than bit width\""
#pragma line 3670 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 3670, __extension__ __PRETTY_FUNCTION__))
#pragma line 3670 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
operator=(lshr(n) | shl(_AP_W - n));
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline ap_private& clear(uint32_t bitPosition) {
pVal[whichWord(bitPosition)] &= ~maskBit(bitPosition);
clearUnusedBits();
return *this;
}
#pragma empty_line
#pragma empty_line
inline void clear() { memset(pVal, 0, _AP_N * APINT_WORD_SIZE); }
#pragma empty_line
#pragma empty_line
ap_private& flip() {
for (int i = 0; i < _AP_N; ++i) pVal[i] ^= ~0ULL;
clearUnusedBits();
return *this;
}
#pragma empty_line
#pragma empty_line
inline ap_private& flip(uint32_t bitPosition) {
#pragma empty_line
#pragma line 3694 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 3694 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
bitPosition < BitWidth && "Out of the bit-width range!"
#pragma line 3694 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 3694 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"bitPosition < BitWidth && \"Out of the bit-width range!\""
#pragma line 3694 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 3694, __extension__ __PRETTY_FUNCTION__))
#pragma line 3694 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
set_bit(bitPosition, !get_bit(bitPosition));
return *this;
}
#pragma empty_line
#pragma empty_line
inline void b_not() { flip(); }
#pragma empty_line
inline ap_private getLoBits(uint32_t numBits) const {
return ap_private_ops::lshr(ap_private_ops::shl(*this, _AP_W - numBits),
_AP_W - numBits);
}
#pragma empty_line
inline ap_private getHiBits(uint32_t numBits) const {
return ap_private_ops::lshr(*this, _AP_W - numBits);
}
#pragma line 3753 "/home/justin/jhai/Xilinx/Vivado/2018.3/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(
#pragma line 3753 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
stderr
#pragma line 3753 "/home/justin/jhai/Xilinx/Vivado/2018.3/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(
#pragma line 3754 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
stderr
#pragma line 3754 "/home/justin/jhai/Xilinx/Vivado/2018.3/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(
#pragma line 3755 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
stderr
#pragma line 3755 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
template <int _AP_W1, bool _AP_S1>
inline ap_private& operator*=(const ap_private<_AP_W1, _AP_S1>& RHS) {
#pragma empty_line
uint32_t lhsBits = getActiveBits();
uint32_t lhsWords = !lhsBits ? 0 : whichWord(lhsBits - 1) + 1;
if (!lhsWords) {
#pragma empty_line
return *this;
}
#pragma empty_line
ap_private dupRHS = RHS;
#pragma empty_line
uint32_t rhsBits = dupRHS.getActiveBits();
uint32_t rhsWords = !rhsBits ? 0 : whichWord(rhsBits - 1) + 1;
if (!rhsWords) {
#pragma empty_line
clear();
return *this;
}
#pragma empty_line
#pragma empty_line
uint32_t destWords = rhsWords + lhsWords;
uint64_t* dest = (uint64_t*)malloc(destWords * sizeof(uint64_t));
#pragma empty_line
#pragma empty_line
ap_private_ops::mul(dest, pVal, lhsWords, dupRHS.get_pVal(), rhsWords,
destWords);
#pragma empty_line
#pragma empty_line
clear();
uint32_t wordsToCopy = destWords >= _AP_N ? _AP_N : destWords;
#pragma empty_line
memcpy(pVal, dest, wordsToCopy * APINT_WORD_SIZE);
#pragma empty_line
uint64_t ext = (isNegative() ^ RHS.isNegative()) ? ~0ULL : 0ULL;
for (int i = wordsToCopy; i < _AP_N; i++) pVal[i] = ext;
clearUnusedBits();
#pragma empty_line
free(dest);
return *this;
}
#pragma line 3832 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma line 3872 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; };
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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));
}
#pragma empty_line
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;
}
#pragma line 3947 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
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;
}
}
#pragma line 3990 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
#pragma empty_line
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;
}
}
#pragma line 4035 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline bool operator==(const ap_private& RHS) const {
#pragma empty_line
uint32_t n1 = getActiveBits();
uint32_t n2 = RHS.getActiveBits();
#pragma empty_line
#pragma empty_line
if (n1 != n2) return false;
#pragma empty_line
#pragma empty_line
#pragma empty_line
if (n1 <= APINT_BITS_PER_WORD) return pVal[0] == RHS.get_pVal(0);
#pragma empty_line
#pragma empty_line
for (int i = whichWord(n1 - 1); i >= 0; --i)
if (pVal[i] != RHS.get_pVal(i)) return false;
return true;
}
#pragma empty_line
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;
}
#pragma empty_line
inline bool operator==(uint64_t Val) const {
uint32_t n = getActiveBits();
if (n <= APINT_BITS_PER_WORD)
return pVal[0] == Val;
else
return false;
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline bool operator!=(const ap_private<_AP_W2, _AP_S2>& op) const {
return !(*this == op);
}
#pragma empty_line
template <bool _AP_S1>
inline bool operator!=(const ap_private<_AP_W, _AP_S1>& RHS) const {
return !((*this) == RHS);
}
#pragma empty_line
inline bool operator!=(uint64_t Val) const { return !((*this) == Val); }
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline bool operator<=(const ap_private<_AP_W2, _AP_S2>& op) const {
return !(*this > op);
}
#pragma empty_line
inline bool operator<(const ap_private& op) const {
return _AP_S ? slt(op) : ult(op);
}
#pragma empty_line
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);
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline bool operator>=(const ap_private<_AP_W2, _AP_S2>& op) const {
return !(*this < op);
}
#pragma empty_line
inline bool operator>(const ap_private& op) const {
return _AP_S ? sgt(op) : ugt(op);
}
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline _private_range_ref<_AP_W, _AP_S> operator()(int Hi, int Lo) {
return _private_range_ref<_AP_W, _AP_S>(this, Hi, Lo);
}
#pragma empty_line
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);
}
#pragma empty_line
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);
}
#pragma empty_line
inline _private_range_ref<_AP_W, _AP_S> range(int Hi, int Lo) {
return _private_range_ref<_AP_W, _AP_S>(this, Hi, Lo);
}
#pragma empty_line
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);
}
#pragma empty_line
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);
}
#pragma empty_line
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);
}
#pragma empty_line
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);
}
#pragma empty_line
inline _private_bit_ref<_AP_W, _AP_S> operator[](int index) {
return _private_bit_ref<_AP_W, _AP_S>(*this, index);
}
#pragma empty_line
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());
}
#pragma empty_line
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());
}
#pragma empty_line
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);
}
#pragma empty_line
inline _private_bit_ref<_AP_W, _AP_S> bit(int index) {
return _private_bit_ref<_AP_W, _AP_S>(*this, index);
}
#pragma empty_line
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());
}
#pragma empty_line
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);
}
#pragma empty_line
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());
}
#pragma line 4405 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
inline ap_private<_AP_W, false> get() const {
ap_private<_AP_W, false> ret(*this);
return ret;
}
#pragma empty_line
template <int _AP_W3>
inline void set(const ap_private<_AP_W3, false>& val) {
operator=(ap_private<_AP_W3, _AP_S>(val));
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline bool isNegative() const {
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline bool isPositive() const { return !isNegative(); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline bool isStrictlyPositive() const {
return isPositive() && (*this) != 0;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline bool isAllOnesValue() const { return countPopulation() == _AP_W; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline bool isMaxValue() const { return countPopulation() == _AP_W; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline bool isMaxSignedValue() const {
return !isNegative() && countPopulation() == _AP_W - 1;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline bool isMinValue() const { return countPopulation() == 0; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline bool isMinSignedValue() const {
return isNegative() && countPopulation() == 1;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline const uint64_t* getRawData() const { return &pVal[0]; }
#pragma line 4480 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
inline ap_private sqrt() const {
#pragma empty_line
uint32_t magnitude = getActiveBits();
#pragma empty_line
#pragma empty_line
#pragma empty_line
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()]);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
if (magnitude < 52) {
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
return ap_private<_AP_W, _AP_S>(
uint64_t(
::round(::sqrt(double(get_VAL())))));
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
#pragma empty_line
#pragma empty_line
for (;; i += 2, testy = testy.shl(2))
if (i >= nbits || this->ule(testy)) {
x_old = x_old.shl(i / 2);
break;
}
#pragma empty_line
#pragma empty_line
for (;;) {
x_new = (this->udiv(x_old) + x_old).udiv(two);
if (x_old.ule(x_new)) break;
x_old = x_new;
}
#pragma line 4547 "/home/justin/jhai/Xilinx/Vivado/2018.3/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
#pragma empty_line
#pragma line 4559 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 4559 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
0 && "Error in ap_private<_AP_W, _AP_S>::sqrt computation"
#pragma line 4559 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 4559 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"0 && \"Error in ap_private<_AP_W, _AP_S>::sqrt computation\""
#pragma line 4559 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 4559, __extension__ __PRETTY_FUNCTION__))
#pragma line 4559 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
return x_old + 1;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline ap_private& operator=(const ap_private& RHS) {
if (this != &RHS) memcpy(pVal, RHS.get_pVal(), _AP_N * APINT_WORD_SIZE);
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);
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);
}
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);
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma line 4650 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline ap_private& operator=(const char* s) {
ap_private tmp(s);
operator=(tmp);
return *this;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline const ap_private operator++(int) {
ap_private API(*this);
++(*this);
return API;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline ap_private& operator++() {
ap_private_ops::add_1(pVal, pVal, _AP_N, 1);
clearUnusedBits();
return *this;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline const ap_private operator--(int) {
ap_private API(*this);
--(*this);
return API;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline ap_private& operator--() {
ap_private_ops::sub_1(pVal, _AP_N, 1);
clearUnusedBits();
return *this;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline ap_private<_AP_W + !_AP_S, true> operator~() const {
ap_private<_AP_W + !_AP_S, true> Result(*this);
Result.flip();
return Result;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline typename RType<1, false>::minus operator-() const {
return ap_private<1, false>(0) - (*this);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline bool operator!() const {
for (int i = 0; i < _AP_N; ++i)
if (pVal[i]) return false;
return true;
}
#pragma empty_line
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);
}
#pragma empty_line
inline ap_private Mul(const ap_private& RHS) const {
ap_private Result(*this);
Result *= RHS;
return Result;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline ap_private ashr(uint32_t shiftAmt) const {
#pragma empty_line
#pragma line 4771 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 4771 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
shiftAmt <= BitWidth && "Invalid shift amount, too big"
#pragma line 4771 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 4771 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"shiftAmt <= BitWidth && \"Invalid shift amount, too big\""
#pragma line 4771 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 4771, __extension__ __PRETTY_FUNCTION__))
#pragma line 4771 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
#pragma empty_line
if (shiftAmt == 0) return ap_private(*this);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
if (shiftAmt == BitWidth) {
if (isNegative())
return ap_private(-1);
else
return ap_private(0);
}
#pragma empty_line
#pragma empty_line
ap_private Retval(0);
uint64_t* val = Retval.get_pVal();
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
if (wordShift == 0) {
#pragma empty_line
for (uint32_t i = 0; i <= breakWord; ++i)
val[i] = pVal[i + offset];
#pragma empty_line
#pragma empty_line
if (isNegative())
if (bitsInWord < APINT_BITS_PER_WORD)
val[breakWord] |= ~0ULL << (bitsInWord);
} else {
#pragma empty_line
for (uint32_t i = 0; i < breakWord; ++i) {
#pragma empty_line
#pragma empty_line
val[i] = ((pVal[i + offset]) >> (wordShift));
val[i] |= ((pVal[i + offset + 1]) << (APINT_BITS_PER_WORD - wordShift));
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
val[breakWord] = (pVal[breakWord + offset]) >> (wordShift);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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));
}
}
#pragma empty_line
#pragma empty_line
uint64_t fillValue = (isNegative() ? ~0ULL : 0);
for (int i = breakWord + 1; i < _AP_N; ++i) val[i] = fillValue;
Retval.clearUnusedBits();
return Retval;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline ap_private lshr(uint32_t shiftAmt) const {
#pragma empty_line
#pragma empty_line
#pragma empty_line
if (shiftAmt == BitWidth) return ap_private(0);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
if (shiftAmt == 0) return ap_private(*this);
#pragma empty_line
#pragma empty_line
ap_private Retval(0);
uint64_t* val = Retval.get_pVal();
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
uint32_t wordShift = shiftAmt % APINT_BITS_PER_WORD;
uint32_t offset = shiftAmt / APINT_BITS_PER_WORD;
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
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));
#pragma empty_line
val[breakWord] = (pVal[breakWord + offset]) >> (wordShift);
#pragma empty_line
#pragma empty_line
for (int i = breakWord + 1; i < _AP_N; ++i) val[i] = 0;
Retval.clearUnusedBits();
return Retval;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline ap_private shl(uint32_t shiftAmt) const {
#pragma empty_line
#pragma line 4900 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 4900 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
shiftAmt <= BitWidth && "Invalid shift amount, too big"
#pragma line 4900 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 4900 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"shiftAmt <= BitWidth && \"Invalid shift amount, too big\""
#pragma line 4900 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 4900, __extension__ __PRETTY_FUNCTION__))
#pragma line 4900 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
#pragma empty_line
#pragma empty_line
#pragma empty_line
if (shiftAmt == BitWidth) return ap_private(0);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
if (shiftAmt == 0) return ap_private(*this);
#pragma empty_line
#pragma empty_line
ap_private Retval(0);
uint64_t* val = Retval.get_pVal();
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
uint32_t wordShift = shiftAmt % APINT_BITS_PER_WORD;
uint32_t offset = shiftAmt / APINT_BITS_PER_WORD;
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
inline ap_private rotl(uint32_t rotateAmt) const {
if (rotateAmt == 0) return ap_private(*this);
#pragma empty_line
ap_private hi(*this);
ap_private lo(*this);
hi.shl(rotateAmt);
lo.lshr(BitWidth - rotateAmt);
return hi | lo;
}
#pragma empty_line
inline ap_private rotr(uint32_t rotateAmt) const {
if (rotateAmt == 0) return ap_private(*this);
#pragma empty_line
ap_private hi(*this);
ap_private lo(*this);
lo.lshr(rotateAmt);
hi.shl(BitWidth - rotateAmt);
return hi | lo;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline ap_private udiv(const ap_private& RHS) const {
#pragma empty_line
uint32_t rhsBits = RHS.getActiveBits();
uint32_t rhsWords = !rhsBits ? 0 : (whichWord(rhsBits - 1) + 1);
#pragma empty_line
#pragma line 4978 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 4978 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
rhsWords && "Divided by zero???"
#pragma line 4978 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 4978 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"rhsWords && \"Divided by zero???\""
#pragma line 4978 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 4978, __extension__ __PRETTY_FUNCTION__))
#pragma line 4978 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
uint32_t lhsBits = this->getActiveBits();
uint32_t lhsWords = !lhsBits ? 0 : (whichWord(lhsBits - 1) + 1);
#pragma empty_line
#pragma empty_line
if (!lhsWords)
#pragma empty_line
return ap_private(0);
else if (lhsWords < rhsWords || this->ult(RHS)) {
#pragma empty_line
return ap_private(0);
} else if (*this == RHS) {
#pragma empty_line
return ap_private(1);
} else if (lhsWords == 1 && rhsWords == 1) {
#pragma empty_line
return ap_private(this->pVal[0] / RHS.get_pVal(0));
}
#pragma empty_line
#pragma empty_line
ap_private Quotient(0);
ap_private_ops::divide(*this, lhsWords, RHS, rhsWords, &Quotient,
(ap_private*)0);
return Quotient;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
}
#pragma line 5025 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
inline ap_private urem(const ap_private& RHS) const {
#pragma empty_line
uint32_t lhsBits = getActiveBits();
uint32_t lhsWords = !lhsBits ? 0 : (whichWord(lhsBits - 1) + 1);
#pragma empty_line
#pragma empty_line
uint32_t rhsBits = RHS.getActiveBits();
uint32_t rhsWords = !rhsBits ? 0 : (whichWord(rhsBits - 1) + 1);
#pragma empty_line
#pragma line 5033 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 5033 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
rhsWords && "Performing remainder operation by zero ???"
#pragma line 5033 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 5033 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"rhsWords && \"Performing remainder operation by zero ???\""
#pragma line 5033 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 5033, __extension__ __PRETTY_FUNCTION__))
#pragma line 5033 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
#pragma empty_line
#pragma empty_line
if (lhsWords == 0) {
#pragma empty_line
return ap_private(0);
} else if (lhsWords < rhsWords || this->ult(RHS)) {
#pragma empty_line
return *this;
} else if (*this == RHS) {
#pragma empty_line
return ap_private(0);
} else if (lhsWords == 1) {
#pragma empty_line
return ap_private(pVal[0] % RHS.get_pVal(0));
}
#pragma empty_line
#pragma empty_line
ap_private Remainder(0);
ap_private_ops::divide(*this, lhsWords, RHS, rhsWords, (ap_private*)(0),
&Remainder);
return Remainder;
}
#pragma empty_line
inline ap_private urem(uint64_t RHS) const {
#pragma empty_line
uint32_t lhsBits = getActiveBits();
uint32_t lhsWords = !lhsBits ? 0 : (whichWord(lhsBits - 1) + 1);
#pragma empty_line
uint32_t rhsWords = 1;
#pragma empty_line
#pragma empty_line
#pragma line 5064 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 5064 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
rhsWords && "Performing remainder operation by zero ???"
#pragma line 5064 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 5064 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"rhsWords && \"Performing remainder operation by zero ???\""
#pragma line 5064 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 5064, __extension__ __PRETTY_FUNCTION__))
#pragma line 5064 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
#pragma empty_line
if (lhsWords == 0) {
#pragma empty_line
return ap_private(0);
} else if (lhsWords < rhsWords || this->ult(RHS)) {
#pragma empty_line
return *this;
} else if (*this == RHS) {
#pragma empty_line
return ap_private(0);
} else if (lhsWords == 1) {
#pragma empty_line
return ap_private(pVal[0] % RHS);
}
#pragma empty_line
#pragma empty_line
ap_private Remainder(0);
divide(*this, lhsWords, RHS, (ap_private*)(0), &Remainder);
return Remainder;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template <bool _AP_S1>
inline bool eq(const ap_private<_AP_W, _AP_S1>& RHS) const {
return (*this) == RHS;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template <bool _AP_S1>
inline bool ne(const ap_private<_AP_W, _AP_S1>& RHS) const {
return !((*this) == RHS);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template <bool _AP_S1>
inline bool ult(const ap_private<_AP_W, _AP_S1>& RHS) const {
#pragma empty_line
uint32_t n1 = getActiveBits();
uint32_t n2 = RHS.getActiveBits();
#pragma empty_line
#pragma empty_line
if (n1 < n2) return true;
#pragma empty_line
#pragma empty_line
if (n2 < n1) return false;
#pragma empty_line
#pragma empty_line
if (n1 <= APINT_BITS_PER_WORD && n2 <= APINT_BITS_PER_WORD)
return pVal[0] < RHS.get_pVal(0);
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
inline bool ult(uint64_t RHS) const {
#pragma empty_line
uint32_t n1 = getActiveBits();
uint32_t n2 =
64 - ap_private_ops::CountLeadingZeros_64(RHS);
#pragma empty_line
#pragma empty_line
if (n1 < n2) return true;
#pragma empty_line
#pragma empty_line
if (n2 < n1) return false;
#pragma empty_line
#pragma empty_line
if (n1 <= APINT_BITS_PER_WORD && n2 <= APINT_BITS_PER_WORD)
return pVal[0] < RHS;
#pragma empty_line
#pragma line 5178 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 5178 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
0
#pragma line 5178 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 5178 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"0"
#pragma line 5178 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 5178, __extension__ __PRETTY_FUNCTION__))
#pragma line 5178 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
}
#pragma empty_line
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) {
#pragma empty_line
lhs.flip();
lhs++;
}
if (rhsNeg) {
#pragma empty_line
rhs.flip();
rhs++;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
if (lhsNeg)
if (rhsNeg)
return lhs.ugt(rhs);
else
return true;
else if (rhsNeg)
return false;
else
return lhs.ult(rhs);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template <bool _AP_S1>
inline bool ule(const ap_private<_AP_W, _AP_S1>& RHS) const {
return ult(RHS) || eq(RHS);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template <bool _AP_S1>
inline bool sle(const ap_private<_AP_W, _AP_S1>& RHS) const {
return slt(RHS) || eq(RHS);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template <bool _AP_S1>
inline bool ugt(const ap_private<_AP_W, _AP_S1>& RHS) const {
return !ult(RHS) && !eq(RHS);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template <bool _AP_S1>
inline bool sgt(const ap_private<_AP_W, _AP_S1>& RHS) const {
return !slt(RHS) && !eq(RHS);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template <bool _AP_S1>
inline bool uge(const ap_private<_AP_W, _AP_S>& RHS) const {
return !ult(RHS);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template <bool _AP_S1>
inline bool sge(const ap_private<_AP_W, _AP_S1>& RHS) const {
return !slt(RHS);
}
#pragma empty_line
#pragma empty_line
template <int _AP_W1, bool _AP_S1>
inline void cpSext(const ap_private<_AP_W1, _AP_S1>& that) {
#pragma empty_line
#pragma line 5268 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 5268 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
_AP_W1 < BitWidth && "Invalid ap_private SignExtend request"
#pragma line 5268 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 5268 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"_AP_W1 < BitWidth && \"Invalid ap_private SignExtend request\""
#pragma line 5268 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 5268, __extension__ __PRETTY_FUNCTION__))
#pragma line 5268 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
#pragma empty_line
#pragma line 5269 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 5269 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
_AP_W1 <= MAX_INT_BITS && "Too many bits"
#pragma line 5269 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 5269 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"_AP_W1 <= MAX_INT_BITS && \"Too many bits\""
#pragma line 5269 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 5269, __extension__ __PRETTY_FUNCTION__))
#pragma line 5269 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
#pragma empty_line
if (!that.isNegative()) {
cpZext(that);
return;
}
#pragma empty_line
#pragma empty_line
enum { wordBits = _AP_W1 % APINT_BITS_PER_WORD };
const int _AP_N1 = ap_private<_AP_W1, _AP_S1>::_AP_N;
#pragma empty_line
if (_AP_N1 == _AP_N) {
enum { newWordBits = _AP_W % APINT_BITS_PER_WORD };
#pragma empty_line
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;
}
#pragma empty_line
enum { newWordBits = _AP_W % APINT_BITS_PER_WORD };
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
template <int _AP_W1, bool _AP_S1>
inline void cpZext(const ap_private<_AP_W1, _AP_S1>& that) {
#pragma empty_line
#pragma line 5304 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 5304 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
_AP_W1 < BitWidth && "Invalid ap_private ZeroExtend request"
#pragma line 5304 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 5304 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"_AP_W1 < BitWidth && \"Invalid ap_private ZeroExtend request\""
#pragma line 5304 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 5304, __extension__ __PRETTY_FUNCTION__))
#pragma line 5304 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
#pragma empty_line
#pragma line 5305 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 5305 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
_AP_W1 <= MAX_INT_BITS && "Too many bits"
#pragma line 5305 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 5305 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"_AP_W1 <= MAX_INT_BITS && \"Too many bits\""
#pragma line 5305 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 5305, __extension__ __PRETTY_FUNCTION__))
#pragma line 5305 "/home/justin/jhai/Xilinx/Vivado/2018.3/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();
}
#pragma empty_line
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();
}
}
#pragma empty_line
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();
}
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline uint32_t getBitWidth() const { return BitWidth; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline uint32_t getNumWords() const {
return (BitWidth + APINT_BITS_PER_WORD - 1) / APINT_BITS_PER_WORD;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline uint32_t getActiveBits() const {
uint32_t bits = BitWidth - countLeadingZeros();
return bits ? bits : 1;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline uint64_t getZExtValue() const {
#pragma empty_line
#pragma line 5362 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 5362 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
getActiveBits() <= 64 && "Too many bits for uint64_t"
#pragma line 5362 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 5362 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"getActiveBits() <= 64 && \"Too many bits for uint64_t\""
#pragma line 5362 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 5362, __extension__ __PRETTY_FUNCTION__))
#pragma line 5362 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
return *pVal;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline int64_t getSExtValue() const {
#pragma empty_line
#pragma line 5372 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 5372 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
getActiveBits() <= 64 && "Too many bits for int64_t"
#pragma line 5372 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 5372 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"getActiveBits() <= 64 && \"Too many bits for int64_t\""
#pragma line 5372 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 5372, __extension__ __PRETTY_FUNCTION__))
#pragma line 5372 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
return int64_t(pVal[0]);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline static uint32_t getBitsNeeded(const char* str, uint32_t slen,
uint8_t radix) {
#pragma empty_line
#pragma line 5381 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 5381 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
str != 0 && "Invalid value string"
#pragma line 5381 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 5381 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"str != 0 && \"Invalid value string\""
#pragma line 5381 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 5381, __extension__ __PRETTY_FUNCTION__))
#pragma line 5381 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
#pragma empty_line
#pragma line 5382 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 5382 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
slen > 0 && "Invalid string length"
#pragma line 5382 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 5382 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"slen > 0 && \"Invalid string length\""
#pragma line 5382 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 5382, __extension__ __PRETTY_FUNCTION__))
#pragma line 5382 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
#pragma empty_line
#pragma empty_line
uint32_t isNegative = str[0] == '-';
if (isNegative) {
slen--;
str++;
}
#pragma empty_line
#pragma empty_line
if (radix == 2) return slen + isNegative;
if (radix == 8) return slen * 3 + isNegative;
if (radix == 16) return slen * 4 + isNegative;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 5397 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 5397 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
radix == 10 && "Invalid radix"
#pragma line 5397 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 5397 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"radix == 10 && \"Invalid radix\""
#pragma line 5397 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 5397, __extension__ __PRETTY_FUNCTION__))
#pragma line 5397 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
return isNegative + slen * 4;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline uint32_t countLeadingOnes() const {
if (isSingleWord())
return countLeadingOnes_64(get_VAL(), APINT_BITS_PER_WORD - BitWidth);
#pragma empty_line
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;
}
#pragma line 5469 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline std::string toString(uint8_t radix, bool wantSigned) const;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline std::string toStringUnsigned(uint8_t radix = 10) const {
return toString(radix, false);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline std::string toStringSigned(uint8_t radix = 10) const {
return toString(radix, true);
}
#pragma empty_line
#pragma empty_line
inline double roundToDouble(bool isSigned) const {
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
bool isNeg = isSigned ? (*this)[BitWidth - 1] : false;
#pragma empty_line
#pragma empty_line
ap_private<_AP_W, _AP_S> Tmp(isNeg ? -(*this) : (*this));
#pragma empty_line
#pragma empty_line
uint32_t n = Tmp.getActiveBits();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
uint64_t exp = n;
#pragma empty_line
#pragma empty_line
if (exp > 1023) {
if (!isSigned || !isNeg)
return std::numeric_limits<double>::infinity();
else
return -std::numeric_limits<double>::infinity();
}
exp += 1023;
#pragma empty_line
#pragma empty_line
#pragma empty_line
uint64_t mantissa;
unsigned hiWord = whichWord(n - 1);
if (hiWord == 0) {
mantissa = Tmp.get_pVal(0);
if (n > 52)
(mantissa) >>= (n - 52);
} else {
#pragma empty_line
#pragma line 5560 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 5560 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
hiWord > 0 && "High word is negative?"
#pragma line 5560 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 5560 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"hiWord > 0 && \"High word is negative?\""
#pragma line 5560 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 5560, __extension__ __PRETTY_FUNCTION__))
#pragma line 5560 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
inline double roundToDouble() const { return roundToDouble(false); }
#pragma empty_line
#pragma empty_line
inline double signedRoundToDouble() const { return roundToDouble(true); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline double bitsToDouble() const {
union {
uint64_t __I;
double __D;
} __T;
__T.__I = pVal[0];
return __T.__D;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline float bitsToFloat() const {
union {
uint32_t __I;
float __F;
} __T;
__T.__I = uint32_t(pVal[0]);
return __T.__F;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline ap_private& doubleToBits(double __V) {
union {
uint64_t __I;
double __D;
} __T;
__T.__D = __V;
pVal[0] = __T.__I;
return *this;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline ap_private& floatToBits(float __V) {
union {
uint32_t __I;
float __F;
} __T;
__T.__F = __V;
pVal[0] = __T.__I;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline bool and_reduce() const { return isMaxValue(); }
#pragma empty_line
inline bool nand_reduce() const { return isMinValue(); }
#pragma empty_line
inline bool or_reduce() const { return (bool)countPopulation(); }
#pragma empty_line
inline bool nor_reduce() const { return countPopulation() == 0; }
#pragma empty_line
inline bool xor_reduce() const {
unsigned int i = countPopulation();
return (i % 2) ? true : false;
}
#pragma empty_line
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);
}
};
#pragma empty_line
namespace ap_private_ops {
#pragma empty_line
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;
}
#pragma empty_line
template <int _AP_W, bool _AP_S>
inline bool operator!=(uint64_t V1, const ap_private<_AP_W, _AP_S>& V2) {
return V2 != V1;
}
#pragma empty_line
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);
}
#pragma empty_line
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);
#pragma empty_line
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);
#pragma empty_line
a.get_pVal(lsb_word) |= lsb_mask;
for (int i = lsb_word + 1; i < msb_word; i++) {
a.set_pVal(i, ~0ULL);
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
a.get_pVal(msb_word) |= msb_mask;
}
a.clearUnusedBits();
}
#pragma empty_line
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));
#pragma empty_line
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));
#pragma empty_line
a.get_pVal(lsb_word) &= lsb_mask;
for (int i = lsb_word + 1; i < msb_word; i++) {
#pragma empty_line
a.get_pVal(i) = 0;
}
#pragma empty_line
a.get_pVal(msb_word) &= msb_mask;
}
a.clearUnusedBits();
}
#pragma empty_line
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);
#pragma empty_line
a.get_pVal(word) |= mask;
a.clearUnusedBits();
}
#pragma empty_line
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));
#pragma empty_line
a.get_pVal(word) &= mask;
a.clearUnusedBits();
}
#pragma empty_line
}
#pragma empty_line
template <int _AP_W, bool _AP_S>
inline std::string ap_private<_AP_W, _AP_S, false>::toString(
uint8_t radix, bool wantSigned) const {
#pragma empty_line
#pragma line 5772 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 5772 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
(radix == 10 || radix == 8 || radix == 16 || radix == 2) && "Radix should be 2, 8, 10, or 16!"
#pragma line 5772 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 5772 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"(radix == 10 || radix == 8 || radix == 16 || radix == 2) && \"Radix should be 2, 8, 10, or 16!\""
#pragma line 5772 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
,
"/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
#pragma line 5772 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
,
5773
#pragma line 5772 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, __extension__ __PRETTY_FUNCTION__))
#pragma empty_line
#pragma line 5773 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
if (radix != 10) {
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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()) {
#pragma empty_line
#pragma empty_line
#pragma empty_line
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:
#pragma empty_line
#pragma line 5812 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 5812 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"invalid radix" && 0
#pragma line 5812 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 5812 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"\"invalid radix\" && 0"
#pragma line 5812 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 5812, __extension__ __PRETTY_FUNCTION__))
#pragma line 5812 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
}
insert_at += 2;
#pragma empty_line
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;
}
#pragma empty_line
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()) {
#pragma empty_line
#pragma empty_line
#pragma empty_line
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();
#pragma empty_line
#pragma line 5855 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
(static_cast <bool> (
#pragma line 5855 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
digit < radix && "divide failed"
#pragma line 5855 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 5855 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
"digit < radix && \"divide failed\""
#pragma line 5855 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h", 5855, __extension__ __PRETTY_FUNCTION__))
#pragma line 5855 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
;
result.insert(insert_at, digits[digit]);
tmp = tmp2;
}
#pragma empty_line
return result;
}
#pragma empty_line
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;
}
#pragma line 6120 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
template <int _AP_W, bool _AP_S>
struct _private_range_ref {
#pragma empty_line
#pragma empty_line
#pragma empty_line
ap_private<_AP_W, _AP_S>& d_bv;
int l_index;
int h_index;
#pragma empty_line
public:
#pragma empty_line
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) {}
#pragma empty_line
#pragma empty_line
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(
#pragma line 6137 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
stderr
#pragma line 6137 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
, "WARNING: " "Higher bound (%d) and lower bound (%d) cannot be " "negative.", h, l); fprintf(
#pragma line 6137 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
stderr
#pragma line 6137 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
, "\n"); } } while (0)
#pragma empty_line
#pragma empty_line
;
do { if ((h >= _AP_W || l >= _AP_W)) { fprintf(
#pragma line 6141 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
stderr
#pragma line 6141 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
, "WARNING: " "Higher bound (%d) or lower bound (%d) out of range (%d).", h, l, _AP_W); fprintf(
#pragma line 6141 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
stderr
#pragma line 6141 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
, "\n"); } } while (0)
#pragma empty_line
;
}
#pragma empty_line
#pragma empty_line
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(
#pragma line 6150 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
stderr
#pragma line 6150 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
, "WARNING: " "Bitsize mismach for ap_private<>.range() &= " "ap_private<>.range()."); fprintf(
#pragma line 6150 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
stderr
#pragma line 6150 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
, "\n"); } } while (0)
#pragma empty_line
;
this->d_bv |= ref.d_bv;
return *this;
}
#pragma empty_line
#pragma empty_line
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(
#pragma line 6161 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
stderr
#pragma line 6161 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
, "WARNING: " "Bitsize mismach for ap_private<>.range() |= _AP_ROOT_TYPE<>."); fprintf(
#pragma line 6161 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
stderr
#pragma line 6161 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
, "\n"); } } while (0)
;
this->d_bv |= ref.V;
return *this;
}
#pragma empty_line
#pragma empty_line
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(
#pragma line 6171 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
stderr
#pragma line 6171 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
, "WARNING: " "Bitsize mismach for ap_private<>.range() &= " "ap_private<>.range()."); fprintf(
#pragma line 6171 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
stderr
#pragma line 6171 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
, "\n"); } } while (0)
#pragma empty_line
;
this->d_bv &= ref.d_bv;
return *this;
};
#pragma empty_line
#pragma empty_line
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(
#pragma line 6182 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
stderr
#pragma line 6182 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
, "WARNING: " "Bitsize mismach for ap_private<>.range() &= _AP_ROOT_TYPE<>."); fprintf(
#pragma line 6182 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
stderr
#pragma line 6182 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
, "\n"); } } while (0)
;
this->d_bv &= ref.V;
return *this;
}
#pragma empty_line
#pragma empty_line
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(
#pragma line 6192 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
stderr
#pragma line 6192 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
, "WARNING: " "Bitsize mismach for ap_private<>.range() ^= " "ap_private<>.range()."); fprintf(
#pragma line 6192 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
stderr
#pragma line 6192 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
, "\n"); } } while (0)
#pragma empty_line
;
this->d_bv ^= ref.d_bv;
return *this;
};
#pragma empty_line
#pragma empty_line
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(
#pragma line 6203 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
stderr
#pragma line 6203 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
, "WARNING: " "Bitsize mismach for ap_private<>.range() ^= _AP_ROOT_TYPE<>."); fprintf(
#pragma line 6203 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
stderr
#pragma line 6203 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
, "\n"); } } while (0)
;
this->d_bv ^= ref.V;
return *this;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
inline operator unsigned long long() const { return to_uint64(); }
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
inline _private_range_ref& operator=(unsigned long long val) {
const ap_private<_AP_W, _AP_S> vval = val;
return operator=(vval);
}
#pragma empty_line
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);
}
#pragma empty_line
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);
}
#pragma line 6304 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
}
#pragma empty_line
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);
}
#pragma empty_line
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);
}
#pragma line 6397 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
#pragma empty_line
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;
#pragma empty_line
}
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;
}
}
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
inline int length() const {
return h_index >= l_index ? h_index - l_index + 1 : l_index - h_index + 1;
}
#pragma empty_line
inline int to_int() const {
ap_private<_AP_W, false> val = get();
return val.to_int();
}
#pragma empty_line
inline unsigned int to_uint() const {
ap_private<_AP_W, false> val = get();
return val.to_uint();
}
#pragma empty_line
inline long to_long() const {
ap_private<_AP_W, false> val = get();
return val.to_long();
}
#pragma empty_line
inline unsigned long to_ulong() const {
ap_private<_AP_W, false> val = get();
return val.to_ulong();
}
#pragma empty_line
inline ap_slong to_int64() const {
ap_private<_AP_W, false> val = get();
return val.to_int64();
}
#pragma empty_line
inline ap_ulong to_uint64() const {
ap_private<_AP_W, false> val = get();
return val.to_uint64();
}
#pragma empty_line
inline std::string to_string(uint8_t radix = 2) const {
return get().to_string(radix);
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template <int _AP_W, bool _AP_S>
struct _private_bit_ref {
#pragma empty_line
#pragma empty_line
#pragma empty_line
ap_private<_AP_W, _AP_S>& d_bv;
int d_index;
#pragma empty_line
public:
#pragma empty_line
inline _private_bit_ref(const _private_bit_ref<_AP_W, _AP_S>& ref)
: d_bv(ref.d_bv), d_index(ref.d_index) {}
#pragma empty_line
#pragma empty_line
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(
#pragma line 6618 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
stderr
#pragma line 6618 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
, "WARNING: " "Index of bit vector (%d) cannot be negative.\n", d_index); fprintf(
#pragma line 6618 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
stderr
#pragma line 6618 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
, "\n"); } } while (0)
;
do { if ((d_index >= _AP_W)) { fprintf(
#pragma line 6620 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
stderr
#pragma line 6620 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
, "WARNING: " "Index of bit vector (%d) out of range (%d).\n", d_index, _AP_W); fprintf(
#pragma line 6620 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h" 3 4
stderr
#pragma line 6620 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
, "\n"); } } while (0)
;
}
#pragma empty_line
inline operator bool() const { return d_bv.get_bit(d_index); }
#pragma empty_line
inline bool to_bool() const { return operator bool(); }
#pragma empty_line
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;
}
#pragma line 6722 "/home/justin/jhai/Xilinx/Vivado/2018.3/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();
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline bool operator!=(const _private_bit_ref<_AP_W2, _AP_S2>& op) const {
return get() != op.get();
}
#pragma empty_line
inline bool get() const { return operator bool(); }
#pragma line 6744 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/ap_private.h"
inline int length() const { return 1; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
};
#pragma line 6772 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma line 6798 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma line 6903 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 6969 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)); }
#pragma empty_line
#pragma empty_line
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; }
#pragma empty_line
#pragma empty_line
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>()); }
#pragma line 7044 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma empty_line
#pragma empty_line
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)); }
#pragma empty_line
#pragma empty_line
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)); }
#pragma line 7109 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)); }
#pragma line 7155 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)); }
#pragma line 7180 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)); }
#pragma line 642 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_common.h" 2
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
}
#pragma line 691 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_common.h"
inline ap_ulong doubleToRawBits(double pf) {
union {
ap_ulong __L;
double __D;
} LD;
LD.__D = pf;
return LD.__L;
}
#pragma empty_line
inline unsigned int floatToRawBits(float pf) {
union {
unsigned int __L;
float __D;
} LD;
LD.__D = pf;
return LD.__L;
}
#pragma empty_line
inline unsigned short halfToRawBits(half pf) {
#pragma line 718 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_common.h"
return pf.get_bits();
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
inline double rawBitsToDouble(ap_ulong pi) {
union {
ap_ulong __L;
double __D;
} LD;
LD.__L = pi;
return LD.__D;
}
#pragma empty_line
#pragma empty_line
inline float rawBitsToFloat(unsigned long pi) {
union {
unsigned int __L;
float __D;
} LD;
LD.__L = pi;
return LD.__D;
}
#pragma empty_line
#pragma empty_line
inline half rawBitsToHalf(unsigned short pi) {
#pragma line 753 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_common.h"
half __D;
__D.set_bits(pi);
return __D;
#pragma empty_line
}
#pragma line 55 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int.h" 2
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 1
#pragma line 82 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
template <int _AP_N, bool _AP_S>
struct retval;
#pragma empty_line
#pragma empty_line
template <int _AP_N>
struct retval<_AP_N, true> {
typedef ap_slong Type;
};
#pragma empty_line
template <int _AP_N>
struct retval<_AP_N, false> {
typedef ap_ulong Type;
};
#pragma empty_line
#pragma empty_line
template <>
struct retval<1, true> {
typedef signed char Type;
};
#pragma empty_line
template <>
struct retval<1, false> {
typedef unsigned char Type;
};
#pragma empty_line
#pragma empty_line
template <>
struct retval<2, true> {
typedef short Type;
};
#pragma empty_line
template <>
struct retval<2, false> {
typedef unsigned short Type;
};
#pragma empty_line
#pragma empty_line
template <>
struct retval<3, true> {
typedef long Type;
};
#pragma empty_line
template <>
struct retval<3, false> {
typedef unsigned long Type;
};
#pragma empty_line
template <>
struct retval<4, true> {
typedef long Type;
};
#pragma empty_line
template <>
struct retval<4, false> {
typedef unsigned long Type;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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; };
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef typename retval<(((_AP_W + 7) / 8) > (8) ? ((_AP_W + 7) / 8) : (8)), _AP_S>::Type RetType;
#pragma empty_line
static const int width = _AP_W;
#pragma empty_line
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
};
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
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;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline ap_int_base() {
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline ap_int_base(const ap_int_base<_AP_W2, _AP_S2>& op) {
Base::V = op.V;
}
#pragma empty_line
#pragma empty_line
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;
}
#pragma line 239 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline ap_int_base(half op) {
ap_int_base<_AP_W, _AP_S> t((float)op);
Base::V = t.V;
}
#pragma empty_line
#pragma empty_line
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));
#pragma empty_line
ap_int_base<8 + 1, true> exp = 0;
exp.V = (reg.V).range((BITS - 2), (23));
exp = exp - ((1L << (8 - 1L)) - 1L);
#pragma empty_line
ap_int_base<23 + 2, true> man;
man.V = (reg.V).range((23 - 1), (0));
#pragma empty_line
do { if ((exp == ((unsigned char)(((1L << (8 - 1L)) - 1L) + 1)) && man.V != 0)) { fprintf(
#pragma line 274 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
stderr
#pragma line 274 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
, "WARNING: " "assign NaN to ap integer value"); fprintf(
#pragma line 274 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
stderr
#pragma line 274 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
, "\n"); } } while (0)
;
#pragma empty_line
man.V = _AP_ROOT_op_set_bit(man.V, 23, 1);
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
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));
#pragma empty_line
ap_int_base<11 + 1, true> exp = 0;
exp.V = (reg.V).range((BITS - 2), (52));
exp = exp - ((1L << (11 - 1L)) - 1L);
#pragma empty_line
ap_int_base<52 + 2, true> man;
man.V = (reg.V).range((52 - 1), (0));
#pragma empty_line
do { if ((exp == ((unsigned char)(((1L << (11 - 1L)) - 1L) + 1)) && man.V != 0)) { fprintf(
#pragma line 322 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
stderr
#pragma line 322 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
, "WARNING: " "assign NaN to ap integer value"); fprintf(
#pragma line 322 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
stderr
#pragma line 322 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
, "\n"); } } while (0)
;
#pragma empty_line
man.V = _AP_ROOT_op_set_bit(man.V, 52, 1);
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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();
}
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
}
#pragma line 407 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma empty_line
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();
}
#pragma empty_line
inline ap_int_base read() volatile {
#pragma empty_line
ap_int_base ret;
ret.V = Base::V;
return ret;
}
#pragma empty_line
inline void write(const ap_int_base<_AP_W, _AP_S>& op2) volatile {
#pragma empty_line
Base::V = op2.V;
}
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
inline void operator=(
const volatile ap_int_base<_AP_W, _AP_S>& op2) volatile {
Base::V = op2.V;
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline void operator=(const ap_int_base<_AP_W2, _AP_S2>& op2) volatile {
Base::V = op2.V;
}
#pragma empty_line
inline void operator=(const ap_int_base<_AP_W, _AP_S>& op2) volatile {
Base::V = op2.V;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
inline ap_int_base& operator=(const volatile ap_int_base<_AP_W, _AP_S>& op2) {
Base::V = op2.V;
return *this;
}
#pragma empty_line
inline ap_int_base& operator=(const ap_int_base<_AP_W, _AP_S>& op2) {
Base::V = op2.V;
return *this;
}
#pragma line 484 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline operator RetType() const { return (RetType)(Base::V); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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); }
#pragma line 588 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
inline int length() const volatile { return _AP_W; }
#pragma empty_line
#pragma empty_line
inline bool iszero() const { return Base::V == 0; }
#pragma empty_line
#pragma empty_line
inline bool is_zero() const { return Base::V == 0; }
#pragma empty_line
#pragma empty_line
inline bool sign() const {
if (_AP_S &&
(Base::V).get_bit((_AP_W - 1)))
return true;
else
return false;
}
#pragma empty_line
#pragma empty_line
inline void clear(int i) {
#pragma empty_line
#pragma line 607 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
(static_cast <bool> (
#pragma line 607 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
(i >= 0 && i < _AP_W) && ("position out of range")
#pragma line 607 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 607 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
"(i >= 0 && i < _AP_W) && (\"position out of range\")"
#pragma line 607 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h", 607, __extension__ __PRETTY_FUNCTION__))
#pragma line 607 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
;
Base::V = _AP_ROOT_op_set_bit(Base::V, i, 0);
}
#pragma empty_line
#pragma empty_line
inline void invert(int i) {
#pragma empty_line
#pragma line 613 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
(static_cast <bool> (
#pragma line 613 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
(i >= 0 && i < _AP_W) && ("position out of range")
#pragma line 613 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 613 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
"(i >= 0 && i < _AP_W) && (\"position out of range\")"
#pragma line 613 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h", 613, __extension__ __PRETTY_FUNCTION__))
#pragma line 613 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
}
#pragma empty_line
inline bool test(int i) const {
#pragma empty_line
#pragma line 622 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
(static_cast <bool> (
#pragma line 622 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
(i >= 0 && i < _AP_W) && ("position out of range")
#pragma line 622 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 622 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
"(i >= 0 && i < _AP_W) && (\"position out of range\")"
#pragma line 622 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h", 622, __extension__ __PRETTY_FUNCTION__))
#pragma line 622 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
;
return (Base::V).get_bit((i));
}
#pragma empty_line
#pragma empty_line
inline ap_int_base& get() { return *this; }
#pragma empty_line
#pragma empty_line
inline void set(int i) {
#pragma empty_line
#pragma line 631 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
(static_cast <bool> (
#pragma line 631 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
(i >= 0 && i < _AP_W) && ("position out of range")
#pragma line 631 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 631 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
"(i >= 0 && i < _AP_W) && (\"position out of range\")"
#pragma line 631 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h", 631, __extension__ __PRETTY_FUNCTION__))
#pragma line 631 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
;
Base::V = _AP_ROOT_op_set_bit(Base::V, i, 1);
}
#pragma empty_line
#pragma empty_line
inline void set(int i, bool v) {
#pragma empty_line
#pragma line 637 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
(static_cast <bool> (
#pragma line 637 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
(i >= 0 && i < _AP_W) && ("position out of range")
#pragma line 637 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 637 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
"(i >= 0 && i < _AP_W) && (\"position out of range\")"
#pragma line 637 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h", 637, __extension__ __PRETTY_FUNCTION__))
#pragma line 637 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
;
Base::V = _AP_ROOT_op_set_bit(Base::V, i, v);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline ap_int_base& lrotate(int n) {
#pragma empty_line
#pragma line 644 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
(static_cast <bool> (
#pragma line 644 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
(n >= 0 && n < _AP_W) && ("shift value out of range")
#pragma line 644 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 644 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
"(n >= 0 && n < _AP_W) && (\"shift value out of range\")"
#pragma line 644 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h", 644, __extension__ __PRETTY_FUNCTION__))
#pragma line 644 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
Base::V.lrotate(n);
#pragma empty_line
return *this;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline ap_int_base& rrotate(int n) {
#pragma empty_line
#pragma line 659 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
(static_cast <bool> (
#pragma line 659 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
(n >= 0 && n < _AP_W) && ("shift value out of range")
#pragma line 659 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 659 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
"(n >= 0 && n < _AP_W) && (\"shift value out of range\")"
#pragma line 659 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h", 659, __extension__ __PRETTY_FUNCTION__))
#pragma line 659 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
Base::V.rrotate(n);
#pragma empty_line
return *this;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline ap_int_base& reverse() {
Base::V = (Base::V).range((0), (_AP_W - 1));
return *this;
}
#pragma empty_line
#pragma empty_line
inline void set_bit(int i, bool v) {
Base::V = _AP_ROOT_op_set_bit(Base::V, i, v);
}
#pragma empty_line
#pragma empty_line
inline bool get_bit(int i) const {
return (bool)(Base::V).get_bit((i));
}
#pragma empty_line
#pragma empty_line
inline void b_not() { Base::V = ~Base::V; }
#pragma line 701 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma line 719 "/home/justin/jhai/Xilinx/Vivado/2018.3/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(
#pragma line 719 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
stderr
#pragma line 719 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
, "WARNING: " "Bitsize mismatch for ap_[u]int" "&=" "ap_[u]int."); fprintf(
#pragma line 719 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
stderr
#pragma line 719 "/home/justin/jhai/Xilinx/Vivado/2018.3/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(
#pragma line 720 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
stderr
#pragma line 720 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
, "WARNING: " "Bitsize mismatch for ap_[u]int" "|=" "ap_[u]int."); fprintf(
#pragma line 720 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
stderr
#pragma line 720 "/home/justin/jhai/Xilinx/Vivado/2018.3/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(
#pragma line 721 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
stderr
#pragma line 721 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
, "WARNING: " "Bitsize mismatch for ap_[u]int" "^=" "ap_[u]int."); fprintf(
#pragma line 721 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
stderr
#pragma line 721 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
, "\n"); } } while (0); Base::V ^= op2.V; return *this; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline typename RType<_AP_W,_AP_S>::arg1 operator+() const { return *this; }
#pragma empty_line
#pragma empty_line
inline typename RType<1, false>::minus operator-() const {
return ap_int_base<1, false>(0) - *this;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline bool operator!() const { return Base::V == 0; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline typename RType<_AP_W,_AP_S>::arg1 operator~() const {
ap_int_base<_AP_W, _AP_S> r;
r.V = ~Base::V;
return r;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
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;
}
#pragma empty_line
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);
}
#pragma empty_line
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;
}
#pragma line 830 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
}
#pragma empty_line
template <int _AP_W2>
inline ap_int_base& operator<<=(const ap_int_base<_AP_W2, false>& op2) {
Base::V <<= op2.to_uint();
return *this;
}
#pragma empty_line
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);
}
#pragma empty_line
template <int _AP_W2>
inline ap_int_base& operator>>=(const ap_int_base<_AP_W2, false>& op2) {
Base::V >>= op2.to_uint();
return *this;
}
#pragma line 879 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline ap_range_ref<_AP_W, _AP_S> range(int Hi, int Lo) {
do { if ((Hi >= _AP_W)) { fprintf(
#pragma line 908 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
stderr
#pragma line 908 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
, "ERROR: " "Hi(%d)out of bound(%d) in range()", Hi, _AP_W); fprintf(
#pragma line 908 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
stderr
#pragma line 908 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
, "\n"); abort(); } } while (0);
do { if ((Lo >= _AP_W)) { fprintf(
#pragma line 909 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
stderr
#pragma line 909 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
, "ERROR: " "Lo(%d)out of bound(%d) in range()", Lo, _AP_W); fprintf(
#pragma line 909 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
stderr
#pragma line 909 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
, "\n"); abort(); } } while (0);
return ap_range_ref<_AP_W, _AP_S>(this, Hi, Lo);
}
#pragma empty_line
#pragma empty_line
inline ap_range_ref<_AP_W, _AP_S> range(int Hi, int Lo) const {
do { if ((Hi >= _AP_W)) { fprintf(
#pragma line 915 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
stderr
#pragma line 915 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
, "ERROR: " "Hi(%d)out of bound(%d) in range()", Hi, _AP_W); fprintf(
#pragma line 915 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
stderr
#pragma line 915 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
, "\n"); abort(); } } while (0);
do { if ((Lo >= _AP_W)) { fprintf(
#pragma line 916 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
stderr
#pragma line 916 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
, "ERROR: " "Lo(%d)out of bound(%d) in range()", Lo, _AP_W); fprintf(
#pragma line 916 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
stderr
#pragma line 916 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
}
#pragma empty_line
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);
}
#pragma empty_line
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);
}
#pragma empty_line
inline ap_range_ref<_AP_W, _AP_S> range() {
return this->range(_AP_W - 1, 0);
}
#pragma empty_line
inline ap_range_ref<_AP_W, _AP_S> range() const {
return this->range(_AP_W - 1, 0);
}
#pragma empty_line
inline ap_range_ref<_AP_W, _AP_S> operator()(int Hi, int Lo) {
return this->range(Hi, Lo);
}
#pragma empty_line
inline ap_range_ref<_AP_W, _AP_S> operator()(int Hi, int Lo) const {
return this->range(Hi, Lo);
}
#pragma empty_line
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);
}
#pragma empty_line
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);
}
#pragma line 988 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
inline ap_bit_ref<_AP_W, _AP_S> operator[](int index) {
#pragma empty_line
#pragma line 989 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
(static_cast <bool> (
#pragma line 989 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
(index >= 0) && ("Attempting to read bit with negative index")
#pragma line 989 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 989 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
"(index >= 0) && (\"Attempting to read bit with negative index\")"
#pragma line 989 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h", 989, __extension__ __PRETTY_FUNCTION__))
#pragma line 989 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
;
#pragma empty_line
#pragma line 990 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
(static_cast <bool> (
#pragma line 990 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
(index < _AP_W) && ("Attempting to read bit beyond MSB")
#pragma line 990 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 990 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
"(index < _AP_W) && (\"Attempting to read bit beyond MSB\")"
#pragma line 990 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h", 990, __extension__ __PRETTY_FUNCTION__))
#pragma line 990 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
;
ap_bit_ref<_AP_W, _AP_S> bvh(this, index);
return bvh;
}
#pragma empty_line
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) {
#pragma empty_line
#pragma line 998 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
(static_cast <bool> (
#pragma line 998 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
(index >= 0) && ("Attempting to read bit with negative index")
#pragma line 998 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 998 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
"(index >= 0) && (\"Attempting to read bit with negative index\")"
#pragma line 998 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h", 998, __extension__ __PRETTY_FUNCTION__))
#pragma line 998 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
;
#pragma empty_line
#pragma line 999 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
(static_cast <bool> (
#pragma line 999 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
(index < _AP_W) && ("Attempting to read bit beyond MSB")
#pragma line 999 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 999 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
"(index < _AP_W) && (\"Attempting to read bit beyond MSB\")"
#pragma line 999 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h", 999, __extension__ __PRETTY_FUNCTION__))
#pragma line 999 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
;
ap_bit_ref<_AP_W, _AP_S> bvh(this, index.to_int());
return bvh;
}
#pragma empty_line
inline bool operator[](int index) const {
#pragma empty_line
#pragma line 1005 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
(static_cast <bool> (
#pragma line 1005 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
(index >= 0) && ("Attempting to read bit with negative index")
#pragma line 1005 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 1005 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
"(index >= 0) && (\"Attempting to read bit with negative index\")"
#pragma line 1005 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h", 1005, __extension__ __PRETTY_FUNCTION__))
#pragma line 1005 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
;
#pragma empty_line
#pragma line 1006 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
(static_cast <bool> (
#pragma line 1006 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
(index < _AP_W) && ("Attempting to read bit beyond MSB")
#pragma line 1006 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 1006 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
"(index < _AP_W) && (\"Attempting to read bit beyond MSB\")"
#pragma line 1006 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h", 1006, __extension__ __PRETTY_FUNCTION__))
#pragma line 1006 "/home/justin/jhai/Xilinx/Vivado/2018.3/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 {
#pragma empty_line
#pragma line 1012 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
(static_cast <bool> (
#pragma line 1012 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
(index < _AP_W) && ("Attempting to read bit beyond MSB")
#pragma line 1012 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 1012 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
"(index < _AP_W) && (\"Attempting to read bit beyond MSB\")"
#pragma line 1012 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h", 1012, __extension__ __PRETTY_FUNCTION__))
#pragma line 1012 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
;
ap_bit_ref<_AP_W, _AP_S> br(this, index.to_int());
return br.to_bool();
}
#pragma empty_line
inline ap_bit_ref<_AP_W, _AP_S> bit(int index) {
#pragma empty_line
#pragma line 1018 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
(static_cast <bool> (
#pragma line 1018 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
(index >= 0) && ("Attempting to read bit with negative index")
#pragma line 1018 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 1018 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
"(index >= 0) && (\"Attempting to read bit with negative index\")"
#pragma line 1018 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h", 1018, __extension__ __PRETTY_FUNCTION__))
#pragma line 1018 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
;
#pragma empty_line
#pragma line 1019 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
(static_cast <bool> (
#pragma line 1019 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
(index < _AP_W) && ("Attempting to read bit beyond MSB")
#pragma line 1019 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 1019 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
"(index < _AP_W) && (\"Attempting to read bit beyond MSB\")"
#pragma line 1019 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h", 1019, __extension__ __PRETTY_FUNCTION__))
#pragma line 1019 "/home/justin/jhai/Xilinx/Vivado/2018.3/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) {
#pragma empty_line
#pragma line 1026 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
(static_cast <bool> (
#pragma line 1026 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
(index >= 0) && ("Attempting to read bit with negative index")
#pragma line 1026 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 1026 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
"(index >= 0) && (\"Attempting to read bit with negative index\")"
#pragma line 1026 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h", 1026, __extension__ __PRETTY_FUNCTION__))
#pragma line 1026 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
;
#pragma empty_line
#pragma line 1027 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
(static_cast <bool> (
#pragma line 1027 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
(index < _AP_W) && ("Attempting to read bit beyond MSB")
#pragma line 1027 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 1027 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
"(index < _AP_W) && (\"Attempting to read bit beyond MSB\")"
#pragma line 1027 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h", 1027, __extension__ __PRETTY_FUNCTION__))
#pragma line 1027 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
;
ap_bit_ref<_AP_W, _AP_S> bvh(this, index.to_int());
return bvh;
}
#pragma empty_line
inline bool bit(int index) const {
#pragma empty_line
#pragma line 1033 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
(static_cast <bool> (
#pragma line 1033 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
(index >= 0) && ("Attempting to read bit with negative index")
#pragma line 1033 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 1033 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
"(index >= 0) && (\"Attempting to read bit with negative index\")"
#pragma line 1033 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h", 1033, __extension__ __PRETTY_FUNCTION__))
#pragma line 1033 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
;
#pragma empty_line
#pragma line 1034 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
(static_cast <bool> (
#pragma line 1034 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
(index < _AP_W) && ("Attempting to read bit beyond MSB")
#pragma line 1034 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
) ? void (0) : __assert_fail (
#pragma line 1034 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
"(index < _AP_W) && (\"Attempting to read bit beyond MSB\")"
#pragma line 1034 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h" 3 4
, "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h", 1034, __extension__ __PRETTY_FUNCTION__))
#pragma line 1034 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
;
ap_bit_ref<_AP_W, _AP_S> br(this, index);
return br.to_bool();
}
#pragma empty_line
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());
}
#pragma line 1055 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
inline int countLeadingZeros() {
#pragma line 1090 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_base.h"
return (Base::V).countLeadingZeros();
#pragma empty_line
}
#pragma empty_line
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));
}
#pragma empty_line
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);
}
#pragma empty_line
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));
}
#pragma empty_line
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);
}
#pragma empty_line
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));
}
#pragma empty_line
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);
}
#pragma empty_line
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));
}
#pragma empty_line
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);
}
#pragma empty_line
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));
}
#pragma empty_line
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);
}
#pragma empty_line
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));
}
#pragma empty_line
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);
}
#pragma empty_line
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));
}
#pragma empty_line
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);
}
#pragma empty_line
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));
}
#pragma empty_line
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);
}
#pragma empty_line
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();
}
#pragma empty_line
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();
}
#pragma empty_line
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();
}
#pragma empty_line
template <int _AP_W3>
inline void set(const ap_int_base<_AP_W3, false>& val) {
Base::V = val.V;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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());
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
std::string to_string(signed char rd = 2, bool sign = _AP_S) const {
#pragma empty_line
#pragma empty_line
if (rd == 2) sign = false;
return (Base::V).to_string(rd, sign);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma line 1354 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma line 1373 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma line 1401 "/home/justin/jhai/Xilinx/Vivado/2018.3/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) { std::ptrdiff_t op2 = op.to_long(); 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) { std::ptrdiff_t op2 = op.to_long(); 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) { std::ptrdiff_t op2 = op.to_long(); 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) { std::ptrdiff_t op2 = op.to_long(); return op2 - i_op; }
#pragma line 1429 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma line 1463 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 1502 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma line 1526 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma line 1557 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 1594 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 1631 "/home/justin/jhai/Xilinx/Vivado/2018.3/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() ; }
#pragma line 1661 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 1690 "/home/justin/jhai/Xilinx/Vivado/2018.3/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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, ap_int_base<_AP_W2, _AP_S2>& op2) { ap_int_base<_AP_W1, false> tmp(op1); tmp <<= op2; op1 = tmp; return op1; }
#pragma line 1716 "/home/justin/jhai/Xilinx/Vivado/2018.3/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>()); }
#pragma line 1743 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma line 1772 "/home/justin/jhai/Xilinx/Vivado/2018.3/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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, ap_int_base<_AP_W2, _AP_S2>& op2) { ap_int_base<1, false> tmp(op1); tmp <<= op2; op1 = tmp; return op1; }
#pragma line 1798 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma line 1906 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma line 56 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int.h" 2
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_ref.h" 1
#pragma line 72 "/home/justin/jhai/Xilinx/Vivado/2018.3/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,
};
#pragma empty_line
_AP_T1& mbv1;
_AP_T2& mbv2;
#pragma empty_line
inline ap_concat_ref(const ap_concat_ref<_AP_W1, _AP_T1, _AP_W2, _AP_T2>& ref)
: mbv1(ref.mbv1), mbv2(ref.mbv2) {}
#pragma empty_line
inline ap_concat_ref(_AP_T1& bv1, _AP_T2& bv2) : mbv1(bv1), mbv2(bv2) {}
#pragma empty_line
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;
}
#pragma line 115 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
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);
}
#pragma empty_line
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);
}
#pragma empty_line
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));
}
#pragma empty_line
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());
}
#pragma empty_line
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));
}
#pragma empty_line
inline operator ap_int_base<_AP_WR, false>() const { return get(); }
#pragma empty_line
inline operator ap_ulong() const { return get().to_uint64(); }
#pragma empty_line
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));
}
#pragma empty_line
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);
}
#pragma empty_line
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));
}
#pragma empty_line
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));
}
#pragma empty_line
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) {
#pragma empty_line
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));
}
#pragma empty_line
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));
}
#pragma empty_line
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));
}
#pragma empty_line
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));
}
#pragma empty_line
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));
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma line 303 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma empty_line
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);
}
#pragma empty_line
inline int length() const { return mbv1.length() + mbv2.length(); }
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template <int _AP_W, bool _AP_S>
struct ap_range_ref {
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef ap_int_base<_AP_W, _AP_S> ref_type;
ref_type& d_bv;
int l_index;
int h_index;
#pragma empty_line
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) {}
#pragma empty_line
inline ap_range_ref(ref_type* bv, int h, int l)
: d_bv(*bv), l_index(l), h_index(h) {}
#pragma empty_line
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) {}
#pragma empty_line
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;
}
#pragma empty_line
inline operator ap_ulong() const { return to_uint64(); }
#pragma line 384 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline ap_range_ref& operator=(const ap_range_ref& val) {
return operator=((const ap_int_base<_AP_W, false>)val);
}
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
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));
}
#pragma empty_line
#pragma empty_line
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());
}
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
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));
}
#pragma empty_line
#pragma empty_line
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));
}
#pragma empty_line
#pragma empty_line
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));
}
#pragma empty_line
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);
}
#pragma empty_line
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);
}
#pragma empty_line
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));
}
#pragma empty_line
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));
}
#pragma empty_line
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));
}
#pragma empty_line
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));
}
#pragma empty_line
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));
}
#pragma empty_line
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));
}
#pragma empty_line
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));
}
#pragma empty_line
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;
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline bool operator!=(const ap_range_ref<_AP_W2, _AP_S2>& op2) {
return !(operator==(op2));
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline bool operator>(const ap_range_ref<_AP_W2, _AP_S2>& op2) {
return !(operator<=(op2));
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline bool operator>=(const ap_range_ref<_AP_W2, _AP_S2>& op2) {
return !(operator<(op2));
}
#pragma empty_line
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;
};
#pragma empty_line
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;
};
#pragma empty_line
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;
};
#pragma empty_line
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;
};
#pragma empty_line
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;
};
#pragma empty_line
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;
};
#pragma empty_line
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;
}
#pragma empty_line
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);
}
#pragma empty_line
inline int length() const {
return h_index >= l_index ? h_index - l_index + 1 : l_index - h_index + 1;
}
#pragma empty_line
inline int to_int() const {
return (int)((d_bv.V).range((h_index), (l_index)));
}
#pragma empty_line
inline unsigned to_uint() const {
return (unsigned)((d_bv.V).range((h_index), (l_index)));
}
#pragma empty_line
inline long to_long() const {
return (long)((d_bv.V).range((h_index), (l_index)));
}
#pragma empty_line
inline unsigned long to_ulong() const {
return (unsigned long)((d_bv.V).range((h_index), (l_index)));
}
#pragma empty_line
inline ap_slong to_int64() const {
return (ap_slong)((d_bv.V).range((h_index), (l_index)));
}
#pragma empty_line
inline ap_ulong to_uint64() const {
return (ap_ulong)((d_bv.V).range((h_index), (l_index)));
}
#pragma empty_line
inline bool and_reduce() const {
bool ret = true;
bool reverse = l_index > h_index;
unsigned low = reverse ? h_index : l_index;
unsigned high = reverse ? l_index : h_index;
for (unsigned i = low; i != high; ++i) {
#pragma empty_line
#pragma empty_line
#pragma empty_line
ret &= (d_bv.V).get_bit((i));
}
return ret;
}
#pragma empty_line
inline bool or_reduce() const {
bool ret = false;
bool reverse = l_index > h_index;
unsigned low = reverse ? h_index : l_index;
unsigned high = reverse ? l_index : h_index;
for (unsigned i = low; i != high; ++i) {
#pragma empty_line
#pragma empty_line
#pragma empty_line
ret |= (d_bv.V).get_bit((i));
}
return ret;
}
#pragma empty_line
inline bool xor_reduce() const {
bool ret = false;
bool reverse = l_index > h_index;
unsigned low = reverse ? h_index : l_index;
unsigned high = reverse ? l_index : h_index;
for (unsigned i = low; i != high; ++i) {
#pragma empty_line
#pragma empty_line
#pragma empty_line
ret ^= (d_bv.V).get_bit((i));
}
return ret;
}
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template <int _AP_W, bool _AP_S>
struct ap_bit_ref {
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef ap_int_base<_AP_W, _AP_S> ref_type;
ref_type& d_bv;
int d_index;
#pragma empty_line
public:
#pragma empty_line
inline ap_bit_ref(const ap_bit_ref<_AP_W, _AP_S>& ref)
: d_bv(ref.d_bv), d_index(ref.d_index) {}
#pragma empty_line
inline ap_bit_ref(ref_type* bv, int index = 0) : d_bv(*bv), d_index(index) {}
#pragma empty_line
inline ap_bit_ref(const ref_type* bv, int index = 0)
: d_bv(*const_cast<ref_type*>(bv)), d_index(index) {}
#pragma empty_line
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)); }
#pragma line 809 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma line 831 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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));
}
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline ap_bit_ref& operator=(const ap_bit_ref& val) {
return operator=((ap_ulong)(bool)val);
}
#pragma empty_line
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);
}
#pragma empty_line
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);
}
#pragma empty_line
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);
}
#pragma empty_line
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);
}
#pragma empty_line
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);
}
#pragma empty_line
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));
}
#pragma empty_line
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));
}
#pragma empty_line
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));
}
#pragma empty_line
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));
}
#pragma empty_line
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));
}
#pragma empty_line
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));
}
#pragma empty_line
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));
}
#pragma empty_line
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));
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline bool operator==(const ap_bit_ref<_AP_W2, _AP_S2>& op) {
return get() == op.get();
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline bool operator!=(const ap_bit_ref<_AP_W2, _AP_S2>& op) {
return get() != op.get();
}
#pragma empty_line
inline bool get() const { return (d_bv.V).get_bit((d_index)); }
#pragma empty_line
inline bool get() { return (d_bv.V).get_bit((d_index)); }
#pragma empty_line
template <int _AP_W3>
inline void set(const ap_int_base<_AP_W3, false>& val) {
operator=(val);
}
#pragma empty_line
inline bool operator~() const {
bool bit = (d_bv.V).get_bit((d_index));
return bit ? false : true;
}
#pragma empty_line
inline int length() const { return 1; }
#pragma empty_line
#pragma empty_line
std::string to_string() const { return get() ? "1" : "0"; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
};
#pragma line 1029 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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); }
#pragma line 1088 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 1111 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 1139 "/home/justin/jhai/Xilinx/Vivado/2018.3/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>()); }
#pragma line 1188 "/home/justin/jhai/Xilinx/Vivado/2018.3/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(); }
#pragma line 1335 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma line 1359 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma empty_line
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); }
#pragma line 57 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int.h" 2
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template <int _AP_W>
struct ap_int : ap_int_base<_AP_W, true> {
typedef ap_int_base<_AP_W, true> Base;
#pragma empty_line
inline ap_int() : Base() {}
template <int _AP_W2>
inline ap_int(const ap_int<_AP_W2>& op) {
Base::V = op.V;
}
#pragma empty_line
template <int _AP_W2>
inline ap_int(const volatile ap_int<_AP_W2>& op) {
Base::V = op.V;
}
#pragma empty_line
template <int _AP_W2>
inline ap_int(const ap_uint<_AP_W2>& op) {
Base::V = op.V;
}
#pragma empty_line
template <int _AP_W2>
inline ap_int(const volatile ap_uint<_AP_W2>& op) {
Base::V = op.V;
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline ap_int(const ap_range_ref<_AP_W2, _AP_S2>& ref) : Base(ref) {}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline ap_int(const ap_bit_ref<_AP_W2, _AP_S2>& ref) : Base(ref) {}
#pragma empty_line
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) {}
#pragma empty_line
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) {}
#pragma empty_line
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) {
}
#pragma empty_line
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) {}
#pragma empty_line
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) {
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline ap_int(const ap_int_base<_AP_W2, _AP_S2>& op) {
Base::V = op.V;
}
#pragma empty_line
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) {}
#pragma empty_line
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) {}
#pragma empty_line
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) {}
#pragma empty_line
#pragma empty_line
#pragma empty_line
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; }
#pragma empty_line
ap_int(double val) : Base(val) {}
ap_int(float val) : Base(val) {}
ap_int(half val) : Base(val) {}
#pragma empty_line
#pragma empty_line
inline ap_int(const char* s) : Base(s) {}
#pragma empty_line
inline ap_int(const char* s, signed char rd) : Base(s, rd) {}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline ap_int& operator=(const ap_int<_AP_W>& op2) {
Base::V = op2.V;
return *this;
}
#pragma empty_line
#pragma empty_line
inline ap_int& operator=(const volatile ap_int<_AP_W>& op2) {
Base::V = op2.V;
return *this;
}
#pragma empty_line
#pragma empty_line
inline void operator=(const ap_int<_AP_W>& op2) volatile { Base::V = op2.V; }
#pragma empty_line
inline void operator=(const volatile ap_int<_AP_W>& op2) volatile {
Base::V = op2.V;
}
#pragma empty_line
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template <int _AP_W>
struct ap_uint : ap_int_base<_AP_W, false> {
typedef ap_int_base<_AP_W, false> Base;
#pragma empty_line
inline ap_uint() : Base() {}
template <int _AP_W2>
inline ap_uint(const ap_uint<_AP_W2>& op) {
Base::V = op.V;
}
#pragma empty_line
template <int _AP_W2>
inline ap_uint(const ap_int<_AP_W2>& op) {
Base::V = op.V;
}
#pragma empty_line
template <int _AP_W2>
inline ap_uint(const volatile ap_uint<_AP_W2>& op) {
Base::V = op.V;
}
#pragma empty_line
template <int _AP_W2>
inline ap_uint(const volatile ap_int<_AP_W2>& op) {
Base::V = op.V;
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline ap_uint(const ap_range_ref<_AP_W2, _AP_S2>& ref) : Base(ref) {}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline ap_uint(const ap_bit_ref<_AP_W2, _AP_S2>& ref) : Base(ref) {}
#pragma empty_line
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) {}
#pragma empty_line
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) {}
#pragma empty_line
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) {
}
#pragma empty_line
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) {}
#pragma empty_line
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) {
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline ap_uint(const ap_int_base<_AP_W2, _AP_S2>& op) {
Base::V = op.V;
}
#pragma empty_line
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) {}
#pragma empty_line
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) {}
#pragma empty_line
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) {}
#pragma empty_line
#pragma empty_line
#pragma empty_line
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; }
#pragma empty_line
ap_uint(double val) : Base(val) {}
ap_uint(float val) : Base(val) {}
ap_uint(half val) : Base(val) {}
#pragma empty_line
#pragma empty_line
inline ap_uint(const char* s) : Base(s) {}
#pragma empty_line
inline ap_uint(const char* s, signed char rd) : Base(s, rd) {}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline ap_uint& operator=(const ap_uint<_AP_W>& op2) {
Base::V = op2.V;
return *this;
}
#pragma empty_line
#pragma empty_line
inline ap_uint& operator=(const volatile ap_uint<_AP_W>& op2) {
Base::V = op2.V;
return *this;
}
#pragma empty_line
#pragma empty_line
inline void operator=(const ap_uint<_AP_W>& op2) volatile { Base::V = op2.V; }
#pragma empty_line
inline void operator=(const volatile ap_uint<_AP_W>& op2) volatile {
Base::V = op2.V;
}
#pragma empty_line
};
#pragma line 341 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int.h"
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_special.h" 1
#pragma line 54 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_special.h"
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdio" 1 3
#pragma line 39 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdio" 3
#pragma empty_line
#pragma line 40 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdio" 3
#pragma line 55 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_special.h" 2
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 1 3
#pragma line 39 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 3
#pragma empty_line
#pragma line 40 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 3
#pragma line 56 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_special.h" 2
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std {
template<typename _Tp> class complex;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std {
#pragma line 88 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int_special.h"
template <int _AP_W>
struct complex<ap_int<_AP_W> > {
typedef ap_int<_AP_W> _Tp;
typedef _Tp value_type;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
complex() : _M_real(_Tp()), _M_imag(_Tp()) {}
#pragma empty_line
#pragma empty_line
complex(const _Tp &__r, const _Tp &__i = _Tp(0))
: _M_real(__r), _M_imag(__i) {}
#pragma empty_line
#pragma empty_line
template <typename _Up>
complex(const complex<_Up> &__z) : _M_real(__z.real()), _M_imag(__z.imag()) {}
#pragma empty_line
#pragma empty_line
const _Tp& real() const { return _M_real; }
const _Tp& imag() const { return _M_imag; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
void real(_Tp __val) { _M_real = __val; }
#pragma empty_line
void imag(_Tp __val) { _M_imag = __val; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
complex<_Tp> &operator=(const _Tp __t) {
_M_real = __t;
_M_imag = _Tp(0);
return *this;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
complex<_Tp> &operator+=(const _Tp &__t) {
_M_real += __t;
return *this;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
complex<_Tp> &operator-=(const _Tp &__t) {
_M_real -= __t;
return *this;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
complex<_Tp> &operator*=(const _Tp &__t) {
_M_real *= __t;
_M_imag *= __t;
return *this;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
complex<_Tp> &operator/=(const _Tp &__t) {
_M_real /= __t;
_M_imag /= __t;
return *this;
}
#pragma empty_line
#pragma empty_line
template <typename _Up>
complex<_Tp> &operator=(const complex<_Up> &__z) {
_M_real = __z.real();
_M_imag = __z.imag();
return *this;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
template <typename _Up>
complex<_Tp> &operator+=(const complex<_Up> &__z) {
_M_real += __z.real();
_M_imag += __z.imag();
return *this;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
template <typename _Up>
complex<_Tp> &operator-=(const complex<_Up> &__z) {
_M_real -= __z.real();
_M_imag -= __z.imag();
return *this;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
private:
_Tp _M_real;
_Tp _M_imag;
#pragma empty_line
};
#pragma line 220 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma empty_line
#pragma empty_line
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();
}
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
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();
}
#pragma empty_line
}
#pragma line 342 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int.h" 2
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed.h" 1
#pragma line 55 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed.h"
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 1
#pragma line 61 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int.h" 1
#pragma line 62 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 2
#pragma line 77 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cfenv" 1 3
#pragma line 32 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cfenv" 3
#pragma empty_line
#pragma line 33 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cfenv" 3
#pragma line 41 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cfenv" 3
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/fenv.h" 1 3
#pragma line 32 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/fenv.h" 3
#pragma empty_line
#pragma line 33 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/fenv.h" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/fenv.h" 1 3 4
#pragma line 26 "/usr/include/fenv.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4
#pragma line 27 "/usr/include/fenv.h" 2 3 4
#pragma line 64 "/usr/include/fenv.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/fenv.h" 1 3 4
#pragma line 24 "/usr/include/x86_64-linux-gnu/bits/fenv.h" 3 4
#pragma empty_line
#pragma line 24 "/usr/include/x86_64-linux-gnu/bits/fenv.h" 3 4
enum
{
FE_INVALID =
#pragma empty_line
0x01,
__FE_DENORM = 0x02,
FE_DIVBYZERO =
#pragma empty_line
0x04,
FE_OVERFLOW =
#pragma empty_line
0x08,
FE_UNDERFLOW =
#pragma empty_line
0x10,
FE_INEXACT =
#pragma empty_line
0x20
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
enum
{
FE_TONEAREST =
#pragma empty_line
0,
FE_DOWNWARD =
#pragma empty_line
0x400,
FE_UPWARD =
#pragma empty_line
0x800,
FE_TOWARDZERO =
#pragma empty_line
0xc00
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef unsigned short int fexcept_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef struct
{
unsigned short int __control_word;
unsigned short int __glibc_reserved1;
unsigned short int __status_word;
unsigned short int __glibc_reserved2;
unsigned short int __tags;
unsigned short int __glibc_reserved3;
unsigned int __eip;
unsigned short int __cs_selector;
unsigned int __opcode:11;
unsigned int __glibc_reserved4:5;
unsigned int __data_offset;
unsigned short int __data_selector;
unsigned short int __glibc_reserved5;
#pragma empty_line
unsigned int __mxcsr;
#pragma empty_line
}
fenv_t;
#pragma line 106 "/usr/include/x86_64-linux-gnu/bits/fenv.h" 3 4
typedef struct
{
unsigned short int __control_word;
unsigned short int __glibc_reserved;
unsigned int __mxcsr;
}
femode_t;
#pragma line 65 "/usr/include/fenv.h" 2 3 4
#pragma empty_line
extern "C" {
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int feclearexcept (int __excepts) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int fegetexceptflag (fexcept_t *__flagp, int __excepts) throw ();
#pragma empty_line
#pragma empty_line
extern int feraiseexcept (int __excepts) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int fesetexcept (int __excepts) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int fesetexceptflag (const fexcept_t *__flagp, int __excepts) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int fetestexcept (int __excepts) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int fetestexceptflag (const fexcept_t *__flagp, int __excepts) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int fegetround (void) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
extern int fesetround (int __rounding_direction) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int fegetenv (fenv_t *__envp) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int feholdexcept (fenv_t *__envp) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int fesetenv (const fenv_t *__envp) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int feupdateenv (const fenv_t *__envp) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int fegetmode (femode_t *__modep) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int fesetmode (const femode_t *__modep) throw ();
#pragma line 161 "/usr/include/fenv.h" 3 4
extern int feenableexcept (int __excepts) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int fedisableexcept (int __excepts) throw ();
#pragma empty_line
#pragma empty_line
extern int fegetexcept (void) throw ();
#pragma empty_line
#pragma empty_line
}
#pragma line 37 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/fenv.h" 2 3
#pragma line 55 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/fenv.h" 3
namespace std
{
#pragma empty_line
using ::fenv_t;
using ::fexcept_t;
#pragma empty_line
#pragma empty_line
using ::feclearexcept;
using ::fegetexceptflag;
using ::feraiseexcept;
using ::fesetexceptflag;
using ::fetestexcept;
#pragma empty_line
using ::fegetround;
using ::fesetround;
#pragma empty_line
using ::fegetenv;
using ::feholdexcept;
using ::fesetenv;
using ::feupdateenv;
}
#pragma line 42 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cfenv" 2 3
#pragma line 58 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cfenv" 3
namespace std
{
#pragma empty_line
using ::fenv_t;
using ::fexcept_t;
#pragma empty_line
#pragma empty_line
using ::feclearexcept;
using ::fegetexceptflag;
using ::feraiseexcept;
using ::fesetexceptflag;
using ::fetestexcept;
#pragma empty_line
using ::fegetround;
using ::fesetround;
#pragma empty_line
using ::fegetenv;
using ::feholdexcept;
using ::fesetenv;
using ::feupdateenv;
}
#pragma line 78 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 2
#pragma line 98 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
#pragma empty_line
#pragma line 98 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
};
#pragma line 153 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
#pragma empty_line
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,
#pragma empty_line
div_w = _AP_S2 + _AP_W + ((F2) > (0) ? (F2) : (0)),
#pragma empty_line
#pragma empty_line
#pragma empty_line
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
};
#pragma empty_line
typedef ap_fixed_base<_AP_W, _AP_I, _AP_S> lhs;
typedef ap_fixed_base<_AP_W2, _AP_I2, _AP_S2> rhs;
#pragma empty_line
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;
#pragma empty_line
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;
};
#pragma empty_line
private:
#pragma empty_line
#pragma empty_line
void fromString(const std::string& val, unsigned char radix) {
do { if ((!(radix == 2 || radix == 8 || radix == 10 || radix == 16))) { fprintf(
#pragma line 219 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 219 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
, "ERROR: " "ap_fixed_base::fromString(%s, %d)", val.c_str(), radix); fprintf(
#pragma line 219 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 219 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
, "\n"); abort(); } } while (0)
;
#pragma empty_line
Base::V = 0;
int startPos = 0;
int endPos = val.length();
int decPos = val.find(".");
if (decPos == -1) decPos = endPos;
#pragma empty_line
#pragma empty_line
bool isNegative = false;
if (val[0] == '-') {
isNegative = true;
++startPos;
} else if (val[0] == '+')
++startPos;
#pragma line 243 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
#pragma empty_line
unsigned shift = (radix == 16 ? 4 : radix == 8 ? 3 : radix == 2 ? 1 : 0);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
bool sticky_int = false;
#pragma empty_line
#pragma empty_line
for (int i = startPos; i < decPos; i++) {
#pragma empty_line
char cdigit = val[i];
if (cdigit == '\0') continue;
unsigned digit = ap_private_ops::decode_digit(cdigit, radix);
#pragma empty_line
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];
#pragma empty_line
if (shift)
integer_bits <<= shift;
else
integer_bits *= radix;
#pragma empty_line
#pragma empty_line
integer_bits += digit;
#pragma empty_line
#pragma empty_line
}
integer_bits[((_AP_I) > (4) ? (_AP_I) : (4)) + 4 - 3] =
integer_bits[((_AP_I) > (4) ? (_AP_I) : (4)) + 4 - 3] | sticky_int;
#pragma empty_line
ap_fixed_base<((_AP_W - _AP_I) > (0) ? (_AP_W - _AP_I) : (0)) + 4 + 4, 4, false> fractional_bits = 0;
bool sticky = false;
#pragma empty_line
#pragma empty_line
for (int i = endPos - 1; i >= decPos + 1; i--) {
#pragma empty_line
char cdigit = val[i];
if (cdigit == '\0') continue;
unsigned digit = ap_private_ops::decode_digit(cdigit, radix);
#pragma empty_line
fractional_bits += digit;
#pragma empty_line
sticky |= fractional_bits[0] | fractional_bits[1] | fractional_bits[2] |
fractional_bits[3];
#pragma empty_line
if (shift)
fractional_bits >>= shift;
else
fractional_bits /= radix;
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
fractional_bits[0] = fractional_bits[0] | sticky;
#pragma empty_line
if (isNegative)
*this = -(integer_bits + fractional_bits);
else
*this = integer_bits + fractional_bits;
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
inline void report() {
if (!_AP_S && _AP_O == AP_WRAP_SM) {
fprintf(
#pragma line 319 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 319 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
, "ap_ufxied<...> cannot support AP_WRAP_SM.\n");
exit(1);
}
if (_AP_W > ((1024 + 1023) / 1024) * 1024) {
fprintf(
#pragma line 323 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 323 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
}
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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) {
#pragma empty_line
#pragma empty_line
Base::V = _AP_ROOT_op_set_bit(Base::V, _AP_W - 1, sign);
if (_AP_N > 1) {
#pragma empty_line
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 {
#pragma empty_line
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;
}
}
}
#pragma empty_line
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)));
}
#pragma empty_line
#pragma empty_line
public:
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline ap_fixed_base() {}
#pragma empty_line
#pragma empty_line
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();
}
#pragma empty_line
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();
}
#pragma empty_line
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();
}
#pragma empty_line
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();
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
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(
#pragma line 463 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 463 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
, "ERROR: " "ap_fixed_base(const char* \"%s\", %d), str=%s, radix = %d", s, rd, str.c_str(), radix); fprintf(
#pragma line 463 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 463 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
, "\n"); abort(); } } while (0)
;
fromString(str, radix);
}
#pragma line 490 "/home/justin/jhai/Xilinx/Vivado/2018.3/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();
}
#pragma empty_line
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();
}
#pragma empty_line
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();
}
#pragma empty_line
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();
}
#pragma empty_line
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();
}
#pragma line 534 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
ap_fixed_base(double d) {
ap_int_base<64, false> ireg;
ireg.V = doubleToRawBits(d);
bool isneg = (ireg.V).get_bit((63));
#pragma empty_line
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));
#pragma empty_line
do { if ((exp == ((1L << (11 - 1L)) - 1L) + 1 && man.V != 0)) { fprintf(
#pragma line 566 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 566 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
, "WARNING: " "assign NaN to fixed point value"); fprintf(
#pragma line 566 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 566 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
#pragma empty_line
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))
#pragma empty_line
!= 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;
}
#pragma empty_line
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)
#pragma empty_line
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);
#pragma empty_line
if (pos2 >= 0 && pos2 < _AP_W2) {
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
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();
}
#pragma empty_line
#pragma empty_line
inline ap_fixed_base(float d) { *this = ap_fixed_base(double(d)); }
#pragma empty_line
#pragma empty_line
inline ap_fixed_base(half d) { *this = ap_fixed_base(double(d)); }
#pragma line 687 "/home/justin/jhai/Xilinx/Vivado/2018.3/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) {
#pragma empty_line
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));
#pragma empty_line
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;
#pragma empty_line
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));
#pragma empty_line
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) };
#pragma empty_line
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;
#pragma empty_line
if (sh_amt < _AP_W) {
if (_AP_W > _AP_W2) {
#pragma empty_line
Base::V = op.V;
Base::V <<= sh_amt;
} else {
#pragma empty_line
Base::V = op.V << sh_amt;
}
} else {
Base::V = 0;
}
}
#pragma empty_line
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);
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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);
#pragma empty_line
overflow_adjust(underflow, overflow, lD, neg_src);
}
return *this;
}
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
inline ap_fixed_base& setBits(ap_ulong bv) {
#pragma empty_line
Base::V = bv;
return *this;
}
#pragma empty_line
#pragma empty_line
static inline ap_fixed_base bitsToFixed(ap_ulong bv) {
#pragma empty_line
ap_fixed_base t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
t.V.set_bits(bv);
#pragma empty_line
return t;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
}
#pragma line 847 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
if (Cnative && _AP_I < _AP_W) {
#pragma empty_line
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 {
#pragma empty_line
}
return ret;
};
#pragma empty_line
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());
}
#pragma empty_line
#pragma empty_line
inline char to_char() const { return to_ap_int_base().to_char(); }
#pragma empty_line
inline int to_int() const { return to_ap_int_base().to_int(); }
#pragma empty_line
inline unsigned to_uint() const { return to_ap_int_base().to_uint(); }
#pragma empty_line
inline ap_slong to_int64() const { return to_ap_int_base().to_int64(); }
#pragma empty_line
inline ap_ulong to_uint64() const { return to_ap_int_base().to_uint64(); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline double to_double() const {
#pragma empty_line
do { if ((std::fegetround() !=
#pragma line 880 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
0
#pragma line 880 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
)) { fprintf(
#pragma line 880 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 880 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
, "WARNING: " "Only FE_TONEAREST is supported"); fprintf(
#pragma line 880 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 880 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
, "\n"); } } while (0)
;
#pragma empty_line
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;
#pragma empty_line
bool a = (lsb_index >=2) ?
((tmp.V).range((lsb_index - 2), (0)) != 0) : 0;
#pragma empty_line
a |= (lsb_index >=0) ? (tmp.V).get_bit((lsb_index)) : 0;
#pragma empty_line
ap_ulong m;
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
if (_AP_ctype_op_get_bit(m, 52 + 1)) {
e += 1;
}
#pragma empty_line
m = _AP_ctype_op_set_bit(m, BITS - 1, s);
#pragma empty_line
m = _AP_ctype_op_set_range(m, 52, 52 + 11 - 1, e);
#pragma empty_line
#pragma empty_line
return rawBitsToDouble(m);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline float to_float() const {
#pragma empty_line
do { if ((std::fegetround() !=
#pragma line 930 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
0
#pragma line 930 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
)) { fprintf(
#pragma line 930 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 930 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
, "WARNING: " "Only FE_TONEAREST is supported"); fprintf(
#pragma line 930 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 930 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
, "\n"); } } while (0)
;
#pragma empty_line
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;
#pragma empty_line
bool a = (lsb_index >=2) ?
((tmp.V).range((lsb_index - 2), (0)) != 0) : 0;
#pragma empty_line
a |= (lsb_index >=0) ? (tmp.V).get_bit((lsb_index)) : 0;
#pragma empty_line
unsigned long m;
#pragma empty_line
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;
#pragma empty_line
if (_AP_ctype_op_get_bit(m, 23 + 1)) {
e += 1;
}
#pragma empty_line
m = _AP_ctype_op_set_bit(m, BITS - 1, s);
m = _AP_ctype_op_set_range(m, 23, 23 + 8 - 1, e);
#pragma empty_line
return rawBitsToFloat(m);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline half to_half() const {
#pragma empty_line
do { if ((std::fegetround() !=
#pragma line 977 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
0
#pragma line 977 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
)) { fprintf(
#pragma line 977 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 977 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
, "WARNING: " "Only FE_TONEAREST is supported"); fprintf(
#pragma line 977 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 977 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
, "\n"); } } while (0)
;
#pragma empty_line
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;
#pragma empty_line
bool a = (lsb_index >=2) ?
((tmp.V).range((lsb_index - 2), (0)) != 0) : 0;
#pragma empty_line
a |= (lsb_index >=0) ? (tmp.V).get_bit((lsb_index)) : 0;
#pragma empty_line
unsigned short m;
#pragma empty_line
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;
#pragma empty_line
if (_AP_ctype_op_get_bit(m, 10 + 1)) {
e += 1;
}
#pragma empty_line
m = _AP_ctype_op_set_bit(m, BITS - 1, s);
m = _AP_ctype_op_set_range(m, 10, 10 + 5 - 1, e);
#pragma empty_line
return rawBitsToHalf(m);
}
#pragma empty_line
#pragma empty_line
inline operator long double() const { return (long double)to_double(); }
#pragma empty_line
inline operator double() const { return to_double(); }
#pragma empty_line
inline operator float() const { return to_float(); }
#pragma empty_line
inline operator half() const { return to_half(); }
#pragma empty_line
inline operator bool() const { return (bool)Base::V != 0; }
#pragma empty_line
inline operator char() const { return (char)to_int(); }
#pragma empty_line
inline operator signed char() const { return (signed char)to_int(); }
#pragma empty_line
inline operator unsigned char() const { return (unsigned char)to_uint(); }
#pragma empty_line
inline operator short() const { return (short)to_int(); }
#pragma empty_line
inline operator unsigned short() const { return (unsigned short)to_uint(); }
#pragma empty_line
inline operator int() const { return to_int(); }
#pragma empty_line
inline operator unsigned int() const { return to_uint(); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline operator long() const { return (long)to_int64(); }
#pragma empty_line
inline operator unsigned long() const { return (unsigned long)to_uint64(); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline operator ap_ulong() const { return to_uint64(); }
#pragma empty_line
inline operator ap_slong() const { return to_int64(); }
#pragma empty_line
inline int length() const { return _AP_W; };
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline ap_ulong bits_to_uint64() const {
return (Base::V).to_uint64();
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline int countLeadingZeros() {
#pragma line 1103 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
return Base::V.countLeadingZeros();
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
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));
#pragma line 1176 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
return r;
}
#pragma line 1191 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma line 1209 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline ap_fixed_base& operator++() {
operator+=(ap_fixed_base<_AP_W - _AP_I + 1, 1, false>(1));
return *this;
}
#pragma empty_line
#pragma empty_line
inline ap_fixed_base& operator--() {
operator-=(ap_fixed_base<_AP_W - _AP_I + 1, 1, false>(1));
return *this;
}
#pragma empty_line
#pragma empty_line
inline const ap_fixed_base operator++(int) {
ap_fixed_base r(*this);
operator++();
return r;
}
#pragma empty_line
#pragma empty_line
inline const ap_fixed_base operator--(int) {
ap_fixed_base r(*this);
operator--();
return r;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline ap_fixed_base operator+() { return *this; }
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline bool operator!() const { return Base::V == 0; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline ap_fixed_base operator<<(unsigned int sh) const {
ap_fixed_base r;
r.V = Base::V << sh;
#pragma line 1327 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
return r;
}
#pragma empty_line
inline ap_fixed_base operator>>(unsigned int sh) const {
ap_fixed_base r;
r.V = Base::V >> sh;
#pragma line 1349 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
return r;
}
#pragma empty_line
#pragma empty_line
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);
}
}
#pragma empty_line
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);
}
}
#pragma empty_line
#pragma empty_line
template <int _AP_W2>
inline ap_fixed_base operator<<(const ap_int_base<_AP_W2, true>& op2) const {
#pragma empty_line
#pragma empty_line
int sh = op2.to_int();
return operator<<(sh);
}
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
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());
}
#pragma empty_line
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());
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline ap_fixed_base& operator<<=(const int sh) {
*this = operator<<(sh);
return *this;
}
#pragma empty_line
inline ap_fixed_base& operator<<=(const unsigned int sh) {
*this = operator<<(sh);
return *this;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
inline ap_fixed_base& operator>>=(const int sh) {
*this = operator>>(sh);
return *this;
}
#pragma empty_line
inline ap_fixed_base& operator>>=(const unsigned int sh) {
*this = operator>>(sh);
return *this;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma line 1493 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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; }
#pragma empty_line
#pragma empty_line
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(
#pragma line 1514 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 1514 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
, "WARNING: " "Attempting to read bit beyond MSB"); fprintf(
#pragma line 1514 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 1514 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
}
#pragma empty_line
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(
#pragma line 1521 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 1521 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
, "WARNING: " "Attempting to read bit with negative index"); fprintf(
#pragma line 1521 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 1521 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
, "\n"); } } while (0);
do { if ((index >= _AP_W)) { fprintf(
#pragma line 1522 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 1522 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
, "WARNING: " "Attempting to read bit beyond MSB"); fprintf(
#pragma line 1522 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 1522 "/home/justin/jhai/Xilinx/Vivado/2018.3/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());
}
#pragma empty_line
inline bool operator[](unsigned index) const {
do { if ((index >= _AP_W)) { fprintf(
#pragma line 1528 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 1528 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
, "WARNING: " "Attempting to read bit beyond MSB"); fprintf(
#pragma line 1528 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 1528 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
, "\n"); } } while (0);
return (const_cast<ap_fixed_base*>(this)->V).get_bit((index));
}
#pragma empty_line
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(
#pragma line 1534 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 1534 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
, "WARNING: " "Attempting to read bit beyond MSB"); fprintf(
#pragma line 1534 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 1534 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
}
#pragma empty_line
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(
#pragma line 1541 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 1541 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
, "WARNING: " "Attempting to read bit with negative index"); fprintf(
#pragma line 1541 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 1541 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
, "\n"); } } while (0);
do { if ((index >= _AP_W)) { fprintf(
#pragma line 1542 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 1542 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
, "WARNING: " "Attempting to read bit beyond MSB"); fprintf(
#pragma line 1542 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 1542 "/home/justin/jhai/Xilinx/Vivado/2018.3/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());
}
#pragma empty_line
inline bool bit(unsigned index) const {
do { if ((index >= _AP_W)) { fprintf(
#pragma line 1548 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 1548 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
, "WARNING: " "Attempting to read bit beyond MSB"); fprintf(
#pragma line 1548 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 1548 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
, "\n"); } } while (0);
return (const_cast<ap_fixed_base*>(this)->V).get_bit((index));
}
#pragma empty_line
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(
#pragma line 1555 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 1555 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
, "WARNING: " "Attempting to read bit with negative index"); fprintf(
#pragma line 1555 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 1555 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
, "\n"); } } while (0)
;
do { if ((index >= _AP_I)) { fprintf(
#pragma line 1557 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 1557 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
, "WARNING: " "Attempting to read bit beyond MSB"); fprintf(
#pragma line 1557 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 1557 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
}
#pragma empty_line
inline bool get_bit(int index) const {
do { if ((index >= _AP_I)) { fprintf(
#pragma line 1563 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 1563 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
, "WARNING: " "Attempting to read bit beyond MSB"); fprintf(
#pragma line 1563 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 1563 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
, "\n"); } } while (0);
do { if ((index < _AP_I - _AP_W)) { fprintf(
#pragma line 1564 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 1564 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
, "WARNING: " "Attempting to read bit beyond MSB"); fprintf(
#pragma line 1564 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 1564 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
, "\n"); } } while (0);
return (const_cast<ap_fixed_base*>(this)->V).get_bit((index + _AP_W - _AP_I))
;
}
#pragma line 1579 "/home/justin/jhai/Xilinx/Vivado/2018.3/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(
#pragma line 1581 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 1581 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
, "WARNING: " "Attempting to read bit beyond MSB"); fprintf(
#pragma line 1581 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 1581 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
, "\n"); } } while (0);
do { if ((index < _AP_I - _AP_W)) { fprintf(
#pragma line 1582 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 1582 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
, "WARNING: " "Attempting to read bit beyond MSB"); fprintf(
#pragma line 1582 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 1582 "/home/justin/jhai/Xilinx/Vivado/2018.3/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))
;
}
#pragma empty_line
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(
#pragma line 1589 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 1589 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
, "WARNING: " "Out of bounds in range()"); fprintf(
#pragma line 1589 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 1589 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
}
#pragma empty_line
#pragma empty_line
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(
#pragma line 1596 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 1596 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
, "WARNING: " "Out of bounds in range()"); fprintf(
#pragma line 1596 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h" 3 4
stderr
#pragma line 1596 "/home/justin/jhai/Xilinx/Vivado/2018.3/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);
}
#pragma empty_line
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);
}
#pragma empty_line
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);
}
#pragma empty_line
inline af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> range() {
return this->range(_AP_W - 1, 0);
}
#pragma empty_line
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);
}
#pragma empty_line
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);
}
#pragma empty_line
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);
}
#pragma empty_line
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);
}
#pragma empty_line
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);
}
#pragma empty_line
inline bool is_zero() const { return Base::V == 0; }
#pragma empty_line
inline bool is_neg() const {
if (_AP_S && (Base::V).get_bit((_AP_W - 1))) return true;
return false;
}
#pragma empty_line
inline int wl() const { return _AP_W; }
#pragma empty_line
inline int iwl() const { return _AP_I; }
#pragma empty_line
inline ap_q_mode q_mode() const { return _AP_Q; }
#pragma empty_line
inline ap_o_mode o_mode() const { return _AP_O; }
#pragma empty_line
inline int n_bits() const { return _AP_N; }
#pragma line 1679 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
std::string to_string(unsigned char radix = 2, bool sign = _AP_S) const {
#pragma empty_line
#pragma empty_line
if (radix == 2) sign = false;
#pragma empty_line
std::string str;
str.clear();
char step = 0;
bool isNeg = sign && (Base::V < 0);
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
if (_AP_I > 0) {
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
ap_int_base<((_AP_I + 1) > (1) ? (_AP_I + 1) : (1)), false> int_part;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
int_part.V = (tmp.V).range((_AP_W), (_AP_W - _AP_I))
;
str += int_part.to_string(radix, false);
} else {
str += prefix;
str += '0';
}
#pragma empty_line
ap_fixed_base<((_AP_W - _AP_I) > (1) ? (_AP_W - _AP_I) : (1)), 0, false> frac_part = tmp;
#pragma empty_line
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();
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
};
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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,
};
#pragma empty_line
ap_fixed_base<_AP_W3, _AP_I3, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> t;
t.V = op.V;
t.V <<= i;
#pragma empty_line
ret = t;
}
#pragma empty_line
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,
};
#pragma empty_line
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;
#pragma empty_line
ret = t;
}
#pragma line 1868 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_base.h"
inline std::string scientificFormat(std::string& input) {
if (input.length() == 0) return input;
#pragma empty_line
size_t decPosition = input.find('.');
if (decPosition == std::string::npos) decPosition = input.length();
#pragma empty_line
size_t firstNonZeroPos = 0;
for (; input[firstNonZeroPos] > '9' || input[firstNonZeroPos] < '1';
firstNonZeroPos++)
;
#pragma empty_line
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+";
#pragma empty_line
if (exp < 10 && exp > 0) {
expString += '0';
expString += (char)('0' + exp);
} else if (exp != 0) {
std::string tmp;
#pragma empty_line
std::ostringstream oss;
oss << exp;
#pragma empty_line
tmp = oss.str();
expString += tmp;
}
#pragma empty_line
int lastNonZeroPos = (int)(input.length() - 1);
for (; lastNonZeroPos >= 0; --lastNonZeroPos)
if (input[lastNonZeroPos] <= '9' && input[lastNonZeroPos] > '0') break;
#pragma empty_line
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];
}
#pragma empty_line
ans += expString;
return ans;
}
#pragma empty_line
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";
#pragma empty_line
#pragma empty_line
int FirstNonZeroPos = 0;
int LastNonZeroPos = (int)inputLen - 1;
int truncBitPosition = 0;
size_t decPosition = input.find('.');
for (; input[FirstNonZeroPos] < '1' || input[FirstNonZeroPos] > '9';
FirstNonZeroPos++)
;
#pragma empty_line
for (; input[LastNonZeroPos] < '1' || input[LastNonZeroPos] > '9';
LastNonZeroPos--)
;
#pragma empty_line
if (decPosition == std::string::npos) decPosition = inputLen;
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
std::string ans = "";
std::string dupInput = "0";
if (input[0] == '-') {
ans += '-';
dupInput += input.substr(1, inputLen - 1);
} else {
dupInput += input.substr(0, inputLen);
++truncBitPosition;
}
#pragma empty_line
#pragma empty_line
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;
}
}
#pragma empty_line
#pragma empty_line
if (dupInput[0] == '1')
FirstNonZeroPos = 0;
else {
FirstNonZeroPos = 0;
while (dupInput[FirstNonZeroPos] < '1' || dupInput[FirstNonZeroPos] > '9')
++FirstNonZeroPos;
}
#pragma empty_line
unsigned it = FirstNonZeroPos;
int NValidNumber = 0;
while (it < dupInput.length()) {
if (dupInput[it] == '.') {
++it;
continue;
}
++NValidNumber;
if (NValidNumber > precision) dupInput[it] = '0';
++it;
}
#pragma empty_line
#pragma empty_line
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;
}
}
#pragma empty_line
if (dupInput[0] == '1')
dupInput = dupInput.substr(0, truncBitPosition);
else
dupInput = dupInput.substr(1, truncBitPosition - 1);
#pragma empty_line
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;
}
#pragma empty_line
ans += scientificFormat(dupInput);
return ans;
}
#pragma empty_line
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);
}
}
#pragma line 2079 "/home/justin/jhai/Xilinx/Vivado/2018.3/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) {
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma line 2212 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 2300 "/home/justin/jhai/Xilinx/Vivado/2018.3/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)); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
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()); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
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); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template <int _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);
}
#pragma empty_line
template <int _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);
}
#pragma empty_line
template <int _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);
}
#pragma empty_line
template <int _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);
}
#pragma empty_line
template <int _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);
}
#pragma empty_line
template <int _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);
}
#pragma line 56 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed.h" 2
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_ref.h" 1
#pragma line 69 "/home/justin/jhai/Xilinx/Vivado/2018.3/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 {
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
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) {
#pragma empty_line
do { if ((d_index < 0)) { fprintf(
#pragma line 84 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_ref.h" 3 4
stderr
#pragma line 84 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_ref.h"
, "WARNING: " "Index of bit vector (%d) cannot be negative.", d_index); fprintf(
#pragma line 84 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_ref.h" 3 4
stderr
#pragma line 84 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_ref.h"
, "\n"); } } while (0)
;
do { if ((d_index >= _AP_W)) { fprintf(
#pragma line 86 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_ref.h" 3 4
stderr
#pragma line 86 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_ref.h"
, "WARNING: " "Index of bit vector (%d) out of range (%d).", d_index, _AP_W); fprintf(
#pragma line 86 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_ref.h" 3 4
stderr
#pragma line 86 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_ref.h"
, "\n"); } } while (0)
;
#pragma empty_line
}
#pragma empty_line
inline af_bit_ref(ref_type* bv, int index = 0) : d_bv(*bv), d_index(index) {}
#pragma empty_line
inline af_bit_ref(const ref_type* bv, int index = 0)
: d_bv(*const_cast<ref_type*>(bv)), d_index(index) {}
#pragma empty_line
#pragma empty_line
inline operator bool() const { return (d_bv.V).get_bit((d_index)); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline af_bit_ref& operator=(bool val) {
d_bv.V = _AP_ROOT_op_set_bit(d_bv.V, d_index, val);
return *this;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline af_bit_ref& operator=(const af_bit_ref& val) {
return operator=(bool(val));
}
#pragma empty_line
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));
}
#pragma empty_line
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));
}
#pragma empty_line
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);
}
#pragma empty_line
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));
}
#pragma empty_line
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));
}
#pragma empty_line
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));
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
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);
}
#pragma empty_line
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);
}
#pragma empty_line
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);
}
#pragma empty_line
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);
}
#pragma empty_line
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));
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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();
}
#pragma empty_line
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();
}
#pragma empty_line
#pragma empty_line
inline bool operator~() const {
bool bit = (d_bv.V).get_bit((d_index));
return bit ? false : true;
}
#pragma empty_line
inline bool get() const { return (d_bv.V).get_bit((d_index)); }
#pragma empty_line
inline int length() const { return 1; }
#pragma empty_line
#pragma empty_line
std::string to_string() const { return get() ? "1" : "0"; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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 {
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
public:
#pragma empty_line
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) {}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline af_range_ref(ref_type* bv, int h, int l)
: d_bv(*bv), l_index(l), h_index(h) {
#pragma empty_line
do { if ((h < 0 || l < 0)) { fprintf(
#pragma line 279 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_ref.h" 3 4
stderr
#pragma line 279 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_ref.h"
, "WARNING: " "Higher bound(%d) and lower(%d) bound cannot be negative.", h, l); fprintf(
#pragma line 279 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_ref.h" 3 4
stderr
#pragma line 279 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_ref.h"
, "\n"); } } while (0)
#pragma empty_line
;
do { if ((h >= _AP_W || l >= _AP_W)) { fprintf(
#pragma line 282 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_ref.h" 3 4
stderr
#pragma line 282 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_ref.h"
, "WARNING: " "Higher bound(%d) or lower(%d) bound out of range.", h, l); fprintf(
#pragma line 282 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_ref.h" 3 4
stderr
#pragma line 282 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_ref.h"
, "\n"); } } while (0)
;
do { if ((h < l)) { fprintf(
#pragma line 284 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_ref.h" 3 4
stderr
#pragma line 284 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_ref.h"
, "WARNING: " "The bits selected will be returned in reverse order."); fprintf(
#pragma line 284 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_ref.h" 3 4
stderr
#pragma line 284 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_ref.h"
, "\n"); } } while (0);
#pragma empty_line
}
#pragma empty_line
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) {
#pragma empty_line
do { if ((h < 0 || l < 0)) { fprintf(
#pragma line 291 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_ref.h" 3 4
stderr
#pragma line 291 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_ref.h"
, "WARNING: " "Higher bound(%d) and lower(%d) bound cannot be negative.", h, l); fprintf(
#pragma line 291 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_ref.h" 3 4
stderr
#pragma line 291 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_ref.h"
, "\n"); } } while (0)
#pragma empty_line
;
do { if ((h >= _AP_W || l >= _AP_W)) { fprintf(
#pragma line 294 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_ref.h" 3 4
stderr
#pragma line 294 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_ref.h"
, "WARNING: " "Higher bound(%d) or lower(%d) bound out of range.", h, l); fprintf(
#pragma line 294 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_ref.h" 3 4
stderr
#pragma line 294 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_ref.h"
, "\n"); } } while (0)
;
do { if ((h < l)) { fprintf(
#pragma line 296 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_ref.h" 3 4
stderr
#pragma line 296 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_ref.h"
, "WARNING: " "The bits selected will be returned in reverse order."); fprintf(
#pragma line 296 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_ref.h" 3 4
stderr
#pragma line 296 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_ref.h"
, "\n"); } } while (0);
#pragma empty_line
}
#pragma line 310 "/home/justin/jhai/Xilinx/Vivado/2018.3/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; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline af_range_ref& operator=(const af_range_ref& val) {
ap_int_base<_AP_W, false> tmp(val);
return operator=(tmp);
}
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline bool operator!=(const ap_range_ref<_AP_W2, _AP_S2>& op2) {
return !(operator==(op2));
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline bool operator<=(const ap_range_ref<_AP_W2, _AP_S2>& op2) {
return !(operator>(op2));
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline bool operator>=(const ap_range_ref<_AP_W2, _AP_S2>& op2) {
return !(operator<(op2));
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
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));
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
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));
}
#pragma empty_line
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));
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
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));
}
#pragma empty_line
#pragma empty_line
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));
}
#pragma empty_line
#pragma empty_line
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));
}
#pragma empty_line
#pragma empty_line
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));
}
#pragma empty_line
#pragma empty_line
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));
}
#pragma empty_line
#pragma empty_line
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();
}
#pragma empty_line
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;
}
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
inline char to_char() const {
return (char)((d_bv.V).range((h_index), (l_index)));
}
#pragma empty_line
inline int to_int() const {
return (int)((d_bv.V).range((h_index), (l_index)));
}
#pragma empty_line
inline unsigned to_uint() const {
return (unsigned)((d_bv.V).range((h_index), (l_index)));
}
#pragma empty_line
inline long to_long() const {
return (long)((d_bv.V).range((h_index), (l_index)));
}
#pragma empty_line
inline unsigned long to_ulong() const {
return (unsigned long)((d_bv.V).range((h_index), (l_index)));
}
#pragma empty_line
inline ap_slong to_int64() const {
return (ap_slong)((d_bv.V).range((h_index), (l_index)));
}
#pragma empty_line
inline ap_ulong to_uint64() const {
return (ap_ulong)((d_bv.V).range((h_index), (l_index)));
}
#pragma empty_line
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;
}
#pragma empty_line
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);
}
#pragma empty_line
inline int length() const {
return h_index >= l_index ? h_index - l_index + 1 : l_index - h_index + 1;
}
#pragma empty_line
#pragma empty_line
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);
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma line 695 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 741 "/home/justin/jhai/Xilinx/Vivado/2018.3/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); }
#pragma line 57 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed.h" 2
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
inline ap_fixed() : Base() {}
#pragma empty_line
#pragma empty_line
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) {}
#pragma empty_line
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) {}
#pragma line 111 "/home/justin/jhai/Xilinx/Vivado/2018.3/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) {}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline ap_fixed(const volatile ap_int_base<_AP_W2, _AP_S2>& op) : Base(op) {}
#pragma line 136 "/home/justin/jhai/Xilinx/Vivado/2018.3/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) {}
#pragma empty_line
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline ap_fixed(const ap_range_ref<_AP_W2, _AP_S2>& op) : Base(op) {}
#pragma empty_line
#pragma empty_line
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) {}
#pragma empty_line
#pragma empty_line
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) {}
#pragma empty_line
#pragma empty_line
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) {}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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) {}
#pragma empty_line
#pragma empty_line
inline ap_fixed(const char* s) : Base(s) {}
#pragma empty_line
inline ap_fixed(const char* s, signed char rd) : Base(s, rd) {}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline ap_fixed& operator=(
const ap_fixed<_AP_W, _AP_I, _AP_Q, _AP_O, _AP_N>& op) {
Base::V = op.V;
return *this;
}
#pragma empty_line
inline void operator=(
const ap_fixed<_AP_W, _AP_I, _AP_Q, _AP_O, _AP_N>& op) volatile {
Base::V = op.V;
}
#pragma empty_line
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;
}
#pragma empty_line
inline void operator=(
const volatile ap_fixed<_AP_W, _AP_I, _AP_Q, _AP_O, _AP_N>& op) volatile {
Base::V = op.V;
}
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
#pragma empty_line
#pragma empty_line
inline ap_ufixed() : Base() {}
#pragma empty_line
#pragma empty_line
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) {}
#pragma empty_line
#pragma empty_line
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) {}
#pragma line 267 "/home/justin/jhai/Xilinx/Vivado/2018.3/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) {}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline ap_ufixed(const volatile ap_int_base<_AP_W2, _AP_S2>& op) : Base(op) {}
#pragma line 289 "/home/justin/jhai/Xilinx/Vivado/2018.3/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) {}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline ap_ufixed(const ap_range_ref<_AP_W2, _AP_S2>& op) : Base(op) {}
#pragma empty_line
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) {}
#pragma empty_line
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) {}
#pragma empty_line
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) {}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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) {}
#pragma empty_line
#pragma empty_line
inline ap_ufixed(const char* s) : Base(s) {}
#pragma empty_line
inline ap_ufixed(const char* s, signed char rd) : Base(s, rd) {}
#pragma empty_line
#pragma empty_line
inline ap_ufixed& operator=(
const ap_ufixed<_AP_W, _AP_I, _AP_Q, _AP_O, _AP_N>& op) {
Base::V = op.V;
return *this;
}
#pragma empty_line
inline void operator=(
const ap_ufixed<_AP_W, _AP_I, _AP_Q, _AP_O, _AP_N>& op) volatile {
Base::V = op.V;
}
#pragma empty_line
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;
}
#pragma empty_line
inline void operator=(const volatile ap_ufixed<_AP_W, _AP_I, _AP_Q, _AP_O,
_AP_N>& op) volatile {
Base::V = op.V;
}
};
#pragma line 380 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed.h"
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_special.h" 1
#pragma line 54 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_special.h"
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdio" 1 3
#pragma line 39 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdio" 3
#pragma empty_line
#pragma line 40 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdio" 3
#pragma line 55 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_special.h" 2
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 1 3
#pragma line 39 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 3
#pragma empty_line
#pragma line 40 "/home/justin/jhai/Xilinx/Vivado/2018.3/tps/lnx64/gcc-6.2.0/include/c++/6.2.0/cstdlib" 3
#pragma line 56 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed_special.h" 2
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std {
template<typename _Tp> class complex;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std {
#pragma line 88 "/home/justin/jhai/Xilinx/Vivado/2018.3/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>
struct complex<ap_fixed<_AP_W, _AP_I, _AP_Q, _AP_O, _AP_N> > {
typedef ap_fixed<_AP_W, _AP_I, _AP_Q, _AP_O, _AP_N> _Tp;
typedef _Tp value_type;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
complex() : _M_real(_Tp()), _M_imag(_Tp()) {}
#pragma empty_line
#pragma empty_line
complex(const _Tp &__r, const _Tp &__i = _Tp(0))
: _M_real(__r), _M_imag(__i) {}
#pragma empty_line
#pragma empty_line
template <typename _Up>
complex(const complex<_Up> &__z) : _M_real(__z.real()), _M_imag(__z.imag()) {}
#pragma empty_line
#pragma empty_line
const _Tp& real() const { return _M_real; }
const _Tp& imag() const { return _M_imag; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
void real(_Tp __val) { _M_real = __val; }
#pragma empty_line
void imag(_Tp __val) { _M_imag = __val; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
complex<_Tp> &operator=(const _Tp __t) {
_M_real = __t;
_M_imag = _Tp(0);
return *this;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
complex<_Tp> &operator+=(const _Tp &__t) {
_M_real += __t;
return *this;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
complex<_Tp> &operator-=(const _Tp &__t) {
_M_real -= __t;
return *this;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
complex<_Tp> &operator*=(const _Tp &__t) {
_M_real *= __t;
_M_imag *= __t;
return *this;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
complex<_Tp> &operator/=(const _Tp &__t) {
_M_real /= __t;
_M_imag /= __t;
return *this;
}
#pragma empty_line
#pragma empty_line
template <typename _Up>
complex<_Tp> &operator=(const complex<_Up> &__z) {
_M_real = __z.real();
_M_imag = __z.imag();
return *this;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
template <typename _Up>
complex<_Tp> &operator+=(const complex<_Up> &__z) {
_M_real += __z.real();
_M_imag += __z.imag();
return *this;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
template <typename _Up>
complex<_Tp> &operator-=(const complex<_Up> &__z) {
_M_real -= __z.real();
_M_imag -= __z.imag();
return *this;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
private:
_Tp _M_real;
_Tp _M_imag;
#pragma empty_line
};
#pragma line 219 "/home/justin/jhai/Xilinx/Vivado/2018.3/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;
}
#pragma empty_line
#pragma empty_line
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();
}
#pragma empty_line
#pragma empty_line
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;
}
#pragma empty_line
#pragma empty_line
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();
}
#pragma empty_line
}
#pragma line 381 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_fixed.h" 2
#pragma line 350 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_int.h" 2
#pragma line 5 "/home/justin/jhai/paulchowresearch2020/xvc/test_hls_server/test_hls_server.h" 2
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_utils.h" 1
#pragma line 75 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_utils.h"
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/autopilot_enum.h" 1
#pragma line 58 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/autopilot_enum.h"
enum SsdmDataTypes {
_ssdm_sc_int = 0,
_ssdm_c_int = _ssdm_sc_int,
_ssdm_sc_uint = 1,
_ssdm_c_uint = _ssdm_sc_uint,
_ssdm_sc_bigint = 2,
_ssdm_sc_biguint = 3,
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
enum SsdmPortTypes {
_ssdm_sc_in = 0,
_ssdm_sc_out = 1,
_ssdm_sc_inout = 2,
_ssdm_sc_in_clk,
#pragma empty_line
_ssdm_fifo_in,
_ssdm_sc_fifo_in = _ssdm_fifo_in,
_ssdm_tlm_fifo_in = _ssdm_fifo_in,
_ssdm_fifo_out,
_ssdm_sc_fifo_out = _ssdm_fifo_out,
_ssdm_tlm_fifo_out = _ssdm_fifo_out,
_ssdm_fifo_inout,
_ssdm_sc_fifo_inout = _ssdm_fifo_inout,
_ssdm_tlm_fifo_inout = _ssdm_fifo_inout,
_ssdm_sc_bus,
_ssdm_hls_bus_port = _ssdm_sc_bus,
_ssdm_AXI4M_bus_port = _ssdm_sc_bus,
_ssdm_port_end,
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
enum SsdmProcessTypes {
_ssdm_method = 0,
_ssdm_sc_method = _ssdm_method,
_ssdm_thread = 1,
_ssdm_sc_thread = _ssdm_thread,
_ssdm_cthread = 2,
_ssdm_sc_cthread = _ssdm_cthread,
_ssdm_process_end,
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
enum SsdmSensitiveTypes {
_ssdm_sensitive = 0,
_ssdm_sensitive_pos,
_ssdm_sensitive_neg,
_ssdm_sensitive_reset0,
_ssdm_sensitive_reset1,
_ssdm_sensitive_end,
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
enum SsdmChannelTypes {
_ssdm_sc_sig,
_ssdm_fifo,
_ssdm_sc_fifo = _ssdm_fifo,
_ssdm_mem_fifo,
_ssdm_sc_mem_fifo = _ssdm_mem_fifo,
};
#pragma empty_line
#pragma empty_line
enum SsdmRegionTypes {
_ssdm_region_reset,
_ssdm_region_protocol,
_ssdm_region_pipeline,
_ssdm_region_parallel,
};
#pragma line 76 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_utils.h" 2
#pragma line 1 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/autopilot_ssdm_op.h" 1
#pragma line 157 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/etc/autopilot_ssdm_op.h"
extern "C" {
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
void _ssdm_op_IfRead(...) __attribute__ ((nothrow)) __attribute__((overloadable));
void _ssdm_op_IfWrite(...) __attribute__ ((nothrow)) __attribute__((overloadable));
unsigned int __attribute__ ((bitwidth(1))) _ssdm_op_IfNbRead(...) __attribute__ ((nothrow)) __attribute__((overloadable));
unsigned int __attribute__ ((bitwidth(1))) _ssdm_op_IfNbWrite(...) __attribute__ ((nothrow)) __attribute__((overloadable));
unsigned int __attribute__ ((bitwidth(1))) _ssdm_op_IfCanRead(...) __attribute__ ((nothrow)) __attribute__((overloadable));
unsigned int __attribute__ ((bitwidth(1))) _ssdm_op_IfCanWrite(...) __attribute__ ((nothrow)) __attribute__((overloadable));
#pragma empty_line
#pragma empty_line
void _ssdm_StreamRead(...) __attribute__ ((nothrow)) __attribute__((overloadable));
void _ssdm_StreamWrite(...) __attribute__ ((nothrow)) __attribute__((overloadable));
unsigned int __attribute__ ((bitwidth(1))) _ssdm_StreamNbRead(...) __attribute__ ((nothrow)) __attribute__((overloadable));
unsigned int __attribute__ ((bitwidth(1))) _ssdm_StreamNbWrite(...) __attribute__ ((nothrow)) __attribute__((overloadable));
unsigned int __attribute__ ((bitwidth(1))) _ssdm_StreamCanRead(...) __attribute__ ((nothrow)) __attribute__((overloadable));
unsigned int __attribute__ ((bitwidth(1))) _ssdm_StreamCanWrite(...) __attribute__ ((nothrow)) __attribute__((overloadable));
unsigned _ssdm_StreamSize(...) __attribute__ ((nothrow)) __attribute__((overloadable));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
void _ssdm_op_MemShiftRead(...) __attribute__ ((nothrow)) __attribute__((overloadable));
#pragma empty_line
void _ssdm_op_Wait(...) __attribute__ ((nothrow)) __attribute__((overloadable));
void _ssdm_op_Poll(...) __attribute__ ((nothrow)) __attribute__((overloadable));
#pragma empty_line
void _ssdm_op_Return(...) __attribute__ ((nothrow)) __attribute__((overloadable));
#pragma empty_line
#pragma empty_line
void _ssdm_op_SpecSynModule(...) __attribute__ ((nothrow)) __attribute__((overloadable));
void _ssdm_op_SpecTopModule(...) __attribute__ ((nothrow)) __attribute__((overloadable));
void _ssdm_op_SpecProcessDecl(...) __attribute__ ((nothrow)) __attribute__((overloadable));
void _ssdm_op_SpecProcessDef(...) __attribute__ ((nothrow)) __attribute__((overloadable));
void _ssdm_op_SpecPort(...) __attribute__ ((nothrow)) __attribute__((overloadable));
void _ssdm_op_SpecConnection(...) __attribute__ ((nothrow)) __attribute__((overloadable));
void _ssdm_op_SpecChannel(...) __attribute__ ((nothrow)) __attribute__((overloadable));
void _ssdm_op_SpecSensitive(...) __attribute__ ((nothrow)) __attribute__((overloadable));
void _ssdm_op_SpecModuleInst(...) __attribute__ ((nothrow)) __attribute__((overloadable));
void _ssdm_op_SpecPortMap(...) __attribute__ ((nothrow)) __attribute__((overloadable));
#pragma empty_line
void _ssdm_op_SpecReset(...) __attribute__ ((nothrow)) __attribute__((overloadable));
#pragma empty_line
void _ssdm_op_SpecPlatform(...) __attribute__ ((nothrow)) __attribute__((overloadable));
void _ssdm_op_SpecClockDomain(...) __attribute__ ((nothrow)) __attribute__((overloadable));
void _ssdm_op_SpecPowerDomain(...) __attribute__ ((nothrow)) __attribute__((overloadable));
#pragma empty_line
int _ssdm_op_SpecRegionBegin(...) __attribute__ ((nothrow)) __attribute__((overloadable));
int _ssdm_op_SpecRegionEnd(...) __attribute__ ((nothrow)) __attribute__((overloadable));
#pragma empty_line
void _ssdm_op_SpecLoopName(...) __attribute__ ((nothrow)) __attribute__((overloadable));
#pragma empty_line
void _ssdm_op_SpecLoopTripCount(...) __attribute__ ((nothrow)) __attribute__((overloadable));
#pragma empty_line
int _ssdm_op_SpecStateBegin(...) __attribute__ ((nothrow)) __attribute__((overloadable));
int _ssdm_op_SpecStateEnd(...) __attribute__ ((nothrow)) __attribute__((overloadable));
#pragma empty_line
void _ssdm_op_SpecInterface(...) __attribute__ ((nothrow)) __attribute__((overloadable));
#pragma empty_line
void _ssdm_op_SpecPipeline(...) __attribute__ ((nothrow)) __attribute__((overloadable));
void _ssdm_op_SpecDataflowPipeline(...) __attribute__ ((nothrow)) __attribute__((overloadable));
#pragma empty_line
#pragma empty_line
void _ssdm_op_SpecLatency(...) __attribute__ ((nothrow)) __attribute__((overloadable));
void _ssdm_op_SpecParallel(...) __attribute__ ((nothrow)) __attribute__((overloadable));
void _ssdm_op_SpecProtocol(...) __attribute__ ((nothrow)) __attribute__((overloadable));
void _ssdm_op_SpecOccurrence(...) __attribute__ ((nothrow)) __attribute__((overloadable));
#pragma empty_line
void _ssdm_op_SpecResource(...) __attribute__ ((nothrow)) __attribute__((overloadable));
void _ssdm_op_SpecResourceLimit(...) __attribute__ ((nothrow)) __attribute__((overloadable));
void _ssdm_op_SpecCHCore(...) __attribute__ ((nothrow)) __attribute__((overloadable));
void _ssdm_op_SpecFUCore(...) __attribute__ ((nothrow)) __attribute__((overloadable));
void _ssdm_op_SpecIFCore(...) __attribute__ ((nothrow)) __attribute__((overloadable));
void _ssdm_op_SpecIPCore(...) __attribute__ ((nothrow)) __attribute__((overloadable));
void _ssdm_op_SpecKeepValue(...) __attribute__ ((nothrow)) __attribute__((overloadable));
void _ssdm_op_SpecMemCore(...) __attribute__ ((nothrow)) __attribute__((overloadable));
#pragma empty_line
void _ssdm_op_SpecExt(...) __attribute__ ((nothrow)) __attribute__((overloadable));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
void _ssdm_SpecArrayDimSize(...) __attribute__ ((nothrow)) __attribute__((overloadable));
#pragma empty_line
void _ssdm_RegionBegin(...) __attribute__ ((nothrow)) __attribute__((overloadable));
void _ssdm_RegionEnd(...) __attribute__ ((nothrow)) __attribute__((overloadable));
#pragma empty_line
void _ssdm_Unroll(...) __attribute__ ((nothrow)) __attribute__((overloadable));
void _ssdm_UnrollRegion(...) __attribute__ ((nothrow)) __attribute__((overloadable));
#pragma empty_line
void _ssdm_InlineAll(...) __attribute__ ((nothrow)) __attribute__((overloadable));
void _ssdm_InlineLoop(...) __attribute__ ((nothrow)) __attribute__((overloadable));
void _ssdm_Inline(...) __attribute__ ((nothrow)) __attribute__((overloadable));
void _ssdm_InlineSelf(...) __attribute__ ((nothrow)) __attribute__((overloadable));
void _ssdm_InlineRegion(...) __attribute__ ((nothrow)) __attribute__((overloadable));
#pragma empty_line
void _ssdm_SpecArrayMap(...) __attribute__ ((nothrow)) __attribute__((overloadable));
void _ssdm_SpecArrayPartition(...) __attribute__ ((nothrow)) __attribute__((overloadable));
void _ssdm_SpecArrayReshape(...) __attribute__ ((nothrow)) __attribute__((overloadable));
#pragma empty_line
void _ssdm_SpecStream(...) __attribute__ ((nothrow)) __attribute__((overloadable));
#pragma empty_line
void _ssdm_SpecExpr(...) __attribute__ ((nothrow)) __attribute__((overloadable));
void _ssdm_SpecExprBalance(...) __attribute__ ((nothrow)) __attribute__((overloadable));
#pragma empty_line
void _ssdm_SpecDependence(...) __attribute__ ((nothrow)) __attribute__((overloadable));
#pragma empty_line
void _ssdm_SpecLoopMerge(...) __attribute__ ((nothrow)) __attribute__((overloadable));
void _ssdm_SpecLoopFlatten(...) __attribute__ ((nothrow)) __attribute__((overloadable));
void _ssdm_SpecLoopRewind(...) __attribute__ ((nothrow)) __attribute__((overloadable));
#pragma empty_line
void _ssdm_SpecFuncInstantiation(...) __attribute__ ((nothrow)) __attribute__((overloadable));
void _ssdm_SpecFuncBuffer(...) __attribute__ ((nothrow)) __attribute__((overloadable));
void _ssdm_SpecFuncExtract(...) __attribute__ ((nothrow)) __attribute__((overloadable));
void _ssdm_SpecConstant(...) __attribute__ ((nothrow)) __attribute__((overloadable));
#pragma empty_line
void _ssdm_DataPack(...) __attribute__ ((nothrow)) __attribute__((overloadable));
void _ssdm_SpecDataPack(...) __attribute__ ((nothrow)) __attribute__((overloadable));
#pragma empty_line
void _ssdm_op_SpecBitsMap(...) __attribute__ ((nothrow)) __attribute__((overloadable));
void _ssdm_op_SpecLicense(...) __attribute__ ((nothrow)) __attribute__((overloadable));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 77 "/home/justin/jhai/Xilinx/Vivado/2018.3/include/ap_utils.h" 2
#pragma line 6 "/home/justin/jhai/paulchowresearch2020/xvc/test_hls_server/test_hls_server.h" 2
#pragma empty_line
#pragma empty_line
#pragma empty_line
struct axistream
{
ap_uint <512> tdata;
ap_uint <512/8> tkeep;
ap_uint <1> tlast;
};
#pragma empty_line
void test_hls_server
(
hls::stream<axistream> &input,
hls::stream<axistream> &output
);
#pragma line 2 "/home/justin/jhai/paulchowresearch2020/xvc/test_hls_server/test_hls_server.cpp" 2
#pragma empty_line
void test_hls_server
(
hls::stream<axistream> &input,
hls::stream<axistream> &output
)
{
#pragma HLS DATAFLOW
#pragma HLS INTERFACE ap_ctrl_none port=return
#pragma HLS resource core=AXI4Stream variable=input
#pragma HLS DATA_PACK variable=input
#pragma HLS resource core=AXI4Stream variable=output
#pragma HLS DATA_PACK variable=output
#pragma empty_line
axistream temp_data_in;
axistream temp_data_out;
if (!input.empty() && !output.full())
{
temp_data_in = input.read();
temp_data_out.tdata = 2 * temp_data_in.tdata;
temp_data_out.tkeep = (temp_data_in.tkeep << 1) + 1;
temp_data_out.tlast = temp_data_in.tlast;
output.write(temp_data_out);
}
#pragma empty_line
}
| [
"justinkinhanghai@gmail.com"
] | justinkinhanghai@gmail.com |
99bb58c15439f43598d6f785626860c6737025ba | 708b8b9f4b6435adf8a12d6048223d6ecd2ffb9c | /assignment 3/Multi_Command.h | 9116b7d7af7ed7613c2eca9460f203a6a69e219c | [] | no_license | baderhosny/CSC363_Calculator | a00ebbb319daa3e8b059c69069279a99a7a87ce1 | 8426a94fc193101bed66fddd9a599d2a379f3e44 | refs/heads/main | 2023-04-26T06:30:49.680976 | 2021-05-21T20:50:14 | 2021-05-21T20:50:14 | 369,648,803 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 315 | h | #ifndef _MULTI_COMMAND_H_
#define _MULTI_COMMAND_H_
#include "Binary_Op_Command.h"
class Multi_Command : public Binary_Op_Command
{
public:
Multi_Command(void);
~Multi_Command();
int evaluate(int n1, int n2);
int importance(void);
};
#endif | [
"noreply@github.com"
] | noreply@github.com |
8674c7b3d5fd4469abe69d5d638d5d4b68507b5a | cf8ddfc720bf6451c4ef4fa01684327431db1919 | /SDK/ARKSurvivalEvolved_PrimalItem_WeaponProd_parameters.hpp | 5395a4ae16e5a391e90bd6fb6ca56f474b215303 | [
"MIT"
] | permissive | git-Charlie/ARK-SDK | 75337684b11e7b9f668da1f15e8054052a3b600f | c38ca9925309516b2093ad8c3a70ed9489e1d573 | refs/heads/master | 2023-06-20T06:30:33.550123 | 2021-07-11T13:41:45 | 2021-07-11T13:41:45 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 728 | hpp | #pragma once
// ARKSurvivalEvolved (329.9) SDK
#ifdef _MSC_VER
#pragma pack(push, 0x8)
#endif
#include "ARKSurvivalEvolved_PrimalItem_WeaponProd_classes.hpp"
namespace sdk
{
//---------------------------------------------------------------------------
//Parameters
//---------------------------------------------------------------------------
// Function PrimalItem_WeaponProd.PrimalItem_WeaponProd_C.ExecuteUbergraph_PrimalItem_WeaponProd
struct UPrimalItem_WeaponProd_C_ExecuteUbergraph_PrimalItem_WeaponProd_Params
{
int EntryPoint; // (Parm, ZeroConstructor, IsPlainOldData)
};
}
#ifdef _MSC_VER
#pragma pack(pop)
#endif
| [
"sergey.2bite@gmail.com"
] | sergey.2bite@gmail.com |
364f768ee9f108fd244a7beeb39c6222904badd4 | b4347cebc83e360b2bb35ea79701f82565f7cbf7 | /hal/cpp/include/metavision/hal/utils/detail/demangle.h | 1f9fe563902f3506b34db9eb01de5a03c9c20852 | [] | no_license | sssphil/openeb | 5f3903eb6997c344764d3df63fff8b876177d357 | e77750b77cc9dc3dcef26518f2bdedafad0d6a5b | refs/heads/main | 2023-08-20T14:16:44.245289 | 2021-10-14T08:00:31 | 2021-10-14T08:20:57 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,478 | h | /**********************************************************************************************************************
* Copyright (c) Prophesee S.A. *
* *
* 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 METAVISION_HAL_DETAIL_DEMANGLE_H
#define METAVISION_HAL_DETAIL_DEMANGLE_H
#include <string>
namespace Metavision {
namespace detail {
std::string demangle(const char *name);
} // namespace detail
} // namespace Metavision
#endif // METAVISION_HAL_DETAIL_DEMANGLE_H
| [
"nmartin@prophesee.ai"
] | nmartin@prophesee.ai |
e0f026da5a5db5ed50369d4088c3c8bae9e2ce4c | 286ed096189502f61e2e9cf36f4db31e793e7b47 | /constexpr_json/include/constexpr_json/impl/document_access.h | f14d41c45081dec657f10537cf5e355ec1c8ddbb | [
"JSON",
"MIT"
] | permissive | suluke/monobo | 03b35cce7cd3b165ab3439da7b5153c466dbaa6d | 2f330f4307b2320ae416dafc5bde0397be9595aa | refs/heads/master | 2022-01-01T20:12:50.648393 | 2021-12-27T15:31:33 | 2021-12-27T15:31:33 | 195,854,647 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,134 | h | #ifndef CONSTEXPR_JSON_DOCUMENT_ACCESS_H
#define CONSTEXPR_JSON_DOCUMENT_ACCESS_H
#include "constexpr_json/impl/document_entities.h"
#include <map>
#include <vector>
namespace cjson {
namespace impl {
template <typename DocumentTy> struct EntityRefImpl;
template <typename DocumentTy> struct ArrayIteratorImpl {
constexpr ArrayIteratorImpl() noexcept = default;
constexpr ArrayIteratorImpl(const DocumentTy &theDoc,
const Entity *thePosition) noexcept
: itsDoc{&theDoc}, itsPosition{thePosition} {}
constexpr EntityRefImpl<DocumentTy> operator*() const;
constexpr ArrayIteratorImpl &operator++() {
++itsPosition;
return *this;
}
constexpr bool operator==(const ArrayIteratorImpl &theOther) const noexcept {
return itsDoc == theOther.itsDoc && itsPosition == theOther.itsPosition;
}
constexpr bool operator!=(const ArrayIteratorImpl &theOther) const noexcept {
return !(*this == theOther);
}
private:
const DocumentTy *itsDoc = {};
const Entity *itsPosition = nullptr;
};
template <typename DocumentTy> struct ArrayRefImpl {
using iterator = ArrayIteratorImpl<DocumentTy>;
constexpr ArrayRefImpl(const DocumentTy &theDoc, const Entity &theEntity)
: itsDoc{&theDoc}, itsBegin{itsDoc->array_begin(theEntity.itsPayload)},
itsNumElements{itsDoc->array_size(theEntity.itsPayload)} {}
constexpr iterator begin() const { return {*itsDoc, itsBegin}; }
constexpr iterator end() const { return {*itsDoc, itsBegin + size()}; }
constexpr EntityRefImpl<DocumentTy> operator[](size_t theIdx) const;
template <typename OtherRefTy>
constexpr bool operator==(const OtherRefTy &theOther) const noexcept {
if (size() != theOther.size())
return false;
auto aOtherIter = theOther.begin();
for (const EntityRefImpl aEntry : *this) {
if (!(aEntry == *aOtherIter))
return false;
++aOtherIter;
}
return true;
}
constexpr size_t size() const { return itsNumElements; }
constexpr bool empty() const { return !size(); }
private:
const DocumentTy *itsDoc;
const Entity *itsBegin;
size_t itsNumElements;
};
template <typename DocumentTy> struct ObjectIteratorImpl {
constexpr ObjectIteratorImpl() noexcept = default;
constexpr ObjectIteratorImpl(const DocumentTy &theDoc,
const intptr_t &theObjectIdx,
const size_t thePosition) noexcept
: itsDoc{&theDoc}, itsObjectIdx{theObjectIdx}, itsPosition{thePosition} {}
using EntityRef = EntityRefImpl<DocumentTy>;
using value_type = std::pair<std::string_view, EntityRef>;
constexpr value_type operator*() const;
constexpr ObjectIteratorImpl &operator++() {
++itsPosition;
return *this;
}
constexpr bool operator==(const ObjectIteratorImpl &theOther) const noexcept {
return itsDoc == theOther.itsDoc && itsObjectIdx == theOther.itsObjectIdx &&
itsPosition == theOther.itsPosition;
}
constexpr bool operator!=(const ObjectIteratorImpl &theOther) const noexcept {
return !(*this == theOther);
}
private:
const DocumentTy *itsDoc = {};
intptr_t itsObjectIdx = 0;
size_t itsPosition = 0;
};
template <typename DocumentTy> struct ObjectRefImpl {
using EntityRef = EntityRefImpl<DocumentTy>;
using iterator = ObjectIteratorImpl<DocumentTy>;
constexpr ObjectRefImpl(const DocumentTy &theDoc, const Entity &theEntity)
: itsDoc{&theDoc}, itsObjectIdx{theEntity.itsPayload} {}
constexpr iterator begin() const { return {*itsDoc, itsObjectIdx, 0}; }
constexpr iterator end() const { return {*itsDoc, itsObjectIdx, size()}; }
constexpr std::optional<EntityRef> operator[](std::string_view theKey) const;
template<typename OtherRefTy>
constexpr bool operator==(const OtherRefTy &theOther) const noexcept {
if (size() != theOther.size())
return false;
for (const auto aKVPair : *this) {
const auto aOtherVal = theOther[aKVPair.first];
if (!aOtherVal || !(aKVPair.second == *aOtherVal))
return false;
}
return true;
}
constexpr size_t size() const {
return itsDoc->getNumProperties(itsObjectIdx);
}
constexpr bool empty() const { return !size(); }
private:
const DocumentTy *itsDoc;
intptr_t itsObjectIdx = 0;
};
template <typename DocumentTy> struct EntityRefImpl {
public:
constexpr EntityRefImpl(const DocumentTy &theDoc,
const Entity &theEntity) noexcept
: itsDoc(&theDoc), itsEntity(&theEntity) {}
constexpr EntityRefImpl() = delete;
constexpr EntityRefImpl(const EntityRefImpl &) = default;
constexpr EntityRefImpl(EntityRefImpl &&) = default;
constexpr EntityRefImpl &operator=(const EntityRefImpl &) = default;
constexpr EntityRefImpl &operator=(EntityRefImpl &&) = default;
using ArrayRef = ArrayRefImpl<DocumentTy>;
using ObjectRef = ObjectRefImpl<DocumentTy>;
template <typename OtherRefTy>
constexpr bool operator==(const OtherRefTy &theOther) const noexcept {
if (theOther.getType() != getType())
return false;
switch (getType()) {
case Entity::NUL:
return true;
case Entity::ARRAY:
return toArray() == theOther.toArray();
case Entity::BOOL:
return toBool() == theOther.toBool();
case Entity::NUMBER:
return toNumber() == theOther.toNumber();
case Entity::OBJECT:
return toObject() == theOther.toObject();
break;
case Entity::STRING:
return toString() == theOther.toString();
}
return false;
}
template <typename OtherRefTy>
constexpr bool operator!=(const OtherRefTy &theOther) const noexcept {
return !(*this == theOther);
}
constexpr Entity::KIND getType() const { return itsEntity->itsKind; }
constexpr bool toBool() const { return itsEntity->itsPayload; }
constexpr double toNumber() const {
return itsDoc->getNumber(itsEntity->itsPayload);
}
constexpr std::string_view toString() const {
return itsDoc->getString(itsEntity->itsPayload);
}
constexpr ArrayRef toArray() const { return ArrayRef{*itsDoc, *itsEntity}; }
std::vector<EntityRefImpl> toVector() const {
intptr_t aIdx = itsEntity->itsPayload;
std::vector<EntityRefImpl> aArray;
aArray.reserve(itsDoc->array_size(aIdx));
for (const Entity *aIter = itsDoc->array_begin(aIdx),
*aEnd = itsDoc->array_end(aIdx);
aIter != aEnd; ++aIter) {
aArray.emplace_back(*itsDoc, *aIter);
}
return aArray;
}
constexpr ObjectRef toObject() const { return {*itsDoc, *itsEntity}; }
std::map<std::string_view, EntityRefImpl> toMap() const {
intptr_t aObjectIdx = itsEntity->itsPayload;
std::map<std::string_view, EntityRefImpl> aObject;
for (size_t aPropIdx = 0u; aPropIdx < itsDoc->getNumProperties(aObjectIdx);
++aPropIdx) {
const auto [aKey, aValuePtr] = itsDoc->getProperty(aObjectIdx, aPropIdx);
aObject.emplace(std::make_pair(aKey, EntityRefImpl{*itsDoc, *aValuePtr}));
}
std::ignore = aObject;
return aObject;
}
private:
const DocumentTy *itsDoc = {};
const Entity *itsEntity = nullptr;
};
template <typename DocumentTy>
constexpr EntityRefImpl<DocumentTy>
ArrayIteratorImpl<DocumentTy>::operator*() const {
return {*itsDoc, *itsPosition};
}
template <typename DocumentTy>
constexpr EntityRefImpl<DocumentTy>
ArrayRefImpl<DocumentTy>::operator[](size_t theIdx) const {
return {*itsDoc, *(itsBegin + theIdx)};
}
template <typename DocumentTy>
constexpr typename ObjectIteratorImpl<DocumentTy>::value_type
ObjectIteratorImpl<DocumentTy>::operator*() const {
const auto [aKey, aValuePtr] = itsDoc->getProperty(itsObjectIdx, itsPosition);
return {aKey, EntityRef{*itsDoc, *aValuePtr}};
}
template <typename DocumentTy>
constexpr std::optional<EntityRefImpl<DocumentTy>>
ObjectRefImpl<DocumentTy>::operator[](std::string_view theKey) const {
const Entity *const aPropPtr = itsDoc->getProperty(itsObjectIdx, theKey);
if (!aPropPtr)
return std::nullopt;
return EntityRef{*itsDoc, *aPropPtr};
}
} // namespace impl
} // namespace cjson
#endif // CONSTEXPR_JSON_DOCUMENT_ACCESS_H
| [
"suluke93@gmail.com"
] | suluke93@gmail.com |
293d6fde95568361a8414488347834912722cd7b | 698fc2ccf662f1e12e6077548b4fd881e9db379f | /C++/flightcapacity.cpp | 60943c3fea047cde81e8d2eaa44b45c49b0f839e | [] | no_license | DKalenscher/projects | 22273290ab6ea6330cb613aa1dc208b31d8bd37d | 1f424186f45b788f5291962f4fe7e1ba91fae3d0 | refs/heads/master | 2021-01-17T06:00:37.258687 | 2014-03-12T14:31:33 | 2014-03-12T14:31:33 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,198 | cpp | //Daniel Kalenscher
//2-26-2014
//Ch 8 - HW [Flight Capacity]
#include <iostream>
#include <fstream>
using namespace std;
void fillSeatInfo(int passCapacity[],int passTickets[], int FlightArraySZ,int &flightNum); //populates two parallel arrays and counts the number of entries in the loaded file.
int deniedBoarding(int passCapacity[], int passTickets[], int FlightArraySZ, int flightNum); //compares tickets sold to seats available
void flightSales(int passCapacity[], int passTickets[], int FlightArraySZ, int flightNum); //categorizes the % of flight fullness
int main(){
const int FlightArraySZ = 100;
int passCapacity[FlightArraySZ];
int passTickets[FlightArraySZ];
int flightNum = 0; //used as a counter to determine how many values get put into the arrays from file.
fillSeatInfo(passCapacity,passTickets,FlightArraySZ, flightNum); //populates two parallel arrays for tickets sold and number of seats available
cout << "There were "<< deniedBoarding(passCapacity,passTickets,FlightArraySZ, flightNum) << " people denied boarding." << endl << endl;
flightSales(passCapacity,passTickets,FlightArraySZ,flightNum);
system("pause");
return 0;
}
void fillSeatInfo(int passCapacity[],int passTickets[],int FlightArraySZ,int &flightNum){
ifstream getseatData("FlightData.txt");
if (getseatData.fail()){ //check that file is opened correctly
cerr << "Opening Flight Data file failed." << endl;
cerr << "Program exiting." << endl;
system("pause");
exit(1);
}
while(!getseatData.eof() && flightNum < FlightArraySZ){
getseatData >> passCapacity[flightNum];
getseatData >> passTickets[flightNum];
flightNum++;
}
}//endfillSeatInfo()
int deniedBoarding(int passCapacity[], int passTickets[], int FlightArraySZ, int flightNum){
int numDenied = 0;
int oversold = 0;
for(int i = 0; i < flightNum; i++){
oversold = passTickets[i] - passCapacity[i];
if(oversold > 0){ //only adds the positive numbers of 3rd array, aka only when tickets > seats
numDenied += oversold;
}
}// end for
return numDenied;
}//end deniedBoarding()
void flightSales(int passCapacity[], int passTickets[], int FlightArraySZ, int flightNum){
double percentSold = 0.0;
int a = 0, b = 0, c = 0, d= 0; //counters for percentage categories
for(int i = 0; i < flightNum; i++){
percentSold = (static_cast<double>(passTickets[i])/static_cast<double>(passCapacity[i]))*100;
if(percentSold < 70.0){
a++;
}
else if (percentSold >= 70.0 && percentSold < 90.0){
b++;
}
else if (percentSold >= 90.0 && percentSold <= 100.0){
c++;
}
else{
d++;
}
}//end for
cout << a << " flights were less than 70% full." << endl << endl;
cout << b << " flights were between 70% and 90% full." << endl << endl;
cout << c << " flights were between 90% and 100% full." << endl << endl;
cout << d << " flights were oversold." << endl << endl;
}//end flightSales()
////1. # of people denied boarding = tickets > capacity So do tickets - capacity to find and add only positive numbers.
//
//
////2. number of flights < 70% full
// between 70 and 90% full
// 90% to 100% full
// > 100% full | [
"DKalenscher@gmail.com"
] | DKalenscher@gmail.com |
6f8d74643b76a5fb35c2f635b57b00a610cf4b65 | 5fc2c309e369ea342ea244bcc2530e4dfbbe8f82 | /impressionist/scatpointBrush.cpp | 973b7d921191d79aac25e7203b8fbd5c7f6908bc | [] | no_license | lijia516/CG_Project-1 | 162c976a3a9ef8367919146569203c487d2258f3 | b20a036020fa2628840f01f1c787a82cac56213b | refs/heads/master | 2020-04-09T19:16:54.423105 | 2015-02-12T04:35:55 | 2015-02-12T04:35:55 | 30,162,557 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,525 | cpp | //
// scatpointBrush.cpp
//
// The implementation of Scatpoint Brush. It is a kind of ImpBrush. All your brush implementations
// will look like the file with the different GL primitive calls.
//
#include "impressionistDoc.h"
#include "impressionistUI.h"
#include "scatpointBrush.h"
extern float frand();
ScatpointBrush::ScatpointBrush( ImpressionistDoc* pDoc, const char* name ) :
ImpBrush(pDoc,name)
{
}
void ScatpointBrush::BrushBegin( const Point source, const Point target )
{
ImpressionistDoc* pDoc = GetDocument();
ImpressionistUI* dlg=pDoc->m_pUI;
BrushMove( source, target );
}
void ScatpointBrush::BrushMove( const Point source, const Point target )
{
ImpressionistDoc* pDoc = GetDocument();
ImpressionistUI* dlg=pDoc->m_pUI;
if ( pDoc == NULL ) {
printf( "PointBrush::BrushMove document is NULL\n" );
return;
}
int size = pDoc->getSize();
int half_size = size / 2;
glPointSize(1);
for (int i = -half_size; i < half_size; i++) {
for (int j = -half_size; j < half_size; j++) {
if (frand() < 0.8f) continue;
Point p = Point(target.x + i, target.y + j);
if (pDoc->getMultiColor()) ImpBrush::c_pBrushes[BRUSH_POINTS]->BrushMove(p, p);
else ImpBrush::c_pBrushes[BRUSH_POINTS]->BrushMove(source, p);
}
}
}
void ScatpointBrush::BrushEnd( const Point source, const Point target )
{
// do nothing so far
}
| [
"lxl377@case.edu"
] | lxl377@case.edu |
059f8e5088a8cda3a9cf63d34c7456fbde18591f | 6b2a8dd202fdce77c971c412717e305e1caaac51 | /solutions_5766201229705216_1/C++/claire/b.cpp | e20bc1b8e417880824919d550c7012e261bcb335 | [] | no_license | alexandraback/datacollection | 0bc67a9ace00abbc843f4912562f3a064992e0e9 | 076a7bc7693f3abf07bfdbdac838cb4ef65ccfcf | refs/heads/master | 2021-01-24T18:27:24.417992 | 2017-05-23T09:23:38 | 2017-05-23T09:23:38 | 84,313,442 | 2 | 4 | null | null | null | null | UTF-8 | C++ | false | false | 1,185 | cpp | #include <iostream>
#include <stdio.h>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <vector>
using namespace std;
const int N=1100;
vector<int> v[N];
int f[N],num[N];
int dfs(int now)
{
vector<int> a;
a.clear();
num[now]=1;
for (int i=0; i<v[now].size(); i++)
{
int x=v[now][i];
if (x==f[now]) continue;
f[x]=now;
a.push_back(dfs(x)-num[x]);
num[now]+=num[x];
}
if (a.size()==0) return 0;
if (a.size()==1) return num[now]-1;
sort(a.begin(),a.end());
return num[now]-1+a[0]+a[1];
}
int main()
{
int o,n,x,y,cas=0;
scanf("%d",&o);
while (o--)
{
scanf("%d",&n);
for (int i=1; i<=n; i++) v[i].clear();
for (int i=1; i<n; i++)
{
scanf("%d%d",&x,&y);
v[x].push_back(y);
v[y].push_back(x);
}
int ans=-1;
for (int i=1; i<=n; i++)
{
memset(f,0,sizeof(f));
memset(num,0,sizeof(num));
f[i]=-1;
int s=dfs(i);
if (ans==-1 || ans>s) ans=s;
}
printf("Case #%d: %d\n",++cas,ans);
}
} | [
"eewestman@gmail.com"
] | eewestman@gmail.com |
1cea4cac0c3d9bee63555e296b21a3301480f9a8 | 3a93366d200fc1f0f271cf466c7993ee3122ac33 | /lib/bgfx/include/bx/fpumath.h | deaaa1dfc18392e17d6a03ca4feb270dd43ff721 | [
"MIT",
"LicenseRef-scancode-public-domain",
"BSD-2-Clause"
] | permissive | ZelimDamian/Torque6 | 03b55f57c3903051ac854af01fc5a5f7d6de597a | e2266bcdb6d199595201aab75e0a0e9f4e155a80 | refs/heads/master | 2021-01-18T07:04:27.712341 | 2015-08-08T00:10:32 | 2015-08-08T00:10:32 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 26,160 | h | /*
* Copyright 2011-2015 Branimir Karadzic. All rights reserved.
* License: http://www.opensource.org/licenses/BSD-2-Clause
*/
// FPU math lib
#ifndef BX_FPU_MATH_H_HEADER_GUARD
#define BX_FPU_MATH_H_HEADER_GUARD
#include "bx.h"
#include <math.h>
#include <string.h>
namespace bx
{
static const float pi = 3.14159265358979323846f;
static const float invPi = 1.0f/3.14159265358979323846f;
static const float piHalf = 1.57079632679489661923f;
static const float sqrt2 = 1.41421356237309504880f;
inline float toRad(float _deg)
{
return _deg * pi / 180.0f;
}
inline float toDeg(float _rad)
{
return _rad * 180.0f / pi;
}
inline float fround(float _f)
{
return float(int(_f) );
}
inline float fmin(float _a, float _b)
{
return _a < _b ? _a : _b;
}
inline float fmax(float _a, float _b)
{
return _a > _b ? _a : _b;
}
inline float fmin3(float _a, float _b, float _c)
{
return fmin(_a, fmin(_b, _c) );
}
inline float fmax3(float _a, float _b, float _c)
{
return fmax(_a, fmax(_b, _c) );
}
inline float fclamp(float _a, float _min, float _max)
{
return fmin(fmax(_a, _min), _max);
}
inline float fsaturate(float _a)
{
return fclamp(_a, 0.0f, 1.0f);
}
inline float flerp(float _a, float _b, float _t)
{
return _a + (_b - _a) * _t;
}
inline float fsign(float _a)
{
return _a < 0.0f ? -1.0f : 1.0f;
}
inline float fstep(float _edge, float _a)
{
return _a < _edge ? 0.0f : 1.0f;
}
inline float fpulse(float _a, float _start, float _end)
{
return fstep(_a, _start) - fstep(_a, _end);
}
inline float fabsolute(float _a)
{
return fabsf(_a);
}
inline float fsqrt(float _a)
{
return sqrtf(_a);
}
inline float ffract(float _a)
{
return _a - floorf(_a);
}
inline bool fequal(float _a, float _b, float _epsilon)
{
return fabsolute(_a - _b) <= _epsilon;
}
inline bool fequal(const float* __restrict _a, const float* __restrict _b, uint32_t _num, float _epsilon)
{
bool equal = fequal(_a[0], _b[0], _epsilon);
for (uint32_t ii = 1; equal && ii < _num; ++ii)
{
equal = fequal(_a[ii], _b[ii], _epsilon);
}
return equal;
}
inline float fwrap(float _a, float _wrap)
{
const float mod = fmodf(_a, _wrap);
const float result = mod < 0.0f ? _wrap + mod : mod;
return result;
}
// References:
// - Bias And Gain Are Your Friend
// http://blog.demofox.org/2012/09/24/bias-and-gain-are-your-friend/
// - http://demofox.org/biasgain.html
inline float fbias(float _time, float _bias)
{
return _time / ( ( (1.0f/_bias - 2.0f)*(1.0f - _time) ) + 1.0f);
}
inline float fgain(float _time, float _gain)
{
if (_time < 0.5f)
{
return fbias(_time * 2.0f, _gain) * 0.5f;
}
return fbias(_time * 2.0f - 1.0f, 1.0f - _gain) * 0.5f + 0.5f;
}
inline void vec3Move(float* __restrict _result, const float* __restrict _a)
{
_result[0] = _a[0];
_result[1] = _a[1];
_result[2] = _a[2];
}
inline void vec3Abs(float* __restrict _result, const float* __restrict _a)
{
_result[0] = fabsolute(_a[0]);
_result[1] = fabsolute(_a[1]);
_result[2] = fabsolute(_a[2]);
}
inline void vec3Neg(float* __restrict _result, const float* __restrict _a)
{
_result[0] = -_a[0];
_result[1] = -_a[1];
_result[2] = -_a[2];
}
inline void vec3Add(float* __restrict _result, const float* __restrict _a, const float* __restrict _b)
{
_result[0] = _a[0] + _b[0];
_result[1] = _a[1] + _b[1];
_result[2] = _a[2] + _b[2];
}
inline void vec3Sub(float* __restrict _result, const float* __restrict _a, const float* __restrict _b)
{
_result[0] = _a[0] - _b[0];
_result[1] = _a[1] - _b[1];
_result[2] = _a[2] - _b[2];
}
inline void vec3Mul(float* __restrict _result, const float* __restrict _a, const float* __restrict _b)
{
_result[0] = _a[0] * _b[0];
_result[1] = _a[1] * _b[1];
_result[2] = _a[2] * _b[2];
}
inline void vec3Mul(float* __restrict _result, const float* __restrict _a, float _b)
{
_result[0] = _a[0] * _b;
_result[1] = _a[1] * _b;
_result[2] = _a[2] * _b;
}
inline float vec3Dot(const float* __restrict _a, const float* __restrict _b)
{
return _a[0]*_b[0] + _a[1]*_b[1] + _a[2]*_b[2];
}
inline void vec3Cross(float* __restrict _result, const float* __restrict _a, const float* __restrict _b)
{
_result[0] = _a[1]*_b[2] - _a[2]*_b[1];
_result[1] = _a[2]*_b[0] - _a[0]*_b[2];
_result[2] = _a[0]*_b[1] - _a[1]*_b[0];
}
inline float vec3Length(const float* _a)
{
return fsqrt(vec3Dot(_a, _a) );
}
inline float vec3Norm(float* __restrict _result, const float* __restrict _a)
{
const float len = vec3Length(_a);
const float invLen = 1.0f/len;
_result[0] = _a[0] * invLen;
_result[1] = _a[1] * invLen;
_result[2] = _a[2] * invLen;
return len;
}
inline void quatIdentity(float* _result)
{
_result[0] = 0.0f;
_result[1] = 0.0f;
_result[2] = 0.0f;
_result[3] = 1.0f;
}
inline void quatMulXYZ(float* __restrict _result, const float* __restrict _qa, const float* __restrict _qb)
{
const float ax = _qa[0];
const float ay = _qa[1];
const float az = _qa[2];
const float aw = _qa[3];
const float bx = _qb[0];
const float by = _qb[1];
const float bz = _qb[2];
const float bw = _qb[3];
_result[0] = aw * bx + ax * bw + ay * bz - az * by;
_result[1] = aw * by - ax * bz + ay * bw + az * bx;
_result[2] = aw * bz + ax * by - ay * bx + az * bw;
}
inline void quatMul(float* __restrict _result, const float* __restrict _qa, const float* __restrict _qb)
{
const float ax = _qa[0];
const float ay = _qa[1];
const float az = _qa[2];
const float aw = _qa[3];
const float bx = _qb[0];
const float by = _qb[1];
const float bz = _qb[2];
const float bw = _qb[3];
_result[0] = aw * bx + ax * bw + ay * bz - az * by;
_result[1] = aw * by - ax * bz + ay * bw + az * bx;
_result[2] = aw * bz + ax * by - ay * bx + az * bw;
_result[3] = aw * bw - ax * bx - ay * by - az * bz;
}
inline void quatInvert(float* __restrict _result, const float* __restrict _quat)
{
_result[0] = -_quat[0];
_result[1] = -_quat[1];
_result[2] = -_quat[2];
_result[3] = _quat[3];
}
inline void quatToEuler(float* __restrict _result, const float* __restrict _quat)
{
const float x = _quat[0];
const float y = _quat[1];
const float z = _quat[2];
const float w = _quat[3];
const float yy = y * y;
const float zz = z * z;
const float xx = x * x;
_result[0] = atan2f(2.0f * (x * w - y * z), 1.0f - 2.0f * (xx + zz) );
_result[1] = atan2f(2.0f * (y * w + x * z), 1.0f - 2.0f * (yy + zz) );
_result[2] = asinf (2.0f * (x * y + z * w) );
}
inline void quatRotateX(float* _result, float _ax)
{
const float hx = _ax * 0.5f;
const float cx = cosf(hx);
const float sx = sinf(hx);
_result[0] = sx;
_result[1] = 0.0f;
_result[2] = 0.0f;
_result[3] = cx;
}
inline void quatRotateY(float* _result, float _ay)
{
const float hy = _ay * 0.5f;
const float cy = cosf(hy);
const float sy = sinf(hy);
_result[0] = 0.0f;
_result[1] = sy;
_result[2] = 0.0f;
_result[3] = cy;
}
inline void quatRotateZ(float* _result, float _az)
{
const float hz = _az * 0.5f;
const float cz = cosf(hz);
const float sz = sinf(hz);
_result[0] = 0.0f;
_result[1] = 0.0f;
_result[2] = sz;
_result[3] = cz;
}
inline void vec3MulQuat(float* __restrict _result, const float* __restrict _vec, const float* __restrict _quat)
{
float tmp0[4];
quatInvert(tmp0, _quat);
float qv[4];
qv[0] = _vec[0];
qv[1] = _vec[1];
qv[2] = _vec[2];
qv[3] = 0.0f;
float tmp1[4];
quatMul(tmp1, tmp0, qv);
quatMulXYZ(_result, tmp1, _quat);
}
inline void mtxIdentity(float* _result)
{
memset(_result, 0, sizeof(float)*16);
_result[0] = _result[5] = _result[10] = _result[15] = 1.0f;
}
inline void mtxTranslate(float* _result, float _tx, float _ty, float _tz)
{
mtxIdentity(_result);
_result[12] = _tx;
_result[13] = _ty;
_result[14] = _tz;
}
inline void mtxScale(float* _result, float _sx, float _sy, float _sz)
{
memset(_result, 0, sizeof(float) * 16);
_result[0] = _sx;
_result[5] = _sy;
_result[10] = _sz;
_result[15] = 1.0f;
}
inline void mtxQuat(float* __restrict _result, const float* __restrict _quat)
{
const float x = _quat[0];
const float y = _quat[1];
const float z = _quat[2];
const float w = _quat[3];
const float x2 = x + x;
const float y2 = y + y;
const float z2 = z + z;
const float x2x = x2 * x;
const float x2y = x2 * y;
const float x2z = x2 * z;
const float x2w = x2 * w;
const float y2y = y2 * y;
const float y2z = y2 * z;
const float y2w = y2 * w;
const float z2z = z2 * z;
const float z2w = z2 * w;
_result[ 0] = 1.0f - (y2y + z2z);
_result[ 1] = x2y - z2w;
_result[ 2] = x2z + y2w;
_result[ 3] = 0.0f;
_result[ 4] = x2y + z2w;
_result[ 5] = 1.0f - (x2x + z2z);
_result[ 6] = y2z - x2w;
_result[ 7] = 0.0f;
_result[ 8] = x2z - y2w;
_result[ 9] = y2z + x2w;
_result[10] = 1.0f - (x2x + y2y);
_result[11] = 0.0f;
_result[12] = 0.0f;
_result[13] = 0.0f;
_result[14] = 0.0f;
_result[15] = 1.0f;
}
inline void mtxQuatTranslation(float* __restrict _result, const float* __restrict _quat, const float* __restrict _translation)
{
mtxQuat(_result, _quat);
_result[12] = -(_result[0]*_translation[0] + _result[4]*_translation[1] + _result[ 8]*_translation[2]);
_result[13] = -(_result[1]*_translation[0] + _result[5]*_translation[1] + _result[ 9]*_translation[2]);
_result[14] = -(_result[2]*_translation[0] + _result[6]*_translation[1] + _result[10]*_translation[2]);
}
inline void mtxQuatTranslationHMD(float* __restrict _result, const float* __restrict _quat, const float* __restrict _translation)
{
float quat[4];
quat[0] = -_quat[0];
quat[1] = -_quat[1];
quat[2] = _quat[2];
quat[3] = _quat[3];
mtxQuatTranslation(_result, quat, _translation);
}
inline void mtxLookAt(float* __restrict _result, const float* __restrict _eye, const float* __restrict _at, const float* __restrict _up = NULL)
{
float tmp[4];
vec3Sub(tmp, _at, _eye);
float view[4];
vec3Norm(view, tmp);
float up[3] = { 0.0f, 1.0f, 0.0f };
if (NULL != _up)
{
up[0] = _up[0];
up[1] = _up[1];
up[2] = _up[2];
}
vec3Cross(tmp, up, view);
float right[4];
vec3Norm(right, tmp);
vec3Cross(up, view, right);
memset(_result, 0, sizeof(float)*16);
_result[ 0] = right[0];
_result[ 1] = up[0];
_result[ 2] = view[0];
_result[ 4] = right[1];
_result[ 5] = up[1];
_result[ 6] = view[1];
_result[ 8] = right[2];
_result[ 9] = up[2];
_result[10] = view[2];
_result[12] = -vec3Dot(right, _eye);
_result[13] = -vec3Dot(up, _eye);
_result[14] = -vec3Dot(view, _eye);
_result[15] = 1.0f;
}
inline void mtxProjXYWH(float* _result, float _x, float _y, float _width, float _height, float _near, float _far, bool _oglNdc = false)
{
const float diff = _far-_near;
const float aa = _oglNdc ? (_far+_near)/diff : _far/diff;
const float bb = _oglNdc ? -(2.0f*_far*_near)/diff : -_near*aa;
memset(_result, 0, sizeof(float)*16);
_result[ 0] = _width;
_result[ 5] = _height;
_result[ 8] = _x;
_result[ 9] = -_y;
_result[10] = aa;
_result[11] = 1.0f;
_result[14] = bb;
}
inline void mtxProj(float* _result, float _ut, float _dt, float _lt, float _rt, float _near, float _far, bool _oglNdc = false)
{
const float width = 2.0f / (_lt + _rt);
const float height = 2.0f / (_ut + _dt);
const float xx = (_lt - _rt) * width * 0.5f;
const float yy = (_ut - _dt) * height * 0.5f;
mtxProjXYWH(_result, xx, yy, width, height, _near, _far, _oglNdc);
}
inline void mtxProj(float* _result, const float _fov[4], float _near, float _far, bool _oglNdc = false)
{
mtxProj(_result, _fov[0], _fov[1], _fov[2], _fov[3], _near, _far, _oglNdc);
}
inline void mtxProj(float* _result, float _fovy, float _aspect, float _near, float _far, bool _oglNdc = false)
{
const float height = 1.0f/tanf(toRad(_fovy)*0.5f);
const float width = height * 1.0f/_aspect;
mtxProjXYWH(_result, 0.0f, 0.0f, width, height, _near, _far, _oglNdc);
}
inline void mtxOrtho(float* _result, float _left, float _right, float _bottom, float _top, float _near, float _far, float _offset = 0.0f)
{
const float aa = 2.0f/(_right - _left);
const float bb = 2.0f/(_top - _bottom);
const float cc = 1.0f/(_far - _near);
const float dd = (_left + _right)/(_left - _right);
const float ee = (_top + _bottom)/(_bottom - _top);
const float ff = _near / (_near - _far);
memset(_result, 0, sizeof(float)*16);
_result[ 0] = aa;
_result[ 5] = bb;
_result[10] = cc;
_result[12] = dd + _offset;
_result[13] = ee;
_result[14] = ff;
_result[15] = 1.0f;
}
inline void mtxRotateX(float* _result, float _ax)
{
const float sx = sinf(_ax);
const float cx = cosf(_ax);
memset(_result, 0, sizeof(float)*16);
_result[ 0] = 1.0f;
_result[ 5] = cx;
_result[ 6] = -sx;
_result[ 9] = sx;
_result[10] = cx;
_result[15] = 1.0f;
}
inline void mtxRotateY(float* _result, float _ay)
{
const float sy = sinf(_ay);
const float cy = cosf(_ay);
memset(_result, 0, sizeof(float)*16);
_result[ 0] = cy;
_result[ 2] = sy;
_result[ 5] = 1.0f;
_result[ 8] = -sy;
_result[10] = cy;
_result[15] = 1.0f;
}
inline void mtxRotateZ(float* _result, float _az)
{
const float sz = sinf(_az);
const float cz = cosf(_az);
memset(_result, 0, sizeof(float)*16);
_result[ 0] = cz;
_result[ 1] = -sz;
_result[ 4] = sz;
_result[ 5] = cz;
_result[10] = 1.0f;
_result[15] = 1.0f;
}
inline void mtxRotateXY(float* _result, float _ax, float _ay)
{
const float sx = sinf(_ax);
const float cx = cosf(_ax);
const float sy = sinf(_ay);
const float cy = cosf(_ay);
memset(_result, 0, sizeof(float)*16);
_result[ 0] = cy;
_result[ 2] = sy;
_result[ 4] = sx*sy;
_result[ 5] = cx;
_result[ 6] = -sx*cy;
_result[ 8] = -cx*sy;
_result[ 9] = sx;
_result[10] = cx*cy;
_result[15] = 1.0f;
}
inline void mtxRotateXYZ(float* _result, float _ax, float _ay, float _az)
{
const float sx = sinf(_ax);
const float cx = cosf(_ax);
const float sy = sinf(_ay);
const float cy = cosf(_ay);
const float sz = sinf(_az);
const float cz = cosf(_az);
memset(_result, 0, sizeof(float)*16);
_result[ 0] = cy*cz;
_result[ 1] = -cy*sz;
_result[ 2] = sy;
_result[ 4] = cz*sx*sy + cx*sz;
_result[ 5] = cx*cz - sx*sy*sz;
_result[ 6] = -cy*sx;
_result[ 8] = -cx*cz*sy + sx*sz;
_result[ 9] = cz*sx + cx*sy*sz;
_result[10] = cx*cy;
_result[15] = 1.0f;
}
inline void mtxRotateZYX(float* _result, float _ax, float _ay, float _az)
{
const float sx = sinf(_ax);
const float cx = cosf(_ax);
const float sy = sinf(_ay);
const float cy = cosf(_ay);
const float sz = sinf(_az);
const float cz = cosf(_az);
memset(_result, 0, sizeof(float)*16);
_result[ 0] = cy*cz;
_result[ 1] = cz*sx*sy-cx*sz;
_result[ 2] = cx*cz*sy+sx*sz;
_result[ 4] = cy*sz;
_result[ 5] = cx*cz + sx*sy*sz;
_result[ 6] = -cz*sx + cx*sy*sz;
_result[ 8] = -sy;
_result[ 9] = cy*sx;
_result[10] = cx*cy;
_result[15] = 1.0f;
};
inline void mtxSRT(float* _result, float _sx, float _sy, float _sz, float _ax, float _ay, float _az, float _tx, float _ty, float _tz)
{
const float sx = sinf(_ax);
const float cx = cosf(_ax);
const float sy = sinf(_ay);
const float cy = cosf(_ay);
const float sz = sinf(_az);
const float cz = cosf(_az);
const float sxsz = sx*sz;
const float cycz = cy*cz;
_result[ 0] = _sx * (cycz - sxsz*sy);
_result[ 1] = _sx * -cx*sz;
_result[ 2] = _sx * (cz*sy + cy*sxsz);
_result[ 3] = 0.0f;
_result[ 4] = _sy * (cz*sx*sy + cy*sz);
_result[ 5] = _sy * cx*cz;
_result[ 6] = _sy * (sy*sz -cycz*sx);
_result[ 7] = 0.0f;
_result[ 8] = _sz * -cx*sy;
_result[ 9] = _sz * sx;
_result[10] = _sz * cx*cy;
_result[11] = 0.0f;
_result[12] = _tx;
_result[13] = _ty;
_result[14] = _tz;
_result[15] = 1.0f;
}
inline void vec3MulMtx(float* __restrict _result, const float* __restrict _vec, const float* __restrict _mat)
{
_result[0] = _vec[0] * _mat[ 0] + _vec[1] * _mat[4] + _vec[2] * _mat[ 8] + _mat[12];
_result[1] = _vec[0] * _mat[ 1] + _vec[1] * _mat[5] + _vec[2] * _mat[ 9] + _mat[13];
_result[2] = _vec[0] * _mat[ 2] + _vec[1] * _mat[6] + _vec[2] * _mat[10] + _mat[14];
}
inline void vec3MulMtxH(float* __restrict _result, const float* __restrict _vec, const float* __restrict _mat)
{
float xx = _vec[0] * _mat[ 0] + _vec[1] * _mat[4] + _vec[2] * _mat[ 8] + _mat[12];
float yy = _vec[0] * _mat[ 1] + _vec[1] * _mat[5] + _vec[2] * _mat[ 9] + _mat[13];
float zz = _vec[0] * _mat[ 2] + _vec[1] * _mat[6] + _vec[2] * _mat[10] + _mat[14];
float ww = _vec[0] * _mat[ 3] + _vec[1] * _mat[7] + _vec[2] * _mat[11] + _mat[15];
float invW = fsign(ww)/ww;
_result[0] = xx*invW;
_result[1] = yy*invW;
_result[2] = zz*invW;
}
inline void vec4MulMtx(float* __restrict _result, const float* __restrict _vec, const float* __restrict _mat)
{
_result[0] = _vec[0] * _mat[ 0] + _vec[1] * _mat[4] + _vec[2] * _mat[ 8] + _vec[3] * _mat[12];
_result[1] = _vec[0] * _mat[ 1] + _vec[1] * _mat[5] + _vec[2] * _mat[ 9] + _vec[3] * _mat[13];
_result[2] = _vec[0] * _mat[ 2] + _vec[1] * _mat[6] + _vec[2] * _mat[10] + _vec[3] * _mat[14];
_result[3] = _vec[0] * _mat[ 3] + _vec[1] * _mat[7] + _vec[2] * _mat[11] + _vec[3] * _mat[15];
}
inline void mtxMul(float* __restrict _result, const float* __restrict _a, const float* __restrict _b)
{
vec4MulMtx(&_result[ 0], &_a[ 0], _b);
vec4MulMtx(&_result[ 4], &_a[ 4], _b);
vec4MulMtx(&_result[ 8], &_a[ 8], _b);
vec4MulMtx(&_result[12], &_a[12], _b);
}
inline void mtxTranspose(float* __restrict _result, const float* __restrict _a)
{
_result[ 0] = _a[ 0];
_result[ 4] = _a[ 1];
_result[ 8] = _a[ 2];
_result[12] = _a[ 3];
_result[ 1] = _a[ 4];
_result[ 5] = _a[ 5];
_result[ 9] = _a[ 6];
_result[13] = _a[ 7];
_result[ 2] = _a[ 8];
_result[ 6] = _a[ 9];
_result[10] = _a[10];
_result[14] = _a[11];
_result[ 3] = _a[12];
_result[ 7] = _a[13];
_result[11] = _a[14];
_result[15] = _a[15];
}
inline void mtx3Inverse(float* __restrict _result, const float* __restrict _a)
{
float xx = _a[0];
float xy = _a[1];
float xz = _a[2];
float yx = _a[3];
float yy = _a[4];
float yz = _a[5];
float zx = _a[6];
float zy = _a[7];
float zz = _a[8];
float det = 0.0f;
det += xx * (yy*zz - yz*zy);
det -= xy * (yx*zz - yz*zx);
det += xz * (yx*zy - yy*zx);
float invDet = 1.0f/det;
_result[0] = +(yy*zz - yz*zy) * invDet;
_result[1] = -(xy*zz - xz*zy) * invDet;
_result[2] = +(xy*yz - xz*yy) * invDet;
_result[3] = -(yx*zz - yz*zx) * invDet;
_result[4] = +(xx*zz - xz*zx) * invDet;
_result[5] = -(xx*yz - xz*yx) * invDet;
_result[6] = +(yx*zy - yy*zx) * invDet;
_result[7] = -(xx*zy - xy*zx) * invDet;
_result[8] = +(xx*yy - xy*yx) * invDet;
}
inline void mtxInverse(float* __restrict _result, const float* __restrict _a)
{
float xx = _a[ 0];
float xy = _a[ 1];
float xz = _a[ 2];
float xw = _a[ 3];
float yx = _a[ 4];
float yy = _a[ 5];
float yz = _a[ 6];
float yw = _a[ 7];
float zx = _a[ 8];
float zy = _a[ 9];
float zz = _a[10];
float zw = _a[11];
float wx = _a[12];
float wy = _a[13];
float wz = _a[14];
float ww = _a[15];
float det = 0.0f;
det += xx * (yy*(zz*ww - zw*wz) - yz*(zy*ww - zw*wy) + yw*(zy*wz - zz*wy) );
det -= xy * (yx*(zz*ww - zw*wz) - yz*(zx*ww - zw*wx) + yw*(zx*wz - zz*wx) );
det += xz * (yx*(zy*ww - zw*wy) - yy*(zx*ww - zw*wx) + yw*(zx*wy - zy*wx) );
det -= xw * (yx*(zy*wz - zz*wy) - yy*(zx*wz - zz*wx) + yz*(zx*wy - zy*wx) );
float invDet = 1.0f/det;
_result[ 0] = +(yy*(zz*ww - wz*zw) - yz*(zy*ww - wy*zw) + yw*(zy*wz - wy*zz) ) * invDet;
_result[ 1] = -(xy*(zz*ww - wz*zw) - xz*(zy*ww - wy*zw) + xw*(zy*wz - wy*zz) ) * invDet;
_result[ 2] = +(xy*(yz*ww - wz*yw) - xz*(yy*ww - wy*yw) + xw*(yy*wz - wy*yz) ) * invDet;
_result[ 3] = -(xy*(yz*zw - zz*yw) - xz*(yy*zw - zy*yw) + xw*(yy*zz - zy*yz) ) * invDet;
_result[ 4] = -(yx*(zz*ww - wz*zw) - yz*(zx*ww - wx*zw) + yw*(zx*wz - wx*zz) ) * invDet;
_result[ 5] = +(xx*(zz*ww - wz*zw) - xz*(zx*ww - wx*zw) + xw*(zx*wz - wx*zz) ) * invDet;
_result[ 6] = -(xx*(yz*ww - wz*yw) - xz*(yx*ww - wx*yw) + xw*(yx*wz - wx*yz) ) * invDet;
_result[ 7] = +(xx*(yz*zw - zz*yw) - xz*(yx*zw - zx*yw) + xw*(yx*zz - zx*yz) ) * invDet;
_result[ 8] = +(yx*(zy*ww - wy*zw) - yy*(zx*ww - wx*zw) + yw*(zx*wy - wx*zy) ) * invDet;
_result[ 9] = -(xx*(zy*ww - wy*zw) - xy*(zx*ww - wx*zw) + xw*(zx*wy - wx*zy) ) * invDet;
_result[10] = +(xx*(yy*ww - wy*yw) - xy*(yx*ww - wx*yw) + xw*(yx*wy - wx*yy) ) * invDet;
_result[11] = -(xx*(yy*zw - zy*yw) - xy*(yx*zw - zx*yw) + xw*(yx*zy - zx*yy) ) * invDet;
_result[12] = -(yx*(zy*wz - wy*zz) - yy*(zx*wz - wx*zz) + yz*(zx*wy - wx*zy) ) * invDet;
_result[13] = +(xx*(zy*wz - wy*zz) - xy*(zx*wz - wx*zz) + xz*(zx*wy - wx*zy) ) * invDet;
_result[14] = -(xx*(yy*wz - wy*yz) - xy*(yx*wz - wx*yz) + xz*(yx*wy - wx*yy) ) * invDet;
_result[15] = +(xx*(yy*zz - zy*yz) - xy*(yx*zz - zx*yz) + xz*(yx*zy - zx*yy) ) * invDet;
}
/// Convert LH to RH projection matrix and vice versa.
inline void mtxProjFlipHandedness(float* __restrict _dst, const float* __restrict _src)
{
_dst[ 0] = -_src[ 0];
_dst[ 1] = -_src[ 1];
_dst[ 2] = -_src[ 2];
_dst[ 3] = -_src[ 3];
_dst[ 4] = _src[ 4];
_dst[ 5] = _src[ 5];
_dst[ 6] = _src[ 6];
_dst[ 7] = _src[ 7];
_dst[ 8] = -_src[ 8];
_dst[ 9] = -_src[ 9];
_dst[10] = -_src[10];
_dst[11] = -_src[11];
_dst[12] = _src[12];
_dst[13] = _src[13];
_dst[14] = _src[14];
_dst[15] = _src[15];
}
/// Convert LH to RH view matrix and vice versa.
inline void mtxViewFlipHandedness(float* __restrict _dst, const float* __restrict _src)
{
_dst[ 0] = -_src[ 0];
_dst[ 1] = _src[ 1];
_dst[ 2] = -_src[ 2];
_dst[ 3] = _src[ 3];
_dst[ 4] = -_src[ 4];
_dst[ 5] = _src[ 5];
_dst[ 6] = -_src[ 6];
_dst[ 7] = _src[ 7];
_dst[ 8] = -_src[ 8];
_dst[ 9] = _src[ 9];
_dst[10] = -_src[10];
_dst[11] = _src[11];
_dst[12] = -_src[12];
_dst[13] = _src[13];
_dst[14] = -_src[14];
_dst[15] = _src[15];
}
inline void calcNormal(float _result[3], float _va[3], float _vb[3], float _vc[3])
{
float ba[3];
vec3Sub(ba, _vb, _va);
float ca[3];
vec3Sub(ca, _vc, _va);
float baxca[3];
vec3Cross(baxca, ba, ca);
vec3Norm(_result, baxca);
}
inline void calcPlane(float _result[4], float _va[3], float _vb[3], float _vc[3])
{
float normal[3];
calcNormal(normal, _va, _vb, _vc);
_result[0] = normal[0];
_result[1] = normal[1];
_result[2] = normal[2];
_result[3] = -vec3Dot(normal, _va);
}
inline void calcLinearFit2D(float _result[2], const void* _points, uint32_t _stride, uint32_t _numPoints)
{
float sumX = 0.0f;
float sumY = 0.0f;
float sumXX = 0.0f;
float sumXY = 0.0f;
const uint8_t* ptr = (const uint8_t*)_points;
for (uint32_t ii = 0; ii < _numPoints; ++ii, ptr += _stride)
{
const float* point = (const float*)ptr;
float xx = point[0];
float yy = point[1];
sumX += xx;
sumY += yy;
sumXX += xx*xx;
sumXY += xx*yy;
}
// [ sum(x^2) sum(x) ] [ A ] = [ sum(x*y) ]
// [ sum(x) numPoints ] [ B ] [ sum(y) ]
float det = (sumXX*_numPoints - sumX*sumX);
float invDet = 1.0f/det;
_result[0] = (-sumX * sumY + _numPoints * sumXY) * invDet;
_result[1] = (sumXX * sumY - sumX * sumXY) * invDet;
}
inline void calcLinearFit3D(float _result[3], const void* _points, uint32_t _stride, uint32_t _numPoints)
{
float sumX = 0.0f;
float sumY = 0.0f;
float sumZ = 0.0f;
float sumXX = 0.0f;
float sumXY = 0.0f;
float sumXZ = 0.0f;
float sumYY = 0.0f;
float sumYZ = 0.0f;
const uint8_t* ptr = (const uint8_t*)_points;
for (uint32_t ii = 0; ii < _numPoints; ++ii, ptr += _stride)
{
const float* point = (const float*)ptr;
float xx = point[0];
float yy = point[1];
float zz = point[2];
sumX += xx;
sumY += yy;
sumZ += zz;
sumXX += xx*xx;
sumXY += xx*yy;
sumXZ += xx*zz;
sumYY += yy*yy;
sumYZ += yy*zz;
}
// [ sum(x^2) sum(x*y) sum(x) ] [ A ] [ sum(x*z) ]
// [ sum(x*y) sum(y^2) sum(y) ] [ B ] = [ sum(y*z) ]
// [ sum(x) sum(y) numPoints ] [ C ] [ sum(z) ]
float mtx[9] =
{
sumXX, sumXY, sumX,
sumXY, sumYY, sumY,
sumX, sumY, float(_numPoints),
};
float invMtx[9];
mtx3Inverse(invMtx, mtx);
_result[0] = invMtx[0]*sumXZ + invMtx[1]*sumYZ + invMtx[2]*sumZ;
_result[1] = invMtx[3]*sumXZ + invMtx[4]*sumYZ + invMtx[5]*sumZ;
_result[2] = invMtx[6]*sumXZ + invMtx[7]*sumYZ + invMtx[8]*sumZ;
}
inline void rgbToHsv(float _hsv[3], const float _rgb[3])
{
const float rr = _rgb[0];
const float gg = _rgb[1];
const float bb = _rgb[2];
const float s0 = fstep(bb, gg);
const float px = flerp(bb, gg, s0);
const float py = flerp(gg, bb, s0);
const float pz = flerp(-1.0f, 0.0f, s0);
const float pw = flerp(2.0f/3.0f, -1.0f/3.0f, s0);
const float s1 = fstep(px, rr);
const float qx = flerp(px, rr, s1);
const float qy = py;
const float qz = flerp(pw, pz, s1);
const float qw = flerp(rr, px, s1);
const float dd = qx - fmin(qw, qy);
const float ee = 1.0e-10f;
_hsv[0] = fabsolute(qz + (qw - qy) / (6.0f * dd + ee) );
_hsv[1] = dd / (qx + ee);
_hsv[2] = qx;
}
inline void hsvToRgb(float _rgb[3], const float _hsv[3])
{
const float hh = _hsv[0];
const float ss = _hsv[1];
const float vv = _hsv[2];
const float px = fabsolute(ffract(hh + 1.0f ) * 6.0f - 3.0f);
const float py = fabsolute(ffract(hh + 2.0f/3.0f) * 6.0f - 3.0f);
const float pz = fabsolute(ffract(hh + 1.0f/3.0f) * 6.0f - 3.0f);
_rgb[0] = vv * flerp(1.0f, fsaturate(px - 1.0f), ss);
_rgb[1] = vv * flerp(1.0f, fsaturate(py - 1.0f), ss);
_rgb[2] = vv * flerp(1.0f, fsaturate(pz - 1.0f), ss);
}
} // namespace bx
#endif // BX_FPU_MATH_H_HEADER_GUARD
| [
"andrewmac@gmail.com"
] | andrewmac@gmail.com |
741252d74aff114919a9d52b08440887ea47d231 | 2e72a74d760a8c14ca242df077413a9ff9699774 | /src/d2_ee_ppdd_DA.cpp | 564b7b183c2dcaf9760be65c39a3a74d0309bf81 | [] | no_license | chemiczny/automateusz_gto_d2 | ba3f1bec939a135a3591d512663ee01c4aa10b0c | b4c7e0978424bf53fd4b1f67de8e65ab3373fc10 | refs/heads/master | 2020-03-21T15:30:46.767378 | 2019-05-08T14:33:56 | 2019-05-08T14:33:56 | 138,716,717 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 837 | cpp | #include "gto_d2_kit/d2_ee_ppdd_AD.hpp"
void second_derivative_ee_1122_41( const double ae,
const double xA,
const double yA,
const double zA,
const double be,
const double xB,
const double yB,
const double zB,
const double ce,
const double xC,
const double yC,
const double zC,
const double de,
const double xD,
const double yD,
const double zD,
const double* const bs, double* const d2eexx, double* const d2eexy, double* const d2eexz, double* const d2eeyx, double* const d2eeyy, double* const d2eeyz, double* const d2eezx, double* const d2eezy, double* const d2eezz){
second_derivative_ee_1122_14( ae, xA, yA, zA, be, xB, yB, zB, ce, xC, yC, zC, de, xD, yD, zD, bs, d2eexx, d2eeyx, d2eezx, d2eexy, d2eeyy, d2eezy, d2eexz, d2eeyz, d2eezz);}
| [
"mglanows@kierkur.ch.uj.edu.pl"
] | mglanows@kierkur.ch.uj.edu.pl |
d3fcd8a5a98ea21da80fb8ca7b5721f54f7df2c7 | c6703471bc66a9f8d1f75e98441e7aa33cb8f799 | /20190117/cowtest.cc | 5706b5ced0d8ad40f744633b5b44724b45842a61 | [] | no_license | fanmanqian/learnCplusplus | 86a40f53e94a977d36a0c48b93f2cb36e0a6306b | 4c76732dd1cf8e490320cfa63ac4fcc108315ea6 | refs/heads/master | 2023-03-31T03:46:42.610368 | 2021-04-01T11:07:25 | 2021-04-01T11:07:25 | 352,980,894 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,665 | cc | ///
/// @file cowtest.cc
/// @author mfm(2563965485@qq.com)
/// @date 2020-12-09 14:48:26
///
#include <iostream>
#include <string.h>
using std::cout;
using std::endl;
class String
{
class CharProxy
{
public:
CharProxy(String & self,size_t idx)
: _self(self)
, _idx(idx)
{
}
char & operator=(const char & ch);
friend std::ostream & operator<<(std::ostream & os, const CharProxy & rhs);
private:
String & _self;
size_t _idx;
};
friend std::ostream & operator<<(std::ostream & os, const String & rhs);
friend std::ostream & operator<<(std::ostream & os, const CharProxy & rhs);
public:
CharProxy operator[](size_t idx)
{
return CharProxy(*this,idx);
}
public:
String()
: _pstr(new char[5]() + 4)
{
cout << "String()" << endl;
//*(int*(_pstr - 4)) = 1;
initRefcount();
}
String(const char * pstr)
: _pstr(new char[strlen(pstr) + 5]() + 4)
{
strcpy(_pstr,pstr);
//*(int*(_pstr - 4)) = 1;
initRefcount();
cout << "String(const char * pstr)" << endl;
}
String(const String & rhs)
: _pstr(rhs._pstr)
{
increaseRefcount();
cout << "String(const String & rhs)" << endl;
}
String & operator=(const String & rhs)
{
cout << "String & operator=(const String &)" << endl;
if(this!=&rhs)//自复制
{
release();
_pstr = rhs._pstr;//浅拷贝
increaseRefcount();
}
return *this;
}
~String()
{
release();
cout << "~String()" << endl;
}
const char * c_str() const
{
return _pstr;
}
size_t size() const
{
return strlen(_pstr);
}
int refCount() const
{
return *(int*)(_pstr - 4);
}
private:
void initRefcount()
{
*(int*)(_pstr - 4 ) = 1;
}
void increaseRefcount()
{
++*(int*)(_pstr - 4);
}
void decreaseRefcount()
{
--*(int*)(_pstr - 4);
}
void release()
{
decreaseRefcount();
if(refCount() == 0){
delete [] (_pstr-4);
cout << ">> delete heap data!!!" << endl;
}
}
private:
char * _pstr;//永远指向字符串内容本身
};
std::ostream & operator<<(std::ostream & os, const String & rhs)
{
os << rhs._pstr;
return os;
}
char & String::CharProxy::operator=(const char & ch)
{
if(_idx < _self.size()){
char * ptmp = new char[5]() + 4;
strcpy(ptmp,_self._pstr);
_self.decreaseRefcount();
_self._pstr = ptmp;
_self.initRefcount();
_self._pstr[_idx] = ch;
return _self._pstr[_idx];
}
else{
static char nullchar='\0';
return nullchar;
}
}
std::ostream & operator<<(std::ostream & os,const String::CharProxy & rhs)
{
os << rhs._self._pstr[rhs._idx];
return os;
}
int main(void)
{
String s1("hello,world");
String s2 = s1;
cout << "s1 = " << s1 << endl;
cout << "s2 = " << s2 << endl;
cout << "s1's refCount = " << s1.refCount() << endl;
cout << "s2's refCount = " << s2.refCount() << endl;
printf("s1's address = %p\n",s1.c_str());
printf("s2's address = %p\n",s2.c_str());
String s3("hebeihuwan");
cout << ">> 执行String s3 = s1 之后: " << endl;
s3 = s1;
cout << "s3 = " << s3 << endl;
cout << "s3's refCount = " << s3.refCount() << endl;
printf("s3's address = %p\n",s3.c_str());
cout << endl << "对s3[0]执行写操作: " << endl;
s3[0] = 'H';
cout << "s3 = " << s3 << endl;
cout << "s3's refCount = " << s3.refCount() << endl;
printf("s3's address = %p\n",s3.c_str());
cout << endl << "对s1[0]执行读操作:" << endl;
cout << s1[0] << endl;
cout << "s1's refCount = " << s1.refCount() << endl;
cout << "s2's refCount = " << s2.refCount() << endl;
printf("s1's address = %p\n",s1.c_str());
printf("s2's address = %p\n",s2.c_str());
cout << "s3's refCount = " << s3.refCount() << endl;
printf("s3's address = %p\n",s3.c_str());
return 0;
}
| [
"2563965485@qq.com"
] | 2563965485@qq.com |
fd2fcccadc85a8df61dac93b15dc8b0a4e09ddaf | e3b24172bc02528259a328b6ff8908c8315d7dbe | /NewCompositionOptimization/Component.h | 918afebedc9780e65a45106cb7ab9050538a9607 | [] | no_license | TZYhub/NewCompositionOptimization | 289ee3808dc0b2818d5064940912fd8c5d6ab6db | e34ef1a0a339fd9ac6155206b0cfd954f43539bf | refs/heads/master | 2021-01-21T09:59:43.816065 | 2017-06-19T09:40:02 | 2017-06-19T09:40:02 | 91,675,575 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 1,276 | h |
#pragma once
class CComponent
{
public:
CComponent(void);
~CComponent(void);
static void SetComponentFixedValue(const map<CString, float>& mapFixedValue);//设置组分计算的固定系数
//T获取组分截取数组
vector<float> &GetVtComponentRange(){return m_vtComponentRange;}
vector<float>& GetVtComponentBeforeRange(){return m_vtBeforeCalcRange;}
const CString& GetComponentName(){return m_ComponentName;}
const CString& GetStrComponentRange(){return m_strRange;}
void SetComponentName(const CString& cName);
void SetStrComponentRange(const CString& sRange);
float GetBeforeRangeValue(const float afterCalcValue);//T使用计算后的值来查找计算前的截断值，用于显示
protected:
void CStringToFloat(CString str,float &a,float &b,bool bNeedSort=true);//字符串解析为浮点 如“1-2”，a=1.0,b=2.0;
float FindFixedValue();//从m_ComponentFixedValue找到组分对应的固定系数值
protected:
CString m_ComponentName;//T组分名
CString m_strRange;//T取值范围的字符串
vector<float> m_vtBeforeCalcRange;//T计算前的截取值
vector<float> m_vtComponentRange;//T计算后的截取值
static map<CString, float> m_ComponentFixedValue;//T截取值计算时分母使用的固定系数，从配置文件中获取
};
| [
"542382610@qq.com"
] | 542382610@qq.com |
c596548b030c04a39adfb87487689c92b3170110 | 363f0119ce7093c252235fd4827864e017b5732d | /employee.cpp | 9fb2ba918bcea4dc52511178797da0e7ba86a8bc | [] | no_license | KhinHtayKyi/Object-Oriented-Programming-in-CPP | ecd3f7ef051a297a8a6dc6869f7d24dfb082a9a9 | d03450c1900eb2c4e63a1acb91d8247f66add543 | refs/heads/master | 2020-12-03T04:13:33.485096 | 2017-06-30T01:14:22 | 2017-06-30T01:14:22 | 95,834,094 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 592 | cpp | #include<iostream>
#include<string.h>
using namespace std;
class employee
{
char name[20];
int enno;
float comp;
public:
employee()
{
name[0]='\0';
enno=0;
comp=0.0;
}
employee(char s[],int e,float n)
{
strcpy(name,s);
enno=e;
comp=n;
}
void getdata()
{
cout<<"Enter name";
cin.getline(name,20);
cout<<"Enter no and comp";
cin>>enno>>comp;
}
void showdata()
{
cout<<name<<enno<<comp;
}
};
int main()
{
employee e1("David",10,11.5);
employee e2;
e2.getdata();
e1.showdata();
e2.showdata();
} | [
"noreply@github.com"
] | noreply@github.com |
94c5fc809575e8e633d733b6590078ee60d3a67a | 49d9b160dde6917ae8b4ad17e963faeaf7c4daae | /StanfordLibrary/StanfordLibraries/StanfordCPPLib/util/strlib.cpp | e062fc6bbe1f1d2a891d8dac0f01a5fadde78995 | [] | no_license | redls/partIIProject | 854d4b4568e2d7e869cd90bd132bdd55d56c9e73 | 8a1457bba81284c3c5ff0b8f47b43ff547aa5b4d | refs/heads/master | 2021-01-12T15:35:04.472757 | 2016-11-24T19:59:29 | 2016-11-24T19:59:29 | 71,839,554 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 19,853 | cpp | /*
* File: strlib.cpp
* ----------------
* This file implements the strlib.h interface.
*
* @version 2016/10/30
* - alphabetized functions
* - added overloads that take type char instead of string:
* stringContains, stringIndexOf, stringJoin, stringLastIndexOf, stringReplace,
* stringSplit, toLowerCase, toUpperCase
* @version 2016/10/13
* - modified writeQuotedString to return ostream
* @version 2016/08/03
* - modified readQuotedString not to throw error() on parse failures
* (needed to support idiomatic silent-failing >> operators)
* @version 2015/11/07
* - fixed bugs in urlDecode (wasn't decoding % sequences properly, oops)
* @version 2015/10/26
* - added charToInteger/integerToChar functions
* @version 2015/06/19
* - slight bug fix to make stringToInteger functions compile with int radix
* @version 2015/05/22
* - slight bug fix in stringToBool function
* @version 2014/10/31
* - fixed infinite loop bug in stringReplace function
* @version 2014/10/19
* - alphabetized functions
* - added several 'inPlace' variants of existing functions that return strings
* @version 2014/10/08
* - removed 'using namespace' statement
*/
#include "strlib.h"
#include <cctype>
#include <iomanip>
#include <iostream>
#include <sstream>
#include "error.h"
/* Function prototypes */
std::string boolToString(bool b) {
return (b ? "true" : "false");
}
std::string boolToString(int b) {
return (b ? "true" : "false");
}
int charToInteger(char c) {
if (c < '0' || c > '9') {
std::ostringstream out;
out << "charToInteger: character is not numeric: '" << c
<< "' (ASCII value " << (int) c << ")";
error(out.str());
}
return c - '0';
}
std::string charToString(char c) {
std::string s;
s += c;
return s;
}
std::string doubleToString(double d) {
return realToString(d);
}
bool endsWith(const std::string& str, char suffix) {
return str.length() > 0 && str[str.length() - 1] == suffix;
}
bool endsWith(const std::string& str, const std::string& suffix) {
int nChars = suffix.length();
int start = str.length() - nChars;
if (start < 0) return false;
for (int i = 0; i < nChars; i++) {
if (str[start + i] != suffix[i]) return false;
}
return true;
}
/*
* Implementation notes: equalsIgnoreCase
* --------------------------------------
* This implementation uses a for loop to cycle through the characters in
* each string. Converting each string to uppercase and then comparing
* the results makes for a shorter but less efficient implementation.
*/
bool equalsIgnoreCase(const std::string& s1, const std::string& s2) {
if (s1.length() != s2.length()) return false;
int nChars = s1.length();
for (int i = 0; i < nChars; i++) {
if (tolower(s1[i]) != tolower(s2[i])) return false;
}
return true;
}
std::string htmlDecode(const std::string& s) {
std::string result = s;
stringReplaceInPlace(result, "<", "<");
stringReplaceInPlace(result, ">", ">");
stringReplaceInPlace(result, """, "\"");
stringReplaceInPlace(result, "&", "&");
return result;
}
std::string htmlEncode(const std::string& s) {
std::string result = s;
stringReplaceInPlace(result, "&", "&");
stringReplaceInPlace(result, "<", "<");
stringReplaceInPlace(result, ">", ">");
stringReplaceInPlace(result, "\"", """);
return result;
}
char integerToChar(int n) {
if (n < 0 || n > 9) {
std::ostringstream out;
out << "integerToChar: number must be between 0-9: " << n;
error(out.str());
}
return (char) (n + '0');
}
/*
* Implementation notes: numeric conversion
* ----------------------------------------
* These functions use the <sstream> library to perform the conversion.
*/
std::string integerToString(int n, int radix) {
if (radix <= 0) {
error("integerToString: Illegal radix: " + integerToString(radix));
}
std::ostringstream stream;
if (radix != 10) {
stream << std::setbase(radix);
}
stream << n;
return stream.str();
}
std::string longToString(long n, int radix) {
if (radix <= 0) {
error("longToString: Illegal radix: " + integerToString(radix));
}
std::ostringstream stream;
if (radix != 10) {
stream << std::setbase(radix);
}
stream << n;
return stream.str();
}
std::string pointerToString(void* p) {
if (p) {
std::ostringstream stream;
stream << std::hex;
stream << "0x" << p;
return stream.str();
} else {
return "NULL";
}
}
std::string realToString(double d) {
std::ostringstream stream;
stream << std::uppercase << d;
return stream.str();
}
bool startsWith(const std::string& str, char prefix) {
return str.length() > 0 && str[0] == prefix;
}
bool startsWith(const std::string& str, const std::string& prefix) {
if (str.length() < prefix.length()) return false;
int nChars = prefix.length();
for (int i = 0; i < nChars; i++) {
if (str[i] != prefix[i]) return false;
}
return true;
}
bool stringIsBool(const std::string& str) {
return str == "true" || str == "false";
}
bool stringIsDouble(const std::string& str) {
return stringIsReal(str);
}
bool stringIsInteger(const std::string& str, int radix) {
if (radix <= 0) {
error("stringIsInteger: Illegal radix: " + integerToString(radix));
}
std::istringstream stream(trim(str));
stream >> std::setbase(radix);
int value;
stream >> value;
return !(stream.fail() || !stream.eof());
}
bool stringIsLong(const std::string& str, int radix) {
if (radix <= 0) {
error("stringIsLong: Illegal radix: " + integerToString(radix));
}
std::istringstream stream(trim(str));
stream >> std::setbase(radix);
long value;
stream >> value;
return !(stream.fail() || !stream.eof());
}
bool stringIsReal(const std::string& str) {
std::istringstream stream(trim(str));
double value;
stream >> value;
return !(stream.fail() || !stream.eof());
}
bool stringContains(const std::string& s, char ch) {
return s.find(ch) != std::string::npos;
}
bool stringContains(const std::string& s, const std::string& substring) {
return s.find(substring) != std::string::npos;
}
int stringIndexOf(const std::string& s, char ch, int startIndex) {
size_t index = s.find(ch, (size_t) startIndex);
if (index == std::string::npos) {
return -1;
} else {
return index;
}
}
int stringIndexOf(const std::string& s, const std::string& substring, int startIndex) {
size_t index = s.find(substring, (size_t) startIndex);
if (index == std::string::npos) {
return -1;
} else {
return index;
}
}
std::string stringJoin(const std::vector<std::string>& v, char delimiter) {
std::string delim = charToString(delimiter);
return stringJoin(v, delim);
}
std::string stringJoin(const std::vector<std::string>& v, const std::string& delimiter) {
if (v.empty()) {
return "";
} else {
std::ostringstream out;
out << v[0];
for (int i = 1; i < (int) v.size(); i++) {
out << delimiter;
out << v[i];
}
return out.str();
}
}
int stringLastIndexOf(const std::string& s, char ch, int startIndex) {
size_t index = s.rfind(ch, (size_t) startIndex);
if (index == std::string::npos) {
return -1;
} else {
return index;
}
}
int stringLastIndexOf(const std::string& s, const std::string& substring, int startIndex) {
size_t index = s.rfind(substring, (size_t) startIndex);
if (index == std::string::npos) {
return -1;
} else {
return index;
}
}
std::string stringReplace(const std::string& str, char old, char replacement, int limit) {
std::string str2 = str;
stringReplaceInPlace(str2, old, replacement, limit);
return str2;
}
std::string stringReplace(const std::string& str, const std::string& old, const std::string& replacement, int limit) {
std::string str2 = str;
stringReplaceInPlace(str2, old, replacement, limit);
return str2;
}
int stringReplaceInPlace(std::string& str, char old, char replacement, int limit) {
int count = 0;
for (size_t i = 0, len = str.length(); i < len; i++) {
if (str[i] == old) {
str[i] = replacement;
count++;
if (limit > 0 && count >= limit) {
break;
}
}
}
return count;
}
int stringReplaceInPlace(std::string& str, const std::string& old, const std::string& replacement, int limit) {
int count = 0;
size_t startIndex = 0;
size_t rlen = replacement.length();
while (limit <= 0 || count < limit) {
size_t index = str.find(old, startIndex);
if (index == std::string::npos) {
break;
}
str.replace(index, old.length(), replacement);
startIndex = index + rlen;
count++;
}
return count;
}
std::vector<std::string> stringSplit(const std::string& str, char delimiter, int limit) {
std::string delim = charToString(delimiter);
return stringSplit(str, delim, limit);
}
std::vector<std::string> stringSplit(const std::string& str, const std::string& delimiter, int limit) {
std::string str2 = str;
std::vector<std::string> result;
int count = 0;
size_t index = 0;
while (limit < 0 || count < limit) {
index = str2.find(delimiter);
if (index == std::string::npos) {
break;
}
result.push_back(str2.substr(0, index));
str2.erase(str2.begin(), str2.begin() + index + delimiter.length());
count++;
}
if ((int) str2.length() > 0) {
result.push_back(str2);
}
return result;
}
bool stringToBool(const std::string& str) {
std::istringstream stream(trim(str));
if (str == "true" || str == "1") {
return true;
} else if (str == "false" || str == "0") {
return false;
}
bool value;
stream >> std::boolalpha >> value;
if (stream.fail() || !stream.eof()) {
error("stringToBool: Illegal bool format (" + str + ")");
}
return value;
}
char stringToChar(const std::string& str) {
std::string str2 = trim(str);
if ((int) str2.length() != 1) {
error("stringToChar: string must contain exactly 1 non-whitespace character");
}
return str2[0];
}
double stringToDouble(const std::string& str) {
return stringToReal(str);
}
int stringToInteger(const std::string& str, int radix) {
if (radix <= 0) {
error("stringToInteger: Illegal radix: " + integerToString(radix));
}
std::istringstream stream(trim(str));
stream >> std::setbase(radix);
int value;
stream >> value;
if (stream.fail() || !stream.eof()) {
error("stringToInteger: Illegal integer format: \"" + str + "\"");
}
return value;
}
long stringToLong(const std::string& str, int radix) {
if (radix <= 0) {
error("stringToLong: Illegal radix: " + integerToString(radix));
}
std::istringstream stream(trim(str));
stream >> std::setbase(radix);
long value;
stream >> value;
if (stream.fail() || !stream.eof()) {
error("stringToLong: Illegal long format \"" + str + "\"");
}
return value;
}
double stringToReal(const std::string& str) {
std::istringstream stream(trim(str));
double value;
stream >> value;
if (stream.fail() || !stream.eof()) {
error("stringToReal: Illegal floating-point format (" + str + ")");
}
return value;
}
char toLowerCase(char ch) {
return (char) tolower(ch);
}
std::string toLowerCase(const std::string& str) {
std::string str2 = str;
toLowerCaseInPlace(str2);
return str2;
}
void toLowerCaseInPlace(std::string& str) {
int nChars = str.length();
for (int i = 0; i < nChars; i++) {
str[i] = tolower(str[i]);
}
}
char toUpperCase(char ch) {
return (char) toupper(ch);
}
std::string toUpperCase(const std::string& str) {
std::string str2 = str;
toUpperCaseInPlace(str2);
return str2;
}
void toUpperCaseInPlace(std::string& str) {
int nChars = str.length();
for (int i = 0; i < nChars; i++) {
str[i] = toupper(str[i]);
}
}
std::string trim(const std::string& str) {
std::string str2 = str;
trimInPlace(str2);
return str2;
}
void trimInPlace(std::string& str) {
trimEndInPlace(str);
trimStartInPlace(str);
}
std::string trimEnd(const std::string& str) {
std::string str2 = str;
trimEndInPlace(str2);
return str2;
}
void trimEndInPlace(std::string& str) {
int end = (int) str.length();
int finish = end;
while (finish > 0 && isspace(str[finish - 1])) {
finish--;
}
if (finish < end) {
str.erase(finish, end - finish);
}
}
std::string trimStart(const std::string& str) {
std::string str2 = str;
trimStartInPlace(str2);
return str2;
}
void trimStartInPlace(std::string& str) {
int start = 0;
int finish = (int) str.length() - 1;
while (start <= finish && isspace(str[start])) {
start++;
}
if (start > 0) {
str.erase(0, start);
}
}
std::string urlDecode(const std::string& str) {
std::ostringstream unescaped;
for (std::string::const_iterator i = str.begin(), n = str.end(); i != n; ++i) {
std::string::value_type c = (*i);
if (isalnum(c) || c == '-' || c == '_' || c == '.' || c == '~' || c == '*') {
unescaped << c;
} else if (c == '+') {
unescaped << ' ';
} else if (c == '%') {
// decode a URL-encoded ASCII character, e.g. %40 => &
// TODO: fails if string is invalid and doesn't have 2 char after %
// or if it has non-hex chars here
char ch1 = *(i + 1);
char ch2 = *(i + 2);
int hex1 = (isdigit(ch1) ? (ch1 - '0') : (toupper(ch1) - 'A' + 10));
int hex2 = (isdigit(ch2) ? (ch2 - '0') : (toupper(ch2) - 'A' + 10));
int decodedChar = (hex1 << 4) + hex2;
unescaped << (char) decodedChar;
i += 2;
} else {
std::ostringstream msg;
msg << "urlDecode: Unexpected character in string: "
<< (int) c << " (" << (char) c << ")";
error(msg.str());
}
}
return unescaped.str();
}
void urlDecodeInPlace(std::string& str) {
str = urlDecode(str); // no real efficiency gain here
}
std::string urlEncode(const std::string& str) {
std::ostringstream escaped;
escaped.fill('0');
escaped << std::hex << std::uppercase;
for (std::string::const_iterator i = str.begin(), n = str.end(); i != n; ++i) {
std::string::value_type c = (*i);
if (isalnum(c) || c == '-' || c == '_' || c == '.' || c == '~' || c == '*') {
escaped << c;
} else if (c == ' ') {
escaped << '+';
} else {
escaped << '%' << std::setw(2) << ((int) c) << std::setw(0);
}
}
return escaped.str();
}
void urlEncodeInPlace(std::string& str) {
str = urlEncode(str); // no real efficiency gain here
}
/*
* Implementation notes: readQuotedString and writeQuotedString
* ------------------------------------------------------------
* Most of the work in these functions has to do with escape sequences.
*/
static const std::string STRING_DELIMITERS = ",:)}]\n";
bool stringNeedsQuoting(const std::string& str) {
int n = str.length();
for (int i = 0; i < n; i++) {
char ch = str[i];
if (isspace(ch)) return false;
if (STRING_DELIMITERS.find(ch) != std::string::npos) return true;
}
return false;
}
bool readQuotedString(std::istream& is, std::string& str, bool throwOnError) {
str = "";
char ch;
while (is.get(ch) && isspace(ch)) {
/* Empty */
}
if (is.fail()) {
return true; // empty string?
}
if (ch == '\'' || ch == '"') {
char delim = ch;
while (is.get(ch) && ch != delim) {
if (is.fail()) {
if (throwOnError) {
error("Unterminated string");
}
return false;
}
if (ch == '\\') {
if (!is.get(ch)) {
if (throwOnError) {
error("Unterminated string");
}
is.setstate(std::ios_base::failbit);
return false;
}
if (isdigit(ch) || ch == 'x') {
int maxDigits = 3;
int base = 8;
if (ch == 'x') {
base = 16;
maxDigits = 2;
}
int result = 0;
int digit = 0;
for (int i = 0; i < maxDigits && ch != delim; i++) {
if (isdigit(ch)) {
digit = ch - '0';
} else if (base == 16 && isxdigit(ch)) {
digit = toupper(ch) - 'A' + 10;
} else {
break;
}
result = base * result + digit;
if (!is.get(ch)) {
if (throwOnError) {
error("Unterminated string");
}
is.setstate(std::ios_base::failbit);
return false;
}
}
ch = char(result);
is.unget();
} else {
switch (ch) {
case 'a': ch = '\a'; break;
case 'b': ch = '\b'; break;
case 'f': ch = '\f'; break;
case 'n': ch = '\n'; break;
case 'r': ch = '\r'; break;
case 't': ch = '\t'; break;
case 'v': ch = '\v'; break;
case '"': ch = '"'; break;
case '\'': ch = '\''; break;
case '\\': ch = '\\'; break;
}
}
}
str += ch;
}
} else {
str += ch;
int endTrim = 0;
while (is.get(ch) && STRING_DELIMITERS.find(ch) == std::string::npos) {
str += ch;
if (!isspace(ch)) endTrim = str.length();
}
if (is) is.unget();
str = str.substr(0, endTrim);
}
return true; // read successfully
}
std::ostream& writeQuotedString(std::ostream& os, const std::string& str, bool forceQuotes) {
if (!forceQuotes && stringNeedsQuoting(str)) {
forceQuotes = true;
}
if (forceQuotes) {
os << '"';
}
int len = str.length();
for (int i = 0; i < len; i++) {
char ch = str.at(i);
switch (ch) {
case '\a': os << "\\a"; break;
case '\b': os << "\\b"; break;
case '\f': os << "\\f"; break;
case '\n': os << "\\n"; break;
case '\r': os << "\\r"; break;
case '\t': os << "\\t"; break;
case '\v': os << "\\v"; break;
case '\\': os << "\\\\"; break;
default:
if (isprint(ch) && ch != '"') {
os << ch;
} else {
std::ostringstream oss;
oss << std::oct << std::setw(3) << std::setfill('0') << (int(ch) & 0xFF);
os << "\\" << oss.str();
}
}
}
if (forceQuotes) {
os << '"';
}
return os;
}
| [
"laura.nechita@gmail.com"
] | laura.nechita@gmail.com |
e6e3e01789bddf9de9070c8d297ba7ac20e8e367 | db73d29b17fae08c348deec15d8c7c3851f2e53e | /week 6/pdf - divide & conquer/cal_pow.cpp | 6378631e3aaf31b63a4126865a7fa778f2334aa7 | [] | no_license | deekshikatomar/IPMP1921 | 839539432f7a78b124e42c0c1a53aabb749364b5 | a4193d9605d17d006511b986b0b6ca9689711b61 | refs/heads/main | 2023-06-03T10:28:48.257743 | 2021-06-19T18:14:39 | 2021-06-19T18:14:39 | 354,489,609 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 372 | cpp | #include<iostream>
using namespace std;
class gfg
{
public:
int power(int x, unsigned int y)
{
if (y == 0)
return 1;
else if (y % 2 == 0)
return power(x, y / 2) * power(x, y / 2);
else
return x * power(x, y / 2) * power(x, y / 2);
}
};
int main()
{
gfg g;
int x = 2;
unsigned int y = 3;
cout << g.power(x, y);
return 0;
}
| [
"noreply@github.com"
] | noreply@github.com |
13c18b3b1f5ead954ffd7361c0fc88dabc3f189f | de9da6df2dce129358e7e4096bb6417c18398c64 | /src/format_parser.cpp | f75a75fca6926d62bcc45242cd9f3adfe0fd7f03 | [
"MIT"
] | permissive | dejak/olc-overlapping | eda1ca47dfa010f022c9b8f26b25bf4131d24a03 | 0437f2390883dec0164313d67121d90eccedbec2 | refs/heads/master | 2021-01-20T05:57:20.066854 | 2017-06-14T22:58:02 | 2017-06-14T22:58:02 | 25,027,340 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 362 | cpp | #include "format_parser.hpp"
#include <random>
namespace OLC
{
NucleotideLetter FormatParser::getRandomNucleotide() const
{
std::random_device rd;
std::mt19937 generator(rd());
std::uniform_int_distribution<> distribution(0, 3);
const uint32_t randomNucleotide = distribution(generator);
return static_cast<NucleotideLetter>(randomNucleotide);
}
}
| [
"josko.nikolic1@gmail.com"
] | josko.nikolic1@gmail.com |
b2bda8921d7e44dd1e8e304b3f67b0793268bd55 | ffecaf1febe33301eaa0de1fca37ff3064281920 | /exercicio43c.cpp | 322d6d3f8214d9b4758fec9dd9e33295b8b0cc7f | [] | no_license | saah974/PracticingC-- | a3d0083489344478cd8a60f4129be56ca14c3e57 | 52f82b78ca9cc4957eaed855ea38dc20b805fbf3 | refs/heads/main | 2023-05-27T14:35:53.543783 | 2021-06-23T01:05:45 | 2021-06-23T01:05:45 | 379,427,881 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 308 | cpp | #include <iostream>
#include <locale.h>
using namespace std;
main(int argc, char** argv){
setlocale(LC_ALL, "Portuguese");
int cont=30;
while(cont>=1){
if(cont%4 == 0){
cout << "[" << cont << "]\n";
}
else
cout << cont << "\n";
cont = cont - 1;
}
cout << "Acabou!";
return 0;
}
| [
"sabrina.souza07@hotmail.com"
] | sabrina.souza07@hotmail.com |
3d1c310076cc8bee37090a6248c1e444b4f7f58a | 3385ba68527b52bfdb5d21d14b4757034f2daad1 | /lcs.cpp | 897984d11cb68fd2e185f6be8793a124f17273dd | [] | no_license | etotientz/Codechef_all | 7735440c437befa3a27a288827b9ee0828f19796 | c295e61eafd6d69b29fda2963ff3fc1749dda263 | refs/heads/master | 2020-12-24T05:48:19.698696 | 2016-06-16T12:07:57 | 2016-06-16T12:07:57 | 42,110,887 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 555 | cpp | #include<bits/stdc++.h>
using namespace std;
int max(int a,int b)
{
return (a>b)?a:b;
}
int lcs[101][101];
int findlcs(char *a,char *b,int m,int n)
{
for(int i=0;i<=m;i++)
lcs[i][0]=0;
for(int i=0;i<=n;i++)
lcs[0][i]=0;
for(int i=1;i<=m;i++)
{
for(int j=1;j<=n;j++)
{
if(a[i]==b[j])
lcs[i][j]=1+lcs[i-1][j-1];
else
lcs[i][j]=max(lcs[i-1][j],lcs[i][j-1]);;
}
}
return lcs[m][n];
}
int main()
{
char a[101],b[101],m,n,ans;
scanf("%s%s",a,b);
m=strlen(a);
n=strlen(b);
ans=findlcs(a,b,m,n);
printf("%d",ans);
return 0;
}
| [
"satraprathore@gmail.com"
] | satraprathore@gmail.com |
a697db8fb45003b2f57a17c0b67d2cc714756b99 | f2c3250674d484b91dd9385d7fac50017b034e4b | /others/百度之星初赛1/A.cpp | e10eb8078880496f54d0a3e8e502a40501ec6033 | [] | no_license | DQSSSSS/Algorithm-Competition-Code | a01d4e8b3a9b9da02a400eb5bb4e063eaade33c9 | 574a0806fadf1433fcb4fac4489a237c58daab3c | refs/heads/master | 2023-01-06T06:17:12.295671 | 2020-11-11T22:44:41 | 2020-11-11T22:44:41 | 309,434,336 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 955 | cpp | #include<bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef long double LD;
typedef pair<int,int> pii;
const int SZ = 200010;
const int INF = 1e9 + 10;
const int mod = 998244353;
const LD eps = 1e-8;
LL read() {
LL n = 0;
char a = getchar();
bool flag = 0;
while(a > '9' || a < '0') { if(a == '-') flag = 1; a = getchar(); }
while(a <= '9' && a >= '0') { n = n * 10 + a - '0',a = getchar(); }
if(flag) n = -n;
return n;
}
int n,a[SZ];
int main() {
while(~scanf("%d",&n)) {
for(int i = 1;i <= n;i ++) a[i] = read();
sort(a + 1,a + 1 + n);
int ans = -1;
for(int i = 1;i <= n;i ++) {
for(int j = i + 1;j <= n;j ++) {
int x = a[i] + a[j];
int id = lower_bound(a + j + 1,a + n + 1,x) - a;
id --;
if(id > j)
ans = max(ans,x + a[id]);
}
}
cout << ans << endl;
}
return 0;
}
| [
"1053181679@qq.com"
] | 1053181679@qq.com |
d51b1459946d8298240999e1278080c5ede51a62 | 0a9854217f953f5b973be91556dcc70df103a471 | /Practicos-Prog-III/Parcial 1/Ejercicio 1/priorityQueue.cpp | d742124810be6702535c195dfeb7c6997cd37644 | [] | no_license | NicoGangi5/Programacion_III | 4d4bad417566b67ce1fda27f35cdd66985c85cbf | 0578b43f73d65c3d5703700c293de9c7c7830bbc | refs/heads/main | 2023-02-02T19:47:19.241233 | 2020-12-15T14:52:43 | 2020-12-15T14:52:43 | 212,640,902 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 74 | cpp | //
// Created by Nico Gangi on 09/10/2019.
//
#include "priorityQueue.h"
| [
"nicogangi@gmail.com"
] | nicogangi@gmail.com |
2e262bfd2ba84d157c4b23e4b5aa1abaeb7c9b83 | 8d953b8783bc94e835b092c72370ff7f4ead90dc | /Source/Gunslinger/Public/InventoryInterface.h | ede8a57ba8d337786587b0365b1f70f0866bd7ff | [] | no_license | mvoitkevics/Gunslinger | c9c906f56f4be15e94d05aac87b75baea4a899a2 | e7ed0a8458416df0fdf87cd6a3af5b0b6decebe6 | refs/heads/master | 2023-06-01T03:18:42.895253 | 2021-06-28T10:43:52 | 2021-06-28T10:43:52 | 237,199,313 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 527 | h | // Fill out your copyright notice in the Description page of Project Settings.
#pragma once
#include "Gunslinger.h"
#include "UObject/Interface.h"
#include "InventoryInterface.generated.h"
// This class does not need to be modified.
UINTERFACE(MinimalAPI)
class UInventoryInterface : public UInterface
{
GENERATED_BODY()
};
/**
*
*/
class GUNSLINGER_API IInventoryInterface
{
GENERATED_BODY()
// Add interface functions to this class. This is the class that will be inherited to implement this interface.
public:
};
| [
"maksims.voitkevichs@hotmail.com"
] | maksims.voitkevichs@hotmail.com |
0e1c48e192126c68defc0d5bb0b74616eac3747a | aec7f94b82706bccc64aaff8cb050db972145a34 | /AMAN/schedulers.h | 329b9a590929c359f6e188668e5767161ea6c435 | [] | no_license | muali/AMAN-DMAN | 2399337f2edac5c3d4d4888a875994b95346df8b | 3dbeb80607fc3cd7d4fe47213612469f64cef0c6 | refs/heads/master | 2020-04-26T01:51:05.777460 | 2016-02-15T11:00:34 | 2016-02-15T11:00:34 | 32,746,923 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,351 | h | #pragma once
#include "aircraft.h"
#include "input_data.h"
#include "schedule.h"
#include <vector>
#include <memory>
namespace AMAN
{
//-------------------------------------------------------------------------------------
struct scheduler
{
virtual schedule do_scheduling(const input_data&, const std::vector<aircraft>& sequence) const = 0;
virtual ~scheduler() = default;
};
//-------------------------------------------------------------------------------------
struct estimator
{
estimator(std::shared_ptr<scheduler>);
double estimate(const input_data&, std::vector<aircraft> sequence) const;
private:
std::shared_ptr<scheduler> p_scheduler_;
};
struct greedy_scheduler
: scheduler
{
schedule do_scheduling(const input_data&, const std::vector<aircraft>& sequence) const override;
};
//-------------------------------------------------------------------------------------
struct dp_scheduler
: scheduler
{
dp_scheduler(uint64_t time_sampling);
schedule do_scheduling(const input_data&, const std::vector<aircraft>& sequence) const override;
};
//-------------------------------------------------------------------------------------
struct linear_scheduler
: scheduler
{
schedule do_scheduling(const input_data&, const std::vector<aircraft>& sequence) const override;
};
} // AMAN | [
"m-moskvitin92@yandex.ru"
] | m-moskvitin92@yandex.ru |
e5526b56a14e6aeb24aedd580630cd43c574c511 | 71139ac0e49209af20baf3fe88456912482c86f2 | /types/dynamic/format-arg.hh | cedfe4504e232f3bdb220e77a5b7919d7931b3bc | [] | no_license | sjolsen/sbcl-format-port | 8dc32c648d67d80d659115ac0a855bace3bd1820 | e447913862718ffc5267f1ab28b40d625ae73472 | refs/heads/master | 2021-01-10T19:16:22.482070 | 2015-07-28T04:06:13 | 2015-07-28T04:06:13 | 38,029,236 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 385 | hh | #ifndef TYPES_DYNAMIC_FORMAT_ARG_HH
#define TYPES_DYNAMIC_FORMAT_ARG_HH
#include "vtable.hh"
class format_arg
{
protected:
const void* _arg;
const vtable_t* _vtable;
public:
template <typename T>
format_arg (const T& obj)
: _arg (&obj),
_vtable (&vtable_instance <T>::instance)
{
}
void print (writable& w) const {
_vtable->print_object (_arg, w);
}
};
#endif
| [
"so1132@txstate.edu"
] | so1132@txstate.edu |
a27fee9e54ec42174be4ab0ef227f0a310ae0dd4 | fef4e595750c0c68b38613adc6d5aba740d995f0 | /PASS/Lab9(PASS).cpp | 4db29631c8b55fe4702a073b87e2aed1e5c9f8f1 | [] | no_license | DiasDogalakov/PP1_fall-spring2020 | 851ab09cb6fe26a677fa6461a3d7904e4a4d276a | 586d0105b0ec699a60ed8a753804878078cb7397 | refs/heads/main | 2023-01-27T22:08:05.025442 | 2020-12-06T22:42:22 | 2020-12-06T22:42:22 | 319,144,842 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,354 | cpp | // Lab 9
// A
#include<iostream>
#include<algorithm>
using namespace std;
int main(){
int n;
pair<int, int> a[2222];
cin >> n;
for(int i = 0; i < n; ++i)
cin >> a[i].first >> a[i].second;
sort(a, a + n);
for(int i = 0; i < n; ++i)
cout << a[i].first << " " << a[i].second << "\n";
return 0;
}
// B
#include<iostream>
#include<algorithm>
using namespace std;
bool cmp(int a, int b)
{
if(a % 2 == 0 && b % 2 == 1) return true;
if(b % 2 == 0 && a % 2 == 1) return false;
if(a % 2 == 0 && b % 2 == 0) return b < a;
if(a % 2 == 1 && b % 2 == 1) return a < b;
}
int main()
{
int n;
int a[111];
cin >> n;
for(int i = 0; i < n; ++i)
cin >> a[i];
sort(a, a + n, cmp);
for(int i = 0; i < n; ++i)
cout << a[i] << " ";
return 0;
}
// C
#include<iostream>
#include<map>
using namespace std;
int main()
{
int n;
map<int, int> q;
cin >> n;
for(int i = 0; i < n; ++i)
{
int x;
cin >> x;
q[x]++;
}
int ans = 0;
for(map<int, int> :: iterator it = q.begin(); it !=q.end(); ++it)
{
if(it->second > 1) ans++;
}
cout << ans << "\n";
return 0;
}
// D
#include<iostream>
#include<map>
using namespace std;
int main()
{
int n, k;
map<int, int> q;
cin >> n >> k;
for(int i = 0; i < n; ++i)
{
int x;
cin >> x;
q[x]++;
}
cout << q[k] << "\n";
return 0;
}
// E
#include<iostream>
#include<map>
using namespace std;
int main()
{
int n;
map<string, int> q;
cin >> n;
for(int i = 0; i < n; ++i){
string s;
cin >> s;
q[s]++;
}
int ans = 0;
for(map<string,int> :: iterator it = q.begin(); it != q.end(); ++it)
{
if(it->second == 3) ans++;
}
cout << ans << "\n";
return 0;
}
// F
#include<iostream>
#include<stack>
using namespace std;
int main(){
string s;
stack<char> st;
cin >> s;
for(int i = 0; i < (int)s.size(); ++i)
{
if(s[i] == ’(’) st.push(’(’);
else if(s[i] == ’)’)
{
if(st.size() == 0)
{
cout << "NO\n";
return 0;
}
else if(st.top() == ’)’)
{
cout << "NO\n";
return 0;
}
else st.pop();
}
}
if(st.size() == 0)
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
// G
#include<iostream>
#include<stack>
using namespace std;
int main(){
string s;
stack<char> st;
cin >> s;
for(int i = 0; i < s.size(); ++i)
{
if(!st.size())
st.push(s[i]);
else if(st.top() == ’1’ && s[i] == ’1’)
{
st.pop();
}
else st.push(s[i]);
}
string ans = "";
while(st.size()){
ans += st.top();
st.pop();
}
for(int i = (int)ans.size() - 1; i >= 0; --i)
cout << ans[i];
return 0;
}
// H
#include<iostream>
#include<map>
using namespace std;
int main()
{
int n;
map<string, int> q;
cin >> n;
for(int i = 1; i <= n; ++i)
{
string s;
cin >> s;
if(!q[s])
q[s] = i;
}
for(map<string, int> :: iterator it = q.begin(); it != q.end(); ++it)
{
cout << it->first << " " << it->second << "\n";
}
return 0;
}
// I
#include<iostream>
#include<map>
using namespace std;
int main()
{
int n;
map<string, int> q;
cin >> n;
for(int i = 0; i < n; ++i)
{
string s;
cin >> s;
if(q[s] == 1)
cout << "user already exists\n";
else
cout << "new user added\n";
q[s] = 1;
}
return 0;
}
// J
#include <iostream>
#include <map>
using namespace std;
int main()
{
int n;
map<string, int> q;
cin >> n;
for(int i = 0; i < n; ++i)
{
string s;
int k;
cin >> s >> k;
q[s] += k;
}
for(map<string,int> :: iterator it = q.begin(); it != q.end(); ++it)
{
cout << it->first << " " << it->second << "\n";
}
return 0;
}
// L
#include<iostream>
#include<algorithm>
using namespace std;
int main()
{
int n;
pair<int, int> a[555];
cin >> n;
for(int i = 0; i < n; ++i)
{
int x, y;
cin >> x >> y;
a[i].first = x + y;
a[i].second = i + 1;
}
sort(a, a + n);
for(int i = 0; i < n; ++i)
cout << a[i].second << " ";
return 0;
}
// M
#include<iostream>
#include<queue>
using namespace std;
int main()
{
int n;
queue<string> q;
cin >> n;
for(int i = 0; i < n; ++i)
{
int type;
cin >> type;
if(type == 2)
q.pop();
else
{
string s;
cin >> s;
q.push(s);
}
if(!q.empty())
cout << q.front() << "\n";
else
cout << "queue is empty\n";
}
return 0;
}
// N
#include<iostream>
#include<map>
using namespace std;
int main()
{
int n;
int a[1111];
map<int, int> q;
cin >> n;
for(int i = 0; i < n; ++i)
{
cin >> a[i];
q[a[i]] = 1;
}
int ans = 0;
for(int i = 0; i < n; ++i)
{
for(int j = 0; j < i; ++j)
if(q[a[i]^a[j]])
ans++;
}
cout << ans << "\n";
return 0;
}
// O
#include<iostream>
#include<map>
using namespace std;
int main()
{
int n, m;
map<string, string> q;
cin >> n;
for(int i = 0; i < n; ++i)
{
string login, password;
cin >> login >> password;
q[login] = password;
}
cin >> m;
while(m--)
{
string login, password;
cin >> login >> password;
if(!q.count(login))
cout << "login error\n";
else if(q[login] != password)
cout << "password error\n";
else
cout << "correct password\n";
}
return 0;
} | [
"noreply@github.com"
] | noreply@github.com |
291653ad1532b79561a6c27bf8b6766b282becc1 | 1c0f4d6f20270af9cf40633246d8aa741f1c575c | /Source/Roguelike3D/EnemySpawnPlace.cpp | d45d52232c61c04e7aee27edccf25e48fc120faa | [] | no_license | shield1203/Roguelike3D | c39e8e53d852bc68dbc5ee1dbf65d790e47b50d9 | 023ae0cb4da6abd305d66cb78f32e7d1c760be0a | refs/heads/master | 2023-03-10T15:36:44.898672 | 2021-02-28T17:46:26 | 2021-02-28T17:46:26 | 327,898,457 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,658 | cpp | #include "EnemySpawnPlace.h"
#include "Components/SceneComponent.h"
#include "Components/SphereComponent.h"
#include "Particles/ParticleSystemComponent.h"
#include "Components/AudioComponent.h"
#include "Sound/SoundCue.h"
#include "Kismet/GameplayStatics.h"
#include "TimerManager.h"
#include "Roguelike3DCharacter.h"
#include "EnemyBase.h"
#include "ChapterGameMode.h"
#include "ChapterAssetManager.h"
AEnemySpawnPlace::AEnemySpawnPlace()
{
PrimaryActorTick.bCanEverTick = true;
m_spawnEnemy = false;
m_spawnFinished = false;
m_sceneCompoent = CreateDefaultSubobject<USceneComponent>(TEXT("EnemySpawnPlaceSceneComponent"));
RootComponent = m_sceneCompoent;
m_collisionComponent = CreateDefaultSubobject<USphereComponent>(TEXT("EnemySpawnPlaceCollisionComponent"));
m_collisionComponent->SetupAttachment(RootComponent);
m_collisionComponent->SetSphereRadius(500.f);
m_collisionComponent->SetGenerateOverlapEvents(true);
m_collisionComponent->OnComponentBeginOverlap.AddDynamic(this, &AEnemySpawnPlace::OnPlayerInRange);
m_particleComponent = CreateDefaultSubobject<UParticleSystemComponent>(TEXT("EnemyspawnParticleComponent"));
m_particleComponent->SetupAttachment(RootComponent);
static ConstructorHelpers::FObjectFinder<UParticleSystem> EnemySpawnParticleAsset(TEXT("/Game/TandP/Teleportation/Particle/P_EnemySpawn"));
if (EnemySpawnParticleAsset.Succeeded())
{
m_particleComponent->SetTemplate(EnemySpawnParticleAsset.Object);
}
m_audioComponent = CreateDefaultSubobject<UAudioComponent>(TEXT("EnemySpawnAudioComponent"));
static ConstructorHelpers::FObjectFinder<USoundCue>EnemySpawnSound(TEXT("SoundCue'/Game/Resource/Sound/EnemySpawn_Cue.EnemySpawn_Cue'"));
if (EnemySpawnSound.Succeeded())
{
m_audioComponent->SetSound(EnemySpawnSound.Object);
}
m_audioComponent->bAutoActivate = false;
}
void AEnemySpawnPlace::BeginPlay()
{
Super::BeginPlay();
m_particleComponent->SetActive(false);
AChapterGameMode* pGameMode = Cast<AChapterGameMode>(UGameplayStatics::GetGameMode(GetWorld()));
if (pGameMode)
{
pGameMode->AddEnemyCount(m_mapNumber);
}
}
void AEnemySpawnPlace::Tick(float DeltaTime)
{
Super::Tick(DeltaTime);
}
void AEnemySpawnPlace::OnPlayerInRange(class UPrimitiveComponent* OverlappedComp, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult)
{
ARoguelike3DCharacter* pPlayerPawn = Cast<ARoguelike3DCharacter>(OtherActor);
if (pPlayerPawn != nullptr && !m_spawnEnemy)
{
m_spawnEnemy = true;
GetWorldTimerManager().SetTimer(m_enemySpawnTimerHandle, this, &AEnemySpawnPlace::EnemySpawnFinished, 2.5f, true);
UWorld* pWorld = GetWorld();
if (pWorld)
{
AChapterGameMode* pGameMode = Cast<AChapterGameMode>(UGameplayStatics::GetGameMode(pWorld));
if (pGameMode)
{
m_particleComponent->SetActive(true);
m_collisionComponent->SetCollisionEnabled(ECollisionEnabled::NoCollision);
FActorSpawnParameters SpawnParams;
SpawnParams.Owner = this;
SpawnParams.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AdjustIfPossibleButAlwaysSpawn;
AEnemyBase* pEnemy = pWorld->SpawnActor<AEnemyBase>(pGameMode->GetChapterAssetManager()->GetEnemyBlueprintClass(static_cast<uint8>(m_spawnEnemyCode)), GetActorLocation(), GetActorRotation(), SpawnParams);
pEnemy->SetMapNumber(m_mapNumber);
m_audioComponent->Play();
}
}
}
}
void AEnemySpawnPlace::EnemySpawnFinished()
{
if (m_spawnFinished)
{
GetWorldTimerManager().ClearTimer(m_enemySpawnTimerHandle);
Destroy();
}
else
{
m_spawnFinished = true;
m_particleComponent->SetActive(false);
}
} | [
"shield1203@naver.com"
] | shield1203@naver.com |
8547936241d2b6d25c172cf13d1415ba7519f283 | 36fbe3af801e12ee419167b6cd351da0f7b5cd7a | /myexample/include/G01PhysicsList.hh | a36b06fd5391527ddd3a0aa5f4b93a3331e2853c | [] | no_license | thwillia/firstrepo | b2021ba36dd332e2c2cb34788bbe46f5d2368b3d | 7997ba25992261fb9922f0570fd86b523f9b5bb0 | refs/heads/master | 2021-01-22T02:05:00.656598 | 2014-09-30T11:08:44 | 2014-09-30T11:08:44 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,556 | hh | //
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
// $Id: G01PhysicsList.hh 66241 2012-12-13 18:34:42Z gunter $
//
//
#ifndef G01PhysicsList_h
#define G01PhysicsList_h 1
#include "G4VUserPhysicsList.hh"
#include "globals.hh"
class G01PhysicsList: public G4VUserPhysicsList
{
public:
G01PhysicsList();
virtual ~G01PhysicsList();
protected:
// Construct particle and physics
virtual void ConstructParticle();
virtual void ConstructProcess();
//
virtual void SetCuts();
protected:
// these methods Construct particles
virtual void ConstructBosons();
virtual void ConstructLeptons();
virtual void ConstructMesons();
virtual void ConstructBaryons();
virtual void ConstructIons();
protected:
// these methods Construct physics processes and register them
void AddParameterisation();
virtual void ConstructGeneral();
virtual void ConstructEM();
virtual void AddTransportation();
};
#endif
| [
"themistoklis.williams@cern.ch"
] | themistoklis.williams@cern.ch |
9da14d827501fa097438935a29f74f0620d96464 | ad49c8dfa079f212f679788d9dae2aa5e7bf4ac3 | /費式數列 比較/unrecursion/main.cpp | d60fa962a2629657e8ded399cf46cf3ede5202ec | [] | no_license | whitepig3s/1071_Introduction-to-Computer | 2cb3fbbd9d4efb1a5c50340981c6176aeecbdac6 | a22e300dc9ddf2cb70c81393a7661b51fefde0a8 | refs/heads/master | 2020-06-19T16:38:16.615535 | 2019-07-14T04:05:47 | 2019-07-14T04:05:47 | 196,786,876 | 0 | 0 | null | null | null | null | WINDOWS-1252 | C++ | false | false | 463 | cpp | #include <iostream>
#include <time.h>
using namespace std;
int main ()
{
int input;
clock_t t;
cout<<"¶O¤ó¼Æ¦C («D»¼°j¹Bºâ)"<<endl;
cin>>input;
t = clock();
cout<<endl<<"Calculating..."<<endl;
double Fi[input+1]= {0,1,1};
for (int i=3; i<=input; i++)
{
Fi[i]=Fi[i-1]+Fi[i-2];
}
t = clock() - t;
cout<<Fi[input]<<endl;
cout<<"Time: "<<((float)t)/CLOCKS_PER_SEC<<"s"<<endl;
return 0;
}
| [
"whitepig3s@gmail.com"
] | whitepig3s@gmail.com |
c410c5eb18a52dc8979acf2f24c8e2961493f5de | e5d20900e3aafea054529576e9ca11e7a218115f | /Lab8/string_manip.cpp | 7c7a55109c9414c1b9175fc1251368403172277e | [] | no_license | Quiltic/Intro_CS_Class | 282fb2d7f35629d67f4f78b653f55aa7828f6cb3 | ba60db262252d6dc52be8b4c41888166d61966f3 | refs/heads/master | 2020-06-13T05:26:34.167871 | 2020-04-30T01:05:53 | 2020-04-30T01:05:53 | 194,552,714 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,658 | cpp | #include <iostream>
#include <string>
#include <cctype>
using namespace std;
// This prototype is complete
class stringManip {
public:
stringManip();
stringManip(string input);
string retrieve();
void setString(string input);
void chop();
void padString(int n);
void center(int length);
void truncate(int n);
void removeNonAlpha();
void convertToUpperCase();
void convertToLowerCase();
private:
string tobeEdited;
};
// Not all functions are defined here
// Default Constructor
stringManip::stringManip(){
tobeEdited = "";
}
// Overloaded Constructor
stringManip::stringManip(string in_string){
tobeEdited = in_string;
}
// retrieve function
string stringManip::retrieve(){
return tobeEdited;
}
// padString() function
void stringManip::padString(int length){
while (tobeEdited.length() < length)//makes it the same length
tobeEdited.append(" ");
}
//Cuts off the front and back spaces
void stringManip::chop(){
//front
if (tobeEdited.length()){//if its achualy something
char ch = tobeEdited.at(0);
while (isspace(ch)){//checks to see if it is a charicter or a string then removes it if need be
tobeEdited.erase(0,1);
ch = tobeEdited.at(0);
}
//back of string
ch = tobeEdited.at(tobeEdited.length()-1);
while (isspace(ch)){//makes it the same length
tobeEdited.erase(tobeEdited.length()-1,1);
ch = tobeEdited.at(tobeEdited.length()-1);
}
}
}
//truncate(int n) is a function which shortens the string to n characters.
void stringManip::truncate(int length){
if (tobeEdited.length()){//if its achualy something
char ch = tobeEdited.at(tobeEdited.length()-1);
while (tobeEdited.length() > length){//makes it the same length
tobeEdited.erase(tobeEdited.length()-1,1);
ch = tobeEdited.at(tobeEdited.length()-1);
}
}}
//removeNonAlpha() is function that removes all characters (including spaces) that are not alphabetical from the string. The isalpha function may be helpful for this purpose.
void stringManip::removeNonAlpha(){
if (tobeEdited.length()){//if its achualy something
char ch = tobeEdited.at(0);
unsigned a = 0;
bool something;
while (tobeEdited.length() != a){//go through the entire string
ch = tobeEdited.at(a);
something = isalpha((ch));
if (!something)
tobeEdited.erase(a,1);//removes the non alfa charicter
else{
a++;//next thing
}
}
}
}
//convertToUpperCase() is a function that converts all lowercase characters in the string to uppercase. All other characters remain the same.4
void stringManip::convertToUpperCase(){
if (tobeEdited.length()){//if its achualy something
char ch = tobeEdited.at(0);
unsigned a = 0;
while (tobeEdited.length()-1 != a){
tobeEdited[a] = toupper(tobeEdited.at(a));//iterates and upercases the letters
a++;
ch = tobeEdited.at(a);
}
tobeEdited[a] = toupper(tobeEdited.at(a));//last letter to upper
}
}
//convertToLowerCase() is a function that converts all lowercase characters in the string to uppercase. All other characters remain the same.
void stringManip::convertToLowerCase(){
if (tobeEdited.length()){//if its achualy something
char ch = tobeEdited.at(0);
unsigned a = 0;
while (tobeEdited.length()-1 != a){
tobeEdited[a] = tolower(tobeEdited.at(a));//makes the letters lowercase
a++;
ch = tobeEdited.at(a);
}
tobeEdited[a] = tolower(tobeEdited.at(a));//make the last letter lower
}}
//center(int length) - Write a function to center the string within the space specified by length. You should remove any existing leading and trailing spaces in the string before centering it.
void stringManip::center(int length){
chop();
unsigned a = 1;//to swich between beginging and end
while (tobeEdited.length() != length){//go untill x
if (a % 2)
tobeEdited.append(" ");//to end
else
tobeEdited = " " + tobeEdited;//to begining
a++;
}
}
//Add blanks to the front and back of the string. If an odd number of blanks have to be added, put the extra blank on the right. You should store the result back in the “tobeEdited” string.
void stringManip::setString(string str){
tobeEdited = str;
}
// Add test cases to main()
int main(){
stringManip S1;
stringManip S2("I miss spring break already!!!");
// Test case for padString() You should correct some of your own.
cout << "S2 before Chop(): <" << S2.retrieve() << ">" << endl;
S2.chop();
cout << "S2 before padString(20): <" << S2.retrieve() << ">" << endl;
//S2.padString(20);
//cout << "S2 before truncate(11): <" << S2.retrieve() << ">" << endl;
//S2.truncate(11);
cout << "S2 before removeNonAlfa(): <" << S2.retrieve() << ">" << endl;
S2.removeNonAlpha();
cout << "S2 before ToUpper: <" << S2.retrieve() << ">" << endl;
S2.convertToUpperCase();
cout << "S2 before tolower: <" << S2.retrieve() << ">" << endl;
S2.convertToLowerCase();
cout << "S2 before center: <" << S2.retrieve() << ">" << endl;
S2.center(20);
cout << "S2 at end: <" << S2.retrieve() << ">" << endl;
cout << "Should be: <testing>" << endl;
return 0;
}
//<testing 123 >
//<testing 123 >
| [
"noreply@github.com"
] | noreply@github.com |
e10cc6937180747a932d9bd2e809425917c5a28e | 8665ac8f6c0a7faebccb9fdf12e944ebe8a95c4f | /src/PulseViewer.cpp | 09db9c1fa72de9c779d2896b5cd1926c11f73a2b | [] | no_license | cthornsb/AnalysisTools | 093ab7e4886ac86430c6b33049dce829e35b6d65 | b4804d1c6e017baa75c3c39ba2dc4e02020bdf8b | refs/heads/master | 2020-06-06T04:40:29.905205 | 2014-10-02T15:21:31 | 2014-10-02T15:21:31 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,356 | cpp | // PulseViewer.cpp
// C. Thornsberry
// Aug. 25th, 2014
// Load detector pulses and view them in sequence
// SYNTAX: Viewer {root_filename} {root_treename} {root_branchname} {skip#}
#include "TFile.h"
#include "TTree.h"
#include "TCanvas.h"
#include "TBranch.h"
#include "TGraph.h"
#include "TSystem.h"
#include "TApplication.h"
#include <sstream>
#include <iostream>
#include <unistd.h>
#include <stdlib.h>
#include <vector>
double PIXIE_TIME_RES = 4.0; // In ns
// For compilation
int main(int argc, char* argv[]){
if(argc < 5){
std::cout << " Error! Invalid number of arguments. Expected 4, received " << argc-1 << "\n";
std::cout << " SYNTAX: Viewer {filename} {treename} {branch} {skip#}\n";
return 1;
}
// Variables for root graphics
char* dummy[0];
TApplication* rootapp = new TApplication("rootapp",0,dummy);
gSystem->Load("libTree");
unsigned int skip = atol(argv[4]);
std::cout << " Showing every " << skip << " pulses\n";
// Branch variables
std::vector<int> wave;
std::vector<double> energy;
unsigned int mult;
unsigned int wave_size = 0;
TFile *file = new TFile(argv[1], "READ");
if(!file->IsOpen()){
std::cout << " Failed to load the input file '" << argv[1] << "'\n";
return 1;
}
TTree *tree = (TTree*)file->Get(argv[2]);
if(!tree){
std::cout << " Failed to load the input tree '" << argv[2] << "'\n";
file->Close();
return 1;
}
tree->SetMakeClass(1);
std::stringstream branch_name;
branch_name << argv[3];
TBranch *b_wave, *b_mult;
tree->SetBranchAddress((branch_name.str()+"_wave").c_str(), &wave, &b_wave);
tree->SetBranchAddress((branch_name.str()+"_mult").c_str(), &mult, &b_mult);
if(!b_wave){
std::cout << " Failed to load the input branch '" << branch_name.str() << "_wave'\n";
file->Close();
return 1;
}
if(!b_mult){
std::cout << " Failed to load the input branch '" << branch_name.str() << "_mult'\n";
file->Close();
return 1;
}
// Get the pulse size
for(unsigned int i = 0; i < tree->GetEntries(); i++){
tree->GetEntry(i);
if(mult == 0){ continue; }
else{
wave_size = wave.size()/mult;
break;
}
}
std::cout << " Using wave size " << wave_size << std::endl;
TCanvas *can = new TCanvas("can", "canvas");
can->cd();
// Variables for TGraph
double *x = new double[wave_size];
const double *x_val = new double[wave_size];
const double *y_val = new double[wave_size];
TGraph *graph = new TGraph(wave_size, x_val, y_val);
for(unsigned int i = 0; i < wave_size; i++){
x[i] = i*PIXIE_TIME_RES;
}
unsigned int count = 0, index = 0;
std::cout << " Processing " << tree->GetEntries() << " entries\n";
for(unsigned int i = 0; i < tree->GetEntries(); i++){
tree->GetEntry(i);
if(i % 100000 == 0 && i != 0){ std::cout << " Entry no. " << i << std::endl; }
if(mult > 0 && count > skip){
count = 0;
index = 0;
std::cout << " " << i << std::endl;
for(std::vector<int>::iterator iter = wave.begin(); iter != wave.end(); iter++){
if(index >= wave_size){ break; } // Reached maximum graph container size
graph->SetPoint(index, x[index], (*iter));
index++;
}
graph->Draw();
can->Update();
sleep(1);
}
else{ count += mult; }
}
can->Close();
file->Close();
graph->Delete();
rootapp->Delete();
return 0;
}
// For CINT
int Viewer(int argc, char* argv[]){ return main(argc, argv); }
| [
"corythornsberry@gmail.com"
] | corythornsberry@gmail.com |
4d76bac247b86d60259e5e32784fb1900504e6ac | bfc4712e6bfdd184b714e2082ed83d1cb67d0fd1 | /src/ntupleReader.cc | 43db3c22500e1397c0288d54c44b21948fa21924 | [] | no_license | mdelcourt/ntupleToCP3 | b5d89a28b5c16bb37b8dca1f374a24702efd8d80 | 3767ac513e34cd426d6d451339bad4cd44f4be02 | refs/heads/master | 2020-03-16T00:51:35.999507 | 2018-10-15T13:34:02 | 2018-10-15T13:34:02 | 132,426,859 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,453 | cc | #include "include/ntupleReader.h"
#include <iostream>
using namespace std;
ntupleReader::ntupleReader(string inputFile):fName_(inputFile){
inputFile_ = new TFile(fName_.c_str());
if (not inputFile_)
cerr<<"Unable to open input file!"<<endl;
t_event_ = (TTree* ) inputFile_ ->Get("ntuple/Event");
t_genParts_ = (TTree* ) inputFile_ ->Get("ntuple/Particle");
t_genPhotons_ = (TTree* ) inputFile_ ->Get("ntuple/GenPhoton");
t_vertices_ = (TTree* ) inputFile_ ->Get("ntuple/Vertex");
t_genJets_ = (TTree* ) inputFile_ ->Get("ntuple/GenJet");
t_looseElecs_ = (TTree* ) inputFile_ ->Get("ntuple/ElectronLoose");
t_mediumElecs_ = (TTree* ) inputFile_ ->Get("ntuple/ElectronMedium");
t_tightElecs_ = (TTree* ) inputFile_ ->Get("ntuple/ElectronTight");
t_looseMuons_ = (TTree* ) inputFile_ ->Get("ntuple/MuonLoose");
t_tightMuons_ = (TTree* ) inputFile_ ->Get("ntuple/MuonTight");
t_allTaus_ = (TTree* ) inputFile_ ->Get("ntuple/TauAll");
t_puppiJets_ = (TTree* ) inputFile_ ->Get("ntuple/JetPUPPI");
t_puppiMET_ = (TTree* ) inputFile_ ->Get("ntuple/PuppiMissingET");
t_loosePhotons_ = (TTree* ) inputFile_ ->Get("ntuple/PhotonLoose");
t_tightPhotons_ = (TTree* ) inputFile_ ->Get("ntuple/PhotonTight");
attachToMiniEventTree(t_event_, t_genParts_, t_vertices_, t_genJets_, t_genPhotons_, t_looseElecs_, t_mediumElecs_,t_tightElecs_, t_looseMuons_, t_tightMuons_, t_allTaus_,t_puppiJets_, t_puppiMET_,t_loosePhotons_, t_tightPhotons_, ev_);
}
void ntupleReader::GetEntry(long int evtId){
t_event_ ->GetEntry(evtId) ;
t_genParts_ ->GetEntry(evtId) ;
t_genPhotons_ ->GetEntry(evtId) ;
t_vertices_ ->GetEntry(evtId) ;
t_genJets_ ->GetEntry(evtId) ;
t_looseElecs_ ->GetEntry(evtId) ;
t_mediumElecs_ ->GetEntry(evtId) ;
t_tightElecs_ ->GetEntry(evtId) ;
t_looseMuons_ ->GetEntry(evtId) ;
t_tightMuons_ ->GetEntry(evtId) ;
t_allTaus_ ->GetEntry(evtId) ;
t_puppiJets_ ->GetEntry(evtId) ;
t_puppiMET_ ->GetEntry(evtId) ;
t_loosePhotons_ ->GetEntry(evtId) ;
t_tightPhotons_ ->GetEntry(evtId) ;
}
long int ntupleReader::GetEntries(){
return t_event_->GetEntries();
}
void ntupleReader::Print(){
cout<<"NeleTight :"<<ev_.nte<<endl;
for (int ii = 0; ii<ev_.nte; ii++)
cout<<"pt["<<ii<<"] = "<<ev_.te_pt[ii]<<endl;
}
| [
"mdelcourt@uclouvain.be"
] | mdelcourt@uclouvain.be |
4d426584275f69607ff24e21c3efed8fc9c078c2 | a9260585aaf24423a2a8f6757ae919abdbd03387 | /trainings/05-avr-explotation/materials/JTAGenum/JTAGenum.ino | 62c2ac1bf332ef3692b73ec14d9837024a3232c8 | [] | no_license | radareorg/r2con2016 | 6d8d5951ad3f1971282902164e2cb1c5b5e08268 | 03f27eba5410e9edaa517af3be8c7a4cc06cedb1 | refs/heads/master | 2020-03-28T10:38:29.611000 | 2016-09-25T15:58:46 | 2016-09-25T15:58:46 | 148,129,504 | 9 | 5 | null | null | null | null | UTF-8 | C++ | false | false | 26,356 | ino | /*
JTAGenum
Given a Arduino compatible microcontroller JTAGenum scans
pins[] for basic JTAG functionality. After programming
your microcontroller open a serial terminal with 115200
baud and send 'h' to see usage information.
SETUP:
Define the pins[] and pinnames[] map of pin names to pins
you want to scan with. If you are using a 3.3v board
uncomment the CPU_PRESCALE defintions at the top and in
the setup() function.
If you plan to use IDCODE, Boundary or IR scan routines
define the IR_IDCODE, IR_SAMPLE+SCAN_LEN and
IR_LEN+CHAIN_LEN values according to suspected or
documented values.
Further documentation:
http://deadhacker.com/2010/02/03/jtag-enumeration/
AUTHORS & CODE BRANCHES:
cyphunk http://github.com/cyphunk/JTAGenum/
jal2 http://github.com/jal2/JTAGenum/
zoobab http://new.hackerspace.be/JTAG_pinout_detector
z1Y2x https://github.com/z1Y2x/JTAGenum/
Most modifications are merged back into the first URL.
Check the others for cutting edge or solutions if you
run into problems. JTAGenum is based on Lekernel's
ArduiNull[1] which was itself inspired by Hunz's
JTAG Finder[2]. Tested on Arduino Mini Pro, Arduino
Mega, Arduino Duemilanove and Teensy++[3].
[1]http://lekernel.net/blog/?p=319
[2]http://www.c3a.de/wiki/index.php/JTAG_Finder
[4]http://www.pjrc.com/teensy/
This code is public domain, use as you wish and at your own risk
*/
//needed to put help strings into flash
#include <avr/pgmspace.h>
/*
* BEGIN USER DEFINITIONS
*/
//#define DEBUGTAP
//#define DEBUGIR
// For 3.3v AVR boards. Cuts clock in half. Also see cmd in setup()
#define CPU_PRESCALE(n) (CLKPR = 0x80, CLKPR = (n))
// Setup the pins to be checked
/*
* Teensy v3.1: usable digital pins are: A0-A7
* (13 is connected to the LED)
*/
//byte pins[] = { A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 };
//char * pinnames[] = { "A0", "A1", "A2", "A3", "A4", "A5", "A6", "A7" };
/*
* Teensy v2
*/
//byte pins[] = { PIN_B0, PIN_B1, PIN_B2, PIN_B4, PIN_B5 };
//char * pinnames[] = { "TRST", " TDI", " TMS", " TCK", " TDO" };
/*
* Arduino Pro: usable digital pins are: 2-12, 14-19 (ANALOG 0-5)
* (0,1 are the serial line, 13 is connected to the LED)
*/
byte pins[] = { 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
char * pinnames[] = { "DIG_2", "DIG_3", "DIG_4", "DIG_5", "DIG_6",
"DIG_7", "DIG_8", "DIG_9", "DIG_10", "DIG_11" };
// Once you have found the JTAG pins you can define
// the following to allow for the boundary scan and
// irenum functions to be run. Define the values
// as the index for the pins[] array of the found
// jtag pin:
#define TCK 0
#define TMS 1
#define TDO 2
#define TDI 3
#define TRST 4
// Pattern used for scan() and loopback() tests
#define PATTERN_LEN 64
// Use something random when trying find JTAG lines:
static char pattern[PATTERN_LEN] = "0110011101001101101000010111001001";
// Use something more determinate when trying to find
// length of the DR register:
//static char pattern[PATTERN_LEN] = "1000000000000000000000000000000000";
// Max. number of JTAG enabled chips (MAX_DEV_NR) and length
// of the DR register together define the number of
// iterations to run for scan_idcode():
#define MAX_DEV_NR 8
#define IDCODE_LEN 32
// Target specific, check your documentation or guess
#define SCAN_LEN 1890 // used for IR enum. bigger the better
#define IR_LEN 5
// IR registers must be IR_LEN wide:
#define IR_IDCODE "01100" // always 011
#define IR_SAMPLE "10100" // always 101
#define IR_PRELOAD IR_SAMPLE
/*
* END USER DEFINITIONS
*/
void printProgStr(const char *str);
// TAP TMS states we care to use. NOTE: MSB sent first
// Meaning ALL TAP and IR codes have their leftmost
// bit sent first. This might be the reverse of what
// documentation for your target(s) show.
#define TAP_RESET "11111" // looping 1 will return
// IDCODE if reg available
#define TAP_SHIFTDR "111110100"
#define TAP_SHIFTIR "1111101100" // -11111> Reset -0> Idle -1> SelectDR
// -1> SelectIR -0> CaptureIR -0> ShiftIR
// Ignore TCK, TMS use in loopback check:
#define IGNOREPIN 0xFFFF
// Flags configured by UI:
boolean VERBOSE = 0; // 255 = true
boolean DELAY = 0;
long DELAYUS = 5000; // 5 Milliseconds
boolean PULLUP = 255;
const byte pinslen = sizeof(pins)/sizeof(pins[0]);
void setup(void)
{
// Uncomment for 3.3v boards. Cuts clock in half
// only on avr based arduino & teensy hardware
//CPU_PRESCALE(0x01);
Serial.begin(115200);
}
/*
* Set the JTAG TAP state machine
*/
void tap_state(char tap_state[], int tck, int tms)
{
#ifdef DEBUGTAP
Serial.print("tap_state: tms set to: ");
#endif
while (*tap_state) { // exit when string \0 terminator encountered
if (DELAY) delayMicroseconds(50);
digitalWrite(tck, LOW);
digitalWrite(tms, *tap_state - '0'); // conv from ascii pattern
#ifdef DEBUGTAP
Serial.print(*tap_state - '0',DEC);
#endif
digitalWrite(tck, HIGH); // rising edge shifts in TMS
*tap_state++;
}
#ifdef DEBUGTAP
Serial.println();
#endif
}
static void pulse_tms(int tck, int tms, int s_tms)
{
if (tck == IGNOREPIN) return;
digitalWrite(tck, LOW);
digitalWrite(tms, s_tms);
digitalWrite(tck, HIGH);
}
static void pulse_tdi(int tck, int tdi, int s_tdi)
{
if (DELAY) delayMicroseconds(50);
if (tck != IGNOREPIN) digitalWrite(tck, LOW);
digitalWrite(tdi, s_tdi);
if (tck != IGNOREPIN) digitalWrite(tck, HIGH);
}
byte pulse_tdo(int tck, int tdo)
{
byte tdo_read;
if (DELAY) delayMicroseconds(50);
digitalWrite(tck, LOW); // read in TDO on falling edge
tdo_read = digitalRead(tdo);
digitalWrite(tck, HIGH);
return tdo_read;
}
/*
* Initialize all pins to a default state
* default with no arguments: all pins as INPUTs
*/
void init_pins(int tck = IGNOREPIN, int tms = IGNOREPIN, int tdi = IGNOREPIN, int ntrst = IGNOREPIN)
{
// default all to INPUT state
for (int i = 0; i < pinslen; i++) {
pinMode(pins[i], INPUT);
// internal pullups default to logic 1:
if (PULLUP) digitalWrite(pins[i], HIGH);
}
// TCK = output
if (tck != IGNOREPIN) pinMode(tck, OUTPUT);
// TMS = output
if (tms != IGNOREPIN) pinMode(tms, OUTPUT);
// tdi = output
if (tdi != IGNOREPIN) pinMode(tdi, OUTPUT);
// ntrst = output, fixed to 1
if (ntrst != IGNOREPIN) {
pinMode(ntrst, OUTPUT);
digitalWrite(ntrst, HIGH);
}
}
/*
* send pattern[] to TDI and check for output on TDO
* This is used for both loopback, and Shift-IR testing, i.e.
* the pattern may show up with some delay.
* return: 0 = no match
* 1 = match
* 2 or greater = no pattern found but line appears active
*
* if retval == 1, *reglen returns the length of the register
*/
static int check_data(char pattern[], int iterations, int tck, int tdi, int tdo,
int *reg_len)
{
int i;
int w = 0;
int plen = strlen(pattern);
char tdo_read;
char tdo_prev;
int nr_toggle = 0; // count how often tdo toggled
/* we store the last plen (<=PATTERN_LEN) bits,
* rcv[0] contains the oldest bit */
char rcv[PATTERN_LEN];
tdo_prev = '0' + (digitalRead(tdo) == HIGH);
for(i = 0; i < iterations; i++) {
/* output pattern and incr write index */
pulse_tdi(tck, tdi, pattern[w++] - '0');
if (!pattern[w])
w = 0;
/* read from TDO and put it into rcv[] */
tdo_read = '0' + (digitalRead(tdo) == HIGH);
nr_toggle += (tdo_read != tdo_prev);
tdo_prev = tdo_read;
if (i < plen)
rcv[i] = tdo_read;
else
{
memmove(rcv, rcv + 1, plen - 1);
rcv[plen-1] = tdo_read;
}
/* check if we got the pattern in rcv[] */
if (i >= (plen - 1) ) {
if (!memcmp(pattern, rcv, plen)) {
*reg_len = i + 1 - plen;
return 1;
}
}
} /* for(i=0; ... ) */
*reg_len = 0;
return nr_toggle > 1 ? nr_toggle : 0;
}
static void print_pins(int tck, int tms, int tdo, int tdi, int ntrst)
{
if (ntrst != IGNOREPIN) {
Serial.print(" ntrst:");
Serial.print(pinnames[ntrst]);
}
Serial.print(" tck:");
Serial.print(pinnames[tck]);
Serial.print(" tms:");
Serial.print(pinnames[tms]);
Serial.print(" tdo:");
Serial.print(pinnames[tdo]);
if (tdi != IGNOREPIN) {
Serial.print(" tdi:");
Serial.print(pinnames[tdi]);
}
}
/*
* Shift JTAG TAP to ShiftIR state. Send pattern to TDI and check
* for output on TDO
*/
static void scan()
{
int tck, tms, tdo, tdi, ntrst;
int checkdataret = 0;
int len;
int reg_len;
printProgStr(PSTR("================================\r\n"
"Starting scan for pattern:"));
Serial.println(pattern);
for(ntrst=0;ntrst<pinslen;ntrst++) {
for(tck=0;tck<pinslen;tck++) {
if(tck == ntrst) continue;
for(tms=0;tms<pinslen;tms++) {
if(tms == ntrst) continue;
if(tms == tck ) continue;
for(tdo=0;tdo<pinslen;tdo++) {
if(tdo == ntrst) continue;
if(tdo == tck ) continue;
if(tdo == tms ) continue;
for(tdi=0;tdi<pinslen;tdi++) {
if(tdi == ntrst) continue;
if(tdi == tck ) continue;
if(tdi == tms ) continue;
if(tdi == tdo ) continue;
if(VERBOSE) {
print_pins(tck, tms, tdo, tdi, ntrst);
Serial.print(" ");
}
init_pins(pins[tck], pins[tms], pins[tdi], pins[ntrst]);
tap_state(TAP_SHIFTIR, pins[tck], pins[tms]);
checkdataret = check_data(pattern, (2*PATTERN_LEN),
pins[tck], pins[tdi], pins[tdo], ®_len);
if(checkdataret == 1) {
Serial.print("FOUND! ");
print_pins(tck, tms, tdo, tdi, ntrst);
Serial.print(" IR length: ");
Serial.println(reg_len, DEC);
}
else if(checkdataret > 1) {
Serial.print("active ");
print_pins(tck, tms, tdo, tdi, ntrst);
Serial.print(" bits toggled:");
Serial.println(checkdataret);
}
else if(VERBOSE) Serial.println();
} /* for(tdi=0; ... ) */
} /* for(tdo=0; ... ) */
} /* for(tms=0; ... ) */
} /* for(tck=0; ... ) */
} /* for(ntrst=0; ... ) */
printProgStr(PSTR("================================\r\n"));
}
/*
* Check for pins that pass pattern[] between tdi and tdo
* regardless of JTAG TAP state (tms, tck ignored).
*
* TDO, TDI pairs that match indicate possible shorts between
* pins. Pins that do not match but are active might indicate
* that the patch cable used is not shielded well enough. Run
* the test again without the cable connected between controller
* and target. Run with the verbose flag to examine closely.
*/
static void loopback_check()
{
int tdo, tdi;
int checkdataret = 0;
int reg_len;
printProgStr(PSTR("================================\r\n"
"Starting loopback check...\r\n"));
for(tdo=0;tdo<pinslen;tdo++) {
for(tdi=0;tdi<pinslen;tdi++) {
if(tdi == tdo) continue;
if(VERBOSE) {
Serial.print(" tdo:");
Serial.print(pinnames[tdo]);
Serial.print(" tdi:");
Serial.print(pinnames[tdi]);
Serial.print(" ");
}
init_pins(IGNOREPIN/*tck*/, IGNOREPIN/*tck*/, pins[tdi], IGNOREPIN /*ntrst*/);
checkdataret = check_data(pattern, (2*PATTERN_LEN), IGNOREPIN, pins[tdi], pins[tdo], ®_len);
if(checkdataret == 1) {
Serial.print("FOUND! ");
Serial.print(" tdo:");
Serial.print(pinnames[tdo]);
Serial.print(" tdi:");
Serial.print(pinnames[tdi]);
Serial.print(" reglen:");
Serial.println(reg_len);
}
else if(checkdataret > 1) {
Serial.print("active ");
Serial.print(" tdo:");
Serial.print(pinnames[tdo]);
Serial.print(" tdi:");
Serial.print(pinnames[tdi]);
Serial.print(" bits toggled:");
Serial.println(checkdataret);
}
else if(VERBOSE) Serial.println();
}
}
printProgStr(PSTR("================================\r\n"));
}
/*
* Scan TDO for IDCODE. Handle MAX_DEV_NR many devices.
* We feed zeros into TDI and wait for the first 32 of them to come out at TDO (after n * 32 bit).
* As IEEE 1149.1 requires bit 0 of an IDCODE to be a "1", we check this bit.
* We record the first bit from the idcodes into bit0.
* (oppposite to the old code).
* If we get an IDCODE of all ones, we assume that the pins are wrong.
*/
static void scan_idcode()
{
int tck, tms, tdo, tdi, ntrst;
int i, j;
int nr; /* number of devices */
int tdo_read;
uint32_t idcodes[MAX_DEV_NR];
printProgStr(PSTR("================================\r\n"
"Starting scan for IDCODE...\r\n"));
char idcodestr[] = " ";
int idcode_i = 31; // TODO: artifact that might need to be configurable
uint32_t idcode;
for(ntrst=0;ntrst<pinslen;ntrst++) {
for(tck=0;tck<pinslen;tck++) {
if(tck == ntrst) continue;
for(tms=0;tms<pinslen;tms++) {
if(tms == ntrst) continue;
if(tms == tck ) continue;
for(tdo=0;tdo<pinslen;tdo++) {
if(tdo == ntrst) continue;
if(tdo == tck ) continue;
if(tdo == tms ) continue;
for(tdi=0;tdi<pinslen;tdi++) {
if(tdi == ntrst) continue;
if(tdi == tck ) continue;
if(tdi == tms ) continue;
if(tdi == tdo ) continue;
if(VERBOSE) {
print_pins(tck, tms, tdo, tdi, ntrst);
Serial.print(" ");
}
init_pins(pins[tck], pins[tms], pins[tdi], pins[ntrst]);
/* we hope that IDCODE is the default DR after reset */
tap_state(TAP_RESET, pins[tck], pins[tms]);
tap_state(TAP_SHIFTDR, pins[tck], pins[tms]);
/* j is the number of bits we pulse into TDI and read from TDO */
for(i = 0; i < MAX_DEV_NR; i++) {
idcodes[i] = 0;
for(j = 0; j < IDCODE_LEN;j++) {
/* we send '0' in */
pulse_tdi(pins[tck], pins[tdi], 0);
tdo_read = digitalRead(pins[tdo]);
if (tdo_read)
idcodes[i] |= ( (uint32_t) 1 ) << j;
if (VERBOSE)
Serial.print(tdo_read,DEC);
} /* for(j=0; ... ) */
if (VERBOSE) {
Serial.print(" ");
Serial.println(idcodes[i],HEX);
}
/* save time: break at the first idcode with bit0 != 1 */
if (!(idcodes[i] & 1) || idcodes[i] == 0xffffffff)
break;
} /* for(i=0; ...) */
if (i > 0) {
print_pins(tck,tms,tdo,tdi,ntrst);
Serial.print(" devices: ");
Serial.println(i,DEC);
for(j = 0; j < i; j++) {
Serial.print(" 0x");
Serial.println(idcodes[j],HEX);
}
} /* if (i > 0) */
} /* for(tdo=0; ... ) */
} /* for(tdi=0; ...) */
} /* for(tms=0; ...) */
} /* for(tck=0; ...) */
} /* for(trst=0; ...) */
printProgStr(PSTR("================================\r\n"));
}
static void shift_bypass()
{
int tdi, tdo, tck;
int checkdataret;
int reg_len;
printProgStr(PSTR("================================\r\n"
"Starting shift of pattern through bypass...\r\n"
"Assumes bypass is the default DR on reset.\r\n"
"Hence, no need to check for TMS. Also, currently\r\n"
"not checking for nTRST, which might not work\r\n"));
for(tck=0;tck<pinslen;tck++) {
for(tdi=0;tdi<pinslen;tdi++) {
if(tdi == tck) continue;
for(tdo=0;tdo<pinslen;tdo++) {
if(tdo == tck) continue;
if(tdo == tdi) continue;
if(VERBOSE) {
Serial.print(" tck:");
Serial.print(pinnames[tck]);
Serial.print(" tdi:");
Serial.print(pinnames[tdi]);
Serial.print(" tdo:");
Serial.print(pinnames[tdo]);
Serial.print(" ");
}
init_pins(pins[tck], IGNOREPIN/*tms*/,pins[tdi], IGNOREPIN /*ntrst*/);
// if bypass is default on start, no need to init TAP state
checkdataret = check_data(pattern, (2*PATTERN_LEN), pins[tck], pins[tdi], pins[tdo], ®_len);
if(checkdataret == 1) {
Serial.print("FOUND! ");
Serial.print(" tck:");
Serial.print(pinnames[tck]);
Serial.print(" tdo:");
Serial.print(pinnames[tdo]);
Serial.print(" tdi:");
Serial.println(pinnames[tdi]);
}
else if(checkdataret > 1) {
Serial.print("active ");
Serial.print(" tck:");
Serial.print(pinnames[tck]);
Serial.print(" tdo:");
Serial.print(pinnames[tdo]);
Serial.print(" tdi:");
Serial.print(pinnames[tdi]);
Serial.print(" bits toggled:");
Serial.println(checkdataret);
}
else if(VERBOSE) Serial.println();
}
}
}
printProgStr(PSTR("================================\r\n"));
}
/* ir_state()
* Set TAP to Reset then ShiftIR.
* Shift in state[] as IR value.
* Switch to ShiftDR state and end.
*/
void ir_state(char state[], int tck, int tms, int tdi)
{
#ifdef DEBUGIR
Serial.println("ir_state: set TAP to ShiftIR:");
#endif
tap_state(TAP_SHIFTIR, tck, tms);
#ifdef DEBUGIR
Serial.print("ir_state: pulse_tdi to: ");
#endif
for (int i=0; i < IR_LEN; i++) {
if (DELAY) delayMicroseconds(50);
// TAP/TMS changes to Exit IR state (1) must be executed
// at same time that the last TDI bit is sent:
if (i == IR_LEN-1) {
digitalWrite(tms, HIGH); // ExitIR
#ifdef DEBUGIR
Serial.print(" (will be in ExitIR after next bit) ");
#endif
}
pulse_tdi(tck, tdi, *state-'0');
#ifdef DEBUGIR
Serial.print(*state-'0', DEC);
#endif
// TMS already set to 0 "shiftir" state to shift in bit to IR
*state++;
}
#ifdef DEBUGIR
Serial.println("\r\nir_state: Change TAP from ExitIR to ShiftDR:");
#endif
// a reset would cause IDCODE instruction to be selected again
tap_state("1100", tck, tms); // -1> UpdateIR -1> SelectDR -0> CaptureDR -0> ShiftDR
}
static void sample(int iterations, int tck, int tms, int tdi, int tdo, int ntrst=IGNOREPIN)
{
printProgStr(PSTR("================================\r\n"
"Starting sample (boundary scan)...\r\n"));
init_pins(tck, tms ,tdi, ntrst);
// send instruction and go to ShiftDR
ir_state(IR_SAMPLE, tck, tms, tdi);
// Tell TAP to go to shiftout of selected data register (DR)
// is determined by the instruction we sent, in our case
// SAMPLE/boundary scan
for (int i = 0; i < iterations; i++) {
// no need to set TMS. It's set to the '0' state to
// force a Shift DR by the TAP
Serial.print(pulse_tdo(tck, tdo),DEC);
if (i % 32 == 31 ) Serial.print(" ");
if (i % 128 == 127) Serial.println();
}
}
char ir_buf[IR_LEN+1];
static void brute_ir(int iterations, int tck, int tms, int tdi, int tdo, int ntrst=IGNOREPIN)
{
printProgStr(PSTR("================================\r\n"
"Starting brute force scan of IR instructions...\r\n"
"NOTE: If Verbose mode is off output is only printed\r\n"
" after activity (bit changes) are noticed and\r\n"
" you might not see the first bit of output.\r\n"
"IR_LEN set to "));
Serial.println(IR_LEN,DEC);
init_pins(tck, tms ,tdi, ntrst);
int iractive;
byte tdo_read;
byte prevread;
for (uint32_t ir = 0; ir < (1UL << IR_LEN); ir++) {
iractive=0;
// send instruction and go to ShiftDR (ir_state() does this already)
// convert ir to string.
for (int i = 0; i < IR_LEN; i++)
ir_buf[i]=bitRead(ir, i)+'0';
ir_buf[IR_LEN]=0;// terminate
ir_state(ir_buf, tck, tms, tdi);
// we are now in TAP_SHIFTDR state
prevread = pulse_tdo(tck, tdo);
for (int i = 0; i < iterations-1; i++) {
// no need to set TMS. It's set to the '0' state to force a Shift DR by the TAP
tdo_read = pulse_tdo(tck, tdo);
if (tdo_read != prevread) iractive++;
if (iractive || VERBOSE) {
Serial.print(prevread,DEC);
if (i%16 == 15) Serial.print(" ");
if (i%128 == 127) Serial.println();
}
prevread = tdo_read;
}
if (iractive || VERBOSE) {
Serial.print(prevread,DEC);
Serial.print(" Ir ");
Serial.print(ir_buf);
Serial.print(" bits changed ");
Serial.println(iractive, DEC);
}
}
}
void set_pattern()
{
int i;
char c;
Serial.print("Enter new pattern of 1's or 0's (terminate with new line or '.'):\r\n"
"> ");
i = 0;
while(1) {
c = Serial.read();
switch(c) {
case '0':
case '1':
if(i < (PATTERN_LEN - 1) ) {
pattern[i++] = c;
Serial.print(c);
}
break;
case '\n':
case '\r':
case '.': // bah. for the arduino serial console which does not pass us \n
pattern[i] = 0;
Serial.println();
Serial.print("new pattern set [");
Serial.print(pattern);
Serial.println("]");
return;
}
}
}
// given a PROGMEM string, use Serial.print() to send it out
void printProgStr(const char *str)
{
char c;
if(!str) return;
while((c = pgm_read_byte(str++)))
Serial.print(c);
}
void help()
{
printProgStr(PSTR(
"Short and long form commands can be used.\r\n"
"\r\n"
"SCANS\r\n"
"-----\r\n"
"s > pattern scan\r\n"
" Scans for all JTAG pins. Attempts to set TAP state to\r\n"
" DR_SHIFT and then shift the pattern through the DR.\r\n"
"p > pattern set\r\n"
" currently: ["));
Serial.print(pattern);
printProgStr(PSTR("]\r\n"
"\r\n"
"i > idcode scan\r\n"
" Assumes IDCODE is default DR on reset. Ignores TDI.\r\n"
" Sets TAP state to DR_SHIFT and prints TDO to console\r\n"
" when TDO appears active. Human examination required to\r\n"
" determine if actual IDCODE is present. Run several\r\n"
" times to check for consistancy or compare against\r\n"
" active tdo lines found with loopback test.\r\n"
"\r\n"
"b > bypass scan\r\n"
" Assumes BYPASS is default DR on reset. Ignores TMS and\r\n"
" shifts pattern[] through TDI/TDO using TCK for clock.\r\n"
"\r\n"
"ERATTA\r\n"
"------\r\n"
"l > loopback check\r\n"
" ignores tck,tms. if patterns passed to tdo pins are\r\n"
" connected there is a short or a false-possitive\r\n"
" condition exists that should be taken into account\r\n"
"r > pullups\r\n"
" internal pullups on inputs, on/off. might increase\r\n"
" stability when using a bad patch cable.\r\n"
"v > verbose\r\n"
" on/off. print tdo bits to console during testing. will slow\r\n"
" down scan.\r\n"
"d > delay\r\n"
" on/off. will slow down scan.\r\n"
"- > delay -\r\n"
" reduce delay by 1000us\r\n"
"+ > delay +\r\n"
"h > help\r\n"
"\r\n"
"OTHER JTAG TESTS\r\n"
"----------------\r\n"
"Each of the following will not scan/find JTAG and require\r\n"
"that you manually set the JTAG pins. See their respective\r\n"
"call from the loop() function of code to set.\r\n"
"\r\n"
"1 > pattern scan single\r\n"
" runs a full check on one code-defined tdi<>tdo pair.\r\n"
" look at the main()/loop() code to specify pins.\r\n"
"x > boundary scan\r\n"
" checks code defined tdo for 4000+ bits.\r\n"
" look at the main()/loop() code to specify pins.\r\n"
"y > irenum\r\n"
" sets every possible Instruction Register and then\r\n"
" checks the output of the Data Register.\r\n"
" look at the main()/loop() code to specify pins.\r\n"
));
}
/*
* main()
*/
#define CMDLEN 20
char command[CMDLEN];
int dummy;
void loop()
{
if (Serial.available())
{
// READ COMMAND
delay(5); // hoping read buffer is idle after 5 ms
int i = 0;
while (Serial.available() && i < CMDLEN-1)
command[i++] = Serial.read();
Serial.flush();
command[i] = 0; // terminate string
Serial.println(command); // echo back
// EXECUTE COMMAND
if (strcmp(command, "pattern scan") == 0 || strcmp(command, "s") == 0)
scan();
else if(strcmp(command, "pattern scan single") == 0 || strcmp(command, "1") == 0)
{
init_pins(pins[TCK], pins[TMS], pins[TDI], pins[TRST] /*ntrst*/);
tap_state(TAP_SHIFTIR, pins[TCK], pins[TMS]);
if (check_data(pattern, (2*PATTERN_LEN), pins[TCK], pins[TDI], pins[TDO], &dummy))
Serial.println("found pattern or other");
else
Serial.println("no pattern found");
}
else if(strcmp(command, "pattern set") == 0 || strcmp(command, "p") == 0)
set_pattern();
else if(strcmp(command, "loopback check") == 0 || strcmp(command, "l") == 0)
loopback_check();
else if(strcmp(command, "idcode scan") == 0 || strcmp(command, "i") == 0)
scan_idcode();
else if(strcmp(command, "bypass scan") == 0 || strcmp(command, "b") == 0)
shift_bypass();
else if(strcmp(command, "boundary scan") == 0 || strcmp(command, "x") == 0)
{
Serial.print("pins");
print_pins(TCK, TMS, TDO, TDI, TRST);
Serial.println();
sample(SCAN_LEN+100, pins[TCK], pins[TMS], pins[TDI], pins[TDO], pins[TRST]);
}
else if(strcmp(command, "irenum") == 0 || strcmp(command, "y") == 0)
brute_ir(SCAN_LEN, pins[TCK], pins[TMS], pins[TDI], pins[TDO], pins[TRST]);
else if(strcmp(command, "verbose") == 0 || strcmp(command, "v") == 0)
{
VERBOSE = ~VERBOSE;
Serial.println(VERBOSE ? "Verbose ON" : "Verbose OFF");
}
else if(strcmp(command, "delay") == 0 || strcmp(command, "d") == 0)
{
DELAY = ~DELAY;
Serial.println(DELAY ? "Delay ON" : "Delay OFF");
}
else if(strcmp(command, "delay -") == 0 || strcmp(command, "-") == 0)
{
Serial.print("Delay microseconds: ");
if (DELAYUS != 0 && DELAYUS > 1000) DELAYUS-=1000;
else if (DELAYUS != 0 && DELAYUS <= 1000) DELAYUS-=100;
Serial.println(DELAYUS,DEC);
}
else if(strcmp(command, "delay +") == 0 || strcmp(command, "+") == 0)
{
Serial.print("Delay microseconds: ");
if (DELAYUS < 1000) DELAYUS+=100;
else DELAYUS+=1000;
Serial.println(DELAYUS,DEC);
}
else if(strcmp(command, "pullups") == 0 || strcmp(command, "r") == 0)
{
PULLUP = ~PULLUP;
Serial.println(PULLUP ? "Pullups ON" : "Pullups OFF");
}
else if(strcmp(command, "help") == 0 || strcmp(command, "h") == 0)
help();
else
{
Serial.println("unknown command");
help();
}
Serial.print("\n> ");
}
}
| [
"dukebarman@gmail.com"
] | dukebarman@gmail.com |
961d1fd2643419918371ca3f2bf91031d3dd5409 | 846ca7cd54d9ca58830aac7feb69a17ae0c666ab | /Codeforces/110/A [Nearly Lucky Number].cpp | 8912542a0f1d25baa24b6c5dd70ef077d1e618cc | [] | no_license | NouemanKHAL/Competitive-Programming | 445e722553a1ca11e1a53ca63a0be3b6c4f2f37d | 5021cf43676c72d6049252b9985b8f49738866b8 | refs/heads/master | 2020-03-27T11:50:55.689611 | 2019-04-10T15:53:23 | 2019-04-10T15:53:23 | 146,510,447 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 285 | cpp | #include <iostream>
using namespace std;
int main(){
string s;
cin >> s;
int cpt=0;
for(int i=0;i<s.length();i++){
if(s[i]=='4' || s[i]=='7') cpt++;
}
if(cpt==4 || cpt==7) cout << "YES";
else cout << "NO";
return 0;
} | [
"noueman.khal@gmail.com"
] | noueman.khal@gmail.com |
e7e0c3cc5b67a8a8798397bc563b5fc3167c504e | eecbf9da28dbb2c3336b799478c9666c638e9e86 | /qmlunrimp/ExampleModel.cpp | 50304ae6611a31470af68c4a5496d82b6bdcf174 | [] | no_license | thewolfwillcome/qt-unrimp | cc6c5068c041402f9a6563b037d8562ab3d58725 | d362f29de8d844e2d93e2bf3df2a19c132a843f3 | refs/heads/master | 2021-06-02T10:18:53.020127 | 2017-07-28T12:33:33 | 2017-07-28T12:33:33 | 10,170,899 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,003 | cpp | /*********************************************************\
* Copyright (c) 2013-2013 Stephan Wezel
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of this software
* and associated documentation files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or
* substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
\*********************************************************/
#include "ExampleModel.h"
#include <Basics/FirstTriangle/FirstTriangle.h>
#include <Basics/FirstIndirectBuffer/FirstIndirectBuffer.h>
#include <Basics/VertexBuffer/VertexBuffer.h>
#include <Basics/FirstTexture/FirstTexture.h>
#include <Basics/FirstRenderToTexture/FirstRenderToTexture.h>
#include <Basics/FirstInstancing/FirstInstancing.h>
#include <Basics/FirstMultipleRenderTargets/FirstMultipleRenderTargets.h>
#include <Basics/FirstGeometryShader/FirstGeometryShader.h>
#include <Basics/FirstTessellation/FirstTessellation.h>
#ifndef ANDROID // Generates runtime errors such as "W/Adreno-GSL( 1320): <gsl_ldd_control:405>: ioctl fd 30 code 0x400c0907 (IOCTL_KGSL_DEVICE_WAITTIMESTAMP_CTXTID) failed: errno 35 Resource deadlock would occur" an my GLES 3 device with Adreno 330 GPU
#include <Advanced/InstancedCubes/InstancedCubes.h>
#endif
#include <Runtime/FirstMesh/FirstMesh.h>
#include <Runtime/FirstScene/FirstScene.h>
template <class ExampleClass>
ExampleFabricatorMethod createFabricator(const char* name, bool cyclicUpdate = false, bool needsRendererRuntime = false)
{
auto f =[name, cyclicUpdate, needsRendererRuntime]() {
return new UnrimpExample(std::unique_ptr<ExampleBase>(new ExampleClass()), {name, cyclicUpdate, needsRendererRuntime});
};
return f;
}
ExampleModel::ExampleModel(QObject *parent)
: QAbstractListModel(parent), m_examples({
// Basic
new ExampleItem("FirstTriangle", "Basic", createFabricator<FirstTriangle>("FirstTriangle", false), this ),
// new ExampleItem("FirstIndirectBuffer", "Basic", createFabricator<FirstIndirectBuffer>("FirstIndirectBuffer", false), this ),
// new ExampleItem("VertexBuffer", "Basic", createFabricator<VertexBuffer>("VertexBuffer", false), this ),
// new ExampleItem("FirstTexture", "Basic", createFabricator<FirstTexture>("FirstTexture", false), this ),
// new ExampleItem("FirstRenderToTexture", "Basic", createFabricator<FirstRenderToTexture>("FirstRenderToTexture", false), this ),
// new ExampleItem("FirstInstancing", "Basic", createFabricator<FirstInstancing>("FirstInstancing", false), this ),
// new ExampleItem("FirstMultipleRenderTargets", "Basic", createFabricator<FirstMultipleRenderTargets>("FirstMultipleRenderTargets", false), this ),
// new ExampleItem("FirstGeometryShader", "Basic", createFabricator<FirstGeometryShader>("FirstGeometryShader", false), this ),
// new ExampleItem("FirstTessellation", "Basic", createFabricator<FirstTessellation>("FirstTessellation", false), this ),
// Advanced
// #ifndef ANDROID // Generates runtime errors such as "W/Adreno-GSL( 1320): <gsl_ldd_control:405>: ioctl fd 30 code 0x400c0907 (IOCTL_KGSL_DEVICE_WAITTIMESTAMP_CTXTID) failed: errno 35 Resource deadlock would occur" an my GLES 3 device with Adreno 330 GPU
// new ExampleItem("InstancedCubes", "Advanced", createFabricator<InstancedCubes>("InstancedCubes", true, true), this ),
// #endif
new ExampleItem("FirstMesh", "Advanced", createFabricator<FirstMesh>("FirstMesh", true, true), this ),
new ExampleItem("FirstScene", "Advanced", createFabricator<FirstScene>("FirstScene", true, true), this )
})
{
}
int ExampleModel::rowCount(const QModelIndex& ) const
{
return m_examples.count();
}
QVariant ExampleModel::data(const QModelIndex & index, int role) const
{
if (index.row() < 0 || index.row() >= m_examples.count())
return QVariant();
const ExampleItem *animal = m_examples[index.row()];
if (role == TypeRole)
return animal->type();
else if (role == NameRole)
return animal->name();
return QVariant();
}
QHash<int, QByteArray> ExampleModel::roleNames() const
{
QHash<int, QByteArray> roles;
roles[TypeRole] = "type";
roles[NameRole] = "name";
return roles;
}
| [
"s.wezel@web.de"
] | s.wezel@web.de |
d4a1f262676ca72c61db43c9113c87530dc1544d | fef58dcd0c1434724a0a0a82e4c84ae906200289 | /usages/0x6FF8FF40B6357D45.cpp | 05567b8b38f5a5de5ae574c19b19be5e69766390 | [] | no_license | DottieDot/gta5-additional-nativedb-data | a8945d29a60c04dc202f180e947cbdb3e0842ace | aea92b8b66833f063f391cb86cbcf4d58e1d7da3 | refs/heads/main | 2023-06-14T08:09:24.230253 | 2021-07-11T20:43:48 | 2021-07-11T20:43:48 | 380,364,689 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 824 | cpp | // act_cinema.ysc @ L3916
int func_92(int iParam0, int iParam1)
{
int iVar0;
int iVar1;
iVar0 = 0;
while (iVar0 < NETWORK::NETWORK_GET_MAX_NUM_PARTICIPANTS())
{
if (NETWORK::NETWORK_IS_PARTICIPANT_ACTIVE(PLAYER::INT_TO_PARTICIPANTINDEX(iVar0)))
{
iVar1 = NETWORK::NETWORK_GET_PLAYER_INDEX(PLAYER::INT_TO_PARTICIPANTINDEX(iVar0));
NETWORK::NETWORK_DISABLE_INVINCIBLE_FLASHING(iVar1, 1);
if (iParam1 && PLAYER::GET_PLAYER_TEAM(iVar1) != PLAYER::GET_PLAYER_TEAM(PLAYER::PLAYER_ID()))
{
NETWORK::_0xA7C511FA1C5BDA38(iVar1, 1);
}
}
iVar0++;
}
if (NETWORK::NETWORK_HAS_CONTROL_OF_ENTITY(iParam0))
{
NETWORK::SET_NETWORK_VEHICLE_AS_GHOST(iParam0, 1);
return 1;
}
else
{
NETWORK::NETWORK_REQUEST_CONTROL_OF_ENTITY(iParam0);
}
return 0;
} | [
"tvangroenigen@outlook.com"
] | tvangroenigen@outlook.com |
b8c6a9a6fdc155efd04fa039eb0419efda9fbaf4 | 9d12976468ee1d5f6756e1b02ae0b66c97239998 | /src/feature_map_vertices.cpp | bf990e049d3803c7cb6952435b9ae06babf2664f | [] | no_license | Choirin/point_cloud_registration | caeaefb59e7238a17454baddc7f845b13e1f9c3d | 05d74064e76de18b176a1b79dddb83821e97b798 | refs/heads/master | 2022-02-02T03:07:49.107237 | 2020-04-11T09:38:52 | 2020-04-11T09:38:52 | 250,725,510 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,342 | cpp | #include "feature_map_vertices.hpp"
#include <Eigen/Dense>
#include <fstream>
#include <sstream>
#define NANOSECONDS_IN_A_SECOND 1.0e9
FeatureMapVertices::FeatureMapVertices(const fs::path &file_path)
{
load_from_csv(file_path);
sort_by_timestamp();
}
FeatureMapVertices::FeatureMapVertices(const std::vector<fs::path> &file_paths)
{
for (auto file_path : file_paths)
{
load_from_csv(file_path);
}
sort_by_timestamp();
}
bool FeatureMapVertices::get_pose(double timestamp, Eigen::Vector3d &translation, Eigen::Quaterniond &rotation)
{
std::shared_ptr<Vertex> before = nullptr;
std::shared_ptr<Vertex> after = nullptr;
for (auto vertex : vertices_)
{
if (vertex->timestamp <= timestamp)
before = vertex;
else if (timestamp <= vertex->timestamp)
after = vertex;
if (before != nullptr && after != nullptr)
break;
}
if (before == nullptr || after == nullptr)
return false;
auto t = (timestamp - before->timestamp) / (after->timestamp - before->timestamp);
translation = before->translation * (1 - t) + after->translation * t;
rotation = before->rotation.slerp(t, after->rotation);
return true;
}
void FeatureMapVertices::print(void)
{
for (auto vertex : vertices_)
{
std::cout << vertex->index << ", ";
std::cout.precision(20);
std::cout << vertex->timestamp << ", ";
std::cout << vertex->translation(0) << ", "
<< vertex->translation(1) << ", "
<< vertex->translation(2) << ", ";
std::cout << std::endl;
}
}
size_t FeatureMapVertices::load_from_csv(const fs::path &file_path)
{
std::fstream filestream(file_path.string());
if (!filestream.is_open())
return 0;
std::string buffer;
while (getline(filestream, buffer))
{
std::vector<std::string> record;
std::istringstream streambuffer(buffer);
std::string token;
while (getline(streambuffer, token, ','))
record.emplace_back(token);
std::shared_ptr<Vertex> vertex;
if (record.size() == NUMBER_OF_ELEMENTS_IN_A_VERTEX &&
vertex_from_string_vector(record, vertex))
vertices_.emplace_back(vertex);
}
return vertices_.size();
}
bool FeatureMapVertices::vertex_from_string_vector(const std::vector<std::string> &record, std::shared_ptr<Vertex> &vertex)
{
try
{
vertex = std::make_shared<Vertex>(
std::stol(record[0]),
std::stod(record[1]) / NANOSECONDS_IN_A_SECOND,
Eigen::Vector3d(std::stod(record[2]), std::stod(record[3]), std::stod(record[4])),
// Caution: w, x, y, z
Eigen::Quaterniond(std::stod(record[8]), std::stod(record[5]), std::stod(record[6]), std::stod(record[7])),
Eigen::Vector3d(std::stod(record[9]), std::stod(record[10]), std::stod(record[11])),
Eigen::Vector3d(std::stod(record[12]), std::stod(record[13]), std::stod(record[14])),
Eigen::Vector3d(std::stod(record[15]), std::stod(record[16]), std::stod(record[17])));
return true;
}
catch (const std::exception &e)
{
// std::cerr << e.what() << std::endl;
// std::cerr << "skip this line" << std::endl;
return false;
}
}
void FeatureMapVertices::sort_by_timestamp(void)
{
std::sort(vertices_.begin(), vertices_.end(),
[&](auto const &a, auto const &b) {
return a->timestamp < b->timestamp;
});
}
| [
"khi.tkd@gmail.com"
] | khi.tkd@gmail.com |
29bfac39b59c6fb650e7a0e719afe3b17536be45 | 768371d8c4db95ad629da1bf2023b89f05f53953 | /applayerpluginsandutils/httptransportplugins/httptransporthandler/csecuresocketcontroller.cpp | 2cc173169ebf6945e7a4350abc36d8dc0abb25c4 | [] | no_license | SymbianSource/oss.FCL.sf.mw.netprotocols | 5eae982437f5b25dcf3d7a21aae917f5c7c0a5bd | cc43765893d358f20903b5635a2a125134a2ede8 | refs/heads/master | 2021-01-13T08:23:16.214294 | 2010-10-03T21:53:08 | 2010-10-03T21:53:08 | 71,899,655 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,746 | cpp | // Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
//
// User includes
#include "csecuresocketcontroller.h"
#include "thttptrlayerpanic.h"
#include <x509certext.h>
#include <securesocket.h>
#include <ssl_internal.h>
CSecureSocketController* CSecureSocketController::NewL(TAny* aInitParams)
/**
Factory constructor.
@param aSocket The socket that requires a secure connection,
takes ownership.
@param aCommsInfoProvider The Comms info provider for accessing client
security preferences.
@return Pointer to the newly constructed class.
*/
{
THttpSecureSocketParams* initParams = REINTERPRET_CAST(THttpSecureSocketParams*, aInitParams);
CSecureSocketController* self = new (ELeave) CSecureSocketController(*(initParams->iSocket), *(initParams->iCommsInfoProvider));
return self;
}
CSecureSocketController::~CSecureSocketController()
/**
Destructor.
*/
{
if( iTlsSocket )
{
iTlsSocket->Close();
delete iTlsSocket;
}
else
iSocket.Close(); // Has ownership of socket if secure layer was not created
}
CSecureSocketController::CSecureSocketController(RSocket& aSocket, MCommsInfoProvider& aCommsInfoProvider)
: iSocket(aSocket), iCommsInfoProvider(aCommsInfoProvider)
/**
Constructor.
@param aSocket The socket that requires a secure connection,
takes ownership.
@param aCommsInfoProvider The Comms info provider for accessing client
security preferences.
*/
{
}
void CSecureSocketController::StartSecureHandshakeL(TRequestStatus& aStatus, const TDesC8& aHostName, const TDesC& aProtocolVersion)
/**
Start a secure handshake to upgrade the socket to a secure connection.
@param aStatus The request status, this will complete with KErrNone
if the secure handshake completed succesfully.
@param aHostName The server host name, used for domain name checking
against certificates.
*/
{
// Create the secure layer
if( iTlsSocket == NULL )
{
iTlsSocket = CSecureSocket::NewL(iSocket, aProtocolVersion);
}
// Get the security preferences, dialog prompt and security policy
TBool dialogPref = ETrue;
MSecurityPolicy* securityPolicy = NULL;
iCommsInfoProvider.SecurityPreferences(dialogPref, securityPolicy);
// Dialog preferences
if( !dialogPref )
User::LeaveIfError(iTlsSocket->SetDialogMode(EDialogModeUnattended));
// Security policy preferences
if( securityPolicy )
{
TPtrC8 ciphers = securityPolicy->GetTlsCipherSuites();
if (ciphers.Length() >0)
User::LeaveIfError(iTlsSocket->SetAvailableCipherSuites(ciphers));
}
// Set an option on the socket to not use SSL2
User::LeaveIfError(iTlsSocket->SetOpt(KSoUseSSLv2Handshake, KSolInetSSL, KNullDesC8()));
// Set an option on the socket to check the server certificate domain
User::LeaveIfError(iTlsSocket->SetOpt(KSoSSLDomainName, KSolInetSSL, aHostName));
iTlsSocket->StartClientHandshake(aStatus);
}
void CSecureSocketController::RecvOneOrMore(TDes8& aBuffer, TRequestStatus& aStatus, TSockXfrLength& aLength)
/**
Receives data from a connected remote host when it is available.
@param aBuffer The buffer for the data to be placed.
@param aStatus The request status. Will complete with KErrNone when the
data is avaiable, KErrEof indicating the the connection
has closed and no more data will will be available or
any other system error code.
@param aLength On return, this will contain how much data was read.
*/
{
__ASSERT_DEBUG( iTlsSocket!=NULL, THttpTrLayerPanic::Panic(THttpTrLayerPanic::ETlsSocketNotStarted) );
iTlsSocket->RecvOneOrMore(aBuffer, aStatus, aLength);
}
void CSecureSocketController::CancelRecv()
/**
Cancels an outstanding data receive call made by RecvOneOrMore().
*/
{
if( iTlsSocket )
iTlsSocket->CancelRecv();
}
void CSecureSocketController::Send(const TDesC8& aBuffer, TRequestStatus& aStatus)
/*
Sends data to the connected remote host.
@param aBuffer The buffer containing the data to send to the remote host.
@param aStatus The request status, Will complete with KErrNone when the
data is avaiable, KErrEof indicating the the connection
has closed or any other system error code.
*/
{
__ASSERT_DEBUG( iTlsSocket!=NULL, THttpTrLayerPanic::Panic(THttpTrLayerPanic::ETlsSocketNotStarted) );
iTlsSocket->Send(aBuffer, aStatus);
}
void CSecureSocketController::CancelSend()
/**
Cancels an outstanding send data to a remote host using Send().
*/
{
if( iTlsSocket )
iTlsSocket->CancelSend();
}
const CX509Certificate* CSecureSocketController::ServerCert()
/**
Get the Server Certificate for this socket session.
@return An error code. KErrNone if aServerCert has been completed,
otherwise one of the system wide error codes
*/
{
if( iTlsSocket )
{
return iTlsSocket->ServerCert();
}
return NULL;
}
void CSecureSocketController::CancelHandshake()
/**
Cancel the secure handshake.
*/
{
if( iTlsSocket )
iTlsSocket->CancelHandshake();
}
TInt CSecureSocketController::CipherSuite(TDes8& aCipherSuite)
{
if (iTlsSocket)
return iTlsSocket->CurrentCipherSuite(aCipherSuite);
// else
return KErrNotSupported;
}
TInt CSecureSocketController::PendingBytesToRead ()
{
TInt bytesToRead;
TInt err = iTlsSocket->GetOpt ( KSOReadBytesPending, KSOLSocket, bytesToRead );
if ( err == KErrNone )
return bytesToRead;
return err;
}
| [
"kirill.dremov@nokia.com"
] | kirill.dremov@nokia.com |
4cc5a977ef4c6c74af8a69f5cd05fd5dd616e695 | 4dbfd2b70fa7ea4e4af4b19bbe2ecaa620d70738 | /dae2ma/include/DAE2MAImageImporter.h | 9e052481010078cbea9912f622485e7751665fde | [
"MIT"
] | permissive | RemiArnaud/OpenCOLLADA | e347f5ff7cbe886490ba10c7828e5b6038060021 | cdcd7e7131c640842c99b5066c7320d2ac4899a0 | refs/heads/master | 2023-08-21T09:58:01.559798 | 2023-08-06T08:38:52 | 2023-08-06T08:38:52 | 6,890,659 | 15 | 2 | null | 2023-08-06T08:38:53 | 2012-11-27T20:48:34 | C++ | UTF-8 | C++ | false | false | 2,263 | h | /*
Copyright (c) 2008-2009 NetAllied Systems GmbH
This file is part of DAE2MA.
Licensed under the MIT Open Source License,
for details please see LICENSE file or the website
http://www.opensource.org/licenses/mit-license.php
*/
#ifndef __DAE2MA_IMAGEIMPORTER_H__
#define __DAE2MA_IMAGEIMPORTER_H__
#include "DAE2MAPrerequisites.h"
#include "DAE2MABaseImporter.h"
#include "DAE2MAEffectImporter.h"
#include "COLLADAFWImage.h"
#include <MayaDMFile.h>
namespace DAE2MA
{
/** Imports the image textures. */
class ImageImporter : BaseImporter
{
private:
/** The standard name for image without name. */
static const String IMAGE_NAME;
private:
typedef std::map<COLLADAFW::UniqueId, MayaDM::File> UniqueIdMayaImagesMap;
private:
/**
* A copy of the framework's library image elements.
*/
std::map<COLLADAFW::UniqueId, COLLADAFW::Image*> mImagesMap;
/**
* The map holds the Maya image file objects for the unique image file ids.
*/
UniqueIdMayaImagesMap mImageIdMayaImageFileMap;
public:
/** Constructor. */
ImageImporter ( DocumentImporter* documentImporter );
/** Destructor. */
virtual ~ImageImporter();
/**
* Store's the data of the current image.
*/
void storeImage ( const COLLADAFW::Image* image );
/**
* Imports the data of the used images.
*/
void importImages ();
/**
* Returns a pointer to the maya image file with the given image id,
* or NULL, if it is not in the list.
*/
const MayaDM::File* findMayaImageFile ( const COLLADAFW::UniqueId& imageId );
private:
/**
* Imports the data of the current image and stores the generated maya node into
* the texture info object.
*/
void importImage (
const COLLADAFW::Image* image,
EffectImporter::TextureInfo& textureInfo );
/**
* Get the framework image element of the given id.
*/
const COLLADAFW::Image* findImage ( const COLLADAFW::UniqueId& imageId );
};
} // namespace DAE2MA
#endif // __DAE2MA_IMAGEIMPORTER_H__
| [
"ideasman42@gmail.com"
] | ideasman42@gmail.com |
8dcb6c92daf2bf557702a18b60163f7ea824b82b | 59d48e2e57b99900cda47f2718f4fd917a87b707 | /WorkersRightsComputer/Right.cpp | 575f4c57cb918180a1e4c3a3a5449435c7a9e145 | [] | no_license | YoavHaifa/WorkersRightsComputer | acad8c152ba56d3a6ef77e53e8e08fdab62c26ec | c6443e63dc19fe01cfb9d94387bb350f292a126f | refs/heads/master | 2023-08-09T20:21:37.254929 | 2023-07-29T17:32:46 | 2023-07-29T17:32:46 | 185,610,201 | 1 | 0 | null | 2020-01-07T21:38:39 | 2019-05-08T13:21:13 | C++ | UTF-8 | C++ | false | false | 9,162 | cpp | #include "StdAfx.h"
#include "Right.h"
#include "Utils.h"
#include "HtmlWriter.h"
#include "XMLDump.h"
CString CRight::umsSaveDir = L"";
CString CRight::umsName = L"__";
bool CRight::umbOldStyle = false;
CRight::CRight(const wchar_t *zName, const wchar_t *zHebrewName)
: msName(zName)
, msNameHebrew(zHebrewName)
, mbSkipIfZero(false)
, miPrintOrder(-1)
, mDebug(3)
{
if (!umsSaveDir)
ResetSaveDirAndName();
Init();
}
CRight::~CRight(void)
{
}
CString CRight::GetSaveDir(void)
{
if (umsSaveDir.IsEmpty())
ResetSaveDirAndName();
return umsSaveDir;
}
void CRight::SetSaveDirAndName(const wchar_t *zSaveDir, const wchar_t *zName)
{
umsSaveDir = zSaveDir;
umsName = zName;
}
void CRight::ResetSaveDirAndName(void)
{
umsSaveDir = CUtils::GetBaseDir();
umsSaveDir += "Log";
CUtils::VerifyDirectory(umsSaveDir);
umsSaveDir += "\\";
// umsSaveDir = L"..\\release\\Log\\";
umsName = L"__";
}
void CRight::Init(void)
{
mbValid = false;
mDuePay = 0;
msDue = msName + L": ";
msDebug = msName + L" Debug: ";
}
void CRight::Save(FILE *pfWrite)
{
WriteLine(pfWrite, msName);
WriteLine(pfWrite, msDue);
WriteLine(pfWrite, msDebug);
WriteLine(pfWrite, L"*");
}
void CRight::SaveToXml(CXMLDump& xmlDump)
{
CXMLDumpScope scope(msName, xmlDump);
xmlDump.Write(L"Due", mDuePay);
xmlDump.Write(L"sDue", msDue);
xmlDump.Write(L"Debug", msDebug);
}
CString CRight::GetSaveFileName(const wchar_t *zfName, const wchar_t *zExtension)
{
CString sfName = umsSaveDir;
sfName += umsName;
sfName += zfName;
sfName += ".";
sfName += zExtension;
return sfName;
}
FILE * CRight::OpenFile(const wchar_t *zfName, const wchar_t *zExtension)
{
CString sfName = umsSaveDir;
sfName += umsName;
sfName += zfName;
sfName += ".";
sfName += zExtension;
FILE *pf = NULL;
_wfopen_s(&pf, (const wchar_t *)sfName, L"w");
return pf;
}
bool CRight::ComputeEnvelop(void)
{
mpfWrite = CUtils::OpenSpecialLogFile((const wchar_t *)msName);
CString sLine = L"Computing ";
sLine += msName;
if (mpfWrite)
fwprintf(mpfWrite, L"%s\n\n", (const wchar_t *)sLine);
bool bOK = Compute();
if (mpfWrite)
{
fwprintf(mpfWrite, L"\n");
fwprintf(mpfWrite, L"%s\n", (const wchar_t*)msDue);
fwprintf(mpfWrite, L"%s\n", (const wchar_t*)msDebug);
if (!bOK)
{
WriteLine(L"");
sLine = msName;
sLine += L" not computed!";
WriteLine(sLine);
}
fclose(mpfWrite);
mpfWrite = NULL;
}
return bOK;
}
bool CRight::HasLegalValue()
{
if (mDuePay > 0)
return true;
if ((mDuePay == 0) && !mbSkipIfZero)
return true;
return false;
}
bool CRight::HasLegalRealValue()
{
if (mDuePay > 0)
return true;
return false;
}
bool CRight::PrintToLetter()
{
return mDuePay > 0;
}
void CRight::LogLine(const wchar_t *zText)
{
WriteLine(zText);
}
void CRight::LogLine(const wchar_t* zText, CString s)
{
CString str(zText);
str += " ";
str += s;
WriteLine(str);
}
void CRight::LogLine(const wchar_t *zText, int value)
{
CString s(zText);
s += " ";
s += ToString(value);
WriteLine(s);
}
void CRight::LogLine(const wchar_t *zText, double value)
{
CString s(zText);
s += " ";
s += ToString(value);
WriteLine(s);
}
void CRight::LogLine(const wchar_t *zText, __int64 value)
{
CString s(zText);
s += " ";
s += ToString(value);
WriteLine(s);
}
void CRight::LogLine(const wchar_t *zText, CTime value)
{
CString s(zText);
s += " ";
s += ToString(value);
WriteLine(s);
}
void CRight::LogLine(const wchar_t* zText, CMyTime myTime)
{
CString s(zText);
s += " ";
s += myTime.ToString();
WriteLine(s);
}
void CRight::LogLine(const wchar_t* zText, CMyTime myTime, const wchar_t* zText2)
{
CString s(zText);
s += " ";
s += myTime.ToString();
s += " ";
s += zText2;
WriteLine(s);
}
void CRight::LogLine(const wchar_t *zText, CTime value, const wchar_t *zText2)
{
CString s(zText);
s += " ";
s += ToString(value);
s += " ";
s += zText2;
WriteLine(s);
}
void CRight::LogLine(const wchar_t *zText, CTime value, const wchar_t *zText2, int value2)
{
CString s(zText);
s += " ";
s += ToString(value);
s += " ";
s += zText2;
s += " ";
s += ToString(value2);
WriteLine(s);
}
void CRight::LogLine(const wchar_t *zText, CTime value, const wchar_t *zText2, double value2)
{
CString s(zText);
s += " ";
s += ToString(value);
s += " ";
s += zText2;
s += " ";
s += ToString(value2);
WriteLine(s);
}
void CRight::LogLine(const wchar_t *zText, int ivalue, const wchar_t *zText2, double dvalue)
{
CString s(zText);
s += " ";
s += ToString(ivalue);
s += " ";
s += zText2;
s += " ";
s += ToString(dvalue);
WriteLine(s);
}
void CRight::LogLineSpan(const wchar_t *zText, CMyTime& start, CMyTime& end)
{
int nDays = start.GetNDaysBefore(end);
CString s(zText);
s += L" TIME SPAN days ";
s += ToString(nDays);
//s += L" houres ";
//s += ToString(span.GetHours());
//s += L" minutes ";
//s += ToString(span.GetMinutes());
WriteLine(s);
}
bool CRight::TryReadInt(FILE *pfRead, const wchar_t *zText, int &value)
{
wchar_t zBuf[256];
if (fgetws(zBuf, sizeof(zBuf), pfRead) == NULL)
return false;
if (mDebug & 0x100)
{
CString sDeb(L"Read ");
sDeb += zText;
sDeb += L": ";
sDeb += zBuf;
WriteLine(sDeb);
}
if (!isdigit(zBuf[0]))
{
CString s (L"Read Integer Error: <");
s += zText;
s += L"> Found: ";
s += zBuf;
MessageBox(NULL, s, L"Read Int Error", MB_OK);
return false;
}
value = _wtoi(zBuf);
return true;
}
bool CRight::TryConvertInt(const wchar_t *zSource, const wchar_t *zText, int &value)
{
if (!isdigit(zSource[0]))
{
CString s(L"Convert Integer Error: <");
s += zText;
s += L"> Found: ";
s += zSource;
MessageBox(NULL, s, L"Read Int Error", MB_OK);
return false;
}
value = _wtoi(zSource);
return true;
}
int CRight::SafeGetIntFromTextBox(CEdit &box)
{
CString sText;
box.GetWindowText(sText);
if (sText.IsEmpty())
return 0;
if (!isdigit(sText[0]))
return 0;
int value = _wtoi(sText);
return value;
}
double CRight::SafeGetDoubleFromTextBox(CEdit &box)
{
CString sText;
box.GetWindowText(sText);
if (sText.IsEmpty())
return 0;
if (!isdigit(sText[0]))
return 0;
double value = _wtof(sText);
return value;
}
CString CRight::GetSumLineForLetter(void)
{
CString s (GetRightNameForLetter());
s += " - ";
s += GetDecriptionForLetter();
s += " = ";
CString sPay;
sPay.Format(L"%.2f", mDuePay);
s += sPay;
s += " ";
s += msNameHebrew;
return s;
}
CString CRight::GetRightNameForLetter()
{
return msName;
}
CString CRight::GetDecriptionForLetter()
{
if (!msToLetter.IsEmpty())
return msToLetter;
return msDue;
}
CString CRight::GetDecriptionForLetterHebrew()
{
return GetDecriptionForLetter();
}
void CRight::WriteLine(const wchar_t *zLine)
{
if (!mpfWrite)
return;
if (zLine)
fwprintf(mpfWrite, L"%s\n", zLine);
else
fwprintf(mpfWrite, L"\n");
}
void CRight::WriteLine(FILE *pfWrite, const wchar_t *zLine)
{
if (!pfWrite)
return;
if (zLine)
fwprintf(pfWrite, L"%s\n", zLine);
else
fwprintf(pfWrite, L"\n");
}
CString CRight::ToDayString(int value)
{
switch (value)
{
case 1:
return CString(L"Sunday");
case 2:
return CString(L"Monday");
case 3:
return CString(L"Tuesday");
case 4:
return CString(L"Wednesday");
case 5:
return CString(L"Thursday");
case 6:
return CString(L"Friday");
case 7:
return CString(L"Saturday");
}
return CString(L"???day");
}
CString CRight::ToString(int value)
{
CString s;
s.Format(L"%d", value);
return s;
}
CString CRight::ToString(double value)
{
CString s;
s.Format(L"%.2f", value);
return s;
}
CString CRight::ToString(__int64 value)
{
CString s;
s.Format(L"%I64d", value);
return s;
}
CString CRight::ToString(double value, int nDigits)
{
CString sFormat;
sFormat.Format(L"%%.%df", nDigits);
CString s;
s.Format(sFormat, value);
return s;
}
CString CRight::ToString(CTime value)
{
CString s;
s += ToDayString(value.GetDayOfWeek());
s += L" ";
s += ToString(value.GetDay());
s += L".";
s += ToString(value.GetMonth());
s += L".";
s += ToString(value.GetYear());
return s;
}
bool CRight::GetIntFromEditBox(CEdit *pEdit, const wchar_t *zName, int &value)
{
value = 0;
CString sText;
pEdit->GetWindowText(sText);
if (sText.IsEmpty())
return false;
return TryConvertInt(sText, zName, value);
}
void CRight::WriteLineToHtmlTable(CHtmlWriter &html)
{
html.WriteL(L"<tr>");
html.WriteItemToHtmlTable(msName, msNameHebrew);
CString sDesc = GetDecriptionForLetter();
CString sDescHebrew = GetDecriptionForLetterHebrew();
html.WriteItemToHtmlTable(sDesc, sDescHebrew);
html.WriteNumericItemToHtmlTable(mDuePay);
html.WriteItemToHtmlTable(msNameHebrew, msName, true);
html.WriteL(L"</tr>");
}
bool CRight::IsNumber(CString& s)
{
int len = s.GetLength();
if (len < 1)
return false;
int nDot = 0;
int nDig = 0;
for (int i = 0; i < len; i++)
{
wchar_t ch = s[i];
if (isdigit(ch))
nDig++;
else if (ch == '.')
{
nDot++;
if (nDot > 1)
return false;
}
else
return false;
}
return true;
}
bool CRight::GetInputNumber(CEdit* pEdit, CString& os, double& oValue)
{
pEdit->GetWindowTextW(os);
if (!IsNumber(os))
{
pEdit->SetWindowTextW(L"");
return false;
}
oValue = _wtof(os);
return true;
} | [
"yoav.bar.haifa@gmail.com"
] | yoav.bar.haifa@gmail.com |
fa04b144bb3946c1d5d88982f9513b7f4a3f70f3 | b786b8bfd751ce4e6844dd1b01bd21975d93de18 | /estivaplus/lib/TransMatrix.cpp | f49034e39ef157809d6099863ebd043d034e9b3c | [] | no_license | tsukud-y/estiva | 0ef424d6b60533172d3f1db52f8b4d90661717dc | 7e026670a265d8516a9c989b2d893d0e990fa4a8 | refs/heads/master | 2021-01-10T19:30:31.140339 | 2012-08-29T15:04:28 | 2012-08-29T15:04:28 | 310,598 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 156 | cpp | #include "estivaplus.h"
#include "stwart.h"
Matrix TransMatrix(Matrix &A)
{
Matrix AT(A.size());
forMatrix(A,i,j) AT[j][i] = A[i][j];
return AT;
}
| [
"tsukud-y@galaxy.ocn.ne.jp"
] | tsukud-y@galaxy.ocn.ne.jp |
4569dc558d81b931c6a33aee8ca5350c49ef8aed | bd9d40d0bd8a4759b3db20e10d2dda616a411c48 | /Include/Mathematics/GteIntrSegment3Sphere3.h | 355242fd13b19c36abc2c5b4c943ba3d6d675af3 | [] | no_license | lai3d/GeometricToolsEngine3p16 | d07f909da86e54aa597abd49c57d17981f3dc72f | 50a6096e1b9f021483cf42aaf244587ff9a81f5b | refs/heads/master | 2020-04-01T19:28:22.495042 | 2018-10-18T06:27:05 | 2018-10-18T06:27:05 | 153,555,419 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,133 | h | // David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2018
// Distributed under the Boost Software License, Version 1.0.
// http://www.boost.org/LICENSE_1_0.txt
// http://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// File Version: 3.0.0 (2016/06/19)
#pragma once
#include <Mathematics/GteSegment.h>
#include <Mathematics/GteIntrIntervals.h>
#include <Mathematics/GteIntrLine3Sphere3.h>
namespace gte
{
template <typename Real>
class TIQuery<Real, Segment3<Real>, Sphere3<Real>>
{
public:
struct Result
{
bool intersect;
};
Result operator()(Segment3<Real> const& segment,
Sphere3<Real> const& sphere);
};
template <typename Real>
class FIQuery<Real, Segment3<Real>, Sphere3<Real>>
:
public FIQuery<Real, Line3<Real>, Sphere3<Real>>
{
public:
struct Result
:
public FIQuery<Real, Line3<Real>, Sphere3<Real>>::Result
{
// No additional information to compute.
};
Result operator()(Segment3<Real> const& segment,
Sphere3<Real> const& sphere);
protected:
void DoQuery(Vector3<Real> const& segOrigin,
Vector3<Real> const& segDirection, Real segExtent,
Sphere3<Real> const& sphere, Result& result);
};
template <typename Real>
typename TIQuery<Real, Segment3<Real>, Sphere3<Real>>::Result
TIQuery<Real, Segment3<Real>, Sphere3<Real>>::operator()(
Segment3<Real> const& segment, Sphere3<Real> const& sphere)
{
// The sphere is (X-C)^T*(X-C)-1 = 0 and the line is X = P+t*D.
// Substitute the line equation into the sphere equation to obtain a
// quadratic equation Q(t) = t^2 + 2*a1*t + a0 = 0, where a1 = D^T*(P-C),
// and a0 = (P-C)^T*(P-C)-1.
Result result;
Vector3<Real> segOrigin, segDirection;
Real segExtent;
segment.GetCenteredForm(segOrigin, segDirection, segExtent);
Vector3<Real> diff = segOrigin - sphere.center;
Real a0 = Dot(diff, diff) - sphere.radius * sphere.radius;
Real a1 = Dot(segDirection, diff);
Real discr = a1*a1 - a0;
if (discr < (Real)0)
{
result.intersect = false;
return result;
}
Real tmp0 = segExtent*segExtent + a0;
Real tmp1 = ((Real)2)*a1*segExtent;
Real qm = tmp0 - tmp1;
Real qp = tmp0 + tmp1;
if (qm*qp <= (Real)0)
{
result.intersect = true;
return result;
}
result.intersect = (qm > (Real)0 && std::abs(a1) < segExtent);
return result;
}
template <typename Real>
typename FIQuery<Real, Segment3<Real>, Sphere3<Real>>::Result
FIQuery<Real, Segment3<Real>, Sphere3<Real>>::operator()(
Segment3<Real> const& segment, Sphere3<Real> const& sphere)
{
Vector3<Real> segOrigin, segDirection;
Real segExtent;
segment.GetCenteredForm(segOrigin, segDirection, segExtent);
Result result;
DoQuery(segOrigin, segDirection, segExtent, sphere, result);
for (int i = 0; i < result.numIntersections; ++i)
{
result.point[i] = segOrigin + result.parameter[i] * segDirection;
}
return result;
}
template <typename Real>
void FIQuery<Real, Segment3<Real>, Sphere3<Real>>::DoQuery(
Vector3<Real> const& segOrigin, Vector3<Real> const& segDirection,
Real segExtent, Sphere3<Real> const& sphere, Result& result)
{
FIQuery<Real, Line3<Real>, Sphere3<Real>>::DoQuery(segOrigin,
segDirection, sphere, result);
if (result.intersect)
{
// The line containing the segment intersects the sphere; the
// t-interval is [t0,t1]. The segment intersects the sphere as
// long as [t0,t1] overlaps the segment t-interval
// [-segExtent,+segExtent].
std::array<Real, 2> segInterval = { -segExtent, segExtent };
FIQuery<Real, std::array<Real, 2>, std::array<Real, 2>> iiQuery;
auto iiResult = iiQuery(result.parameter, segInterval);
if (iiResult.intersect)
{
result.numIntersections = iiResult.numIntersections;
result.parameter = iiResult.overlap;
}
else
{
result.intersect = false;
result.numIntersections = 0;
}
}
}
}
| [
"larry@qjt.sg"
] | larry@qjt.sg |
3713d1ee4b8f8e3c6cc5495d14cc5d0c76c133e0 | 0eff74b05b60098333ad66cf801bdd93becc9ea4 | /second/download/curl/gumtree/curl_repos_function_385_curl-7.18.1.cpp | 4f6e0f8edddf14a1e09bcd62b1da2a2757bd975e | [] | no_license | niuxu18/logTracker-old | 97543445ea7e414ed40bdc681239365d33418975 | f2b060f13a0295387fe02187543db124916eb446 | refs/heads/master | 2021-09-13T21:39:37.686481 | 2017-12-11T03:36:34 | 2017-12-11T03:36:34 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,358 | cpp | CURLcode Curl_is_connected(struct connectdata *conn,
int sockindex,
bool *connected)
{
int rc;
struct SessionHandle *data = conn->data;
CURLcode code = CURLE_OK;
curl_socket_t sockfd = conn->sock[sockindex];
long allow = DEFAULT_CONNECT_TIMEOUT;
DEBUGASSERT(sockindex >= FIRSTSOCKET && sockindex <= SECONDARYSOCKET);
*connected = FALSE; /* a very negative world view is best */
if(conn->bits.tcpconnect) {
/* we are connected already! */
long allow_total = 0;
/* subtract the most strict timeout of the ones */
if(data->set.timeout)
allow_total = data->set.timeout;
Curl_expire(data, allow_total);
*connected = TRUE;
return CURLE_OK;
}
/* figure out how long time we have left to connect */
allow = Curl_timeleft(conn, NULL, TRUE);
if(allow < 0) {
/* time-out, bail out, go home */
failf(data, "Connection time-out");
return CURLE_OPERATION_TIMEDOUT;
}
Curl_expire(data, allow);
/* check for connect without timeout as we want to return immediately */
rc = waitconnect(sockfd, 0);
if(WAITCONN_CONNECTED == rc) {
int error;
if(verifyconnect(sockfd, &error)) {
/* we are connected, awesome! */
*connected = TRUE;
return CURLE_OK;
}
/* nope, not connected for real */
data->state.os_errno = error;
infof(data, "Connection failed\n");
if(trynextip(conn, sockindex, connected)) {
failf(data, "Failed connect to %s:%d; %s",
conn->host.name, conn->port, Curl_strerror(conn, error));
code = CURLE_COULDNT_CONNECT;
}
}
else if(WAITCONN_TIMEOUT != rc) {
int error = 0;
/* nope, not connected */
if(WAITCONN_FDSET_ERROR == rc) {
(void)verifyconnect(sockfd, &error);
data->state.os_errno = error;
infof(data, "%s\n",Curl_strerror(conn,error));
}
else
infof(data, "Connection failed\n");
if(trynextip(conn, sockindex, connected)) {
error = SOCKERRNO;
data->state.os_errno = error;
failf(data, "Failed connect to %s:%d; %s",
conn->host.name, conn->port, Curl_strerror(conn, error));
code = CURLE_COULDNT_CONNECT;
}
}
/*
* If the connection failed here, we should attempt to connect to the "next
* address" for the given host.
*/
return code;
} | [
"993273596@qq.com"
] | 993273596@qq.com |
3c3b9621b97697b5e31ee7b59559d03382f7b5fa | 2423355ac00a24056c613abb3d4e6349d0e43207 | /src/engines/Cubbyhole.cpp | 0251617732bd76ef2c5792b74a4ad4442bfea886 | [
"MIT"
] | permissive | jimpark/libvault | b2f68f00167d52b20c91a1c6edefadb026ae7e57 | 35657160c45874cd38bf4b6f0a204c7c26a4dd38 | refs/heads/master | 2022-11-04T05:37:57.866661 | 2020-06-13T15:53:10 | 2020-06-13T15:53:10 | 267,157,147 | 0 | 0 | MIT | 2020-05-26T21:36:33 | 2020-05-26T21:36:32 | null | UTF-8 | C++ | false | false | 755 | cpp | #include "VaultClient.h"
std::optional<std::string> Vault::Cubbyhole::create(const Path &path, const Parameters ¶meters) {
return Vault::HttpConsumer::post(
client_,
getUrl(path),
parameters
);
}
std::optional<std::string> Vault::Cubbyhole::read(const Path &path) {
return Vault::HttpConsumer::get(
client_,
getUrl(path)
);
}
std::optional<std::string> Vault::Cubbyhole::list(const Path &path) {
return Vault::HttpConsumer::list(
client_,
getUrl(path)
);
}
std::optional<std::string> Vault::Cubbyhole::del(const Path &path) {
return Vault::HttpConsumer::del(
client_,
getUrl(path)
);
}
Vault::Url Vault::Cubbyhole::getUrl(const Path &path) {
return client_.getUrl("/v1/cubbyhole/", path);
}
| [
"aaron@aaronbedra.com"
] | aaron@aaronbedra.com |
469efebf0a4f7f71597c39e4a15aa47bb87533a4 | 811bb83f52763e9b2e8f8a19dcc9602cc563fff5 | /Classifier.h | ba58ba97efa26c61d148984109df357c3ce03d1a | [
"MIT"
] | permissive | v3c70r/tdetools | d8d148f139862608572f61476f84bbdef8aa6b38 | 42272a745cfcb3e23551fd37028fe60a28680abb | refs/heads/master | 2020-04-01T14:22:28.714563 | 2014-05-15T18:54:14 | 2014-05-15T18:54:14 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 789 | h | //============================================================================
// Name : Classifier.h
// Author : Jordan Frank (jordan.frank@cs.mcgill.ca)
// Copyright : MIT
//============================================================================
#include <stdlib.h>
#include "ClassifyTrajectory.h"
#include <vector>
#include <ANN/ANN.h>
#ifndef CLASSIFIER_H_
#define CLASSIFIER_H_
class Classifier {
private:
std::vector<NamedModel*>* models;
public:
Classifier(std::vector<NamedModel*>* models);
void go(ANNcoord* data, uint length, uint embdim, uint neighbours, uint seglength, uint algorithm, uint verbosity);
virtual ~Classifier();
};
inline float get_interpolation_coefficient(ANNpoint p, ANNpoint p1, ANNpoint p2, uint dim);
#endif /* CLASSIFIER_H_ */
| [
"jordan.frank@cs.mcgill.ca"
] | jordan.frank@cs.mcgill.ca |
a76ca0f9b6b4b741ac052f7dd3cb922679fa3303 | b1011a23739cff333a9da1b76b71953fdc3579fb | /szescian/Sphere.h | 725fdc99189a5a7684731ed5cc185a35b9468cb8 | [] | no_license | RumSoft/IV-OpenGL-mars-rover | f2489bc7e9737f883ee5507600c0f0502107deaa | 8c5c44250a483236a0c26e39764128c30f894422 | refs/heads/master | 2022-01-13T23:08:08.827040 | 2019-07-01T19:58:32 | 2019-07-01T19:58:32 | 177,123,890 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 794 | h | #pragma once
#include "Geom.h"
class Sphere : public Shape {
public:
Sphere(Vec3 pos, float r, ColorF color = GREEN) : Sphere(pos, r, 5, color) {}
Sphere(Vec3 pos, ColorF color) : Sphere(pos, 4, 5, color) {}
Sphere(Vec3 pos, float r = 5, int steps = 5, ColorF color = GREEN) {
this->Type = TriangleStrip;
this->Color = color;
this->Origin = pos;
const float f = 2 * M_PI / steps;
const float f2 = M_PI / steps;
for (int i = 0; i < steps; i++) {
for (int j = steps; j >= 0; j--) {
auto v1 = Vec3(
sin(j * f2) * cos(i * f),
sin(j * f2) * sin(i * f),
cos(j * f2));
auto v2 = Vec3(
sin(j * f2) * cos((i + 1) * f),
sin(j * f2) * sin((i + 1) * f),
cos(j * f2));
this->AddPoint(r * v1, v1);
this->AddPoint(r * v2, v2);
}
}
}
}; | [
"dr124@o2.pl"
] | dr124@o2.pl |
08e06c493f82f835dd065e00ac9bc032caef9ac6 | f7285b87fce347afd57e220e191bd3c449cf5e0c | /tablemodel.h | 34b655e9f7f1ac003172862d000e4936341877a4 | [] | no_license | lenarano/SeekFace | 2d4121055f4bae26a43c03abd7972f9db2cea4b1 | 0f5107e09f278735c2b06feb7d7fc92048b6d9f8 | refs/heads/master | 2020-03-19T04:58:01.006755 | 2018-06-03T08:34:18 | 2018-06-03T08:34:18 | 135,886,545 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 462 | h | #ifndef TABLEMODEL_H
#define TABLEMODEL_H
#include <QObject>
#include <QSqlTableModel>
#include <QString>
#include <QColor>
#include <QPixmap>
class TableModel : public QSqlTableModel
{
Q_OBJECT
public:
explicit TableModel(QObject *parent = 0);
QVariant data(const QModelIndex &idx, int role) const;
signals:
public slots:
private:
QString RUS(const char* t) { return QString::fromLocal8Bit(t); }
QString unknown;
};
#endif // TABLEMODEL_H
| [
"strozh@mail.ru"
] | strozh@mail.ru |
74326d9a948cb634968f581960f203d50f7f106b | c5ec9ad3e676286d2725e3787363cae8cfd3cacd | /src/packet_writer.cpp | b08d43a3c4311f792cb8529792a5f4ab696e068c | [
"BSD-2-Clause"
] | permissive | MrMugiwara/libtins | adebbd4ea583a3b6ec32b68d7bcc739c34f716dd | 905119760331a55d5ce9aa9382edca9af39d194a | refs/heads/master | 2021-01-11T18:09:30.659004 | 2017-01-16T17:36:33 | 2017-01-16T17:36:33 | 79,504,934 | 1 | 0 | null | 2017-01-19T23:18:38 | 2017-01-19T23:18:38 | null | UTF-8 | C++ | false | false | 2,860 | cpp | /*
* Copyright (c) 2016, Matias Fontanini
* 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.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#ifndef _WIN32
#include <sys/time.h>
#endif
#include <stdexcept>
#include "packet_writer.h"
#include "packet.h"
#include "pdu.h"
#include "exceptions.h"
using std::string;
namespace Tins {
PacketWriter::PacketWriter(const string& file_name, LinkType lt) {
init(file_name, lt);
}
PacketWriter::~PacketWriter() {
if (dumper_ && handle_) {
pcap_dump_close(dumper_);
pcap_close(handle_);
}
}
void PacketWriter::write(PDU& pdu) {
timeval tv;
#ifndef _WIN32
gettimeofday(&tv, 0);
#else
// fixme
tv = timeval();
#endif
write(pdu, tv);
}
void PacketWriter::write(Packet& packet) {
timeval tv;
tv.tv_sec = packet.timestamp().seconds();
tv.tv_usec = packet.timestamp().microseconds();
write(*packet.pdu(), tv);
}
void PacketWriter::write(PDU& pdu, const struct timeval& tv) {
PDU::serialization_type buffer = pdu.serialize();
struct pcap_pkthdr header = {
tv,
static_cast<bpf_u_int32>(buffer.size()),
static_cast<bpf_u_int32>(buffer.size())
};
pcap_dump((u_char*)dumper_, &header, &buffer[0]);
}
void PacketWriter::init(const string& file_name, int link_type) {
handle_ = pcap_open_dead(link_type, 65535);
if (!handle_) {
throw pcap_open_failed();
}
dumper_ = pcap_dump_open(handle_, file_name.c_str());
if (!dumper_) {
pcap_close(handle_);
throw pcap_error(pcap_geterr(handle_));
}
}
} // Tins
| [
"matias.fontanini@gmail.com"
] | matias.fontanini@gmail.com |
7c0498db844cfa3d8694eee15ce542ff73d02eda | 137dc3c195a134588cbcbca0b7a76d2bcff4d067 | /Hashing/Unlock longest permutation 1 to n.cpp | feac63ef028703b493da5345df1959131ae240b4 | [] | no_license | noticeable/Data-Structures-and-Algorithms | aff8b98400d5180fe74a20235c793925d5599102 | 95fb8fef95fae09d86270bd204083f42a49a3b66 | refs/heads/master | 2020-09-07T09:31:53.395077 | 2019-07-28T10:08:36 | 2019-07-28T10:08:36 | 220,738,986 | 1 | 0 | null | 2019-11-10T04:02:42 | 2019-11-10T04:02:41 | null | UTF-8 | C++ | false | false | 1,285 | cpp | #include<bits/stdc++.h>
#include<unordered_map>
using namespace std;
int main()
{
int n,k;
cin>>n>>k;
unordered_map<int,int> h;
vector<int>v;
for(int i=0;i<n;i++)
{
int e;
cin>>e;
v.push_back(e);
h.insert(make_pair(e,i));
}
for(auto y : h)
{
cout<<y.first<<" at "<<y.second<<" index "<<endl;
}
if(n==k)
{
sort(v.begin(),v.end(),greater<int>());
}
for(int j = n; j>=1;j--)
{
if(k>0)
{
int ini = h[j]; /// here j is 5 initially j = num, its original index from hashmap is being extracted
int best = n-j; /// best is the best index of the number. Like 5 should be at 0th index.
if(ini != best)
{
h[j] = best; /// 5 is alloted the best index in hashmap. 5 is now mapped with 0.
int element = v.at(best); /// Change the index of the element which was at position 0. Swap the element basically. Here index of element i.e 3 will become 4 from 0
h[element] = ini;
swap(v[best],v[ini]);
k--;
}
}
}
for(int i=0; i<n; i++)
{
cout<<v[i]<<" ";
}
}
| [
"noreply@github.com"
] | noreply@github.com |
ec02de225bea2e70dd108ac7248e4cdb0c1d8a3f | 630c076b607475818f3cc8a33f325cee30ffdb98 | /Задача 5 (1).cpp | 64c4778f6b233f48246c2e1971f2e641beb0b57d | [] | no_license | firstripecherry/Ambarova | 5c08f7c429bd4e7efba1f5e2ad3bdd53768ed392 | e15e305649ee24c21ddff525442f752936bfc3b2 | refs/heads/master | 2021-07-03T08:07:28.032991 | 2020-07-03T13:38:12 | 2020-07-03T13:38:12 | 209,772,991 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 860 | cpp | #include "stdafx.h"
#include <iostream>
using namespace std;
class Radius
{
private:
double radius;
friend double GetLength(Radius&);
friend double GetArea(Radius&);
friend class Volume;
public:
double Get(void) { return radius; }
void Set(double nradius) { radius = nradius; }
};
double GetLength(Radius& r)
{
return (double)(2 * r.radius * 3.1415);
}
class Volume
{
public:
double GetVolume(Radius* r)
{
return (double)(4.0 / 3.0 * 3.1415 * r->radius * r->radius * r->radius);
}
};
int _tmain(int argc, _TCHAR* argv[])
{
Radius r;
Volume v;
double len, area, vol;
r.Set(3);
len = GetLength(r);
area = ::GetArea(r);
vol = v.GetVolume(&r);
cout << "Length = " << len << endl;
cout << "Area = " << area << endl;
cout << "Volume = " << vol << endl;
return 0;
} | [
"noreply@github.com"
] | noreply@github.com |
7d87a3798bfb9a8b1f004c404c2d4b3e944e5fee | 30e78c3e8f7ba6247819cf98ff4327fd3f37c458 | /src/Window/Window.h | 3d2424e1b41375e3cdf9c4a941eef802dca7abc0 | [
"MIT"
] | permissive | RihamHazem/SonicGame | f9d54f1734f39349c789a578efbfac936699bbf4 | 315d6bb09bd9a297a627773ee76bcc2ca3a5fbe9 | refs/heads/master | 2020-05-04T23:50:13.783290 | 2019-04-04T18:51:06 | 2019-04-04T18:51:06 | 179,556,805 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,129 | h | #pragma once
#include <iostream>
#include <string>
#include <GL/glew.h>
#include <GLFW/glfw3.h>
using namespace std;
class Window
{
private:
public:
GLFWwindow* mWind;
/* Constructs a new Window with the defined properties */
Window(int width, int height, const char* title);
/* Destructs current Window and release any used resources */
~Window();
/* Returns wether the window requested to close or not */
bool CloseRequested() const;
/* Swaps the back screen buffer with the front buffer */
void SwapBuffers();
/* Processes the recived events by calling the corresponding callbacks */
void PollEvents();
/* Clears the screen buffer */
void ClearScreen();
/* Sets the color used when clearing the screen */
void SetClearColor(double red, double green, double blue, double alpha);
/* Sets Window's size */
void SetSize(int width, int height);
/* Gets Window's size */
void GetSize(int* width, int* height) const;
/* Sets Window's position */
void SetPosition(int xpox, int ypos);
/* Shows or hides the mouse */
void EnableMouse(bool enable);
}; | [
"noreply@github.com"
] | noreply@github.com |
bf906a60403e274d3d09ba24494de5faab8f997f | bbcda48854d6890ad029d5973e011d4784d248d2 | /trunk/win/Source/Includes/QtIncludes/src/corelib/tools/qtextboundaryfinder.h | 3f2fef15dfb1fb830d10834cb4a5c86588ab5493 | [
"Apache-2.0",
"MIT",
"curl",
"LGPL-2.1-or-later",
"BSD-3-Clause",
"BSL-1.0",
"LicenseRef-scancode-public-domain",
"LGPL-2.1-only",
"Zlib",
"LicenseRef-scancode-unknown",
"LicenseRef-scancode-unknown-license-reference",
"MS-LPL"
] | permissive | dyzmapl/BumpTop | 9c396f876e6a9ace1099b3b32e45612a388943ff | 1329ea41411c7368516b942d19add694af3d602f | refs/heads/master | 2020-12-20T22:42:55.100473 | 2020-01-25T21:00:08 | 2020-01-25T21:00:08 | 236,229,087 | 0 | 0 | Apache-2.0 | 2020-01-25T20:58:59 | 2020-01-25T20:58:58 | null | UTF-8 | C++ | false | false | 3,320 | h | /****************************************************************************
**
** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the QtCore module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** GNU Lesser General Public License Usage
** This file may be used under the terms of the GNU Lesser General Public
** License version 2.1 as published by the Free Software Foundation and
** appearing in the file LICENSE.LGPL included in the packaging of this
** file. Please review the following information to ensure the GNU Lesser
** General Public License version 2.1 requirements will be met:
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU General
** Public License version 3.0 as published by the Free Software Foundation
** and appearing in the file LICENSE.GPL included in the packaging of this
** file. Please review the following information to ensure the GNU General
** Public License version 3.0 requirements will be met:
** http://www.gnu.org/copyleft/gpl.html.
**
** Other Usage
** Alternatively, this file may be used in accordance with the terms and
** conditions contained in a signed written agreement between you and Nokia.
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QTEXTBOUNDARYFINDER_H
#define QTEXTBOUNDARYFINDER_H
#include <QtCore/qchar.h>
#include <QtCore/qstring.h>
QT_BEGIN_HEADER
QT_BEGIN_NAMESPACE
QT_MODULE(Core)
class QTextBoundaryFinderPrivate;
class Q_CORE_EXPORT QTextBoundaryFinder
{
public:
QTextBoundaryFinder();
QTextBoundaryFinder(const QTextBoundaryFinder &other);
QTextBoundaryFinder &operator=(const QTextBoundaryFinder &other);
~QTextBoundaryFinder();
enum BoundaryType {
Grapheme,
Word,
Line,
Sentence
};
enum BoundaryReason {
NotAtBoundary = 0,
StartWord = 1,
EndWord = 2
//Hyphen
};
Q_DECLARE_FLAGS( BoundaryReasons, BoundaryReason )
QTextBoundaryFinder(BoundaryType type, const QString &string);
QTextBoundaryFinder(BoundaryType type, const QChar *chars, int length, unsigned char *buffer = 0, int bufferSize = 0);
inline bool isValid() const { return d; }
inline BoundaryType type() const { return t; }
QString string() const;
void toStart();
void toEnd();
int position() const;
void setPosition(int position);
int toNextBoundary();
int toPreviousBoundary();
bool isAtBoundary() const;
BoundaryReasons boundaryReasons() const;
private:
BoundaryType t;
QString s;
const QChar *chars;
int length;
int pos;
uint freePrivate : 1;
uint unused : 31;
QTextBoundaryFinderPrivate *d;
};
QT_END_NAMESPACE
QT_END_HEADER
#endif
| [
"anandx@google.com"
] | anandx@google.com |
ba10d9b900d4c7dd3a4d944cff4187a77d486753 | 8405b68c50c0df62db4f4ea40871b21c6d83dab3 | /nefry_handson_1/nefry_handson_1.ino | eb818e8a6a0b43a963bf2766a4c8ccc13b18a091 | [
"MIT"
] | permissive | pokiiio/2018-02-07_hands-on_workshop | e778e8c26978dfb0eb33f1879448a7e7faa325b0 | 901c786f2f270f8ad7846d3447d16a28a7e773cb | refs/heads/master | 2021-05-03T07:49:39.777564 | 2018-02-07T17:03:14 | 2018-02-07T17:03:14 | 120,556,622 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 333 | ino | #include <Nefry.h>
void setup() {
}
void loop() {
Nefry.println("ON"); // シリアルモニタに出力
Nefry.setLed(255, 0, 0); // LEDを光らせる
Nefry.ndelay(1000); // 1秒待つ
Nefry.println("OFF"); // シリアルモニタに出力
Nefry.setLed(0, 0, 0); // LEDを消す
Nefry.ndelay(1000); // 1秒待つ
}
| [
"32353873+pokiiio@users.noreply.github.com"
] | 32353873+pokiiio@users.noreply.github.com |
42240da7da8dd2f76999808630b9c4bdf6da8bf0 | 0eff74b05b60098333ad66cf801bdd93becc9ea4 | /second/download/squid/gumtree/squid_repos_function_7227_last_repos.cpp | 19f7a2a5cd9292f92ab44304d796b733540bceab | [] | no_license | niuxu18/logTracker-old | 97543445ea7e414ed40bdc681239365d33418975 | f2b060f13a0295387fe02187543db124916eb446 | refs/heads/master | 2021-09-13T21:39:37.686481 | 2017-12-11T03:36:34 | 2017-12-11T03:36:34 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 376 | cpp | void
Ipc::Mem::Segment::checkSupport(const char *const context)
{
if (!Enabled()) {
debugs(54, 5, HERE << context <<
": True shared memory segments are not supported. "
"Cannot fake shared segments in SMP config.");
fatalf("Ipc::Mem::Segment: Cannot fake shared segments in SMP config (%s)\n",
context);
}
} | [
"993273596@qq.com"
] | 993273596@qq.com |
6c54563880d6075fc9a034cd70122cd5011c18bf | a075225a2e1fe2d5e60e7802c5f0d0d884816904 | /v0.2.0/src/Common/THierarchicalCostFunctionProvider.h | ad9913192659a6e20446bc3050e4e6f70afd5036 | [
"BSD-3-Clause"
] | permissive | hqng/optimal-transport | 592d225c114b4c478ede2f9f3010a5e5aa160bdf | c868db74f6b7dd675c5892d70e38fb0bd623dded | refs/heads/master | 2020-04-16T22:56:41.962056 | 2019-11-23T08:52:11 | 2019-11-23T08:52:11 | 165,991,297 | 0 | 0 | NOASSERTION | 2019-11-23T08:52:12 | 2019-01-16T07:02:59 | C++ | UTF-8 | C++ | false | false | 4,625 | h | #ifndef THierarchicalCostFunctionProvider_H_
#define THierarchicalCostFunctionProvider_H_
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<Common/Tools.h>
class THierarchicalCostFunctionProvider {
public:
static constexpr double DBL_INFINITY=1E100; // effective value for infinity
double **xPos, **yPos; // pointers to coordinates of points:
// hierarchical: xPos is list of pointers to coordinates at each hierarchy level
double **xRadii, **yRadii; // likewise: radii of each hierarchical cell, used to compute lower bounds
double **alpha, **beta; // pointers to hierarchical dual variables, to compute effective costs if required
bool haveDuals; // indicates whether hierarchical dual variables are available
int posDim; // dimensionality of coordinates in xPos and yPos arrays
int layerBottom; // number of finest layer (0 is coarsest)
THierarchicalCostFunctionProvider(
double **_xPos, double **_yPos,
double **_xRadii, double **_yRadii,
int _posDim, int _layerBottom,
bool _haveDuals,
double **_alpha, double **_beta);
virtual ~THierarchicalCostFunctionProvider();
virtual void setLayerBottom(int _layerBottom);
virtual double getCost(int layer, int x, int y) {
return getCostAsym(layer,x,layer,y);
}
virtual inline double getCostAsym(
__attribute__((unused)) int layerX, __attribute__((unused)) int x,
__attribute__((unused)) int layerY, __attribute__((unused)) int y) {
return 0;
}
inline double getCostEff(int layer, int x, int y) {
// compute effective cost, where dual variable values are subtracted
if(haveDuals) {
return getCost(layer,x,y)-alpha[layer][x]-beta[layer][y];
} else {
// if no duals available, return default cost
return getCost(layer,x,y);
}
}
inline double getCostEffAsym(int layerX, int x, int layerY, int y) {
// compute effective cost, where dual variable values are subtracted
if(haveDuals) {
return getCostAsym(layerX,x,layerY,y)-alpha[layerX][x]-beta[layerY][y];
} else {
// if no duals available, return default cost
return getCostAsym(layerX,x,layerY,y);
}
}
};
/* squared Euclidean distance in \R^n */
class THierarchicalCostFunctionProvider_SquaredEuclidean : public THierarchicalCostFunctionProvider {
public:
double weight; // global rescaling parameter for Euclidean distance
bool WFmode; // whether to compute cost function for Wasserstein--Fisher--Rao distance instead
double WFlenscale; // max transport distance in WF mode
double WFprefactor; // weight prefactor to avoid repeated computation
THierarchicalCostFunctionProvider_SquaredEuclidean(
double **_xPos, double **_yPos,
double **_xRadii, double **_yRadii,
int _posDim, int _layerBottom,
bool _haveDuals,
double **_alpha, double **_beta,
double _weight,
bool _WFmode,
double _WFlenscale);
THierarchicalCostFunctionProvider_SquaredEuclidean(
double **_xPos, double **_yPos,
double **_xRadii, double **_yRadii,
int _posDim, int _layerBottom,
bool _haveDuals,
double **_alpha, double **_beta,
double _weight) :
THierarchicalCostFunctionProvider_SquaredEuclidean(
_xPos, _yPos,
_xRadii, _yRadii,
_posDim, _layerBottom,
_haveDuals,
_alpha, _beta,
_weight,
false,
0) {};
void setWFlenscale(const double _WFlenscale);
double getCostAsym(int layerX, int x, int layerY, int y);
};
/* Wp: Euclidean distance in \R^n to power p*/
class THierarchicalCostFunctionProvider_PEuclidean : public THierarchicalCostFunctionProvider {
public:
double weight; // global rescaling parameter for Euclidean distance
double p; // exponent for distance
THierarchicalCostFunctionProvider_PEuclidean(
double **_xPos, double **_yPos,
double **_xRadii, double **_yRadii,
int _posDim, int _layerBottom,
bool _haveDuals,
double **_alpha, double **_beta,
double _weight,
double _p
);
double getCostAsym(int layerX, int x, int layerY, int y);
};
/* Wp: Euclidean distance in \R^n to power p*/
class THierarchicalCostFunctionProvider_Hyperbolic : public THierarchicalCostFunctionProvider {
public:
double scale; // scale for hyperboloid: x_0^2 = scale^2 + \sum_{i=1}^n x_i^2
double scaleSqr; // to avoid computing the square all the time
// in this implementation, pos only stores coordinates x_1 to x_n; x_0 is implicit via above "Minkowski" formula
THierarchicalCostFunctionProvider_Hyperbolic(
double **_xPos, double **_yPos,
double **_xRadii, double **_yRadii,
int _posDim, int _layerBottom,
bool _haveDuals,
double **_alpha, double **_beta,
double _scale
);
double getCostAsym(int layerX, int x, int layerY, int y);
};
#endif
| [
"schmitzer@uni-muenster.de"
] | schmitzer@uni-muenster.de |
8fa762c3349a7098767f7d58eb47df197f6d6a7b | ca35e9ad7161656b1e3eb4c2ded9fccba0e30549 | /Core/stringparser.cpp | fc1e5d5240c1961863cb190662dbde52391ee3b6 | [] | no_license | leppert/fire | 082725f1dcb79bd72dd9f12142bbe0dae211e6b8 | 9afa3a79d1961551e43d65b0e940b416fc40a65e | refs/heads/master | 2020-11-26T19:36:49.131773 | 2009-12-07T21:14:54 | 2009-12-07T21:14:54 | 1,627,927 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 2,046 | cpp | #include "stringparser.hpp"
#include "diag.hpp"
#include <sstream>
using namespace std;
/// function returning the integer which follows the string t in string s.
/// examples:
/// getIntAfter("egal=7asdf","egal=",1) will return 7
/// getIntAfter("egal=7asdf","doof=",1) will return 1, as the string doof= is not found
const int getIntAfter(const string& s, const string& t, const int def) {
int val=def;
uint pos=s.find(t);
string INTstring="";
if(pos<s.size()) {
for (uint i=pos+t.size(); s[i]>='0' && s[i]<='9' && i<s.size() ; ++i) {
INTstring+=s[i];
}
istringstream istr(INTstring);
istr >> val;
}
return val;
}
/// function returning the double which follows the string t in string s.
/// examples:
/// getDoubleAfter("egal=7asdf","egal=",1) will return 7
/// getDoubleAfter("egal=7asdf","doof=",1) will return 1, as the string doof= is not found
const double getDoubleAfter(const string& s, const string& t, const double def) {
double val=def;
uint pos=s.find(t);
string DOUBLEstring="";
if (pos<s.size()) {
for (uint i=pos+t.size(); (s[i]>='0' && s[i]<='9' || s[i]=='.') && i<s.size(); ++i) {
DOUBLEstring+=s[i];
}
istringstream istr(DOUBLEstring);
istr >> val;
}
return val;
}
/// function returning the string which follows the string t in string s.
/// delimiter can be set
/// examples:
/// getDoubleAfter("egal=7asdf","egal=",1) will return 7
/// getDoubleAfter("egal=7asdf","doof=",1) will return 1, as the string doof= is not found
const string getStringAfter(const string& s, const string& t, const string& def, const char delimiter) {
string val=def;
uint pos=s.find(t);
string STRINGstring="";
if (pos<s.size()) {
for (uint i=pos+t.size(); s[i]!=delimiter && i<s.size() ; ++i) {
STRINGstring+=s[i];
}
val=STRINGstring;
}
return val;
}
///function returning whether a certain string is part of another string
const bool getBooleanString(const string& s, const string &t) {
return s.find(t)<s.size();
}
| [
"deselaers@gmail.com@b4508c54-8848-11de-8bba-6b05ac85e19d"
] | deselaers@gmail.com@b4508c54-8848-11de-8bba-6b05ac85e19d |
7894802903798801fc576af4007dfb742f54b042 | be7be28da870bb8037d2e68a45ee95ffda62ff94 | /include/trainer.h | b056a1b381f2533d92d740691c2afc02dde7c5f0 | [] | no_license | daniel-m-campos/RL-Snake-Game | b93e2c0dc006e2c7aa50c2c6c05ed56620a611e3 | b416784e1ea266b355810f2a2582b017c3725fbc | refs/heads/master | 2023-03-14T10:54:56.949207 | 2021-03-03T20:52:04 | 2021-03-03T20:52:04 | 337,855,377 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 411 | h | #ifndef RLSNAKEGAME_TRAINER_H
#define RLSNAKEGAME_TRAINER_H
#include <string>
void Train(std::size_t grid_width, std::size_t grid_height,
long num_episodes = 1'000, long max_steps = 1'000'000,
double epsilon = 0.5, double discount_factor = 0.9,
double step_size = 0.5);
std::string FileName(std::size_t grid_width, std::size_t grid_height);
#endif // RLSNAKEGAME_TRAINER_H
| [
"daniel.m.campos@icloud.com"
] | daniel.m.campos@icloud.com |
16dd344114bd64df040e9516d5b276d8cd0bb33e | 66ca11eb24a32dc8a72d8bc2c2167cfccfb05878 | /factorial.cpp | e6878fddb5d2c9cfa8d9ab980fd2840ac4d9662b | [] | no_license | brhmyldrm01/Algorithm | 6ca5ae8d11c4ba95ee05eff55b17c4c3c665fe47 | 04f22545f6c77a1be85c7024804c9ccacb58038f | refs/heads/master | 2020-11-24T09:21:50.665374 | 2020-01-23T20:52:12 | 2020-01-23T20:52:12 | 228,076,756 | 1 | 0 | null | null | null | null | ISO-8859-3 | C++ | false | false | 253 | cpp | #include <iostream>
using namespace std;
int main(){
setlocale(LC_ALL, "Turkish");
int a;
cout<<"faktöriyel ";
cin >> a;
int deger=1;
for(int i=a; i > 0; i--)
{
deger = deger*i;
}
cout<< deger << endl;
return -1;
}
| [
"noreply@github.com"
] | noreply@github.com |
20b1bca083f5c01a9f7b46217878b116e14bb3f0 | 258cc0f1875b16d8ec8e75592be90f79e59a9fe0 | /Onboard-SDK-ROS-4.0.1/include/dji_osdk_ros_obsoleted/dji_sdk/dji_sdk_node.h | 886f08b242795a8fa923fc151528ddf70c9f9b3c | [] | no_license | CatchACat083/Onboard-SDK-ROS_Detection-Geolocation | 93cf2085352ce64c8b3d2ba4e8cf3e167c907add | 020649a3790b1bac16196be21333b33073f2b36a | refs/heads/master | 2023-03-03T04:54:03.265372 | 2021-02-02T08:55:13 | 2021-02-02T08:55:13 | 335,208,771 | 5 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 17,686 | h | /** @file dji_sdk_node.h
* @version 3.7
* @date July, 2018
*
* @brief
* A ROS modules to interact with DJI onboard SDK
*
* @copyright 2018 DJI. All rights reserved.
*
*/
#ifndef DJI_SDK_NODE_MAIN_H
#define DJI_SDK_NODE_MAIN_H
//! ROS
#include <ros/ros.h>
#include <tf/tf.h>
//! ROS standard msgs
#include <geometry_msgs/Quaternion.h>
#include <geometry_msgs/Vector3Stamped.h>
#include <sensor_msgs/Imu.h>
#include <sensor_msgs/NavSatFix.h>
#include <sensor_msgs/Joy.h>
#include <sensor_msgs/TimeReference.h>
#include <sensor_msgs/BatteryState.h>
#include <sensor_msgs/Image.h>
#include <std_msgs/UInt8.h>
#include <std_msgs/Int16.h>
#include <std_msgs/Float32.h>
#include <std_msgs/String.h>
#include <nmea_msgs/Sentence.h>
//! msgs
#include <dji_osdk_ros/Gimbal.h>
#include <dji_osdk_ros/MobileData.h>
#include <dji_osdk_ros/PayloadData.h>
#include <dji_osdk_ros/FlightAnomaly.h>
#include <dji_osdk_ros/VOPosition.h>
#include <dji_osdk_ros/FCTimeInUTC.h>
#include <dji_osdk_ros/GPSUTC.h>
//! mission service
// missionManager
#include <dji_osdk_ros/MissionStatus.h>
// waypoint
#include <dji_osdk_ros/MissionWpAction.h>
#include <dji_osdk_ros/MissionWpGetInfo.h>
#include <dji_osdk_ros/MissionWpGetSpeed.h>
#include <dji_osdk_ros/MissionWpSetSpeed.h>
#include <dji_osdk_ros/MissionWpUpload.h>
// hotpoint
#include <dji_osdk_ros/MissionHpAction.h>
#include <dji_osdk_ros/MissionHpGetInfo.h>
#include <dji_osdk_ros/MissionHpResetYaw.h>
#include <dji_osdk_ros/MissionHpUpdateRadius.h>
#include <dji_osdk_ros/MissionHpUpdateYawRate.h>
#include <dji_osdk_ros/MissionHpUpload.h>
// hardsync
#include <dji_osdk_ros/SetHardSync.h>
//! service headers
#include <dji_osdk_ros/Activation.h>
#include <dji_osdk_ros/CameraAction.h>
#include <dji_osdk_ros/DroneArmControl.h>
#include <dji_osdk_ros/DroneTaskControl.h>
#include <dji_osdk_ros/MFIOConfig.h>
#include <dji_osdk_ros/MFIOSetValue.h>
#include <dji_osdk_ros/SDKControlAuthority.h>
#include <dji_osdk_ros/SetLocalPosRef.h>
#include <dji_osdk_ros/SendMobileData.h>
#include <dji_osdk_ros/SendPayloadData.h>
#include <dji_osdk_ros/QueryDroneVersion.h>
#ifdef ADVANCED_SENSING
#include <dji_osdk_ros/Stereo240pSubscription.h>
#include <dji_osdk_ros/StereoDepthSubscription.h>
#include <dji_osdk_ros/StereoVGASubscription.h>
#include <dji_osdk_ros/SetupCameraStream.h>
#endif
//! SDK library
#include <dji_vehicle.hpp>
#include <dji_linux_helpers.hpp>
#define C_EARTH (double)6378137.0
#define C_PI (double)3.141592653589793
#define DEG2RAD(DEG) ((DEG) * ((C_PI) / (180.0)))
#define RAD2DEG(RAD) ((RAD) * (180.0) / (C_PI))
using namespace DJI::OSDK;
class DJISDKNode
{
public:
DJISDKNode(ros::NodeHandle& nh, ros::NodeHandle& nh_private, int argc, char** argv);
~DJISDKNode();
enum TELEMETRY_TYPE
{
USE_BROADCAST = 0,
USE_SUBSCRIBE = 1
};
enum
{
PACKAGE_ID_5HZ = 0,
PACKAGE_ID_50HZ = 1,
PACKAGE_ID_100HZ = 2,
PACKAGE_ID_400HZ = 3
};
private:
bool initVehicle(ros::NodeHandle& nh_private, int argc, char** argv);
bool initServices(ros::NodeHandle& nh);
bool initFlightControl(ros::NodeHandle& nh);
bool initSubscriber(ros::NodeHandle& nh);
bool initPublisher(ros::NodeHandle& nh);
bool initActions(ros::NodeHandle& nh);
bool initDataSubscribeFromFC(ros::NodeHandle& nh);
void cleanUpSubscribeFromFC();
// bool validateSerialDevice(LinuxSerialDevice* serialDevice);
bool isM100();
/*!
* @note this function exists here instead of inside the callback function
* due to the usages, i.e. we not only provide service call but also
* call it for the user when this node was instantiated
* we cannot call a service without serviceClient, which is in another
* node
*/
ACK::ErrorCode activate(int l_app_id, std::string l_enc_key);
//! flight control subscriber callbacks
void flightControlSetpointCallback(
const sensor_msgs::Joy::ConstPtr& pMsg);
void flightControlPxPyPzYawCallback(
const sensor_msgs::Joy::ConstPtr& pMsg);
void flightControlVxVyVzYawrateCallback(
const sensor_msgs::Joy::ConstPtr& pMsg);
void flightControlRollPitchPzYawrateCallback(
const sensor_msgs::Joy::ConstPtr& pMsg);
//! general subscriber callbacks
void gimbalAngleCtrlCallback(const dji_osdk_ros::Gimbal::ConstPtr& msg);
void gimbalSpeedCtrlCallback(
const geometry_msgs::Vector3Stamped::ConstPtr& msg);
//! general service callbacks
bool droneActivationCallback(dji_osdk_ros::Activation::Request& request,
dji_osdk_ros::Activation::Response& response);
bool sdkCtrlAuthorityCallback(
dji_osdk_ros::SDKControlAuthority::Request& request,
dji_osdk_ros::SDKControlAuthority::Response& response);
bool setLocalPosRefCallback(
dji_osdk_ros::SetLocalPosRef::Request& request,
dji_osdk_ros::SetLocalPosRef::Response& response);
//! control service callbacks
bool droneArmCallback(dji_osdk_ros::DroneArmControl::Request& request,
dji_osdk_ros::DroneArmControl::Response& response);
bool droneTaskCallback(dji_osdk_ros::DroneTaskControl::Request& request,
dji_osdk_ros::DroneTaskControl::Response& response);
//! Mobile Data Service
bool sendToMobileCallback(dji_osdk_ros::SendMobileData::Request& request,
dji_osdk_ros::SendMobileData::Response& response);
//! Payload Data Service
bool sendToPayloadCallback(dji_osdk_ros::SendPayloadData::Request& request,
dji_osdk_ros::SendPayloadData::Response& response);
//! Query Drone FW version
bool queryVersionCallback(dji_osdk_ros::QueryDroneVersion::Request& request,
dji_osdk_ros::QueryDroneVersion::Response& response);
bool cameraActionCallback(dji_osdk_ros::CameraAction::Request& request,
dji_osdk_ros::CameraAction::Response& response);
//! mfio service callbacks
bool MFIOConfigCallback(dji_osdk_ros::MFIOConfig::Request& request,
dji_osdk_ros::MFIOConfig::Response& response);
bool MFIOSetValueCallback(dji_osdk_ros::MFIOSetValue::Request& request,
dji_osdk_ros::MFIOSetValue::Response& response);
//! mission service callbacks
// mission manager
bool missionStatusCallback(dji_osdk_ros::MissionStatus::Request& request,
dji_osdk_ros::MissionStatus::Response& response);
// waypoint mission
bool missionWpUploadCallback(dji_osdk_ros::MissionWpUpload::Request& request,
dji_osdk_ros::MissionWpUpload::Response& response);
bool missionWpActionCallback(dji_osdk_ros::MissionWpAction::Request& request,
dji_osdk_ros::MissionWpAction::Response& response);
bool missionWpGetInfoCallback(dji_osdk_ros::MissionWpGetInfo::Request& request,
dji_osdk_ros::MissionWpGetInfo::Response& response);
bool missionWpGetSpeedCallback(
dji_osdk_ros::MissionWpGetSpeed::Request& request,
dji_osdk_ros::MissionWpGetSpeed::Response& response);
bool missionWpSetSpeedCallback(
dji_osdk_ros::MissionWpSetSpeed::Request& request,
dji_osdk_ros::MissionWpSetSpeed::Response& response);
// hotpoint mission
bool missionHpUploadCallback(dji_osdk_ros::MissionHpUpload::Request& request,
dji_osdk_ros::MissionHpUpload::Response& response);
bool missionHpActionCallback(dji_osdk_ros::MissionHpAction::Request& request,
dji_osdk_ros::MissionHpAction::Response& response);
bool missionHpGetInfoCallback(dji_osdk_ros::MissionHpGetInfo::Request& request,
dji_osdk_ros::MissionHpGetInfo::Response& response);
bool missionHpUpdateYawRateCallback(
dji_osdk_ros::MissionHpUpdateYawRate::Request& request,
dji_osdk_ros::MissionHpUpdateYawRate::Response& response);
bool missionHpResetYawCallback(
dji_osdk_ros::MissionHpResetYaw::Request& request,
dji_osdk_ros::MissionHpResetYaw::Response& response);
bool missionHpUpdateRadiusCallback(
dji_osdk_ros::MissionHpUpdateRadius::Request& request,
dji_osdk_ros::MissionHpUpdateRadius::Response& response);
//! hard sync service callback
bool setHardsyncCallback(dji_osdk_ros::SetHardSync::Request& request,
dji_osdk_ros::SetHardSync::Response& response);
#ifdef ADVANCED_SENSING
//! stereo image service callback
bool stereo240pSubscriptionCallback(dji_osdk_ros::Stereo240pSubscription::Request& request,
dji_osdk_ros::Stereo240pSubscription::Response& response);
bool stereoDepthSubscriptionCallback(dji_osdk_ros::StereoDepthSubscription::Request& request,
dji_osdk_ros::StereoDepthSubscription::Response& response);
bool stereoVGASubscriptionCallback(dji_osdk_ros::StereoVGASubscription::Request& request,
dji_osdk_ros::StereoVGASubscription::Response& response);
bool setupCameraStreamCallback(dji_osdk_ros::SetupCameraStream::Request& request,
dji_osdk_ros::SetupCameraStream::Response& response);
#endif
//! data broadcast callback
void dataBroadcastCallback();
void fromMobileDataCallback(RecvContainer recvFrame);
void fromPayloadDataCallback(RecvContainer recvFrame);
static void NMEACallback(Vehicle* vehiclePtr,
RecvContainer recvFrame,
UserData userData);
static void GPSUTCTimeCallback(Vehicle *vehiclePtr,
RecvContainer recvFrame,
UserData userData);
static void FCTimeInUTCCallback(Vehicle* vehiclePtr,
RecvContainer recvFrame,
UserData userData);
static void PPSSourceCallback(Vehicle* vehiclePtr,
RecvContainer recvFrame,
UserData userData);
static void SDKfromMobileDataCallback(Vehicle* vehicle,
RecvContainer recvFrame,
DJI::OSDK::UserData userData);
static void SDKfromPayloadDataCallback(Vehicle *vehicle,
RecvContainer recvFrame,
DJI::OSDK::UserData userData);
static void SDKBroadcastCallback(Vehicle* vehicle,
RecvContainer recvFrame,
DJI::OSDK::UserData userData);
static void publish5HzData(Vehicle* vehicle,
RecvContainer recvFrame,
DJI::OSDK::UserData userData);
static void publish50HzData(Vehicle* vehicle,
RecvContainer recvFrame,
DJI::OSDK::UserData userData);
static void publish100HzData(Vehicle* vehicle,
RecvContainer recvFrame,
DJI::OSDK::UserData userData);
static void publish400HzData(Vehicle* vehicle,
RecvContainer recvFrame,
DJI::OSDK::UserData userData);
#ifdef ADVANCED_SENSING
static void publish240pStereoImage(Vehicle* vehicle,
RecvContainer recvFrame,
DJI::OSDK::UserData userData);
static void publishVGAStereoImage(Vehicle* vehicle,
RecvContainer recvFrame,
DJI::OSDK::UserData userData);
static void publishMainCameraImage(CameraRGBImage img, void* userData);
static void publishFPVCameraImage(CameraRGBImage img, void* userData);
#endif
private:
//! OSDK core
Vehicle* vehicle;
LinuxSetup* linuxEnvironment;
//! general service servers
ros::ServiceServer drone_activation_server;
ros::ServiceServer sdk_ctrlAuthority_server;
ros::ServiceServer camera_action_server;
//! flight control service servers
ros::ServiceServer drone_arm_server;
ros::ServiceServer drone_task_server;
//! mfio service servers
ros::ServiceServer mfio_config_server;
ros::ServiceServer mfio_set_value_server;
//! mission service servers
// mission manager
ros::ServiceServer mission_status_server;
// waypoint mission
ros::ServiceServer waypoint_upload_server;
ros::ServiceServer waypoint_action_server;
ros::ServiceServer waypoint_getInfo_server;
ros::ServiceServer waypoint_getSpeed_server;
ros::ServiceServer waypoint_setSpeed_server;
// hotpoint mission
ros::ServiceServer hotpoint_upload_server;
ros::ServiceServer hotpoint_action_server;
ros::ServiceServer hotpoint_getInfo_server;
ros::ServiceServer hotpoint_setSpeed_server;
ros::ServiceServer hotpoint_resetYaw_server;
ros::ServiceServer hotpoint_setRadius_server;
// send data to mobile device
ros::ServiceServer send_to_mobile_server;
// send data to payload device
ros::ServiceServer send_to_payload_server;
//! hardsync service
ros::ServiceServer set_hardsync_server;
//! Query FW version of FC
ros::ServiceServer query_version_server;
//! Set Local position reference
ros::ServiceServer local_pos_ref_server;
#ifdef ADVANCED_SENSING
//! stereo image service
ros::ServiceServer subscribe_stereo_240p_server;
ros::ServiceServer subscribe_stereo_depth_server;
ros::ServiceServer subscribe_stereo_vga_server;
ros::ServiceServer camera_stream_server;
#endif
//! flight control subscribers
ros::Subscriber flight_control_sub;
ros::Subscriber flight_control_position_yaw_sub;
ros::Subscriber flight_control_velocity_yawrate_sub;
ros::Subscriber flight_control_rollpitch_yawrate_vertpos_sub;
//! general subscribers
ros::Subscriber gimbal_angle_cmd_subscriber;
ros::Subscriber gimbal_speed_cmd_subscriber;
//! telemetry data publisher
ros::Publisher attitude_publisher;
ros::Publisher angularRate_publisher;
ros::Publisher acceleration_publisher;
ros::Publisher battery_state_publisher;
ros::Publisher trigger_publisher;
ros::Publisher imu_publisher;
ros::Publisher flight_status_publisher;
ros::Publisher gps_health_publisher;
ros::Publisher gps_position_publisher;
ros::Publisher vo_position_publisher;
ros::Publisher height_publisher;
ros::Publisher velocity_publisher;
ros::Publisher from_mobile_data_publisher;
ros::Publisher from_payload_data_publisher;
ros::Publisher gimbal_angle_publisher;
ros::Publisher displaymode_publisher;
ros::Publisher rc_publisher;
ros::Publisher rc_connection_status_publisher;
ros::Publisher rtk_position_publisher;
ros::Publisher rtk_velocity_publisher;
ros::Publisher rtk_yaw_publisher;
ros::Publisher rtk_position_info_publisher;
ros::Publisher rtk_yaw_info_publisher;
ros::Publisher rtk_connection_status_publisher;
ros::Publisher flight_anomaly_publisher;
//! Local Position Publisher (Publishes local position in ENU frame)
ros::Publisher local_position_publisher;
ros::Publisher local_frame_ref_publisher;
ros::Publisher time_sync_nmea_publisher;
ros::Publisher time_sync_gps_utc_publisher;
ros::Publisher time_sync_fc_utc_publisher;
ros::Publisher time_sync_pps_source_publisher;
#ifdef ADVANCED_SENSING
ros::Publisher stereo_240p_front_left_publisher;
ros::Publisher stereo_240p_front_right_publisher;
ros::Publisher stereo_240p_down_front_publisher;
ros::Publisher stereo_240p_down_back_publisher;
ros::Publisher stereo_240p_front_depth_publisher;
ros::Publisher stereo_vga_front_left_publisher;
ros::Publisher stereo_vga_front_right_publisher;
ros::Publisher main_camera_stream_publisher;
ros::Publisher fpv_camera_stream_publisher;
#endif
//! constant
const int WAIT_TIMEOUT = 10;
const int MAX_SUBSCRIBE_PACKAGES = 5;
const int INVALID_VERSION = 0;
//! configurations
int app_id;
std::string enc_key;
std::string drone_version;
std::string serial_device;
std::string acm_device;
int baud_rate;
int app_version;
std::string app_bundle_id; // reserved
int uart_or_usb;
double gravity_const;
//! use broadcast or subscription to get telemetry data
TELEMETRY_TYPE telemetry_from_fc;
bool stereo_subscription_success;
bool stereo_vga_subscription_success;
bool user_select_broadcast;
const tf::Matrix3x3 R_FLU2FRD;
const tf::Matrix3x3 R_ENU2NED;
void flightControl(uint8_t flag, float32_t xSP, float32_t ySP, float32_t zSP, float32_t yawSP);
enum AlignState
{
UNALIGNED,
ALIGNING,
ALIGNED
};
AlignState curr_align_state;
static int constexpr STABLE_ALIGNMENT_COUNT = 400;
static double constexpr TIME_DIFF_CHECK = 0.008;
static double constexpr TIME_DIFF_ALERT = 0.020;
ros::Time base_time;
bool align_time_with_FC;
bool local_pos_ref_set;
void alignRosTimeWithFlightController(ros::Time now_time, uint32_t tick);
void setUpM100DefaultFreq(uint8_t freq[16]);
void setUpA3N3DefaultFreq(uint8_t freq[16]);
void gpsConvertENU(double &ENU_x, double &ENU_y,
double gps_t_lon, double gps_t_lat,
double gps_r_lon, double gps_r_lat);
double local_pos_ref_latitude, local_pos_ref_longitude, local_pos_ref_altitude;
double current_gps_latitude, current_gps_longitude, current_gps_altitude;
int current_gps_health;
bool rtkSupport;
};
#endif // DJI_SDK_NODE_MAIN_H
| [
"linbosen083@gmail.com"
] | linbosen083@gmail.com |
a018b9a21d67287ebb3b22b537b965ba1137a01c | 88c68374f69aab6e62b2f9475a3b2e93583adc54 | /KM.cpp | c202666e77f504a1c352b2c2a79a2837a702f297 | [] | no_license | vladvlad00/tema1_SI | 7b7c33385058fc56bccc2d8c85f5cd7fcee881bd | d42a3d565e775c1f0eb05173eabebcd6eccda948 | refs/heads/master | 2023-08-20T22:17:19.775174 | 2021-10-20T19:49:31 | 2021-10-20T19:49:31 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,895 | cpp | #include <iostream>
#include <fstream>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <unistd.h>
#include <openssl/aes.h>
#include <openssl/rand.h>
#include <cstdlib>
#include "common.h"
constexpr int PORT = 8888;
constexpr int MAX_CONNECTIONS = 5;
void generate_key(uint8_t key[16])
{
RAND_bytes(key, 16);
printf("Generated key:\n");
for (int i=0;i<16;i++)
printf("%02X", key[i]);
printf("\n");
}
void handle_connection(int sd)
{
uint8_t k_prim[16];
uint8_t k[16];
uint8_t k_enc[16];
read_key(k_prim);
generate_key(k);
AES_KEY ctx;
AES_set_encrypt_key(k_prim, 128, &ctx);
AES_encrypt(k, k_enc, &ctx);
my_write(sd, k_enc, 16);
close(sd);
}
int main()
{
int sock = socket(AF_INET, SOCK_STREAM, 0);
if (!sock)
{
perror("Socket failed");
exit(1);
}
int opt = true;
if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char *) &opt, sizeof(opt)) < 0)
{
perror("Setsockopt failed");
exit(1);
}
sockaddr_in address{};
address.sin_family = AF_INET;
address.sin_addr.s_addr = INADDR_ANY;
address.sin_port = htons(PORT);
if (bind(sock, (sockaddr*)&address, sizeof(address)) < 0)
{
perror("Bind failed");
exit(1);
}
std::cout << "Listening on port " << PORT << '\n';
if (listen(sock, MAX_CONNECTIONS) < 0)
{
perror("Listen failed");
exit(1);
}
std::cout << "Waiting for connections\n";
int addrlen = sizeof(address);
while (true)
{
int sd = accept(sock, (sockaddr*)&address, (socklen_t*)&addrlen);
if (sd < 0)
{
perror("Accept failed");
exit(1);
}
std::cout << "New connection from " << inet_ntoa(address.sin_addr) << ':' << ntohs(address.sin_port) << '\n';
handle_connection(sd);
}
return 0;
}
| [
"teodorescu.vlad@yahoo.com"
] | teodorescu.vlad@yahoo.com |
2d8b8bb2f1ed4a58d42c47eb6f0f125d9c993e27 | 5bde0d4a83d8a233e089e0882029c73fff65ab1c | /Helbreath.Client/UI/Wmain.cpp | cc4a892b49dccf89a8e2634b84fb16bb7cf7d11b | [] | no_license | isolatorhk/Helbreath.Client | 9ba9c29114f5b16ddd3976258ac31200200da476 | ee93d3d12aac625f16769b43b3a9b6d7633744be | refs/heads/master | 2021-01-17T22:34:40.159443 | 2016-06-26T20:14:19 | 2016-06-26T20:14:19 | 62,503,148 | 1 | 0 | null | 2016-07-03T15:36:13 | 2016-07-03T15:36:12 | null | UTF-8 | C++ | false | false | 10,642 | cpp | // --------------------------------------------------------------
// Helbreath Client
//
// 1998.10 by Soph
//
// --------------------------------------------------------------
#include <windows.h>
#include <windowsx.h>
#include <stdio.h>
#include <stdlib.h>
#include <winbase.h>
#include <mmsystem.h>
#include <process.h>
#include "..\res\resource.h"
#include "..\net\XSocket.h"
#include "winmain.h"
#include "..\Game.h"
#include "..\GlobalDef.h"
extern "C" __declspec( dllimport) int __FindHackingDll__(char *);
// --------------------------------------------------------------
#define WM_USER_TIMERSIGNAL WM_USER + 500
#define WM_USER_CALCSOCKETEVENT WM_USER + 600
int G_iAddTable31[64][510], G_iAddTable63[64][510];
int G_iAddTransTable31[510][64], G_iAddTransTable63[510][64];
long G_lTransG100[64][64], G_lTransRB100[64][64];
long G_lTransG70[64][64], G_lTransRB70[64][64];
long G_lTransG50[64][64], G_lTransRB50[64][64];
long G_lTransG25[64][64], G_lTransRB25[64][64];
long G_lTransG2[64][64], G_lTransRB2[64][64];
char szAppClass[32];
HWND G_hWnd = NULL;
HWND G_hEditWnd = NULL;
HINSTANCE G_hInstance = NULL;
MMRESULT G_mmTimer;
char G_cSpriteAlphaDegree;
class CGame * G_pGame;
class XSocket * G_pCalcSocket = NULL;
BOOL G_bIsCalcSocketConnected = TRUE;
DWORD G_dwCalcSocketTime = NULL, G_dwCalcSocketSendTime = NULL;
char G_cCmdLine[256], G_cCmdLineTokenA[120], G_cCmdLineTokenA_Lowercase[120], G_cCmdLineTokenB[120], G_cCmdLineTokenC[120], G_cCmdLineTokenD[120], G_cCmdLineTokenE[120];
// --------------------------------------------------------------
LRESULT CALLBACK WndProc(HWND hWnd,UINT message,WPARAM wParam, LPARAM lParam)
{
if(G_pGame->GetText( hWnd, message, wParam, lParam)) return 0;
switch (message) {
case WM_USER_CALCSOCKETEVENT:
G_pGame->_CalcSocketClosed();
break;
case WM_CLOSE:
if ( (G_pGame->m_cGameMode == GAMEMODE_ONMAINGAME) && ( G_pGame->m_bForceDisconn == FALSE ) )
{
#ifdef _DEBUG
if (G_pGame->m_cLogOutCount == -1 || G_pGame->m_cLogOutCount > 2) G_pGame->m_cLogOutCount = 1;
#else
if (G_pGame->m_cLogOutCount == -1 || G_pGame->m_cLogOutCount > 11) G_pGame->m_cLogOutCount = 11;
#endif
}
else if (G_pGame->m_cGameMode == GAMEMODE_ONLOADING) return (DefWindowProc(hWnd, message, wParam, lParam));
else if (G_pGame->m_cGameMode == GAMEMODE_ONMAINMENU) G_pGame->ChangeGameMode(GAMEMODE_ONQUIT);
break;
case WM_SYSCOMMAND:
if((wParam&0xFFF0)==SC_SCREENSAVE || (wParam&0xFFF0)==SC_MONITORPOWER)
return 0;
return DefWindowProc(hWnd, message, wParam, lParam);
case WM_USER_TIMERSIGNAL:
G_pGame->OnTimer();
break;
case WM_KEYDOWN:
G_pGame->OnKeyDown(wParam);
return (DefWindowProc(hWnd, message, wParam, lParam));
case WM_KEYUP:
G_pGame->OnKeyUp(wParam);
return (DefWindowProc(hWnd, message, wParam, lParam));
case WM_SYSKEYDOWN:
G_pGame->OnSysKeyDown(wParam);
return (DefWindowProc(hWnd, message, wParam, lParam));
break;
case WM_SYSKEYUP:
G_pGame->OnSysKeyUp(wParam);
return (DefWindowProc(hWnd, message, wParam, lParam));
break;
case WM_ACTIVATEAPP:
if( wParam == 0 )
{ G_pGame->m_bIsProgramActive = FALSE;
G_pGame->m_DInput.SetAcquire(FALSE);
}else
{ G_pGame->m_bIsProgramActive = TRUE;
G_pGame->m_DInput.SetAcquire(TRUE);
G_pGame->m_bCtrlPressed = FALSE;
if (G_pGame->bCheckImportantFile() == FALSE)
{ MessageBox(G_pGame->m_hWnd, "File checksum error! Get Update again please!", "ERROR1", MB_ICONEXCLAMATION | MB_OK);
PostQuitMessage(0);
return 0;
}
if (__FindHackingDll__("CRCCHECK") != 1)
{ G_pGame->ChangeGameMode(GAMEMODE_ONQUIT);
return NULL;
} }
return DefWindowProc(hWnd, message, wParam, lParam);
case WM_SETCURSOR:
SetCursor(NULL);
return TRUE;
case WM_DESTROY:
OnDestroy();
return DefWindowProc(hWnd, message, wParam, lParam);
break;
case WM_USER_GAMESOCKETEVENT:
G_pGame->OnGameSocketEvent(wParam, lParam);
break;
case WM_USER_LOGSOCKETEVENT:
G_pGame->OnLogSocketEvent(wParam, lParam);
break;
default:
return (DefWindowProc(hWnd, message, wParam, lParam));
}
return NULL;
}
int APIENTRY WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPSTR lpCmdLine, int nCmdShow )
{HINSTANCE hDll;
char cSearchDll[] = "rd`qbg-ckk";
char cRealName[12];
srand((unsigned)time(NULL));
char *pJammer = new char[(rand() % 100) +1];
G_pGame = new class CGame;
ZeroMemory(cRealName, sizeof(cRealName));
strcpy(cRealName, cSearchDll);
for (WORD i = 0; i < strlen(cRealName); i++)
if (cRealName[i] != NULL) cRealName[i]++;
hDll = LoadLibrary(cRealName);
if( hDll == NULL )
{ MessageBox(NULL, "don't find search.dll", "ERROR!", MB_OK);
return 0;
}
#ifdef USING_WIN_IME
HINSTANCE hRichDll = LoadLibrary( "Riched20.dll" );
#endif
typedef int (MYPROC)(char *) ;
MYPROC *pFindHook;
pFindHook = (MYPROC *) GetProcAddress(hDll, "__FindHackingDll__") ;
if (pFindHook== NULL)
{ MessageBox(NULL, "can't find search.dll", "ERROR!", MB_OK);
return 0 ;
}else if ((*pFindHook)("CRCCHECK") != 1)
{ return 0 ;
}
FreeLibrary(hDll);
#ifndef _DEBUG
if (OpenMutex(MUTEX_ALL_ACCESS, FALSE, "0543kjg3j31%") != NULL) {
MessageBox(NULL, "Only one Helbreath client program allowed!", "ERROR!", MB_OK);
return 0;
}
HANDLE hMutex = CreateMutex(NULL, FALSE, "0543kjg3j31%");
#endif
sprintf( szAppClass, "Client-I%d", hInstance);
if (!InitApplication( hInstance)) return (FALSE);
if (!InitInstance(hInstance, nCmdShow)) return (FALSE);
Initialize((char *)lpCmdLine);
EventLoop();
#ifndef _DEBUG
ReleaseMutex(hMutex);
CloseHandle(hMutex);
#endif
delete[] pJammer;
delete G_pGame;
#ifdef USING_WIN_IME
FreeLibrary(hRichDll);
#endif
return 0;
}
BOOL InitApplication( HINSTANCE hInstance)
{WNDCLASS wc;
wc.style = (CS_HREDRAW | CS_VREDRAW | CS_OWNDC | CS_DBLCLKS);
wc.lpfnWndProc = (WNDPROC)WndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = sizeof (int);
wc.hInstance = hInstance;
wc.hIcon = LoadCursor(NULL, IDI_APPLICATION);
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
wc.lpszMenuName = NULL;
wc.lpszClassName = szAppClass;
return (RegisterClass(&wc));
}
BOOL InitInstance( HINSTANCE hInstance, int nCmdShow )
{ int cx = GetSystemMetrics(SM_CXFULLSCREEN)/2;
int cy = GetSystemMetrics(SM_CYFULLSCREEN)/2;
if(cy>280) cy -= 40;
G_hWnd = CreateWindowEx(NULL, szAppClass, "Helbreath Poland", WS_POPUP, cx-320, cy-240,
640, 480, NULL, NULL, hInstance, NULL);
if (!G_hWnd) return FALSE;
G_hInstance = hInstance;
ShowWindow(G_hWnd, SW_SHOWDEFAULT);
UpdateWindow(G_hWnd);
return TRUE;
}
void EventLoop()
{ register MSG msg;
while( 1 )
{ if( PeekMessage( &msg, NULL, 0, 0, PM_NOREMOVE ) )
{ if( !GetMessage( &msg, NULL, 0, 0 ) ) return;// msg.wParam;
TranslateMessage(&msg);
DispatchMessage(&msg);
}
else if (G_pGame->m_bIsProgramActive) G_pGame->UpdateScreen();
else if (G_pGame->m_cGameMode == GAMEMODE_ONLOADING) G_pGame->UpdateScreen_OnLoading( FALSE );
else WaitMessage();
}
}
void OnDestroy()
{ G_pGame->m_bIsProgramActive = FALSE;
_StopTimer(G_mmTimer);
G_pGame->Quit();
WSACleanup();
PostQuitMessage(0);
}
void CALLBACK _TimerFunc(UINT wID, UINT wUser, DWORD dwUSer, DWORD dw1, DWORD dw2)
{ PostMessage(G_hWnd, WM_USER_TIMERSIGNAL, wID, NULL);
}
MMRESULT _StartTimer(DWORD dwTime)
{TIMECAPS caps;
timeGetDevCaps(&caps, sizeof(caps));
timeBeginPeriod(caps.wPeriodMin);
return timeSetEvent(dwTime,0,_TimerFunc,0, (UINT)TIME_PERIODIC);
}
void _StopTimer(MMRESULT timerid)
{TIMECAPS caps;
if (timerid != 0)
{ timeKillEvent(timerid);
timerid = 0;
timeGetDevCaps(&caps, sizeof(caps));
timeEndPeriod(caps.wPeriodMin);
}
}
void Initialize(char * pCmdLine)
{int iX, iY, iSum;
int iErrCode;
WORD wVersionRequested;
WSADATA wsaData;
wVersionRequested = MAKEWORD( 2, 2 );
iErrCode = WSAStartup( wVersionRequested, &wsaData );
if ( iErrCode )
{ MessageBox(G_hWnd, "Winsock-V1.1 not found! Cannot execute program.","ERROR",MB_ICONEXCLAMATION | MB_OK);
PostQuitMessage(0);
return;
}
if (G_pGame->bInit(G_hWnd, G_hInstance, pCmdLine) == FALSE)
{ PostQuitMessage(0);
return;
}
G_mmTimer = _StartTimer(1000);
for (iX = 0; iX < 64; iX++)
for (iY = 0; iY < 510; iY++)
{ iSum = iX + (iY - 255);
if (iSum <= 0) iSum = 1;
if (iSum >= 31) iSum = 31;
G_iAddTable31[iX][iY] = iSum;
iSum = iX + (iY - 255);
if (iSum <= 0) iSum = 1;
if (iSum >= 63) iSum = 63;
G_iAddTable63[iX][iY] = iSum;
if ((iY - 255) < iX) G_iAddTransTable31[iY][iX] = iX;
else if ((iY - 255) > 31) G_iAddTransTable31[iY][iX] = 31;
else G_iAddTransTable31[iY][iX] = iY-255;
if ((iY - 255) < iX) G_iAddTransTable63[iY][iX] = iX;
else if ((iY - 255) > 63) G_iAddTransTable63[iY][iX] = 63;
else G_iAddTransTable63[iY][iX] = iY-255;
}
}
LONG GetRegKey(HKEY key, LPCTSTR subkey, LPTSTR retdata)
{ HKEY hkey;
LONG retval = RegOpenKeyEx(key, subkey, 0, KEY_QUERY_VALUE, &hkey);
if (retval == ERROR_SUCCESS)
{ long datasize = MAX_PATH;
TCHAR data[MAX_PATH];
RegQueryValue(hkey, NULL, data, &datasize);
lstrcpy(retdata,data);
RegCloseKey(hkey);
}
return retval;
}
void GoHomepage()
{
LPCTSTR url = MSG_HOMEPAGE;
int showcmd = SW_SHOW;
char key[MAX_PATH + MAX_PATH];
// First try ShellExecute()
HINSTANCE result = ShellExecute(NULL, "open", url, NULL,NULL, showcmd);
// If it failed, get the .htm regkey and lookup the program
if ((UINT)result <= HINSTANCE_ERROR)
{ if (GetRegKey(HKEY_CLASSES_ROOT, ".htm", key) == ERROR_SUCCESS)
{ lstrcat(key, "\\shell\\open\\command");
if (GetRegKey(HKEY_CLASSES_ROOT,key,key) == ERROR_SUCCESS)
{ char *pos;
pos = strstr(key, "\"%1\"");
if (pos == NULL) { // No quotes found
pos = strstr(key, "%1"); // Check for %1, without quotes
if (pos == NULL) // No parameter at all...
pos = key+lstrlen(key)-1;
else *pos = '\0'; // Remove the parameter
}else *pos = '\0'; // Remove the parameter
lstrcat(pos, " ");
lstrcat(pos, url);
result = (HINSTANCE) WinExec(key,showcmd);
} } }
}
////////////////////////////////////////////////////////////////////////
| [
"pawel@sawicz.eu"
] | pawel@sawicz.eu |
dbfdc1203a65fae39da5c2f55abdf80008bc73e9 | 43efb8c60d19d37c2f42805754086f910348a5ae | /Coding/Spoj/BUYINGAPPLES.cpp | d70f53823c3f4abe342df2663cfaf81d6e76cb20 | [] | no_license | akshay2742/Coding-Problems | 961399752b30b6a17b72b2c1b2afada9e839a326 | 838be77b707cc82a9453c964ff8cedce1646dfe8 | refs/heads/master | 2021-06-26T14:08:39.292052 | 2020-10-08T18:34:19 | 2020-10-08T18:34:19 | 151,247,129 | 0 | 1 | null | 2020-10-08T18:34:21 | 2018-10-02T11:59:38 | C++ | UTF-8 | C++ | false | false | 1,235 | cpp | #include<iostream>
#include<cstdio>
#define readint(n) scanf("%d",&n)
using namespace std;
int wt[1001];
int val[1001];
int a[1001];
int max(int a,int b){
return (a>b?a:b);
}
int knapSack(int W,int N,int packets)
{
int K[N+1][W+1];
int i,w;
int count=0;
for (i = 0; i <= N; i++)
{
for (w = 0; w <= W; w++)
{
if (i==0 || w==0)
K[i][w] = 0000;
else if (wt[i-1] <= w)
{
if(val[i-1] + K[i-1][w-wt[i-1]]<K[i-1][w])
count++;
K[i][w] = min(val[i-1] + K[i-1][w-wt[i-1]], K[i-1][w]);
}
else
K[i][w] = K[i-1][w];
cout<<K[i][w]<<" ";
}
cout<<endl;
}
cout<<"count"<<count;
return -1*K[N][W];
}
int main(){
int t,W,N,i;
readint(t);
while(t--){
readint(W);
readint(N);
for(i=0;i<N;i++)
readint(a[i]);
int j=0;
for(i=0;i<N;i++){
if(a[i]!=-1)
{
val[j]=-a[i];
wt[j]=i+1;
j++;
}
}
int packets=W;
cout<<knapSack(N,j,packets)<<endl;
}
return 0;
}
| [
"prateekrishu@yahoo.com"
] | prateekrishu@yahoo.com |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.