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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
d484adc16f72b9f381db49e0491824ee4b2ff217 | 8afb5afd38548c631f6f9536846039ef6cb297b9 | /_REPO/MICROSOFT/cocos2d-x/cocos/editor-support/cocostudio/CCComBase.h | 8479e36220969f009de8f87ba1fde25f11777754 | [
"MIT"
] | permissive | bgoonz/UsefulResourceRepo2.0 | d87588ffd668bb498f7787b896cc7b20d83ce0ad | 2cb4b45dd14a230aa0e800042e893f8dfb23beda | refs/heads/master | 2023-03-17T01:22:05.254751 | 2022-08-11T03:18:22 | 2022-08-11T03:18:22 | 382,628,698 | 10 | 12 | MIT | 2022-10-10T14:13:54 | 2021-07-03T13:58:52 | null | UTF-8 | C++ | false | false | 2,389 | h | /****************************************************************************
Copyright (c) 2013-2017 Chukong Technologies Inc.
http://www.cocos2d-x.org
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
****************************************************************************/
#ifndef __CC_EXTENTIONS_CCCOMBASE_H__
#define __CC_EXTENTIONS_CCCOMBASE_H__
#include <string>
#include "editor-support/cocostudio/DictionaryHelper.h"
#include "editor-support/cocostudio/CocosStudioExport.h"
#include "base/ObjectFactory.h"
#include "editor-support/cocostudio/CocoLoader.h"
#define DECLARE_CLASS_COMPONENT_INFO \
public: \
static cocos2d::ObjectFactory::TInfo Type; \
static cocos2d::Ref* createInstance(void); \
#define IMPLEMENT_CLASS_COMPONENT_INFO(className) \
cocos2d::Ref* className::createInstance(void) \
{ \
return className::create(); \
} \
cocos2d::ObjectFactory::TInfo className::Type(#className, &className::createInstance); \
#define CREATE_CLASS_COMPONENT_INFO(className) \
cocos2d::ObjectFactory::TInfo(#className, &className::createInstance)
struct CC_STUDIO_DLL SerData
{
const rapidjson::Value *_rData;
cocostudio::stExpCocoNode *_cocoNode;
cocostudio::CocoLoader *_cocoLoader;
SerData()
{
_rData = NULL;
_cocoNode = NULL;
_cocoLoader = NULL;
}
};
#endif
| [
"bryan.guner@gmail.com"
] | bryan.guner@gmail.com |
929c531a6c5e2935e954784f4b6e25a3b0d2353b | 2eb76d0e7de1292e885e6069421c49180cf607ea | /zimodem/zimodem/zimodem.ino | 4b5b6dd256eef4f5078c49df5cfc4eff4bccb76b | [
"Apache-2.0"
] | permissive | StuartSeeley/Link232-Wifi | 8fa2f508c11d0dcfe8ae382fe284e7e08f655e98 | 167b1bb02e0688d866754bb09d88365e3120ee16 | refs/heads/master | 2023-06-15T17:31:19.977686 | 2021-07-12T02:58:49 | 2021-07-12T02:58:49 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 13,682 | ino | /*
Copyright 2016-2019 Bo Zimmerman
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
//#define TCP_SND_BUF 4 * TCP_MSS
#define ZIMODEM_VERSION "3.6.3"
const char compile_date[] = __DATE__ " " __TIME__;
#define DEFAULT_NO_DELAY true
#define null 0
#ifdef ARDUINO_ESP32_DEV
# define ZIMODEM_ESP32
#elif defined(ESP32)
# define ZIMODEM_ESP32
#elif defined(ARDUINO_ESP320)
# define ZIMODEM_ESP32
#elif defined(ARDUINO_NANO32)
# define ZIMODEM_ESP32
#elif defined(ARDUINO_LoLin32)
# define ZIMODEM_ESP32
#elif defined(ARDUINO_ESPea32)
# define ZIMODEM_ESP32
#elif defined(ARDUINO_QUANTUM)
# define ZIMODEM_ESP32
#else
# define ZIMODEM_ESP8266
#endif
#ifdef SUPPORT_LED_PINS
# ifdef GPIO_NUM_0
# define DEFAULT_PIN_AA GPIO_NUM_16
# define DEFAULT_PIN_HS GPIO_NUM_15
# define DEFAULT_PIN_WIFI GPIO_NUM_0
# else
# define DEFAULT_PIN_AA 16
# define DEFAULT_PIN_HS 15
# define DEFAULT_PIN_WIFI 0
# endif
# define DEFAULT_HS_BAUD 38400
# define DEFAULT_AA_ACTIVE LOW
# define DEFAULT_AA_INACTIVE HIGH
# define DEFAULT_HS_ACTIVE LOW
# define DEFAULT_HS_INACTIVE HIGH
# define DEFAULT_WIFI_ACTIVE LOW
# define DEFAULT_WIFI_INACTIVE HIGH
#endif
#ifdef ZIMODEM_ESP32
# define PIN_FACTORY_RESET GPIO_NUM_0
# define DEFAULT_PIN_DCD GPIO_NUM_14
# define DEFAULT_PIN_CTS GPIO_NUM_13
# define DEFAULT_PIN_RTS GPIO_NUM_15 // unused
# define DEFAULT_PIN_RI GPIO_NUM_32
# define DEFAULT_PIN_DSR GPIO_NUM_12
# define DEFAULT_PIN_DTR GPIO_NUM_27
# define debugPrintf Serial.printf
# define INCLUDE_SD_SHELL true
# define DEFAULT_FCT FCT_DISABLED
# define SerialConfig uint32_t
# define UART_CONFIG_MASK 0x8000000
# define UART_NB_BIT_MASK 0B00001100 | UART_CONFIG_MASK
# define UART_NB_BIT_5 0B00000000 | UART_CONFIG_MASK
# define UART_NB_BIT_6 0B00000100 | UART_CONFIG_MASK
# define UART_NB_BIT_7 0B00001000 | UART_CONFIG_MASK
# define UART_NB_BIT_8 0B00001100 | UART_CONFIG_MASK
# define UART_PARITY_MASK 0B00000011
# define UART_PARITY_NONE 0B00000000
# define UART_NB_STOP_BIT_MASK 0B00110000
# define UART_NB_STOP_BIT_0 0B00000000
# define UART_NB_STOP_BIT_1 0B00010000
# define UART_NB_STOP_BIT_15 0B00100000
# define UART_NB_STOP_BIT_2 0B00110000
# define preEOLN serial.prints
# define echoEOLN serial.write
//# define HARD_DCD_HIGH 1
//# define HARD_DCD_LOW 1
#else // ESP-8266, e.g. ESP-01, ESP-12E, inverted for C64Net WiFi Modem
# define DEFAULT_PIN_DSR 13
# define DEFAULT_PIN_DTR 12
# define DEFAULT_PIN_RI 14
# define DEFAULT_PIN_RTS 4
# define DEFAULT_PIN_CTS 5 // is 0 for ESP-01, see getDefaultCtsPin() below.
# define DEFAULT_PIN_DCD 2
# define DEFAULT_FCT FCT_RTSCTS
//# define RS232_INVERTED 1
# define debugPrintf doNothing
# define preEOLN(...)
# define echoEOLN(...) serial.prints(EOLN)
#endif
#ifdef RS232_INVERTED
# define DEFAULT_DCD_HIGH HIGH
# define DEFAULT_DCD_LOW LOW
# define DEFAULT_CTS_HIGH HIGH
# define DEFAULT_CTS_LOW LOW
# define DEFAULT_RTS_HIGH HIGH
# define DEFAULT_RTS_LOW LOW
# define DEFAULT_RI_HIGH HIGH
# define DEFAULT_RI_LOW LOW
# define DEFAULT_DSR_HIGH HIGH
# define DEFAULT_DSR_LOW LOW
# define DEFAULT_DTR_HIGH HIGH
# define DEFAULT_DTR_LOW LOW
#else
# define DEFAULT_DCD_HIGH LOW
# define DEFAULT_DCD_LOW HIGH
# define DEFAULT_CTS_HIGH LOW
# define DEFAULT_CTS_LOW HIGH
# define DEFAULT_RTS_HIGH LOW
# define DEFAULT_RTS_LOW HIGH
# define DEFAULT_RI_HIGH LOW
# define DEFAULT_RI_LOW HIGH
# define DEFAULT_DSR_HIGH LOW
# define DEFAULT_DSR_LOW HIGH
# define DEFAULT_DTR_HIGH LOW
# define DEFAULT_DTR_LOW HIGH
#endif
#define DEFAULT_BAUD_RATE 19200
#define DEFAULT_SERIAL_CONFIG SERIAL_8N1
#define MAX_PIN_NO 50
#define INTERNAL_FLOW_CONTROL_DIV 380
class ZMode
{
public:
virtual void serialIncoming();
virtual void loop();
};
#include "pet2asc.h"
#include "rt_clock.h"
#include "filelog.h"
#include "serout.h"
#include "connSettings.h"
#include "wificlientnode.h"
#include "stringstream.h"
#include "phonebook.h"
#include "wifiservernode.h"
#include "zstream.h"
#include "proto_http.h"
#include "proto_ftp.h"
#include "zcommand.h"
#include "zconfigmode.h"
#include "zprint.h"
#ifdef INCLUDE_SD_SHELL
#include "proto_xmodem.h"
#include "proto_zmodem.h"
#include "proto_kermit.h"
#include "zbrowser.h"
#endif
static WiFiClientNode *conns = null;
static WiFiServerNode *servs = null;
static PhoneBookEntry *phonebook = null;
static bool pinSupport[MAX_PIN_NO];
static bool browseEnabled = false;
static String termType = DEFAULT_TERMTYPE;
static String busyMsg = DEFAULT_BUSYMSG;
static ZMode *currMode = null;
static ZStream streamMode;
//static ZSlip slipMode; // not yet implemented
static ZCommand commandMode;
static ZPrint printMode;
static ZConfig configMode;
#ifdef INCLUDE_SD_SHELL
static ZBrowser browseMode;
#endif
static RealTimeClock zclock(0);
enum BaudState
{
BS_NORMAL,
BS_SWITCH_TEMP_NEXT,
BS_SWITCHED_TEMP,
BS_SWITCH_NORMAL_NEXT
};
static bool wifiConnected =false;
static String wifiSSI;
static String wifiPW;
static String hostname;
static IPAddress *staticIP = null;
static IPAddress *staticDNS = null;
static IPAddress *staticGW = null;
static IPAddress *staticSN = null;
static SerialConfig serialConfig = DEFAULT_SERIAL_CONFIG;
static int baudRate=DEFAULT_BAUD_RATE;
static int dequeSize=1+(DEFAULT_BAUD_RATE/INTERNAL_FLOW_CONTROL_DIV);
static BaudState baudState = BS_NORMAL;
static unsigned long resetPushTimer=0;
static int tempBaud = -1; // -1 do nothing
static int dcdStatus = LOW;
static int pinDCD = DEFAULT_PIN_DCD;
static int pinCTS = DEFAULT_PIN_CTS;
static int pinRTS = DEFAULT_PIN_RTS;
static int pinDSR = DEFAULT_PIN_DSR;
static int pinDTR = DEFAULT_PIN_DTR;
static int pinRI = DEFAULT_PIN_RI;
static int dcdActive = DEFAULT_DCD_HIGH;
static int dcdInactive = DEFAULT_DCD_LOW;
static int ctsActive = DEFAULT_CTS_HIGH;
static int ctsInactive = DEFAULT_CTS_LOW;
static int rtsActive = DEFAULT_RTS_HIGH;
static int rtsInactive = DEFAULT_RTS_LOW;
static int riActive = DEFAULT_RI_HIGH;
static int riInactive = DEFAULT_RI_LOW;
static int dtrActive = DEFAULT_DTR_HIGH;
static int dtrInactive = DEFAULT_DTR_LOW;
static int dsrActive = DEFAULT_DSR_HIGH;
static int dsrInactive = DEFAULT_DSR_LOW;
static int getDefaultCtsPin()
{
#ifdef ZIMODEM_ESP32
return DEFAULT_PIN_CTS;
#else
if((ESP.getFlashChipRealSize()/1024)>=4096) // assume this is a striketerm/esp12e
return DEFAULT_PIN_CTS;
else
return 0;
#endif
}
static void doNothing(const char* format, ...)
{
}
static void s_pinWrite(uint8_t pinNo, uint8_t value)
{
if(pinSupport[pinNo])
{
digitalWrite(pinNo, value);
}
}
static void setHostName(const char *hname)
{
#ifdef ZIMODEM_ESP32
tcpip_adapter_set_hostname(TCPIP_ADAPTER_IF_STA, hname);
#else
WiFi.hostname(hname);
#endif
}
static void setNewStaticIPs(IPAddress *ip, IPAddress *dns, IPAddress *gateWay, IPAddress *subNet)
{
if(staticIP != null)
free(staticIP);
staticIP = ip;
if(staticDNS != null)
free(staticDNS);
staticDNS = dns;
if(staticGW != null)
free(staticGW);
staticGW = gateWay;
if(staticSN != null)
free(staticSN);
staticSN = subNet;
}
static bool connectWifi(const char* ssid, const char* password, IPAddress *ip, IPAddress *dns, IPAddress *gateWay, IPAddress *subNet)
{
while(WiFi.status() == WL_CONNECTED)
{
WiFi.disconnect();
delay(100);
yield();
}
#ifndef ZIMODEM_ESP32
if(hostname.length() > 0)
setHostName(hostname.c_str());
#endif
WiFi.mode(WIFI_STA);
if((ip != null)&&(gateWay != null)&&(dns != null)&&(subNet!=null))
{
if(!WiFi.config(*ip,*gateWay,*subNet,*dns))
return false;
}
WiFi.begin(ssid, password);
if(hostname.length() > 0)
setHostName(hostname.c_str());
bool amConnected = (WiFi.status() == WL_CONNECTED) && (strcmp(WiFi.localIP().toString().c_str(), "0.0.0.0")!=0);
int WiFiCounter = 0;
while ((!amConnected) && (WiFiCounter < 30))
{
WiFiCounter++;
if(!amConnected)
delay(500);
amConnected = (WiFi.status() == WL_CONNECTED) && (strcmp(WiFi.localIP().toString().c_str(), "0.0.0.0")!=0);
}
wifiConnected = amConnected;
if(!amConnected)
WiFi.disconnect();
#ifdef SUPPORT_LED_PINS
s_pinWrite(DEFAULT_PIN_WIFI,wifiConnected?DEFAULT_WIFI_ACTIVE:DEFAULT_WIFI_INACTIVE);
#endif
return wifiConnected;
}
static void checkBaudChange()
{
switch(baudState)
{
case BS_SWITCH_TEMP_NEXT:
changeBaudRate(tempBaud);
baudState = BS_SWITCHED_TEMP;
break;
case BS_SWITCH_NORMAL_NEXT:
changeBaudRate(baudRate);
baudState = BS_NORMAL;
break;
default:
break;
}
}
static void changeBaudRate(int baudRate)
{
flushSerial(); // blocking, but very very necessary
delay(500); // give the client half a sec to catch up
logPrintfln("Baud change to %d.\n",baudRate);
debugPrintf("Baud change to %d.\n",baudRate);
dequeSize=1+(baudRate/INTERNAL_FLOW_CONTROL_DIV);
debugPrintf("Deque constant now: %d\n",dequeSize);
#ifdef ZIMODEM_ESP32
HWSerial.changeBaudRate(baudRate);
#else
HWSerial.begin(baudRate, serialConfig); //Change baud rate
#endif
#ifdef SUPPORT_LED_PINS
s_pinWrite(DEFAULT_PIN_HS,(baudRate>=DEFAULT_HS_BAUD)?DEFAULT_HS_ACTIVE:DEFAULT_HS_INACTIVE);
#endif
}
static void changeSerialConfig(SerialConfig conf)
{
flushSerial(); // blocking, but very very necessary
delay(500); // give the client half a sec to catch up
debugPrintf("Config changing %d.\n",(int)conf);
dequeSize=1+(baudRate/INTERNAL_FLOW_CONTROL_DIV);
debugPrintf("Deque constant now: %d\n",dequeSize);
#ifdef ZIMODEM_ESP32
HWSerial.changeConfig(conf);
#else
HWSerial.begin(baudRate, conf); //Change baud rate
#endif
debugPrintf("Config changed.\n");
}
static int checkOpenConnections()
{
int num=WiFiClientNode::getNumOpenWiFiConnections();
if(num == 0)
{
if((dcdStatus == dcdActive)
&&(dcdStatus != dcdInactive))
{
logPrintfln("DCD going inactive.\n");
dcdStatus = dcdInactive;
s_pinWrite(pinDCD,dcdStatus);
if(baudState == BS_SWITCHED_TEMP)
baudState = BS_SWITCH_NORMAL_NEXT;
if(currMode == &commandMode)
clearSerialOutBuffer();
}
}
else
{
if((dcdStatus == dcdInactive)
&&(dcdStatus != dcdActive))
{
logPrintfln("DCD going active.\n");
dcdStatus = dcdActive;
s_pinWrite(pinDCD,dcdStatus);
if((tempBaud > 0) && (baudState == BS_NORMAL))
baudState = BS_SWITCH_TEMP_NEXT;
}
}
return num;
}
void setup()
{
for(int i=0;i<MAX_PIN_NO;i++)
pinSupport[i]=false;
#ifdef ZIMODEM_ESP32
Serial.begin(115200); //the debug port
Serial.setDebugOutput(true);
debugPrintf("Debug port open and ready.\n");
for(int i=12;i<=23;i++)
pinSupport[i]=true;
for(int i=25;i<=27;i++)
pinSupport[i]=true;
for(int i=32;i<=33;i++)
pinSupport[i]=true;
pinSupport[36]=true;
pinSupport[39]=true;
#else
pinSupport[0]=true;
pinSupport[2]=true;
if((ESP.getFlashChipRealSize()/1024)>=4096) // assume this is a strykelink/esp12e
{
pinSupport[4]=true;
pinSupport[5]=true;
for(int i=9;i<=16;i++)
pinSupport[i]=true;
pinSupport[11]=false;
}
#endif
initSDShell();
currMode = &commandMode;
if(!SPIFFS.begin())
{
SPIFFS.format();
SPIFFS.begin();
debugPrintf("SPIFFS Formatted.");
}
HWSerial.begin(DEFAULT_BAUD_RATE, DEFAULT_SERIAL_CONFIG); //Start Serial
#ifdef ZIMODEM_ESP8266
HWSerial.setRxBufferSize(1024);
#endif
commandMode.loadConfig();
PhoneBookEntry::loadPhonebook();
dcdStatus = dcdInactive;
s_pinWrite(pinDCD,dcdStatus);
flushSerial();
#ifdef SUPPORT_LED_PINS
s_pinWrite(DEFAULT_PIN_WIFI,(WiFi.status() == WL_CONNECTED)?DEFAULT_WIFI_ACTIVE:DEFAULT_WIFI_INACTIVE);
s_pinWrite(DEFAULT_PIN_HS,(baudRate>=DEFAULT_HS_BAUD)?DEFAULT_HS_ACTIVE:DEFAULT_HS_INACTIVE);
#endif
}
void checkFactoryReset()
{
#ifdef ZIMODEM_ESP32
if(!digitalRead(PIN_FACTORY_RESET))
{
if(resetPushTimer != 1)
{
if(resetPushTimer==0)
{
resetPushTimer=millis();
if(resetPushTimer==1)
resetPushTimer++;
}
else
if((millis() - resetPushTimer) > 5000)
{
SPIFFS.remove(CONFIG_FILE);
SPIFFS.remove(CONFIG_FILE_OLD);
SPIFFS.remove("/zphonebook.txt");
SPIFFS.remove("/zlisteners.txt");
PhoneBookEntry::clearPhonebook();
SPIFFS.end();
SPIFFS.format();
SPIFFS.begin();
PhoneBookEntry::clearPhonebook();
if(WiFi.status() == WL_CONNECTED)
WiFi.disconnect();
baudRate = DEFAULT_BAUD_RATE;
commandMode.loadConfig();
PhoneBookEntry::loadPhonebook();
dcdStatus = dcdInactive;
s_pinWrite(pinDCD,dcdStatus);
wifiSSI="";
wifiConnected=false;
delay(500);
zclock.reset();
commandMode.reset();
resetPushTimer=1;
}
}
}
else
if(resetPushTimer != 0)
resetPushTimer=0;
#endif
}
void loop()
{
checkFactoryReset();
if(HWSerial.available())
{
currMode->serialIncoming();
}
currMode->loop();
zclock.tick();
}
| [
"dabone@gmail.com"
] | dabone@gmail.com |
b8ff0be3b3a53f2fc09b5af5f77c1ae7d931a75c | 6e5a9fbd9d60c2bcafd7c7d8b4fa0fffd3d8c132 | /src/test.cpp | b0d64bdfac6d75f91314383c8df6929f0a8f98e6 | [] | no_license | ZhaoChunYao/GoLite-Compiler | d53a17ec8fec8572814a3893e39ef690f2aac4ef | 48f458f21866bd4b0b4df4cc43ba2683df7d1077 | refs/heads/master | 2022-12-10T04:14:36.433007 | 2020-09-08T00:20:12 | 2020-09-08T00:20:12 | 293,652,182 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 123 | cpp | #include <iostream>
#include <string>
#include <array>
#include <vector>
using namespace std;
int main()
{
int j = 0 ;
}
| [
"chunyao.zhao@mail.mcgill.ca"
] | chunyao.zhao@mail.mcgill.ca |
d70a405dc3850598a9fee5eb63b99a6f18e61b1d | 85b157d4ea0125ccd821169e1f296db5e41a8991 | /src/ofApp.cpp | cb9435bfc44f1d1b69a11de876cdc76124a40c0d | [
"MIT"
] | permissive | fishkingsin/whiteSpace | d968d7c7e5860ab5fb7096fa2a4d45f49baff604 | e7706b0e1365dd210bf12d3262e0e3dc0db8956d | refs/heads/master | 2020-03-30T06:58:31.246277 | 2015-06-21T16:19:34 | 2015-06-21T16:19:34 | 37,815,682 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,000 | cpp | #include "ofApp.h"
//--------------------------------------------------------------
void ofApp::setup(){
ofSetFrameRate(25);
// ofSetBackgroundAuto(false);
ofSetLogLevel(OF_LOG_VERBOSE);
ofEnableAlphaBlending();
ofEnableArbTex();
kinect.setRegistration(true);
kinect.init();
kinect.open();
if(kinect.isConnected()) {
ofLogNotice() << "sensor-emitter dist: " << kinect.getSensorEmitterDistance() << "cm";
ofLogNotice() << "sensor-camera dist: " << kinect.getSensorCameraDistance() << "cm";
ofLogNotice() << "zero plane pixel size: " << kinect.getZeroPlanePixelSize() << "mm";
ofLogNotice() << "zero plane dist: " << kinect.getZeroPlaneDistance() << "mm";
}
kinect.setCameraTiltAngle(0);
kinect.setUseTexture(true);
kinect.setLed(ofxKinect::LED_GREEN);
colorImg.allocate(kinect.width, kinect.height);
grayImage.allocate(kinect.width, kinect.height);
grayThreshNear.allocate(kinect.width, kinect.height);
grayThreshFar.allocate(kinect.width, kinect.height);
fbo.allocate(kinect.width, kinect.height);
grayImage.setUseTexture(true);
gui.setup();
gui.add(nearThreshold.set("nearThreshold",230, 1,1000));
gui.add(farThreshold.set("farThreshold",70, 1,1000));
gui.loadFromFile("settings.xml");
// if(ofGetGLProgrammableRenderer()){
// string vertex = "#version 150\n\
// \n\
// uniform mat4 projectionMatrix;\n\
// uniform mat4 modelViewMatrix;\n\
// uniform mat4 modelViewProjectionMatrix;\n\
// \n\
// \n\
// in vec4 position;\n\
// in vec2 texcoord;\n\
// \n\
// out vec2 texCoordVarying;\n\
// \n\
// void main()\n\
// {\n\
// texCoordVarying = texcoord;\
// gl_Position = modelViewProjectionMatrix * position;\n\
// }";
// string fragment = "#version 150\n\
// \n\
// uniform sampler2DRect tex0;\
// uniform sampler2DRect maskTex;\
// in vec2 texCoordVarying;\n\
// \
// out vec4 fragColor;\n\
// void main (void){\
// vec2 pos = texCoordVarying;\
// \
// vec3 src = texture(tex0, pos).rgb;\
// float mask = texture(maskTex, pos).r;\
// \
// fragColor = vec4( src , mask);\
// }";
// shader.setupShaderFromSource(GL_VERTEX_SHADER, vertex);
// shader.setupShaderFromSource(GL_FRAGMENT_SHADER, fragment);
// shader.bindDefaults();
// shader.linkProgram();
// }else{
string shaderProgram = "#version 120\n \
#extension GL_ARB_texture_rectangle : enable\n \
\
uniform sampler2DRect tex0;\
uniform sampler2DRect maskTex;\
\
void main (void){\
vec2 pos = gl_TexCoord[0].st;\
\
vec3 src = texture2DRect(tex0, pos).rgb;\
float mask = texture2DRect(maskTex, pos).r;\
\
gl_FragColor = vec4( src , mask);\
}";
shader.setupShaderFromSource(GL_FRAGMENT_SHADER, shaderProgram);
shader.linkProgram();
// }
imageSequence.loadSequence("./");
}
void ofApp::exit(){
kinect.setLed(ofxKinect::LED_OFF);
kinect.close();
}
//--------------------------------------------------------------
void ofApp::update(){
kinect.update();
if(kinect.isFrameNew()) {
// load grayscale depth image from the kinect source
grayImage.setFromPixels(kinect.getDepthPixels(), kinect.width, kinect.height);
// we do two thresholds - one for the far plane and one for the near plane
// we then do a cvAnd to get the pixels which are a union of the two thresholds
grayThreshNear = grayImage;
grayThreshFar = grayImage;
grayThreshNear.threshold(nearThreshold, true);
grayThreshFar.threshold(farThreshold);
cvAnd(grayThreshNear.getCvImage(), grayThreshFar.getCvImage(), grayImage.getCvImage(), NULL);
// update the cv images
grayImage.flagImageChanged();
}
grayImage.draw(0,0,640,480);
fbo.begin();
// Cleaning everthing with alpha mask on 0 in order to make it transparent for default
ofClear(0, 0, 0, 0);
shader.begin();
shader.setUniformTexture("maskTex", grayImage.getTextureReference(), 1 );
kinect.draw(0,0);
shader.end();
fbo.end();
}
//--------------------------------------------------------------
void ofApp::draw(){
ofSetColor(ofColor::white);
ofEnableAlphaBlending();
imageSequence.getTextureForFrame(ofGetFrameNum()%imageSequence.getTotalFrames()).draw(0,0);
// drawFbo.begin();
//
// ofClear(0, 0, 0,0.1);
fbo.draw(0,0);
// drawFbo.end();
// drawFbo.draw(kinect.getWidth(),0,-kinect.getWidth(),kinect.getHeight());
// ofPixels pixels;
// fbo.readToPixels(pixels);
// ofSaveImage(pixels, ofGetTimestampString()+".png");
gui.draw();
}
//--------------------------------------------------------------
void ofApp::keyPressed(int key){
}
//--------------------------------------------------------------
void ofApp::keyReleased(int key){
}
//--------------------------------------------------------------
void ofApp::mouseMoved(int x, int y ){
}
//--------------------------------------------------------------
void ofApp::mouseDragged(int x, int y, int button){
}
//--------------------------------------------------------------
void ofApp::mousePressed(int x, int y, int button){
}
//--------------------------------------------------------------
void ofApp::mouseReleased(int x, int y, int button){
}
//--------------------------------------------------------------
void ofApp::windowResized(int w, int h){
}
//--------------------------------------------------------------
void ofApp::gotMessage(ofMessage msg){
}
//--------------------------------------------------------------
void ofApp::dragEvent(ofDragInfo dragInfo){
}
| [
"fishkingsin@gmail.com"
] | fishkingsin@gmail.com |
77230c7bc68da8299d23e910dd417966cad133ad | 366d6d990cfd02a8592cb6c3a192145a077be01a | /C_plus/chapter5/5_1/ex_2/ARR.cpp | 624f4fdcb24deaccd006986fa518f88d6f9602e1 | [] | no_license | gd5512/xuexi | 50e7f14555ba22c6024e1c1f56d376c0c429ca56 | f684506a40a508e3971e6388df847aeb5bf9374c | refs/heads/master | 2020-03-07T10:20:06.456986 | 2018-09-20T12:45:10 | 2018-09-20T12:45:10 | 127,428,979 | 0 | 0 | null | null | null | null | ISO-8859-7 | C++ | false | false | 702 | cpp | #include<iostream>
#include<cmath>
using namespace std;
int main()
{
int queen[8];
int total=0;
int i,j,k;
for(i=0;i<8;i++)queen[i]=0;
for(i=1;;){
if(queen[i]<8){
k=0;
while(k<i&&(queen[k]-queen[i])&&(abs(queen[k]-queen[i])-abs(k-i)))k++;
if(k<=i-1)
{
queen[i]++;continue;
}
i++;
if(i<8)continue;
for(j=0;j<8;j++)cout<<queen[j];
cout<<" ";
total++;
if(total%5==0)cout<<endl;
queen[7]++;
i=7;
}
else
{
queen[i]=0;
i--;
if(i<0){
cout<<"ΧάΚύ£Ί"<<total<<endl;return 0;
}
else
queen[i]++;
}
}
return 0;
} | [
"noreply@github.com"
] | noreply@github.com |
2f72dc5f199c89447ead3bc512ec1fdf4e199bd6 | 3e09c615deb22f171be1b8acec8ad969c03c9d06 | /src/slamEnd.cpp | cad89008ffa7a5714c0497a5ddabc19e2d44854b | [] | no_license | santoshdahal2016/LearningRGBD-SLAM | d98983b0e58577b61f8b3b846ed6ad5f5b95cfb2 | 08ab2d94a5e55e6554dadfe774d4d8d03bfbdfe8 | refs/heads/master | 2022-04-14T08:45:02.896138 | 2020-04-11T08:27:08 | 2020-04-11T08:27:08 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,360 | cpp |
#include <iostream>
#include <fstream>
#include <sstream>
using namespace std;
#include "slamBase.h"
#include <g2o/types/slam3d/types_slam3d.h>
#include <g2o/core/sparse_optimizer.h>
#include <g2o/core/block_solver.h>
#include <g2o/core/factory.h>
#include <g2o/core/optimization_algorithm_factory.h>
#include <g2o/core/optimization_algorithm_gauss_newton.h>
#include <g2o/core/robust_kernel.h>
#include <g2o/core/robust_kernel_factory.h>
#include <g2o/core/optimization_algorithm_levenberg.h>
#include <g2o/solvers/eigen/linear_solver_eigen.h>
// given index, read one frame of data
FRAME readFrame( int index, ParameterReader& pd );
// Measure the size of the movement
double normofTransform( cv::Mat rvec, cv::Mat tvec );
int main( int argc, char** argv )
{
ParameterReader pd;
int startIndex = atoi( pd.getData( "start_index" ).c_str() );
int endIndex = atoi( pd.getData( "end_index" ).c_str() );
// initialize
cout<<"Initializing ..."<<endl;
int currIndex = startIndex; // currentIndex
FRAME lastFrame = readFrame( currIndex, pd );
CAMERA_INTRINSIC_PARAMETERS camera = getDefaultCamera();
computeKeyPointsAndDesp( lastFrame);
PointCloud::Ptr cloud = image2PointCloud( lastFrame.rgb, lastFrame.depth, camera );
pcl::visualization::CloudViewer viewer("viewer");
bool visualize = pd.getData("visualize_pointcloud")==string("yes");
int min_inliers = atoi( pd.getData("min_inliers").c_str() );
double max_norm = atof( pd.getData("max_norm").c_str() );
// Added: initialization of g2o
// Select the optimization method
std::unique_ptr<g2o::BlockSolver_6_3::LinearSolverType> linearSolver;
linearSolver = g2o::make_unique<g2o::LinearSolverEigen<g2o::BlockSolver_6_3::PoseMatrixType>>();
g2o::OptimizationAlgorithmLevenberg* solver = new g2o::OptimizationAlgorithmLevenberg(
g2o::make_unique<g2o::BlockSolver_6_3>(std::move(linearSolver))
);
g2o::SparseOptimizer globalOptimizer; // This is the last one
globalOptimizer.setAlgorithm( solver );
// Do not output debugging information
globalOptimizer.setVerbose( false );
// Add the first vertex to the globalOptimizer
g2o::VertexSE3* v = new g2o::VertexSE3();
v->setId( currIndex );
v->setEstimate( Eigen::Isometry3d::Identity() ); // Estimation is the identity matrix
v->setFixed( true ); // The first vertex is fixed without optimization
globalOptimizer.addVertex( v );
int lastIndex = currIndex;
for ( currIndex=startIndex+1; currIndex<endIndex; currIndex++ )
{
cout<<"Reading files "<<currIndex<<endl;
FRAME currFrame = readFrame( currIndex,pd );
computeKeyPointsAndDesp( currFrame);
// Compare currFrame and lastFrame
RESULT_OF_PNP result = estimateMotion( lastFrame, currFrame, camera );
if ( result.inliers < min_inliers ) // Inliers are not enough, discard the frame
continue;
// Calculate whether the range of motion is too large
double norm = normofTransform(result.rvec, result.tvec);
cout<<"norm = "<<norm<<endl;
if ( norm >= max_norm )
continue;
Eigen::Isometry3d T = cvMat2Eigen( result.rvec, result.tvec );
cout<<"T="<<T.matrix()<<endl;
// If you remove the visualization, it will be faster
if ( visualize == true )
{
cloud = joinPointCloud( cloud, currFrame, T, camera );
viewer.showCloud( cloud );
}
// Add the edge connected to the previous frame to g2o
// vertex part
// The vertex only needs to set the id
g2o::VertexSE3 *v = new g2o::VertexSE3();
v->setId( currIndex );
v->setEstimate( Eigen::Isometry3d::Identity() );
globalOptimizer.addVertex(v);
// side part
g2o::EdgeSE3* edge = new g2o::EdgeSE3();
// Connect the two vertex ids of this edge
edge->vertices() [0] = globalOptimizer.vertex( lastIndex );
edge->vertices() [1] = globalOptimizer.vertex( currIndex );
// Information matrix
Eigen::Matrix<double, 6, 6> information = Eigen::Matrix< double, 6,6 >::Identity();
// The information matrix is the inverse of the covariance matrix, representing our pre-estimation of the accuracy of the edges
// Because the pose is 6D, the information matrix is a 6 * 6 matrix. It is assumed that the estimated accuracy of position and angle are both 0.1 and independent of each other.
// Then the covariance is a matrix with a diagonal of 0.01, and the information matrix is a matrix with 100
information(0,0) = information(1,1) = information(2,2) = 100;
information(3,3) = information(4,4) = information(5,5) = 100;
// You can also set the angle larger, indicating that the estimation of the angle is more accurate
edge->setInformation( information );
// Edge estimation is the result of pnp solution
edge->setMeasurement( T );
// Add this edge to the graph
globalOptimizer.addEdge(edge);
lastFrame = currFrame;
lastIndex = currIndex;
}
// Optimize all edges
cout<<"optimizing pose graph, vertices: "<<globalOptimizer.vertices().size()<<endl;
globalOptimizer.save("./result_before.g2o");
globalOptimizer.initializeOptimization();
globalOptimizer.optimize( 100 ); // You can specify the number of optimization steps
globalOptimizer.save( "./result_after.g2o" );
cout<<"Optimization done."<<endl;
globalOptimizer.clear();
return 0;
}
FRAME readFrame( int index, ParameterReader& pd )
{
FRAME f;
string rgbDir = pd.getData("rgb_dir");
string depthDir = pd.getData("depth_dir");
string rgbExt = pd.getData("rgb_extension");
string depthExt = pd.getData("depth_extension");
stringstream ss;
ss<<rgbDir<<index<<rgbExt;
string filename;
ss>>filename;
f.rgb = cv::imread( filename );
ss.clear();
filename.clear();
ss<<depthDir<<index<<depthExt;
ss>>filename;
f.depth = cv::imread( filename, -1 );
f.frameID = index;
return f;
}
double normofTransform( cv::Mat rvec, cv::Mat tvec )
{
return fabs(min(cv::norm(rvec), 2*M_PI-cv::norm(rvec)))+ fabs(cv::norm(tvec));
} | [
"webtutor2016@gmail.com"
] | webtutor2016@gmail.com |
5df56ad12d3a37021227a02a9afc97d62aa11295 | b8bc365f96bf72b4706d03db181f79946e5ca234 | /DirectX11/Bindable.cpp | cf033694602894c27655b609323df5311501b5a2 | [] | no_license | minkipro/myDirectX11 | 4d37801914b083d27b5c22c0b3d8c8132112b1cb | d072df515e8c0cba1199c27b21c3b5f099337c50 | refs/heads/master | 2020-08-12T11:28:34.814623 | 2019-11-11T08:56:58 | 2019-11-11T08:56:58 | 214,759,152 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 438 | cpp | #include "Bindable.h"
ID3D11DeviceContext* Bindable::GetContext(Graphics& gfx) noexcept
{
return gfx.pContext.Get();
}
ID3D11Device* Bindable::GetDevice(Graphics& gfx) noexcept
{
return gfx.pDevice.Get();
}
DxgiInfoManager& Bindable::GetInfoManager(Graphics& gfx) noexcept(IS_DEBUG)
{
#ifndef NDEBUG
return gfx.infoManager;
#else
throw std::logic_error("YouFuckedUp! (Tried to access gfx.infoManager in Release config)");
#endif
}
| [
"ghkdalsrl222@gmail.com"
] | ghkdalsrl222@gmail.com |
7b6de69447c6c8b80da4f4c78d8f3f8ddb2a0126 | f4592210511b2fa752ba38d9d047643c3c87ca31 | /wled00/wled05_init.ino | e11d9f9fef28f6c8816b95332d5a845fa96377a9 | [
"MIT"
] | permissive | Eisbaeeer/WLED | 673cc2d83fb89bd762fb0d0916435a3a6616b1da | e3b9b341fd9d389fb9b5e1d0f1db59ba0d7b7f3c | refs/heads/master | 2020-03-29T14:08:22.244647 | 2018-08-31T20:36:38 | 2018-08-31T20:36:38 | 150,000,836 | 1 | 0 | MIT | 2018-09-23T16:04:45 | 2018-09-23T16:04:45 | null | UTF-8 | C++ | false | false | 18,190 | ino | /*
* Setup code
*/
void wledInit()
{
EEPROM.begin(EEPSIZE);
showWelcomePage = (EEPROM.read(233) != 233);
ledCount = ((EEPROM.read(229) << 0) & 0xFF) + ((EEPROM.read(398) << 8) & 0xFF00); if (ledCount > 1200 || ledCount == 0) ledCount = 10;
//RMT eats up too much RAM
#ifdef ARDUINO_ARCH_ESP32
if (ledCount > 600) ledCount = 600;
#endif
if (!EEPROM.read(397)) strip.init(EEPROM.read(372),ledCount,PIN,EEPROM.read(2204)); //quick init
Serial.begin(115200);
Serial.setTimeout(50);
#ifdef USEFS
SPIFFS.begin();
#endif
DEBUG_PRINTLN("Load EEPROM");
loadSettingsFromEEPROM(true);
if (!initLedsLast) initStrip();
DEBUG_PRINT("CSSID: ");
DEBUG_PRINT(clientSSID);
buildCssColorString();
userBeginPreConnection();
initCon();
DEBUG_PRINTLN("");
DEBUG_PRINT("Connected! IP address: ");
DEBUG_PRINTLN(WiFi.localIP());
if (hueIP[0] == 0)
{
hueIP[0] = WiFi.localIP()[0];
hueIP[1] = WiFi.localIP()[1];
hueIP[2] = WiFi.localIP()[2];
}
if (udpPort > 0 && udpPort != ntpLocalPort)
{
udpConnected = notifierUdp.begin(udpPort);
if (udpConnected && udpRgbPort != udpPort) udpRgbConnected = rgbUdp.begin(udpRgbPort);
}
if (ntpEnabled && WiFi.status() == WL_CONNECTED)
ntpConnected = ntpUdp.begin(ntpLocalPort);
//start captive portal
if (onlyAP || strlen(apSSID) > 0)
{
dnsServer.setErrorReplyCode(DNSReplyCode::NoError);
dnsServer.start(53, "*", WiFi.softAPIP());
dnsActive = true;
}
if (!initLedsLast) strip.service();
//SERVER INIT
//settings page
server.on("/settings", HTTP_GET, [](){
serveSettings(0);
});
server.on("/settings/wifi", HTTP_GET, [](){
if (!(wifiLock && otaLock))
{
serveSettings(1);
}else{
serveMessage(500, "Access Denied", txd, 254);
}
});
server.on("/settings/leds", HTTP_GET, [](){
serveSettings(2);
});
server.on("/settings/ui", HTTP_GET, [](){
serveSettings(3);
});
server.on("/settings/sync", HTTP_GET, [](){
serveSettings(4);
});
server.on("/settings/time", HTTP_GET, [](){
serveSettings(5);
});
server.on("/settings/sec", HTTP_GET, [](){
serveSettings(6);
});
server.on("/favicon.ico", HTTP_GET, [](){
if(!handleFileRead("/favicon.ico"))
{
server.send_P(200, "image/x-icon", favicon, 156);
}
});
server.on("/", HTTP_GET, [](){
serveIndexOrWelcome();
});
server.on("/generate_204", HTTP_GET, [](){
serveIndexOrWelcome();
});
server.on("/fwlink", HTTP_GET, [](){
serveIndexOrWelcome();
});
server.on("/sliders", HTTP_GET, serveIndex);
server.on("/welcome", HTTP_GET, [](){
serveSettings(255);
});
server.on("/reset", HTTP_GET, [](){
serveMessage(200,"Rebooting now...","(takes ~20 seconds, wait for auto-redirect)",79);
reset();
});
server.on("/settings/wifi", HTTP_POST, [](){
if (!(wifiLock && otaLock)) handleSettingsSet(1);
serveMessage(200,"WiFi settings saved.","Rebooting now... (takes ~20 seconds, wait for auto-redirect)",139);
reset();
});
server.on("/settings/leds", HTTP_POST, [](){
handleSettingsSet(2);
serveMessage(200,"LED settings saved.","Redirecting...",1);
});
server.on("/settings/ui", HTTP_POST, [](){
handleSettingsSet(3);
serveMessage(200,"UI settings saved.","Reloading to apply theme...",122);
});
server.on("/settings/sync", HTTP_POST, [](){
handleSettingsSet(4);
if (hueAttempt)
{
serveMessage(200,"Hue setup result",hueError,253);
} else {
serveMessage(200,"Sync settings saved.","Redirecting...",1);
}
hueAttempt = false;
});
server.on("/settings/time", HTTP_POST, [](){
handleSettingsSet(5);
serveMessage(200,"Time settings saved.","Redirecting...",1);
});
server.on("/settings/sec", HTTP_POST, [](){
handleSettingsSet(6);
serveMessage(200,"Security settings saved.","Rebooting now... (takes ~20 seconds, wait for auto-redirect)",139);
reset();
});
server.on("/version", HTTP_GET, [](){
server.send(200, "text/plain", (String)VERSION);
});
server.on("/uptime", HTTP_GET, [](){
server.send(200, "text/plain", (String)millis());
});
server.on("/freeheap", HTTP_GET, [](){
server.send(200, "text/plain", (String)ESP.getFreeHeap());
});
server.on("/power", HTTP_GET, [](){
String val = (String)(int)strip.getPowerEstimate(ledCount,strip.getColor(),strip.getBrightness());
val += "mA currently";
serveMessage(200,val,"This is just an estimate (does not take into account several factors like effects and wire resistance). It is NOT an accurate measurement!",254);
});
server.on("/u", HTTP_GET, [](){
server.setContentLength(strlen_P(PAGE_usermod));
server.send(200, "text/html", "");
server.sendContent_P(PAGE_usermod);
});
server.on("/teapot", HTTP_GET, [](){
serveMessage(418, "418. I'm a teapot.","(Tangible Embedded Advanced Project Of Twinkling)",254);
});
server.on("/build", HTTP_GET, [](){
getBuildInfo();
server.send(200, "text/plain", obuf);
});
//if OTA is allowed
if (!otaLock){
server.on("/edit", HTTP_GET, [](){
if(!handleFileRead("/edit.htm")) server.send(200, "text/html", PAGE_edit);
});
#ifdef USEFS
server.on("/edit", HTTP_PUT, handleFileCreate);
server.on("/edit", HTTP_DELETE, handleFileDelete);
server.on("/edit", HTTP_POST, [](){ server.send(200, "text/plain", ""); }, handleFileUpload);
server.on("/list", HTTP_GET, handleFileList);
#endif
//init ota page
httpUpdater.setup(&server);
} else
{
server.on("/edit", HTTP_GET, [](){
serveMessage(500, "Access Denied", txd, 254);
});
server.on("/update", HTTP_GET, [](){
serveMessage(500, "Access Denied", txd, 254);
});
server.on("/list", HTTP_GET, [](){
serveMessage(500, "Access Denied", txd, 254);
});
}
//called when the url is not defined here, ajax-in; get-settings
server.onNotFound([](){
DEBUG_PRINTLN("Not-Found HTTP call:");
DEBUG_PRINTLN("URI: " + server.uri());
DEBUG_PRINTLN("Body: " + server.arg(0));
if(!handleSet(server.uri())){
if(!handleAlexaApiCall(server.uri(),server.arg(0)))
server.send(404, "text/plain", "Not Found");
}
});
#ifndef ARDUINO_ARCH_ESP32
const char * headerkeys[] = {"User-Agent"};
server.collectHeaders(headerkeys,sizeof(headerkeys)/sizeof(char*));
#else
String ua = "User-Agent";
server.collectHeaders(ua);
#endif
if (!initLedsLast) strip.service();
//init Alexa hue emulation
if (alexaEnabled) alexaInit();
server.begin();
DEBUG_PRINTLN("HTTP server started");
//init ArduinoOTA
if (aOtaEnabled)
{
ArduinoOTA.onStart([]() {
#ifndef ARDUINO_ARCH_ESP32
wifi_set_sleep_type(NONE_SLEEP_T);
#endif
DEBUG_PRINTLN("Start ArduinoOTA");
});
if (strlen(cmDNS) > 0) ArduinoOTA.setHostname(cmDNS);
ArduinoOTA.begin();
}
if (!initLedsLast) strip.service();
// Set up mDNS responder:
if (strlen(cmDNS) > 0 && !onlyAP)
{
MDNS.begin(cmDNS);
DEBUG_PRINTLN("mDNS responder started");
// Add service to MDNS
MDNS.addService("http", "tcp", 80);
}
initBlynk(blynkApiKey);
initE131();
if (initLedsLast) initStrip();
userBegin();
if (macroBoot>0) applyMacro(macroBoot);
Serial.println("Ada");
}
void initStrip()
{
// Initialize NeoPixel Strip and button
if (initLedsLast) strip.init(useRGBW,ledCount,PIN,skipFirstLed);
strip.setReverseMode(reverseMode);
strip.setColor(0);
strip.setBrightness(255);
strip.start();
pinMode(buttonPin, INPUT_PULLUP);
pinMode(4,OUTPUT); //this is only needed in special cases
digitalWrite(4,LOW);
if (bootPreset>0) applyPreset(bootPreset, turnOnAtBoot, true, true);
colorUpdated(0);
if(digitalRead(buttonPin) == LOW) buttonEnabled = false; //disable button if it is "pressed" unintentionally
}
void initAP(){
bool set = apSSID[0];
if (!set) strcpy(apSSID,"WLED-AP");
WiFi.softAP(apSSID, apPass, apChannel, apHide);
if (!set) apSSID[0] = 0;
}
void initCon()
{
WiFi.disconnect(); //close old connections
if (staticIP[0] != 0)
{
WiFi.config(staticIP, staticGateway, staticSubnet, staticDNS);
} else
{
WiFi.config(0U, 0U, 0U);
}
if (strlen(apSSID)>0)
{
DEBUG_PRINT("USING AP");
DEBUG_PRINTLN(strlen(apSSID));
initAP();
} else
{
DEBUG_PRINTLN("NO AP");
WiFi.softAPdisconnect(true);
}
int fail_count = 0;
if (strlen(clientSSID) <1 || strcmp(clientSSID,"Your_Network") == 0) fail_count = apWaitTimeSecs*2; //instantly go to ap mode
#ifndef ARDUINO_ARCH_ESP32
WiFi.hostname(serverDescription);
#endif
WiFi.begin(clientSSID, clientPass);
#ifdef ARDUINO_ARCH_ESP32
WiFi.setHostname(serverDescription);
#endif
unsigned long lastTry = 0;
bool con = false;
while(!con)
{
yield();
if (!initLedsLast)
{
handleTransitions();
handleButton();
handleOverlays();
if (briT) strip.service();
}
if (millis()-lastTry > 499) {
con = (WiFi.status() == WL_CONNECTED);
lastTry = millis();
DEBUG_PRINTLN("C_NC");
if (!recoveryAPDisabled && fail_count > apWaitTimeSecs*2)
{
WiFi.disconnect();
DEBUG_PRINTLN("Can't connect. Opening AP...");
onlyAP = true;
initAP();
return;
}
fail_count++;
}
}
}
void buildCssColorString()
{
String cs[]={"","","","","",""};
switch (currentTheme)
{
default: cs[0]="D9B310"; cs[1]="0B3C5D"; cs[2]="1D2731"; cs[3]="328CC1"; cs[4]="000"; cs[5]="328CC1"; break; //night
case 1: cs[0]="eee"; cs[1]="ddd"; cs[2]="b9b9b9"; cs[3]="049"; cs[4]="777"; cs[5]="049"; break; //modern
case 2: cs[0]="abc"; cs[1]="fff"; cs[2]="ddd"; cs[3]="000"; cs[4]="0004"; cs[5]="000"; break; //bright
case 3: cs[0]="c09f80"; cs[1]="d7cec7"; cs[2]="76323f"; cs[3]="888"; cs[4]="3334"; cs[5]="888"; break; //wine
case 4: cs[0]="3cc47c"; cs[1]="828081"; cs[2]="d9a803"; cs[3]="1e392a"; cs[4]="000a"; cs[5]="1e392a"; break; //electric
case 5: cs[0]="57bc90"; cs[1]="a5a5af"; cs[2]="015249"; cs[3]="88c9d4"; cs[4]="0004"; cs[5]="88c9d4"; break; //mint
case 6: cs[0]="f7c331"; cs[1]="dcc7aa"; cs[2]="6b7a8f"; cs[3]="f7882f"; cs[4]="0007"; cs[5]="f7882f"; break; //amber
case 7: cs[0]="fc3"; cs[1]="124"; cs[2]="334"; cs[3]="f1d"; cs[4]="f00"; cs[5]="f1d"; break;//club
case 8: cs[0]="0ac"; cs[1]="124"; cs[2]="224"; cs[3]="003eff"; cs[4]="003eff"; cs[5]="003eff"; break;//air
case 9: cs[0]="f70"; cs[1]="421"; cs[2]="221"; cs[3]="a50"; cs[4]="f70"; cs[5]="f70"; break;//nixie
case 10: cs[0]="2d2"; cs[1]="010"; cs[2]="121"; cs[3]="060"; cs[4]="040"; cs[5]="3f3"; break; //terminal
case 11: cs[0]="867ADE"; cs[1]="4033A3"; cs[2]="483AAA"; cs[3]="483AAA"; cs[4]=""; cs[5]="867ADE"; break; //c64
case 12: cs[0]="fbe8a6"; cs[1]="d2fdff"; cs[2]="b4dfe5"; cs[3]="f4976c"; cs[4]=""; cs[5]="303c6c"; break; //c64
case 14: cs[0]="fc7"; cs[1]="49274a"; cs[2]="94618e"; cs[3]="f4decb"; cs[4]="0008"; cs[5]="f4decb"; break; //end
case 15: for (int i=0;i<6;i++)cs[i]=cssCol[i];//custom
}
cssColorString="<style>:root{--aCol:#";
cssColorString+=cs[0];
cssColorString+=";--bCol:#";
cssColorString+=cs[1];
cssColorString+=";--cCol:#";
cssColorString+=cs[2];
cssColorString+=";--dCol:#";
cssColorString+=cs[3];
cssColorString+=";--sCol:#";
cssColorString+=cs[4];
cssColorString+=";--tCol:#";
cssColorString+=cs[5];
cssColorString+=";--cFn:";
cssColorString+=cssFont;
cssColorString+=";}";
}
void serveIndexOrWelcome()
{
if (!showWelcomePage){
if(!handleFileRead("/index.htm")) {
serveIndex();
}
}else{
if(!handleFileRead("/welcome.htm")) {
serveSettings(255);
}
showWelcomePage = false;
}
}
void serveRealtimeError(bool settings)
{
String mesg = "The ";
mesg += (settings)?"settings":"WLED";
mesg += " UI is not available while receiving real-time data (";
if (realtimeIP[0] == 0)
{
mesg += "E1.31";
} else {
mesg += "UDP from ";
mesg += realtimeIP[0];
for (int i = 1; i < 4; i++)
{
mesg += ".";
mesg += realtimeIP[i];
}
}
mesg += ").";
server.send(200, "text/plain", mesg);
}
void serveIndex()
{
bool serveMobile = false;
if (uiConfiguration == 0) serveMobile = checkClientIsMobile(server.header("User-Agent"));
else if (uiConfiguration == 2) serveMobile = true;
if (!arlsTimeout || enableRealtimeUI) //do not serve while receiving realtime
{
if (serveMobile)
{
server.setContentLength(strlen_P(PAGE_indexM));
server.send(200, "text/html", "");
server.sendContent_P(PAGE_indexM);
} else
{
server.setContentLength(strlen_P(PAGE_index0) + cssColorString.length() + strlen_P(PAGE_index1) + strlen_P(PAGE_index2) + strlen_P(PAGE_index3));
server.send(200, "text/html", "");
server.sendContent_P(PAGE_index0);
server.sendContent(cssColorString);
server.sendContent_P(PAGE_index1);
server.sendContent_P(PAGE_index2);
server.sendContent_P(PAGE_index3);
}
} else {
serveRealtimeError(false);
}
}
void serveMessage(int code, String headl, String subl="", int optionType)
{
String messageBody = "<h2>";
messageBody += headl;
messageBody += "</h2>";
messageBody += subl;
switch(optionType)
{
case 255: break; //simple message
case 254: messageBody += "<br><br><button type=\"button\" onclick=\"B()\">Back</button>"; break; //back button
case 253: messageBody += "<br><br><form action=/settings><button type=submit>Back</button></form>"; //button to settings
}
if (optionType < 60) //redirect to settings after optionType seconds
{
messageBody += "<script>setTimeout(RS," + String(optionType*1000) + ")</script>";
} else if (optionType < 120) //redirect back after optionType-60 seconds
{
messageBody += "<script>setTimeout(B," + String((optionType-60)*1000) + ")</script>";
} else if (optionType < 180) //reload parent after optionType-120 seconds
{
messageBody += "<script>setTimeout(RP," + String((optionType-120)*1000) + ")</script>";
}
messageBody += "</body></html>";
server.setContentLength(strlen_P(PAGE_msg0) + cssColorString.length() + strlen_P(PAGE_msg1) + messageBody.length());
server.send(code, "text/html", "");
server.sendContent_P(PAGE_msg0);
server.sendContent(cssColorString);
server.sendContent_P(PAGE_msg1);
server.sendContent(messageBody);
}
void serveSettings(byte subPage)
{
//0: menu 1: wifi 2: leds 3: ui 4: sync 5: time 6: sec 255: welcomepage
if (!arlsTimeout || enableRealtimeUI) //do not serve while receiving realtime
{
int pl0, pl1;
switch (subPage)
{
case 1: pl0 = strlen_P(PAGE_settings_wifi0); pl1 = strlen_P(PAGE_settings_wifi1); break;
case 2: pl0 = strlen_P(PAGE_settings_leds0); pl1 = strlen_P(PAGE_settings_leds1); break;
case 3: pl0 = strlen_P(PAGE_settings_ui0); pl1 = strlen_P(PAGE_settings_ui1); break;
case 4: pl0 = strlen_P(PAGE_settings_sync0); pl1 = strlen_P(PAGE_settings_sync1); break;
case 5: pl0 = strlen_P(PAGE_settings_time0); pl1 = strlen_P(PAGE_settings_time1); break;
case 6: pl0 = strlen_P(PAGE_settings_sec0); pl1 = strlen_P(PAGE_settings_sec1); break;
case 255: pl0 = strlen_P(PAGE_welcome0); pl1 = strlen_P(PAGE_welcome1); break;
default: pl0 = strlen_P(PAGE_settings0); pl1 = strlen_P(PAGE_settings1);
}
getSettingsJS(subPage);
int sCssLength = (subPage >0 && subPage <7)?strlen_P(PAGE_settingsCss):0;
server.setContentLength(pl0 + cssColorString.length() + olen + sCssLength + pl1);
server.send(200, "text/html", "");
switch (subPage)
{
case 1: server.sendContent_P(PAGE_settings_wifi0); break;
case 2: server.sendContent_P(PAGE_settings_leds0); break;
case 3: server.sendContent_P(PAGE_settings_ui0); break;
case 4: server.sendContent_P(PAGE_settings_sync0); break;
case 5: server.sendContent_P(PAGE_settings_time0); break;
case 6: server.sendContent_P(PAGE_settings_sec0); break;
case 255: server.sendContent_P(PAGE_welcome0); break;
default: server.sendContent_P(PAGE_settings0);
}
server.sendContent(obuf);
server.sendContent(cssColorString);
if (subPage >0 && subPage <7) server.sendContent_P(PAGE_settingsCss);
switch (subPage)
{
case 1: server.sendContent_P(PAGE_settings_wifi1); break;
case 2: server.sendContent_P(PAGE_settings_leds1); break;
case 3: server.sendContent_P(PAGE_settings_ui1); break;
case 4: server.sendContent_P(PAGE_settings_sync1); break;
case 5: server.sendContent_P(PAGE_settings_time1); break;
case 6: server.sendContent_P(PAGE_settings_sec1); break;
case 255: server.sendContent_P(PAGE_welcome1); break;
default: server.sendContent_P(PAGE_settings1);
}
} else {
serveRealtimeError(true);
}
}
void getBuildInfo()
{
//fill string buffer with build info
olen = 0;
oappend("hard-coded build info:\r\n\n");
#ifdef ARDUINO_ARCH_ESP32
oappend("platform: esp32");
#else
oappend("platform: esp8266");
#endif
oappend("\r\nversion: ");
oappend(versionString);
oappend("\r\nbuild: ");
oappendi(VERSION);
oappend("\r\neepver: ");
oappendi(EEPVER);
#ifdef USEFS
oappend("\r\nspiffs: true\r\n");
#else
oappend("\r\nspiffs: false\r\n");
#endif
#ifdef DEBUG
oappend("debug: true\r\n");
#else
oappend("debug: false\r\n");
#endif
oappend("button-pin: gpio");
oappendi(buttonPin);
oappend("\r\n");
#ifdef ARDUINO_ARCH_ESP32
oappend("strip-pin: gpio");
oappendi(PIN);
#else
oappend("strip-pin: gpio2");
#endif
oappend("\r\nbuild-type: src\r\n");
}
bool checkClientIsMobile(String useragent)
{
//to save complexity this function is not comprehensive
if (useragent.indexOf("Android") >= 0) return true;
if (useragent.indexOf("iPhone") >= 0) return true;
if (useragent.indexOf("iPod") >= 0) return true;
return false;
}
| [
"cschwinne@gmail.com"
] | cschwinne@gmail.com |
42e9012323336ef03a1b9d85b9342b0e3c3c240e | d55755141c0e12552562cca50837020e73737ac7 | /source/spring-recruitment/297. Serialize and Deserialize Binary Tree.cpp | d560437f85f7e0da479d6ead91f251199304d0ad | [] | no_license | xulzee/LeetCodeProjectCPP | 5452e218b57b5bf28117cab98b163f07bcce7329 | 129bea6296560676eca4fa9b20fe83dc935a3b92 | refs/heads/master | 2020-06-26T00:09:27.612312 | 2020-03-22T09:06:54 | 2020-03-22T09:06:54 | 199,463,509 | 4 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 6,765 | cpp | // @Time : 2019/3/20 10:40
// @Author : xulzee
// @Email : xulzee@163.com
// @Software: CLion
#include <iostream>
#include <vector>
#include <sstream>
#include <string>
#include <algorithm>
#include <queue>
#include <stack>
#include "utils.h"
using namespace std;
// Definition for a binary tree node.
struct TreeNode {
int val;
TreeNode *left;
TreeNode *right;
explicit TreeNode(int _val) : val(_val), left(nullptr), right(nullptr) {}
};
class Codec1 {
public:
// level serialize
// Encodes a tree to a single string.
string serialize(TreeNode *root) {
if (root == nullptr) {
return "";
}
string res;
queue<TreeNode *> nodeQueue;
TreeNode *cur;
nodeQueue.push(root);
while (!nodeQueue.empty()) {
cur = nodeQueue.front();
nodeQueue.pop();
if (cur != nullptr) {
res += to_string(cur->val);
nodeQueue.push(cur->left);
nodeQueue.push(cur->right);
} else {
res += "null";
}
res += ",";
}
return res.substr(0, res.length() - 1);
}
// Decodes your encoded data to tree.
TreeNode *deserialize(string data) {
string item;
stringstream ss;
ss.str(data);
queue<TreeNode *> nodeQueue;
if (data.empty()) {
return nullptr;
}
// get root
getline(ss, item, ',');
auto *root = new TreeNode(stoi(item));
nodeQueue.push(root);
TreeNode *cur;
while (true) {
cur = nodeQueue.front();
nodeQueue.pop();
if (!getline(ss, item, ',')) {
break;
}
if (item != "null") {
int leftNumber = stoi(item);
cur->left = new TreeNode(leftNumber);
nodeQueue.push(cur->left);
}
if (!getline(ss, item, ',')) {
break;
}
if (item != "null") {
int rightNumber = stoi(item);
cur->right = new TreeNode(rightNumber);
nodeQueue.push(cur->right);
}
}
return root;
}
};
class Codec2 {
public:
string preOrder(TreeNode *root) {
if (root == nullptr) {
return "n,";
}
string s = to_string(root->val) + ",";
s += preOrder(root->left);
s += preOrder(root->right);
return s;
}
// Encodes a tree to a single string.
string serialize(TreeNode *root) {
if (root == nullptr) {
return "n";
}
string res = preOrder(root);
return res.substr(0, res.length() - 1);
}
// Decodes your encoded data to tree.
TreeNode *deserialize(string data) {
string temp;
stringstream ss;
queue<string> q;
ss.str(data);
while (true) {
if (!getline(ss, temp, ',')) {
break;
}
q.push(temp);
}
return reconPreOrder(q);
}
TreeNode *reconPreOrder(queue<string> &q) {
string value = q.front();
q.pop();
if (value == "n") {
return nullptr;
}
TreeNode *head = new TreeNode(stoi(value));
head->left = reconPreOrder(q);
head->right = reconPreOrder(q);
return head;
}
};
// Your Codec object will be instantiated and called as such:
// Codec codec;
// codec.deserialize(codec.serialize(root));
class Codec {
public:
// Encodes a tree to a single string.
string serialize(TreeNode *root) {
string res;
queue<TreeNode *> nodeQueue;
nodeQueue.push(root);
while (!nodeQueue.empty()) {
TreeNode *cur = nodeQueue.front();
nodeQueue.pop();
if (cur == nullptr) {
res += "null";
} else {
res.append(to_string(cur->val));
}
if (cur != nullptr) {
nodeQueue.push(cur->left);
nodeQueue.push(cur->right);
}
res.append(",");
}
return res.substr(0, res.size() - 1);
}
// Decodes your encoded data to tree.
TreeNode *deserialize(const string &data) {
if (data == "null"){
return nullptr;
}
stringstream ss(data);
string item;
getline(ss, item, ',');
TreeNode *root = new TreeNode(stoi(item));
queue<TreeNode *> nodeQueue;
nodeQueue.push(root);
while (true) {
TreeNode *cur = nodeQueue.front();
nodeQueue.pop();
// left
if (!getline(ss, item, ',')) { // ""
break;
}
if (item == "null") {
cur->left = nullptr;
} else {
cur->left = new TreeNode(stoi(item));
nodeQueue.push(cur->left);
}
//right
if (!getline(ss, item, ',')) { // ""
break;
}
if (item == "null") {
cur->right = nullptr;
} else {
cur->right = new TreeNode(stoi(item));
nodeQueue.push(cur->right);
}
}
return root;
}
};
TreeNode *stringToTreeNode(string input) {
trimLeftTrailingSpaces(input);
trimRightTrailingSpaces(input);
input = input.substr(1, input.length() - 2);
if (!input.size()) {
return nullptr;
}
string item;
stringstream ss;
ss.str(input);
getline(ss, item, ',');
TreeNode *root = new TreeNode(stoi(item));
queue<TreeNode *> nodeQueue;
nodeQueue.push(root);
while (true) {
TreeNode *node = nodeQueue.front();
nodeQueue.pop();
if (!getline(ss, item, ',')) {
break;
}
trimLeftTrailingSpaces(item);
if (item != "null") {
int leftNumber = stoi(item);
node->left = new TreeNode(leftNumber);
nodeQueue.push(node->left);
}
if (!getline(ss, item, ',')) {
break;
}
trimLeftTrailingSpaces(item);
if (item != "null") {
int rightNumber = stoi(item);
node->right = new TreeNode(rightNumber);
nodeQueue.push(node->right);
}
}
return root;
}
int main() {
string line;
while (getline(cin, line)) {
TreeNode *root = stringToTreeNode(line);
string ret = Codec().serialize(root);
TreeNode *head = Codec().deserialize(ret);
string out = (ret);
cout << out << endl;
}
return 0;
} | [
"xulzee@163.com"
] | xulzee@163.com |
5198c934bd1fe6c7dfa0065d37db8699637da2a6 | f20e965e19b749e84281cb35baea6787f815f777 | /Rec/Calo/CaloReco/src/SubClusterSelectorTool.cpp | 185a6ebf7c303f2aabaaab1bf95c98a48db6911a | [] | no_license | marromlam/lhcb-software | f677abc9c6a27aa82a9b68c062eab587e6883906 | f3a80ecab090d9ec1b33e12b987d3d743884dc24 | refs/heads/master | 2020-12-23T15:26:01.606128 | 2016-04-08T15:48:59 | 2016-04-08T15:48:59 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 9,670 | cpp | // Include files
// local
#include "SubClusterSelectorTool.h"
//-----------------------------------------------------------------------------
// Implementation file for class : SubClusterSelectorTool
//
// 2014-06-20 : Olivier Deschamps
//-----------------------------------------------------------------------------
// Declaration of the Tool Factory
DECLARE_TOOL_FACTORY( SubClusterSelectorTool )
//=============================================================================
// Standard constructor, initializes variables
//=============================================================================
SubClusterSelectorTool::SubClusterSelectorTool( const std::string& type,
const std::string& name,
const IInterface* parent )
: GaudiTool ( type, name , parent )
, m_condition ("")
, m_taggerE ()
, m_taggerP ()
, m_tagE ()
, m_tagP ()
, m_det ()
, m_energyStatus (LHCb::CaloDigitStatus::UseForEnergy | LHCb::CaloDigitStatus::UseForCovariance)
, m_positionStatus(LHCb::CaloDigitStatus::UseForPosition | LHCb::CaloDigitStatus::UseForCovariance){
declareInterface<SubClusterSelectorTool>(this);
StringArrayProperty eTags( "EnergyTags" , m_taggerE ) ;
StringArrayProperty pTags( "PositionTags" , m_taggerP ) ;
// inherit properties from parents
if( 0 != parent ){
const IProperty* prop = dynamic_cast<const IProperty*> ( parent );
if( 0 != prop ){
StatusCode sc1=prop->getProperty( &eTags );
if( sc1.isSuccess() )m_taggerE = eTags.value();
StatusCode sc2=prop->getProperty( &pTags );
if( sc2.isSuccess() )m_taggerP = pTags.value();
}
}
// declare Properties
declareProperty("EnergyTags" , m_taggerE );
declareProperty("PositionTags" , m_taggerP );
declareProperty("Detector" , m_det );
declareProperty("ConditionName", m_condition );
// define calo-dependent property
m_det = LHCb::CaloAlgUtils::DeCaloLocation( name ) ;
m_condition = "Conditions/Reco/Calo/"+ LHCb::CaloAlgUtils::CaloNameFromAlg( name ) + "ClusterMasks";
// apply local default setting if not defined by parent
if(m_taggerE.size() == 0)m_taggerE = std::vector<std::string>(1,"useDB");
if(m_taggerP.size() == 0)m_taggerP = std::vector<std::string>(1,"useDB");
// associate known cluster mask to tagger tool
declareProperty("ClusterTaggers" , m_clusterTaggers);
m_clusterTaggers[""] = "useDB"; // default
m_clusterTaggers["useDB"] = "useDB";
m_clusterTaggers[ "3x3"] = "SubClusterSelector3x3";
m_clusterTaggers[ "2x2"] = "SubClusterSelector2x2";
m_clusterTaggers[ "SwissCross"] = "SubClusterSelectorSwissCross";
}
//=============================================================================
// Destructor
//=============================================================================
SubClusterSelectorTool::~SubClusterSelectorTool() {}
//=============================================================================
StatusCode SubClusterSelectorTool::initialize() {
StatusCode sc = GaudiTool::initialize(); // must be executed first
if ( sc.isFailure() ) return sc; // error printed already by GaudiTool
if ( msgLevel(MSG::DEBUG) ) debug() << "==> Initialize" << endmsg;
// register to incident service
IIncidentSvc* inc = incSvc() ;
if ( 0 != inc )inc -> addListener ( this , IncidentType::BeginEvent ) ;
// get detector element
m_detector = getDet<DeCalorimeter> ( m_det );
if( NULL == m_detector)return Error("Cannot access DetectorElement at '"+m_det,StatusCode::FAILURE);
// setup DB accessor tool
m_dbAccessor = tool<CaloCorrectionBase>("CaloCorrectionBase","DBAccessor",this);
sc = m_dbAccessor->setConditionParams(m_condition,true);// force access via DB - if not exist will return empty params
if(sc.isFailure())return Warning("Cannot access DB",StatusCode::FAILURE);
m_DBtaggerE=std::vector<std::string>(m_detector->numberOfAreas(),"unset");
m_DBtaggerP=std::vector<std::string>(m_detector->numberOfAreas(),"unset");
m_sourceE=" (none)";
m_sourceP=" (none)";
// always set options parameters first
sc=getParamsFromOptions();
if( sc.isFailure())return Error("Cannot setup initial parameters",StatusCode::FAILURE);
// then possibly update from DB
updateParamsFromDB();
info() << " Energy mask : " << m_DBtaggerE << m_sourceE << endmsg;
info() << " Position mask : " << m_DBtaggerP << m_sourceP << endmsg;
return sc;
}
StatusCode SubClusterSelectorTool::tagEnergy( LHCb::CaloCluster* cluster ){
// get the tagger
LHCb::CaloCellID id = cluster->seed();
ICaloSubClusterTag* tagger = ( id.area() < m_tagE.size() ) ? m_tagE[id.area()] : NULL ;
if( NULL == tagger )return Warning( "Tagger not found" , StatusCode::FAILURE);
return tagger->tag(cluster);
}
StatusCode SubClusterSelectorTool::tagPosition( LHCb::CaloCluster* cluster ){
// get the tagger
LHCb::CaloCellID id = cluster->seed();
ICaloSubClusterTag* tagger = ( id.area() < m_tagP.size() ) ? m_tagP[id.area()] : NULL ;
if( NULL == tagger )return Warning( "Tagger not found" , StatusCode::FAILURE);
return tagger->tag(cluster);
}
StatusCode SubClusterSelectorTool::tag( LHCb::CaloCluster* cluster ){
StatusCode sc;
sc = tagEnergy( cluster);
sc = tagPosition(cluster );
return sc;
}
void SubClusterSelectorTool::updateParamsFromDB(){
using namespace CaloClusterMask;
unsigned int narea = m_detector->numberOfAreas();
for( unsigned int area = 0 ; area < narea ; ++area){
LHCb::CaloCellID id = LHCb::CaloCellID(m_detector->caloName(), area ,0,0);
if( m_taggerE[area] == "useDB"){
m_sourceE=" (from DB) ";
Mask maskE = (Mask) m_dbAccessor->getParameter(CaloCorrection::EnergyMask ,0, id , 0.); // default is 3x3 when no DB
std::string nameE=maskName[maskE];
if( nameE != m_DBtaggerE[area] ){ // DB has changed ! update !
std::string taggerE = (m_clusterTaggers.find(nameE) != m_clusterTaggers.end()) ? m_clusterTaggers[nameE] : "";
if(taggerE != ""){
ICaloSubClusterTag* tE = tool<ICaloSubClusterTag>(taggerE,id.areaName()+"EnergyTagger",this);
tE->setMask(m_energyStatus);
m_tagE.push_back( tE );
m_DBtaggerE[area] = nameE;
}else
Warning("Cannot update energy mask from DB",StatusCode::FAILURE).ignore();
}
}
if( m_taggerP[area] == "useDB"){
m_sourceP=" (from DB) ";
Mask maskP = (Mask) m_dbAccessor->getParameter(CaloCorrection::PositionMask ,0, id , 0.); // default is 3x3 when no DB
std::string nameP=maskName[maskP];
if( nameP != m_DBtaggerP[area] ){ // DB has changed ! update !
std::string taggerP = (m_clusterTaggers.find(nameP) != m_clusterTaggers.end()) ? m_clusterTaggers[nameP] : "";
if(taggerP != ""){
ICaloSubClusterTag* tP = tool<ICaloSubClusterTag>(taggerP,id.areaName()+"PositionTagger",this);
tP->setMask(m_positionStatus);
m_tagP.push_back( tP );
m_DBtaggerP[area] = nameP;
}else
Warning("Cannot update position mask from DB",StatusCode::FAILURE).ignore();
}
}
}
}
StatusCode SubClusterSelectorTool::getParamsFromOptions(){
unsigned int narea = m_detector->numberOfAreas();
LHCb::CaloCellID fake = LHCb::CaloCellID(m_detector->caloName(), 0 ,0,0);
// extend tagger per area when needed
if( m_taggerE.size() == 1)m_taggerE = std::vector<std::string>(narea , m_taggerE[0]);
if( m_taggerP.size() == 1)m_taggerP = std::vector<std::string>(narea , m_taggerP[0]);
if( m_taggerE.size() != m_detector->numberOfAreas() || m_taggerP.size() != m_detector->numberOfAreas())
return Error("You must define the tagger for each calo area");
using namespace CaloClusterMask;
// == Define Energy tagger per area
m_DBtaggerE=std::vector<std::string>(narea,"unset");
m_DBtaggerP=std::vector<std::string>(narea,"unset");
for( unsigned int area = 0 ; area < narea ; ++area){
LHCb::CaloCellID id = LHCb::CaloCellID(m_detector->caloName(), area ,0,0); // fake cell
std::string areaName = id.areaName();
std::string nameE = m_taggerE[area] ;
if( nameE != "useDB" ){
m_sourceE=" (from options) ";
std::string taggerE = (m_clusterTaggers.find(nameE) != m_clusterTaggers.end()) ? m_clusterTaggers[nameE] : "";
if(taggerE == "")
return Error("Cannot find a '"+nameE+"' tagger - You must select or define a known tagging method",StatusCode::FAILURE);
ICaloSubClusterTag* tE = tool<ICaloSubClusterTag>(taggerE,areaName+"EnergyTagger",this);
tE->setMask(m_energyStatus);
m_tagE.push_back( tE );
m_DBtaggerE[area]=nameE;
}
std::string nameP = m_taggerP[area] ;
if( nameP != "useDB" ){
m_sourceP=" (from options) ";
std::string taggerP = (m_clusterTaggers.find(nameP) != m_clusterTaggers.end()) ? m_clusterTaggers[nameP] : "";
if(taggerP == "")
return Error("Cannot find a '"+nameP+"' tagger - You must select or define a known tagging method",StatusCode::FAILURE);
ICaloSubClusterTag* tP= tool<ICaloSubClusterTag>(taggerP,areaName+"PositionTagger",this);
tP->setMask(m_positionStatus);
m_tagP.push_back( tP );
m_DBtaggerP[area]=nameP;
}
}
return StatusCode::SUCCESS;
}
StatusCode SubClusterSelectorTool::finalize() {
return GaudiTool::finalize(); // must be called after all other actions
}
| [
"odescham@cern.ch"
] | odescham@cern.ch |
39f5894702730eaba1b310cc490b06b542729677 | cba2271b98ab5b6e2a17ff193baed58cdcfc7015 | /Week_4/03 Programming Assignment/Example.cpp | ca7f3a38509953751f52d38ef9b8c3e88f99420a | [
"Unlicense"
] | permissive | FakeDefault1/basics-of-c-plus-plus-development-white-belt-1 | ddf54dcd55c55ba325dce5468cb1a68c61c5b96f | 9ad0aec57a54e505955ad4a93a0636903ba92822 | refs/heads/master | 2021-09-29T01:25:11.319091 | 2018-11-22T10:13:07 | 2018-11-22T10:13:07 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,346 | cpp | #include <iostream>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;
struct Image
{
double quality;
double freshness;
double rating;
};
struct Params
{
double a;
double b;
double c;
};
class FunctionsPart
{
public:
FunctionsPart(char new_operation, double new_value)
{
operation = new_operation;
value = new_value;
}
double Apply(double source_value) const
{
if (operation == '+')
{
return source_value + value;
}
else
if (operation == '-')
{
return source_value - value;
}
else
if (operation == '*')
{
return source_value * value;
}
else
{
return source_value / value;
}
}
void Invert()
{
if (operation == '+')
{
operation = '-';
}
else
if (operation == '-')
{
operation = '+';
}
else
if (operation == '*')
{
operation = '/';
}
else
{
operation = '*';
}
}
private:
char operation;
double value;
};
class Function
{
public:
void AddPart(char operation, double value)
{
parts.push_back({operation, value});
}
double Apply(double value) const
{
for (const FunctionsPart& part : parts)
{
value = part.Apply(value);
}
return value;
}
void Invert()
{
for (FunctionsPart& part : parts)
{
part.Invert();
}
reverse(begin(parts), end(parts));
}
private:
vector<FunctionsPart> parts;
};
Function MakeWeightFunction(const Params& params,
const Image& image)
{
Function function;
function.AddPart('*', params.a);
function.AddPart('-', image.freshness * params.b);
function.AddPart('+', image.rating * params.c);
return function;
}
double ComputeImageWeight(const Params& params, const Image& image)
{
Function function = MakeWeightFunction(params, image);
return function.Apply(image.quality);
}
double ComputeQualityByWeight(const Params& params,
const Image& image,
double weight)
{
Function function = MakeWeightFunction(params, image);
function.Invert();
return function.Apply(weight);
}
int main()
{
Image image = {10, 2, 6};
Params params = {4, 2, 6};
cout << ComputeImageWeight(params, image) << endl;
cout << ComputeQualityByWeight(params, image, 52) << endl;
return 0;
} | [
"hitoku@list.ru"
] | hitoku@list.ru |
2830e392df7b811785269086120786c2623dc301 | 8046ceae036515176d89bce65fd0826ae8ae47e9 | /src/com/douma/_1_first_day/_125/代码实现_C++.cpp | 3c924c9a9987c7005012ec7d3c40b6ef7d868481 | [] | no_license | jeffytang/douma_algo_training_camp | 6a9de3cf07fb984f3e71d60762ebbde043b094de | 637cf4faafcc5ad81ca83556e311b5b3f001ea37 | refs/heads/main | 2023-04-14T21:34:07.993697 | 2021-04-23T07:04:54 | 2021-04-23T07:04:54 | 357,849,899 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 646 | cpp | public:
bool isPalindrome(string s) {
int left = 0;
int right = s.size() - 1;
while (left < right) {
// 忽略左边无效字符
while (left < right && !isalnum(s[left])) {
left++;
}
// 忽略右边无效字符
while (left < right && !isalnum(s[right])) {
right--;
}
if (left < right) {
if (tolower(s[left]) != tolower(s[right])) {
return false;
}
left++;
right--;
}
}
return true;
} | [
"tangwq_ok@163.com"
] | tangwq_ok@163.com |
11dd91ca22c43c065b80260da9ebd3e328004072 | 66b7e4373e00f66878e762413dff28b18c4e16a9 | /C++/Untitled1.cpp | 63774dff5281e95370fe305818831f8abfcf5c43 | [] | no_license | AoueXD/OLD | 9fc459a38132646c30109a745677ccbdf1781e95 | b204a5bf7ef0dc85cedf4fa820fa2b0af4de35fe | refs/heads/master | 2022-09-30T07:39:41.317940 | 2020-06-06T07:57:05 | 2020-06-06T07:57:05 | 269,551,755 | 0 | 0 | null | null | null | null | BIG5 | C++ | false | false | 984 | cpp | #include <iostream>
#include <fstream>
using namespace std;
int main(){
int i = 0, j = 0, G = 0, temp = 0, k;
string name, str1, str2; //沒有長度
ifstream data("data.txt", ios::in); //從外面拿進來;
ofstream ofile("ans.txt", ios::out);//appent == 串流; out == 取代 //ofile.open("data.txt");
if(ofile.fail()){
cout << "ERROR";
exit(1);
}
else{
while(!data.eof()){
data >> str1;
cout << str1<<endl;
if( str1[i] == ' '){
k++;
}
for(i = 0; i <str1.length(); i++){
if((str1[i] >=65 && str1[i] <= 90) || (str1[i] >= 97 && str1[i] <= 122))
G++;
if(str1[i] == 'e')
str2 += "a";
if(str1[i] == 'm')
str2 += "OO";
else
str2 += str1[i];
}
str2 += " ";
i++;
temp++;
}
cout << temp << endl;
ofile << temp << endl;
cout << G << endl;
ofile << G << endl;
cout << str2 << endl;
ofile << str2 << endl;
}
ofile.close();
}
| [
"noreply@github.com"
] | noreply@github.com |
874856900e8e6047a6f290f0b7d9d5b839f8f264 | 50588ba0a12e9a3167fe05534a76bda9276b8f1d | /QT Project/JembatanTimbang/mainwindow.cpp | fb01a1140894a5fb64a232ab4484845bfef72704 | [] | no_license | hazmi-e205/Jembatan-Timbang | fa7814f61c1bb8f00a356e111acc88a16af60873 | b859849713c46e2902675c09b8c99aadef2e0615 | refs/heads/master | 2021-08-20T08:45:30.103500 | 2017-11-28T16:36:35 | 2017-11-28T16:36:35 | 112,360,454 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 12,618 | cpp | #include "mainwindow.h"
#include "ui_mainwindow.h"
QString namaFilenya,alamatFilenya,waktu,tipe,balasanSql;
QString alamatPortal,alamatSensor;
QTimer *timer1;
Mat streamKamera, capture;
VideoCapture kamera(0);
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
kameraStart();
ui->progressBar->setVisible(false);
m_manager = new QNetworkAccessManager(this);
connect(m_manager, SIGNAL(finished(QNetworkReply*)), this, SLOT(uploadFinished(QNetworkReply*)));
kbdprog = "onboard";
}
MainWindow::~MainWindow()
{
delete ui;
}
void MainWindow::uploadFinished(QNetworkReply *reply)
{
if (!reply->error())
{
m_file->close();
m_file->deleteLater();
reply->deleteLater();
ui->progressBar->setVisible(false);
if (balasanSql=="berhasil") ui->statusbar_e205->setText("Upload selesai !");
else ui->statusbar_e205->setText("Upload Gagal (database)");
} else {
ui->statusbar_e205->setText("Upload Gagal (foto)");
}
}
void MainWindow::uploadProgress(qint64 bytesSent, qint64 bytesTotal)
{
ui->progressBar->setVisible(true);
ui->progressBar->setValue(100 * bytesSent/bytesTotal);
ui->statusbar_e205->setText("Uploading.....");
}
void MainWindow::onfinishCoy(QNetworkReply *rep)
{
QByteArray bts = rep->readAll();
balasanSql=bts;
}
void MainWindow::cekSensor(QNetworkReply *rep)
{
QByteArray bts = rep->readAll();
QString balasan(bts);
if (balasan=="jembatan_sensor_node"){
ui->ipsensor->setStyleSheet("background-color: rgb(202, 202, 202);");
ui->ipsensor->setReadOnly(true);
} else {
ui->ipsensor->setStyleSheet("background-color: rgb(255, 255, 255);");
ui->ipsensor->setReadOnly(false);
}
}
void MainWindow::cekPortal(QNetworkReply *rep)
{
QByteArray bts = rep->readAll();
QString balasan(bts);
if (balasan=="jembatan_portal_node"){
ui->ipportal->setStyleSheet("background-color: rgb(202, 202, 202);");
ui->ipportal->setReadOnly(true);
} else {
ui->ipportal->setStyleSheet("background-color: rgb(255, 255, 255);");
ui->ipportal->setReadOnly(false);
}
}
void MainWindow::mintaSensor(QNetworkReply *rep)
{
QByteArray bts = rep->readAll();
QString balasan(bts);
if (balasan=="baca"){
ui->pushButton->setText("selesai");
}
}
void MainWindow::terimaSensor(QNetworkReply *rep)
{
QByteArray bts = rep->readAll();
QString balasan(bts);
if (balasan.length()>0){
ui->statusbar_e205->setText("Terima data sensor (" + balasan + ")");
ui->pushButton->setText("Baca Sensor");
if (balasan.length()==7){
QStringList pisah1 = balasan.split('a');
QStringList pisah2 = pisah1[1].split('b');
QString sensor1=pisah2[0];
QStringList pisah3 = pisah2[1].split('c');
QString sensor2=pisah3[0];
QStringList pisah4 = pisah3[1].split('d');
QString sensor3=pisah4[0];
if (tipe=="Tipe1") {
if (sensor1=="1") ui->isi_4->setText("Tilang");
else ui->isi_4->setText("Lolos");
}
if (tipe=="Tipe2") {
if (sensor2=="1") ui->isi_4->setText("Tilang");
else ui->isi_4->setText("Lolos");
}
if (tipe=="Tipe3") {
if (sensor3=="1") ui->isi_4->setText("Tilang");
else ui->isi_4->setText("Lolos");
}
if (ui->isi_4->text()=="Tilang"){
QNetworkAccessManager *mgr1 = new QNetworkAccessManager(this);
connect(mgr1,SIGNAL(finished(QNetworkReply*)),mgr1,SLOT(deleteLater()));
alamatSensor="http://192.168.1.101/tilang";
mgr1->get(QNetworkRequest(QUrl(alamatSensor)));
QNetworkAccessManager *mgr2 = new QNetworkAccessManager(this);
connect(mgr1,SIGNAL(finished(QNetworkReply*)),mgr2,SLOT(deleteLater()));
alamatSensor="http://192.168.1.100/tidak";
mgr2->get(QNetworkRequest(QUrl(alamatSensor)));
}
if (ui->isi_4->text()=="Lolos"){
QNetworkAccessManager *mgr1 = new QNetworkAccessManager(this);
//connect(mgr1,SIGNAL(finished(QNetworkReply*)),this,SLOT(cekSensor(QNetworkReply*)));
connect(mgr1,SIGNAL(finished(QNetworkReply*)),mgr1,SLOT(deleteLater()));
alamatSensor="http://192.168.1.101/lolos";
mgr1->get(QNetworkRequest(QUrl(alamatSensor)));
QNetworkAccessManager *mgr2 = new QNetworkAccessManager(this);
connect(mgr1,SIGNAL(finished(QNetworkReply*)),mgr2,SLOT(deleteLater()));
alamatSensor="http://192.168.1.100/ya";
mgr2->get(QNetworkRequest(QUrl(alamatSensor)));
}
QThread::msleep(3000);
QNetworkAccessManager *mgr3 = new QNetworkAccessManager(this);
connect(mgr3,SIGNAL(finished(QNetworkReply*)),mgr3,SLOT(deleteLater()));
alamatSensor="http://192.168.1.100/reset";
mgr3->get(QNetworkRequest(QUrl(alamatSensor)));
}
}
}
void MainWindow::kameraStart()
{
if (!kamera.isOpened() )
{
qDebug() << "Cannot open the web cam" << endl;
}
timer1=new QTimer(this);
//timer1->start(100);
connect(timer1,SIGNAL(timeout()),this,SLOT(kameraUpdate()));
}
void MainWindow::kameraUpdate()
{
bool berhasil = kamera.read(streamKamera);
if (!berhasil){
qDebug() << "Cannot read a frame from video stream" << endl;
} else {
ui->kamera->setPixmap(QPixmap::fromImage(putImage(streamKamera)));
}
}
QImage MainWindow::putImage(const Mat &mat)
{
// 8-bits unsigned, NO. OF CHANNELS=1
if(mat.type()==CV_8UC1)
{
// Set the color table (used to translate colour indexes to qRgb values)
QVector<QRgb> colorTable;
for (int i=0; i<256; i++)
colorTable.push_back(qRgb(i,i,i));
// Copy input Mat
const uchar *qImageBuffer = (const uchar*)mat.data;
// Create QImage with same dimensions as input Mat
QImage img(qImageBuffer, mat.cols, mat.rows, mat.step, QImage::Format_Indexed8);
img.setColorTable(colorTable);
return img;
}
// 8-bits unsigned, NO. OF CHANNELS=3
if(mat.type()==CV_8UC3)
{
// Copy input Mat
const uchar *qImageBuffer = (const uchar*)mat.data;
// Create QImage with same dimensions as input Mat
QImage img(qImageBuffer, mat.cols, mat.rows, mat.step, QImage::Format_RGB888);
return img.rgbSwapped();
}
else
{
qDebug() << "ERROR: Mat could not be converted to QImage.";
return QImage();
}
}
void MainWindow::on_pushButton_pressed()
{
if (ui->pushButton->text()=="Baca Sensor"){
QNetworkAccessManager *mgr3 = new QNetworkAccessManager(this);
connect(mgr3,SIGNAL(finished(QNetworkReply*)),this,SLOT(mintaSensor(QNetworkReply*)));
connect(mgr3,SIGNAL(finished(QNetworkReply*)),mgr3,SLOT(deleteLater()));
alamatSensor="http://"+ui->ipsensor->text()+"/baca";
mgr3->get(QNetworkRequest(QUrl(alamatSensor)));
} else if (ui->pushButton->text()=="selesai"){
QNetworkAccessManager *mgr3 = new QNetworkAccessManager(this);
connect(mgr3,SIGNAL(finished(QNetworkReply*)),this,SLOT(terimaSensor(QNetworkReply*)));
connect(mgr3,SIGNAL(finished(QNetworkReply*)),mgr3,SLOT(deleteLater()));
alamatSensor="http://"+ui->ipsensor->text()+"/sensor";
mgr3->get(QNetworkRequest(QUrl(alamatSensor)));
}
}
void MainWindow::on_pushButton_2_pressed()
{
QStringList nama=QStandardPaths::standardLocations(QStandardPaths::DesktopLocation);
//qDebug()<<nama[0];
QImage foto=putImage(streamKamera);
namaFilenya=QDateTime::currentDateTime().toString("yyyyMMdd-hhmmss") + ".jpg";
waktu=QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm");
alamatFilenya=nama[0] + "/Foto/";
foto.save(alamatFilenya + namaFilenya,"JPG");
ui->namaFoto_->setText(namaFilenya);
//capture = streamKamera;
//imwrite(nama[0] + "/Foto/test.jpg", capture);
}
void MainWindow::on_pushButton_3_pressed()
{
QNetworkAccessManager * mgr = new QNetworkAccessManager(this);
connect(mgr,SIGNAL(finished(QNetworkReply*)),this,SLOT(onfinishCoy(QNetworkReply*)));
connect(mgr,SIGNAL(finished(QNetworkReply*)),mgr,SLOT(deleteLater()));
QString alamatLengkap="http://jembatan.e205.org/daftar.php?&waktu="+waktu+"&nopol="+ui->isi->text()+"&tipe="+tipe+"&batas="+ui->isi_3->text()+"&ket="+ui->isi_4->text()+"&foto=foto/"+namaFilenya;
mgr->get(QNetworkRequest(QUrl(alamatLengkap)));
m_file = new QFile(alamatFilenya + namaFilenya);
QUrl url("ftp://ftp.e205.org/jembatan.e205.org/foto/" + namaFilenya);
url.setUserName("e205");
url.setPassword("10.124.20.205");
url.setScheme("ftp");
url.setPort(21);
if (m_file->open(QIODevice::ReadOnly))
{
QNetworkReply *reply = m_manager->put(QNetworkRequest(url), m_file);
connect(reply, SIGNAL(uploadProgress(qint64,qint64)), this, SLOT(uploadProgress(qint64,qint64)));
}
//ui->plainTextEdit->setPlainText("====================\nJembatan Timbang\n "+waktu+"\n====================\nNoPol: "+ui->isi->text()+"\nTipe : "+tipe+"\nBatas: "+ui->isi_3->text()+"\nKet : "+ui->isi_4->text()+"\n====================");
QString datanyaa = "====================\nJembatan Timbang\n "+waktu+"\n====================\nNoPol: "+ui->isi->text()+"\nTipe : "+tipe+"\nBatas: "+ui->isi_3->text()+"\nKet : "+ui->isi_4->text()+"\n====================";
QPrinter printer;
QPrintDialog *dialog = new QPrintDialog(&printer);
dialog->setWindowTitle("Print Document");
if (dialog->exec() != QDialog::Accepted)
dialog->close();
QPainter painter;
painter.begin(&printer);
painter.drawText(100, 100, 500, 500, Qt::AlignLeft|Qt::AlignTop, datanyaa);
painter.end();
QNetworkAccessManager *mgr4 = new QNetworkAccessManager(this);
connect(mgr4,SIGNAL(finished(QNetworkReply*)),mgr4,SLOT(deleteLater()));
alamatSensor="http://192.168.1.101/reset";
mgr4->get(QNetworkRequest(QUrl(alamatSensor)));
}
void MainWindow::on_radioButton_pressed()
{
tipe="Tipe1";
ui->isi_3->setText("14");
}
void MainWindow::on_radioButton_2_pressed()
{
tipe="Tipe2";
ui->isi_3->setText("28");
}
void MainWindow::on_radioButton_3_pressed()
{
tipe="Tipe3";
ui->isi_3->setText("42");
}
int status=0;
void MainWindow::on_koneksi_pressed()
{
if (status==0){
kamera.open(0);
timer1->start(50);
QNetworkAccessManager *mgr1 = new QNetworkAccessManager(this);
connect(mgr1,SIGNAL(finished(QNetworkReply*)),this,SLOT(cekSensor(QNetworkReply*)));
connect(mgr1,SIGNAL(finished(QNetworkReply*)),mgr1,SLOT(deleteLater()));
alamatSensor="http://"+ui->ipsensor->text();
mgr1->get(QNetworkRequest(QUrl(alamatSensor)));
QNetworkAccessManager *mgr2 = new QNetworkAccessManager(this);
connect(mgr2,SIGNAL(finished(QNetworkReply*)),this,SLOT(cekPortal(QNetworkReply*)));
connect(mgr2,SIGNAL(finished(QNetworkReply*)),mgr2,SLOT(deleteLater()));
alamatPortal="http://"+ui->ipportal->text();
mgr2->get(QNetworkRequest(QUrl(alamatPortal)));
ui->koneksi->setStyleSheet("border-image: url(:/konten/gambar/tombol/conect.png);");
ui->statusbar_e205->setText("Memulai integrasi sistem");
status=1;
} else {
kamera.release();
timer1->stop();
ui->ipsensor->setStyleSheet("background-color: rgb(255, 255, 255);");
ui->ipsensor->setReadOnly(false);
ui->ipportal->setStyleSheet("background-color: rgb(255, 255, 255);");
ui->ipportal->setReadOnly(false);
ui->kamera->clear();
ui->kamera->setText("Tidak Terhubung Kamera");
ui->koneksi->setStyleSheet("border-image: url(:/konten/gambar/tombol/disconect.png);");
ui->statusbar_e205->setText("Koneksi terputus");
status=0;
}
}
void MainWindow::showOnboard(){
QProcess *kbdproc = new QProcess(this);
kbdproc->start(kbdprog);
}
void MainWindow::on_isi_selectionChanged()
{
showOnboard();
}
| [
"hazmiarifin@gmail.com"
] | hazmiarifin@gmail.com |
057ef04e7dea90e3e5ee3bd69b0aa3e95ff9b6f8 | d14b5d78b72711e4614808051c0364b7bd5d6d98 | /third_party/llvm-16.0/llvm/include/llvm/CodeGen/GlobalISel/MachineIRBuilder.h | e5b48d9d52c031eb112b9d969ad903b6220adb2e | [
"Apache-2.0"
] | permissive | google/swiftshader | 76659addb1c12eb1477050fded1e7d067f2ed25b | 5be49d4aef266ae6dcc95085e1e3011dad0e7eb7 | refs/heads/master | 2023-07-21T23:19:29.415159 | 2023-07-21T19:58:29 | 2023-07-21T20:50:19 | 62,297,898 | 1,981 | 306 | Apache-2.0 | 2023-07-05T21:29:34 | 2016-06-30T09:25:24 | C++ | UTF-8 | C++ | false | false | 85,909 | h | //===-- llvm/CodeGen/GlobalISel/MachineIRBuilder.h - MIBuilder --*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
/// \file
/// This file declares the MachineIRBuilder class.
/// This is a helper class to build MachineInstr.
//===----------------------------------------------------------------------===//
#ifndef LLVM_CODEGEN_GLOBALISEL_MACHINEIRBUILDER_H
#define LLVM_CODEGEN_GLOBALISEL_MACHINEIRBUILDER_H
#include "llvm/CodeGen/GlobalISel/GISelChangeObserver.h"
#include "llvm/CodeGen/MachineBasicBlock.h"
#include "llvm/CodeGen/MachineInstrBuilder.h"
#include "llvm/CodeGen/MachineRegisterInfo.h"
#include "llvm/CodeGen/TargetOpcodes.h"
#include "llvm/IR/DebugLoc.h"
#include "llvm/IR/Module.h"
namespace llvm {
// Forward declarations.
class APInt;
class BlockAddress;
class Constant;
class ConstantFP;
class ConstantInt;
class DataLayout;
class GISelCSEInfo;
class GlobalValue;
class TargetRegisterClass;
class MachineFunction;
class MachineInstr;
class TargetInstrInfo;
class GISelChangeObserver;
/// Class which stores all the state required in a MachineIRBuilder.
/// Since MachineIRBuilders will only store state in this object, it allows
/// to transfer BuilderState between different kinds of MachineIRBuilders.
struct MachineIRBuilderState {
/// MachineFunction under construction.
MachineFunction *MF = nullptr;
/// Information used to access the description of the opcodes.
const TargetInstrInfo *TII = nullptr;
/// Information used to verify types are consistent and to create virtual registers.
MachineRegisterInfo *MRI = nullptr;
/// Debug location to be set to any instruction we create.
DebugLoc DL;
/// PC sections metadata to be set to any instruction we create.
MDNode *PCSections = nullptr;
/// \name Fields describing the insertion point.
/// @{
MachineBasicBlock *MBB = nullptr;
MachineBasicBlock::iterator II;
/// @}
GISelChangeObserver *Observer = nullptr;
GISelCSEInfo *CSEInfo = nullptr;
};
class DstOp {
union {
LLT LLTTy;
Register Reg;
const TargetRegisterClass *RC;
};
public:
enum class DstType { Ty_LLT, Ty_Reg, Ty_RC };
DstOp(unsigned R) : Reg(R), Ty(DstType::Ty_Reg) {}
DstOp(Register R) : Reg(R), Ty(DstType::Ty_Reg) {}
DstOp(const MachineOperand &Op) : Reg(Op.getReg()), Ty(DstType::Ty_Reg) {}
DstOp(const LLT T) : LLTTy(T), Ty(DstType::Ty_LLT) {}
DstOp(const TargetRegisterClass *TRC) : RC(TRC), Ty(DstType::Ty_RC) {}
void addDefToMIB(MachineRegisterInfo &MRI, MachineInstrBuilder &MIB) const {
switch (Ty) {
case DstType::Ty_Reg:
MIB.addDef(Reg);
break;
case DstType::Ty_LLT:
MIB.addDef(MRI.createGenericVirtualRegister(LLTTy));
break;
case DstType::Ty_RC:
MIB.addDef(MRI.createVirtualRegister(RC));
break;
}
}
LLT getLLTTy(const MachineRegisterInfo &MRI) const {
switch (Ty) {
case DstType::Ty_RC:
return LLT{};
case DstType::Ty_LLT:
return LLTTy;
case DstType::Ty_Reg:
return MRI.getType(Reg);
}
llvm_unreachable("Unrecognised DstOp::DstType enum");
}
Register getReg() const {
assert(Ty == DstType::Ty_Reg && "Not a register");
return Reg;
}
const TargetRegisterClass *getRegClass() const {
switch (Ty) {
case DstType::Ty_RC:
return RC;
default:
llvm_unreachable("Not a RC Operand");
}
}
DstType getDstOpKind() const { return Ty; }
private:
DstType Ty;
};
class SrcOp {
union {
MachineInstrBuilder SrcMIB;
Register Reg;
CmpInst::Predicate Pred;
int64_t Imm;
};
public:
enum class SrcType { Ty_Reg, Ty_MIB, Ty_Predicate, Ty_Imm };
SrcOp(Register R) : Reg(R), Ty(SrcType::Ty_Reg) {}
SrcOp(const MachineOperand &Op) : Reg(Op.getReg()), Ty(SrcType::Ty_Reg) {}
SrcOp(const MachineInstrBuilder &MIB) : SrcMIB(MIB), Ty(SrcType::Ty_MIB) {}
SrcOp(const CmpInst::Predicate P) : Pred(P), Ty(SrcType::Ty_Predicate) {}
/// Use of registers held in unsigned integer variables (or more rarely signed
/// integers) is no longer permitted to avoid ambiguity with upcoming support
/// for immediates.
SrcOp(unsigned) = delete;
SrcOp(int) = delete;
SrcOp(uint64_t V) : Imm(V), Ty(SrcType::Ty_Imm) {}
SrcOp(int64_t V) : Imm(V), Ty(SrcType::Ty_Imm) {}
void addSrcToMIB(MachineInstrBuilder &MIB) const {
switch (Ty) {
case SrcType::Ty_Predicate:
MIB.addPredicate(Pred);
break;
case SrcType::Ty_Reg:
MIB.addUse(Reg);
break;
case SrcType::Ty_MIB:
MIB.addUse(SrcMIB->getOperand(0).getReg());
break;
case SrcType::Ty_Imm:
MIB.addImm(Imm);
break;
}
}
LLT getLLTTy(const MachineRegisterInfo &MRI) const {
switch (Ty) {
case SrcType::Ty_Predicate:
case SrcType::Ty_Imm:
llvm_unreachable("Not a register operand");
case SrcType::Ty_Reg:
return MRI.getType(Reg);
case SrcType::Ty_MIB:
return MRI.getType(SrcMIB->getOperand(0).getReg());
}
llvm_unreachable("Unrecognised SrcOp::SrcType enum");
}
Register getReg() const {
switch (Ty) {
case SrcType::Ty_Predicate:
case SrcType::Ty_Imm:
llvm_unreachable("Not a register operand");
case SrcType::Ty_Reg:
return Reg;
case SrcType::Ty_MIB:
return SrcMIB->getOperand(0).getReg();
}
llvm_unreachable("Unrecognised SrcOp::SrcType enum");
}
CmpInst::Predicate getPredicate() const {
switch (Ty) {
case SrcType::Ty_Predicate:
return Pred;
default:
llvm_unreachable("Not a register operand");
}
}
int64_t getImm() const {
switch (Ty) {
case SrcType::Ty_Imm:
return Imm;
default:
llvm_unreachable("Not an immediate");
}
}
SrcType getSrcOpKind() const { return Ty; }
private:
SrcType Ty;
};
/// Helper class to build MachineInstr.
/// It keeps internally the insertion point and debug location for all
/// the new instructions we want to create.
/// This information can be modified via the related setters.
class MachineIRBuilder {
MachineIRBuilderState State;
unsigned getOpcodeForMerge(const DstOp &DstOp, ArrayRef<SrcOp> SrcOps) const;
protected:
void validateTruncExt(const LLT Dst, const LLT Src, bool IsExtend);
void validateUnaryOp(const LLT Res, const LLT Op0);
void validateBinaryOp(const LLT Res, const LLT Op0, const LLT Op1);
void validateShiftOp(const LLT Res, const LLT Op0, const LLT Op1);
void validateSelectOp(const LLT ResTy, const LLT TstTy, const LLT Op0Ty,
const LLT Op1Ty);
void recordInsertion(MachineInstr *InsertedInstr) const {
if (State.Observer)
State.Observer->createdInstr(*InsertedInstr);
}
public:
/// Some constructors for easy use.
MachineIRBuilder() = default;
MachineIRBuilder(MachineFunction &MF) { setMF(MF); }
MachineIRBuilder(MachineBasicBlock &MBB, MachineBasicBlock::iterator InsPt) {
setMF(*MBB.getParent());
setInsertPt(MBB, InsPt);
}
MachineIRBuilder(MachineInstr &MI) :
MachineIRBuilder(*MI.getParent(), MI.getIterator()) {
setInstr(MI);
setDebugLoc(MI.getDebugLoc());
}
MachineIRBuilder(MachineInstr &MI, GISelChangeObserver &Observer) :
MachineIRBuilder(MI) {
setChangeObserver(Observer);
}
virtual ~MachineIRBuilder() = default;
MachineIRBuilder(const MachineIRBuilderState &BState) : State(BState) {}
const TargetInstrInfo &getTII() {
assert(State.TII && "TargetInstrInfo is not set");
return *State.TII;
}
/// Getter for the function we currently build.
MachineFunction &getMF() {
assert(State.MF && "MachineFunction is not set");
return *State.MF;
}
const MachineFunction &getMF() const {
assert(State.MF && "MachineFunction is not set");
return *State.MF;
}
const DataLayout &getDataLayout() const {
return getMF().getFunction().getParent()->getDataLayout();
}
/// Getter for DebugLoc
const DebugLoc &getDL() { return State.DL; }
/// Getter for MRI
MachineRegisterInfo *getMRI() { return State.MRI; }
const MachineRegisterInfo *getMRI() const { return State.MRI; }
/// Getter for the State
MachineIRBuilderState &getState() { return State; }
/// Getter for the basic block we currently build.
const MachineBasicBlock &getMBB() const {
assert(State.MBB && "MachineBasicBlock is not set");
return *State.MBB;
}
MachineBasicBlock &getMBB() {
return const_cast<MachineBasicBlock &>(
const_cast<const MachineIRBuilder *>(this)->getMBB());
}
GISelCSEInfo *getCSEInfo() { return State.CSEInfo; }
const GISelCSEInfo *getCSEInfo() const { return State.CSEInfo; }
/// Current insertion point for new instructions.
MachineBasicBlock::iterator getInsertPt() { return State.II; }
/// Set the insertion point before the specified position.
/// \pre MBB must be in getMF().
/// \pre II must be a valid iterator in MBB.
void setInsertPt(MachineBasicBlock &MBB, MachineBasicBlock::iterator II) {
assert(MBB.getParent() == &getMF() &&
"Basic block is in a different function");
State.MBB = &MBB;
State.II = II;
}
/// @}
void setCSEInfo(GISelCSEInfo *Info) { State.CSEInfo = Info; }
/// \name Setters for the insertion point.
/// @{
/// Set the MachineFunction where to build instructions.
void setMF(MachineFunction &MF);
/// Set the insertion point to the end of \p MBB.
/// \pre \p MBB must be contained by getMF().
void setMBB(MachineBasicBlock &MBB) {
State.MBB = &MBB;
State.II = MBB.end();
assert(&getMF() == MBB.getParent() &&
"Basic block is in a different function");
}
/// Set the insertion point to before MI.
/// \pre MI must be in getMF().
void setInstr(MachineInstr &MI) {
assert(MI.getParent() && "Instruction is not part of a basic block");
setMBB(*MI.getParent());
State.II = MI.getIterator();
setPCSections(MI.getPCSections());
}
/// @}
/// Set the insertion point to before MI, and set the debug loc to MI's loc.
/// \pre MI must be in getMF().
void setInstrAndDebugLoc(MachineInstr &MI) {
setInstr(MI);
setDebugLoc(MI.getDebugLoc());
}
void setChangeObserver(GISelChangeObserver &Observer) {
State.Observer = &Observer;
}
void stopObservingChanges() { State.Observer = nullptr; }
/// @}
/// Set the debug location to \p DL for all the next build instructions.
void setDebugLoc(const DebugLoc &DL) { this->State.DL = DL; }
/// Get the current instruction's debug location.
const DebugLoc &getDebugLoc() { return State.DL; }
/// Set the PC sections metadata to \p MD for all the next build instructions.
void setPCSections(MDNode *MD) { State.PCSections = MD; }
/// Get the current instruction's PC sections metadata.
MDNode *getPCSections() { return State.PCSections; }
/// Build and insert <empty> = \p Opcode <empty>.
/// The insertion point is the one set by the last call of either
/// setBasicBlock or setMI.
///
/// \pre setBasicBlock or setMI must have been called.
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildInstr(unsigned Opcode) {
return insertInstr(buildInstrNoInsert(Opcode));
}
/// Build but don't insert <empty> = \p Opcode <empty>.
///
/// \pre setMF, setBasicBlock or setMI must have been called.
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildInstrNoInsert(unsigned Opcode);
/// Insert an existing instruction at the insertion point.
MachineInstrBuilder insertInstr(MachineInstrBuilder MIB);
/// Build and insert a DBG_VALUE instruction expressing the fact that the
/// associated \p Variable lives in \p Reg (suitably modified by \p Expr).
MachineInstrBuilder buildDirectDbgValue(Register Reg, const MDNode *Variable,
const MDNode *Expr);
/// Build and insert a DBG_VALUE instruction expressing the fact that the
/// associated \p Variable lives in memory at \p Reg (suitably modified by \p
/// Expr).
MachineInstrBuilder buildIndirectDbgValue(Register Reg,
const MDNode *Variable,
const MDNode *Expr);
/// Build and insert a DBG_VALUE instruction expressing the fact that the
/// associated \p Variable lives in the stack slot specified by \p FI
/// (suitably modified by \p Expr).
MachineInstrBuilder buildFIDbgValue(int FI, const MDNode *Variable,
const MDNode *Expr);
/// Build and insert a DBG_VALUE instructions specifying that \p Variable is
/// given by \p C (suitably modified by \p Expr).
MachineInstrBuilder buildConstDbgValue(const Constant &C,
const MDNode *Variable,
const MDNode *Expr);
/// Build and insert a DBG_LABEL instructions specifying that \p Label is
/// given. Convert "llvm.dbg.label Label" to "DBG_LABEL Label".
MachineInstrBuilder buildDbgLabel(const MDNode *Label);
/// Build and insert \p Res = G_DYN_STACKALLOC \p Size, \p Align
///
/// G_DYN_STACKALLOC does a dynamic stack allocation and writes the address of
/// the allocated memory into \p Res.
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p Res must be a generic virtual register with pointer type.
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildDynStackAlloc(const DstOp &Res, const SrcOp &Size,
Align Alignment);
/// Build and insert \p Res = G_FRAME_INDEX \p Idx
///
/// G_FRAME_INDEX materializes the address of an alloca value or other
/// stack-based object.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p Res must be a generic virtual register with pointer type.
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildFrameIndex(const DstOp &Res, int Idx);
/// Build and insert \p Res = G_GLOBAL_VALUE \p GV
///
/// G_GLOBAL_VALUE materializes the address of the specified global
/// into \p Res.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p Res must be a generic virtual register with pointer type
/// in the same address space as \p GV.
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildGlobalValue(const DstOp &Res, const GlobalValue *GV);
/// Build and insert \p Res = G_PTR_ADD \p Op0, \p Op1
///
/// G_PTR_ADD adds \p Op1 addressible units to the pointer specified by \p Op0,
/// storing the resulting pointer in \p Res. Addressible units are typically
/// bytes but this can vary between targets.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p Res and \p Op0 must be generic virtual registers with pointer
/// type.
/// \pre \p Op1 must be a generic virtual register with scalar type.
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildPtrAdd(const DstOp &Res, const SrcOp &Op0,
const SrcOp &Op1);
/// Materialize and insert \p Res = G_PTR_ADD \p Op0, (G_CONSTANT \p Value)
///
/// G_PTR_ADD adds \p Value bytes to the pointer specified by \p Op0,
/// storing the resulting pointer in \p Res. If \p Value is zero then no
/// G_PTR_ADD or G_CONSTANT will be created and \pre Op0 will be assigned to
/// \p Res.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p Op0 must be a generic virtual register with pointer type.
/// \pre \p ValueTy must be a scalar type.
/// \pre \p Res must be 0. This is to detect confusion between
/// materializePtrAdd() and buildPtrAdd().
/// \post \p Res will either be a new generic virtual register of the same
/// type as \p Op0 or \p Op0 itself.
///
/// \return a MachineInstrBuilder for the newly created instruction.
std::optional<MachineInstrBuilder> materializePtrAdd(Register &Res,
Register Op0,
const LLT ValueTy,
uint64_t Value);
/// Build and insert \p Res = G_PTRMASK \p Op0, \p Op1
MachineInstrBuilder buildPtrMask(const DstOp &Res, const SrcOp &Op0,
const SrcOp &Op1) {
return buildInstr(TargetOpcode::G_PTRMASK, {Res}, {Op0, Op1});
}
/// Build and insert \p Res = G_PTRMASK \p Op0, \p G_CONSTANT (1 << NumBits) - 1
///
/// This clears the low bits of a pointer operand without destroying its
/// pointer properties. This has the effect of rounding the address *down* to
/// a specified alignment in bits.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p Res and \p Op0 must be generic virtual registers with pointer
/// type.
/// \pre \p NumBits must be an integer representing the number of low bits to
/// be cleared in \p Op0.
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildMaskLowPtrBits(const DstOp &Res, const SrcOp &Op0,
uint32_t NumBits);
/// Build and insert
/// a, b, ..., x = G_UNMERGE_VALUES \p Op0
/// \p Res = G_BUILD_VECTOR a, b, ..., x, undef, ..., undef
///
/// Pad \p Op0 with undef elements to match number of elements in \p Res.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p Res and \p Op0 must be generic virtual registers with vector type,
/// same vector element type and Op0 must have fewer elements then Res.
///
/// \return a MachineInstrBuilder for the newly created build vector instr.
MachineInstrBuilder buildPadVectorWithUndefElements(const DstOp &Res,
const SrcOp &Op0);
/// Build and insert
/// a, b, ..., x, y, z = G_UNMERGE_VALUES \p Op0
/// \p Res = G_BUILD_VECTOR a, b, ..., x
///
/// Delete trailing elements in \p Op0 to match number of elements in \p Res.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p Res and \p Op0 must be generic virtual registers with vector type,
/// same vector element type and Op0 must have more elements then Res.
///
/// \return a MachineInstrBuilder for the newly created build vector instr.
MachineInstrBuilder buildDeleteTrailingVectorElements(const DstOp &Res,
const SrcOp &Op0);
/// Build and insert \p Res, \p CarryOut = G_UADDO \p Op0, \p Op1
///
/// G_UADDO sets \p Res to \p Op0 + \p Op1 (truncated to the bit width) and
/// sets \p CarryOut to 1 if the result overflowed in unsigned arithmetic.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p Res, \p Op0 and \p Op1 must be generic virtual registers with the
/// same scalar type.
////\pre \p CarryOut must be generic virtual register with scalar type
///(typically s1)
///
/// \return The newly created instruction.
MachineInstrBuilder buildUAddo(const DstOp &Res, const DstOp &CarryOut,
const SrcOp &Op0, const SrcOp &Op1) {
return buildInstr(TargetOpcode::G_UADDO, {Res, CarryOut}, {Op0, Op1});
}
/// Build and insert \p Res, \p CarryOut = G_USUBO \p Op0, \p Op1
MachineInstrBuilder buildUSubo(const DstOp &Res, const DstOp &CarryOut,
const SrcOp &Op0, const SrcOp &Op1) {
return buildInstr(TargetOpcode::G_USUBO, {Res, CarryOut}, {Op0, Op1});
}
/// Build and insert \p Res, \p CarryOut = G_SADDO \p Op0, \p Op1
MachineInstrBuilder buildSAddo(const DstOp &Res, const DstOp &CarryOut,
const SrcOp &Op0, const SrcOp &Op1) {
return buildInstr(TargetOpcode::G_SADDO, {Res, CarryOut}, {Op0, Op1});
}
/// Build and insert \p Res, \p CarryOut = G_SUBO \p Op0, \p Op1
MachineInstrBuilder buildSSubo(const DstOp &Res, const DstOp &CarryOut,
const SrcOp &Op0, const SrcOp &Op1) {
return buildInstr(TargetOpcode::G_SSUBO, {Res, CarryOut}, {Op0, Op1});
}
/// Build and insert \p Res, \p CarryOut = G_UADDE \p Op0,
/// \p Op1, \p CarryIn
///
/// G_UADDE sets \p Res to \p Op0 + \p Op1 + \p CarryIn (truncated to the bit
/// width) and sets \p CarryOut to 1 if the result overflowed in unsigned
/// arithmetic.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p Res, \p Op0 and \p Op1 must be generic virtual registers
/// with the same scalar type.
/// \pre \p CarryOut and \p CarryIn must be generic virtual
/// registers with the same scalar type (typically s1)
///
/// \return The newly created instruction.
MachineInstrBuilder buildUAdde(const DstOp &Res, const DstOp &CarryOut,
const SrcOp &Op0, const SrcOp &Op1,
const SrcOp &CarryIn) {
return buildInstr(TargetOpcode::G_UADDE, {Res, CarryOut},
{Op0, Op1, CarryIn});
}
/// Build and insert \p Res, \p CarryOut = G_USUBE \p Op0, \p Op1, \p CarryInp
MachineInstrBuilder buildUSube(const DstOp &Res, const DstOp &CarryOut,
const SrcOp &Op0, const SrcOp &Op1,
const SrcOp &CarryIn) {
return buildInstr(TargetOpcode::G_USUBE, {Res, CarryOut},
{Op0, Op1, CarryIn});
}
/// Build and insert \p Res, \p CarryOut = G_SADDE \p Op0, \p Op1, \p CarryInp
MachineInstrBuilder buildSAdde(const DstOp &Res, const DstOp &CarryOut,
const SrcOp &Op0, const SrcOp &Op1,
const SrcOp &CarryIn) {
return buildInstr(TargetOpcode::G_SADDE, {Res, CarryOut},
{Op0, Op1, CarryIn});
}
/// Build and insert \p Res, \p CarryOut = G_SSUBE \p Op0, \p Op1, \p CarryInp
MachineInstrBuilder buildSSube(const DstOp &Res, const DstOp &CarryOut,
const SrcOp &Op0, const SrcOp &Op1,
const SrcOp &CarryIn) {
return buildInstr(TargetOpcode::G_SSUBE, {Res, CarryOut},
{Op0, Op1, CarryIn});
}
/// Build and insert \p Res = G_ANYEXT \p Op0
///
/// G_ANYEXT produces a register of the specified width, with bits 0 to
/// sizeof(\p Ty) * 8 set to \p Op. The remaining bits are unspecified
/// (i.e. this is neither zero nor sign-extension). For a vector register,
/// each element is extended individually.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p Res must be a generic virtual register with scalar or vector type.
/// \pre \p Op must be a generic virtual register with scalar or vector type.
/// \pre \p Op must be smaller than \p Res
///
/// \return The newly created instruction.
MachineInstrBuilder buildAnyExt(const DstOp &Res, const SrcOp &Op);
/// Build and insert \p Res = G_SEXT \p Op
///
/// G_SEXT produces a register of the specified width, with bits 0 to
/// sizeof(\p Ty) * 8 set to \p Op. The remaining bits are duplicated from the
/// high bit of \p Op (i.e. 2s-complement sign extended).
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p Res must be a generic virtual register with scalar or vector type.
/// \pre \p Op must be a generic virtual register with scalar or vector type.
/// \pre \p Op must be smaller than \p Res
///
/// \return The newly created instruction.
MachineInstrBuilder buildSExt(const DstOp &Res, const SrcOp &Op);
/// Build and insert \p Res = G_SEXT_INREG \p Op, ImmOp
MachineInstrBuilder buildSExtInReg(const DstOp &Res, const SrcOp &Op, int64_t ImmOp) {
return buildInstr(TargetOpcode::G_SEXT_INREG, {Res}, {Op, SrcOp(ImmOp)});
}
/// Build and insert \p Res = G_FPEXT \p Op
MachineInstrBuilder buildFPExt(const DstOp &Res, const SrcOp &Op,
std::optional<unsigned> Flags = std::nullopt) {
return buildInstr(TargetOpcode::G_FPEXT, {Res}, {Op}, Flags);
}
/// Build and insert a G_PTRTOINT instruction.
MachineInstrBuilder buildPtrToInt(const DstOp &Dst, const SrcOp &Src) {
return buildInstr(TargetOpcode::G_PTRTOINT, {Dst}, {Src});
}
/// Build and insert a G_INTTOPTR instruction.
MachineInstrBuilder buildIntToPtr(const DstOp &Dst, const SrcOp &Src) {
return buildInstr(TargetOpcode::G_INTTOPTR, {Dst}, {Src});
}
/// Build and insert \p Dst = G_BITCAST \p Src
MachineInstrBuilder buildBitcast(const DstOp &Dst, const SrcOp &Src) {
return buildInstr(TargetOpcode::G_BITCAST, {Dst}, {Src});
}
/// Build and insert \p Dst = G_ADDRSPACE_CAST \p Src
MachineInstrBuilder buildAddrSpaceCast(const DstOp &Dst, const SrcOp &Src) {
return buildInstr(TargetOpcode::G_ADDRSPACE_CAST, {Dst}, {Src});
}
/// \return The opcode of the extension the target wants to use for boolean
/// values.
unsigned getBoolExtOp(bool IsVec, bool IsFP) const;
// Build and insert \p Res = G_ANYEXT \p Op, \p Res = G_SEXT \p Op, or \p Res
// = G_ZEXT \p Op depending on how the target wants to extend boolean values.
MachineInstrBuilder buildBoolExt(const DstOp &Res, const SrcOp &Op,
bool IsFP);
// Build and insert \p Res = G_SEXT_INREG \p Op, 1 or \p Res = G_AND \p Op, 1,
// or COPY depending on how the target wants to extend boolean values, using
// the original register size.
MachineInstrBuilder buildBoolExtInReg(const DstOp &Res, const SrcOp &Op,
bool IsVector,
bool IsFP);
/// Build and insert \p Res = G_ZEXT \p Op
///
/// G_ZEXT produces a register of the specified width, with bits 0 to
/// sizeof(\p Ty) * 8 set to \p Op. The remaining bits are 0. For a vector
/// register, each element is extended individually.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p Res must be a generic virtual register with scalar or vector type.
/// \pre \p Op must be a generic virtual register with scalar or vector type.
/// \pre \p Op must be smaller than \p Res
///
/// \return The newly created instruction.
MachineInstrBuilder buildZExt(const DstOp &Res, const SrcOp &Op);
/// Build and insert \p Res = G_SEXT \p Op, \p Res = G_TRUNC \p Op, or
/// \p Res = COPY \p Op depending on the differing sizes of \p Res and \p Op.
/// ///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p Res must be a generic virtual register with scalar or vector type.
/// \pre \p Op must be a generic virtual register with scalar or vector type.
///
/// \return The newly created instruction.
MachineInstrBuilder buildSExtOrTrunc(const DstOp &Res, const SrcOp &Op);
/// Build and insert \p Res = G_ZEXT \p Op, \p Res = G_TRUNC \p Op, or
/// \p Res = COPY \p Op depending on the differing sizes of \p Res and \p Op.
/// ///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p Res must be a generic virtual register with scalar or vector type.
/// \pre \p Op must be a generic virtual register with scalar or vector type.
///
/// \return The newly created instruction.
MachineInstrBuilder buildZExtOrTrunc(const DstOp &Res, const SrcOp &Op);
// Build and insert \p Res = G_ANYEXT \p Op, \p Res = G_TRUNC \p Op, or
/// \p Res = COPY \p Op depending on the differing sizes of \p Res and \p Op.
/// ///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p Res must be a generic virtual register with scalar or vector type.
/// \pre \p Op must be a generic virtual register with scalar or vector type.
///
/// \return The newly created instruction.
MachineInstrBuilder buildAnyExtOrTrunc(const DstOp &Res, const SrcOp &Op);
/// Build and insert \p Res = \p ExtOpc, \p Res = G_TRUNC \p
/// Op, or \p Res = COPY \p Op depending on the differing sizes of \p Res and
/// \p Op.
/// ///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p Res must be a generic virtual register with scalar or vector type.
/// \pre \p Op must be a generic virtual register with scalar or vector type.
///
/// \return The newly created instruction.
MachineInstrBuilder buildExtOrTrunc(unsigned ExtOpc, const DstOp &Res,
const SrcOp &Op);
/// Build and inserts \p Res = \p G_AND \p Op, \p LowBitsSet(ImmOp)
/// Since there is no G_ZEXT_INREG like G_SEXT_INREG, the instruction is
/// emulated using G_AND.
MachineInstrBuilder buildZExtInReg(const DstOp &Res, const SrcOp &Op,
int64_t ImmOp);
/// Build and insert an appropriate cast between two registers of equal size.
MachineInstrBuilder buildCast(const DstOp &Dst, const SrcOp &Src);
/// Build and insert G_BR \p Dest
///
/// G_BR is an unconditional branch to \p Dest.
///
/// \pre setBasicBlock or setMI must have been called.
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildBr(MachineBasicBlock &Dest);
/// Build and insert G_BRCOND \p Tst, \p Dest
///
/// G_BRCOND is a conditional branch to \p Dest.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p Tst must be a generic virtual register with scalar
/// type. At the beginning of legalization, this will be a single
/// bit (s1). Targets with interesting flags registers may change
/// this. For a wider type, whether the branch is taken must only
/// depend on bit 0 (for now).
///
/// \return The newly created instruction.
MachineInstrBuilder buildBrCond(const SrcOp &Tst, MachineBasicBlock &Dest);
/// Build and insert G_BRINDIRECT \p Tgt
///
/// G_BRINDIRECT is an indirect branch to \p Tgt.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p Tgt must be a generic virtual register with pointer type.
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildBrIndirect(Register Tgt);
/// Build and insert G_BRJT \p TablePtr, \p JTI, \p IndexReg
///
/// G_BRJT is a jump table branch using a table base pointer \p TablePtr,
/// jump table index \p JTI and index \p IndexReg
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p TablePtr must be a generic virtual register with pointer type.
/// \pre \p JTI must be be a jump table index.
/// \pre \p IndexReg must be a generic virtual register with pointer type.
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildBrJT(Register TablePtr, unsigned JTI,
Register IndexReg);
/// Build and insert \p Res = G_CONSTANT \p Val
///
/// G_CONSTANT is an integer constant with the specified size and value. \p
/// Val will be extended or truncated to the size of \p Reg.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p Res must be a generic virtual register with scalar or pointer
/// type.
///
/// \return The newly created instruction.
virtual MachineInstrBuilder buildConstant(const DstOp &Res,
const ConstantInt &Val);
/// Build and insert \p Res = G_CONSTANT \p Val
///
/// G_CONSTANT is an integer constant with the specified size and value.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p Res must be a generic virtual register with scalar type.
///
/// \return The newly created instruction.
MachineInstrBuilder buildConstant(const DstOp &Res, int64_t Val);
MachineInstrBuilder buildConstant(const DstOp &Res, const APInt &Val);
/// Build and insert \p Res = G_FCONSTANT \p Val
///
/// G_FCONSTANT is a floating-point constant with the specified size and
/// value.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p Res must be a generic virtual register with scalar type.
///
/// \return The newly created instruction.
virtual MachineInstrBuilder buildFConstant(const DstOp &Res,
const ConstantFP &Val);
MachineInstrBuilder buildFConstant(const DstOp &Res, double Val);
MachineInstrBuilder buildFConstant(const DstOp &Res, const APFloat &Val);
/// Build and insert \p Res = COPY Op
///
/// Register-to-register COPY sets \p Res to \p Op.
///
/// \pre setBasicBlock or setMI must have been called.
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildCopy(const DstOp &Res, const SrcOp &Op);
/// Build and insert G_ASSERT_SEXT, G_ASSERT_ZEXT, or G_ASSERT_ALIGN
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildAssertInstr(unsigned Opc, const DstOp &Res,
const SrcOp &Op, unsigned Val) {
return buildInstr(Opc, Res, Op).addImm(Val);
}
/// Build and insert \p Res = G_ASSERT_ZEXT Op, Size
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildAssertZExt(const DstOp &Res, const SrcOp &Op,
unsigned Size) {
return buildAssertInstr(TargetOpcode::G_ASSERT_ZEXT, Res, Op, Size);
}
/// Build and insert \p Res = G_ASSERT_SEXT Op, Size
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildAssertSExt(const DstOp &Res, const SrcOp &Op,
unsigned Size) {
return buildAssertInstr(TargetOpcode::G_ASSERT_SEXT, Res, Op, Size);
}
/// Build and insert \p Res = G_ASSERT_ALIGN Op, AlignVal
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildAssertAlign(const DstOp &Res, const SrcOp &Op,
Align AlignVal) {
return buildAssertInstr(TargetOpcode::G_ASSERT_ALIGN, Res, Op,
AlignVal.value());
}
/// Build and insert `Res = G_LOAD Addr, MMO`.
///
/// Loads the value stored at \p Addr. Puts the result in \p Res.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p Res must be a generic virtual register.
/// \pre \p Addr must be a generic virtual register with pointer type.
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildLoad(const DstOp &Res, const SrcOp &Addr,
MachineMemOperand &MMO) {
return buildLoadInstr(TargetOpcode::G_LOAD, Res, Addr, MMO);
}
/// Build and insert a G_LOAD instruction, while constructing the
/// MachineMemOperand.
MachineInstrBuilder
buildLoad(const DstOp &Res, const SrcOp &Addr, MachinePointerInfo PtrInfo,
Align Alignment,
MachineMemOperand::Flags MMOFlags = MachineMemOperand::MONone,
const AAMDNodes &AAInfo = AAMDNodes());
/// Build and insert `Res = <opcode> Addr, MMO`.
///
/// Loads the value stored at \p Addr. Puts the result in \p Res.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p Res must be a generic virtual register.
/// \pre \p Addr must be a generic virtual register with pointer type.
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildLoadInstr(unsigned Opcode, const DstOp &Res,
const SrcOp &Addr, MachineMemOperand &MMO);
/// Helper to create a load from a constant offset given a base address. Load
/// the type of \p Dst from \p Offset from the given base address and memory
/// operand.
MachineInstrBuilder buildLoadFromOffset(const DstOp &Dst,
const SrcOp &BasePtr,
MachineMemOperand &BaseMMO,
int64_t Offset);
/// Build and insert `G_STORE Val, Addr, MMO`.
///
/// Stores the value \p Val to \p Addr.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p Val must be a generic virtual register.
/// \pre \p Addr must be a generic virtual register with pointer type.
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildStore(const SrcOp &Val, const SrcOp &Addr,
MachineMemOperand &MMO);
/// Build and insert a G_STORE instruction, while constructing the
/// MachineMemOperand.
MachineInstrBuilder
buildStore(const SrcOp &Val, const SrcOp &Addr, MachinePointerInfo PtrInfo,
Align Alignment,
MachineMemOperand::Flags MMOFlags = MachineMemOperand::MONone,
const AAMDNodes &AAInfo = AAMDNodes());
/// Build and insert `Res0, ... = G_EXTRACT Src, Idx0`.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p Res and \p Src must be generic virtual registers.
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildExtract(const DstOp &Res, const SrcOp &Src, uint64_t Index);
/// Build and insert \p Res = IMPLICIT_DEF.
MachineInstrBuilder buildUndef(const DstOp &Res);
/// Build and insert \p Res = G_MERGE_VALUES \p Op0, ...
///
/// G_MERGE_VALUES combines the input elements contiguously into a larger
/// register. It should only be used when the destination register is not a
/// vector.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre The entire register \p Res (and no more) must be covered by the input
/// registers.
/// \pre The type of all \p Ops registers must be identical.
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildMergeValues(const DstOp &Res,
ArrayRef<Register> Ops);
/// Build and insert \p Res = G_MERGE_VALUES \p Op0, ...
/// or \p Res = G_BUILD_VECTOR \p Op0, ...
/// or \p Res = G_CONCAT_VECTORS \p Op0, ...
///
/// G_MERGE_VALUES combines the input elements contiguously into a larger
/// register. It is used when the destination register is not a vector.
/// G_BUILD_VECTOR combines scalar inputs into a vector register.
/// G_CONCAT_VECTORS combines vector inputs into a vector register.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre The entire register \p Res (and no more) must be covered by the input
/// registers.
/// \pre The type of all \p Ops registers must be identical.
///
/// \return a MachineInstrBuilder for the newly created instruction. The
/// opcode of the new instruction will depend on the types of both
/// the destination and the sources.
MachineInstrBuilder buildMergeLikeInstr(const DstOp &Res,
ArrayRef<Register> Ops);
MachineInstrBuilder buildMergeLikeInstr(const DstOp &Res,
std::initializer_list<SrcOp> Ops);
/// Build and insert \p Res0, ... = G_UNMERGE_VALUES \p Op
///
/// G_UNMERGE_VALUES splits contiguous bits of the input into multiple
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre The entire register \p Res (and no more) must be covered by the input
/// registers.
/// \pre The type of all \p Res registers must be identical.
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildUnmerge(ArrayRef<LLT> Res, const SrcOp &Op);
MachineInstrBuilder buildUnmerge(ArrayRef<Register> Res, const SrcOp &Op);
/// Build and insert an unmerge of \p Res sized pieces to cover \p Op
MachineInstrBuilder buildUnmerge(LLT Res, const SrcOp &Op);
/// Build and insert \p Res = G_BUILD_VECTOR \p Op0, ...
///
/// G_BUILD_VECTOR creates a vector value from multiple scalar registers.
/// \pre setBasicBlock or setMI must have been called.
/// \pre The entire register \p Res (and no more) must be covered by the
/// input scalar registers.
/// \pre The type of all \p Ops registers must be identical.
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildBuildVector(const DstOp &Res,
ArrayRef<Register> Ops);
/// Build and insert \p Res = G_BUILD_VECTOR \p Op0, ... where each OpN is
/// built with G_CONSTANT.
MachineInstrBuilder buildBuildVectorConstant(const DstOp &Res,
ArrayRef<APInt> Ops);
/// Build and insert \p Res = G_BUILD_VECTOR with \p Src replicated to fill
/// the number of elements
MachineInstrBuilder buildSplatVector(const DstOp &Res,
const SrcOp &Src);
/// Build and insert \p Res = G_BUILD_VECTOR_TRUNC \p Op0, ...
///
/// G_BUILD_VECTOR_TRUNC creates a vector value from multiple scalar registers
/// which have types larger than the destination vector element type, and
/// truncates the values to fit.
///
/// If the operands given are already the same size as the vector elt type,
/// then this method will instead create a G_BUILD_VECTOR instruction.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre The type of all \p Ops registers must be identical.
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildBuildVectorTrunc(const DstOp &Res,
ArrayRef<Register> Ops);
/// Build and insert a vector splat of a scalar \p Src using a
/// G_INSERT_VECTOR_ELT and G_SHUFFLE_VECTOR idiom.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p Src must have the same type as the element type of \p Dst
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildShuffleSplat(const DstOp &Res, const SrcOp &Src);
/// Build and insert \p Res = G_SHUFFLE_VECTOR \p Src1, \p Src2, \p Mask
///
/// \pre setBasicBlock or setMI must have been called.
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildShuffleVector(const DstOp &Res, const SrcOp &Src1,
const SrcOp &Src2, ArrayRef<int> Mask);
/// Build and insert \p Res = G_CONCAT_VECTORS \p Op0, ...
///
/// G_CONCAT_VECTORS creates a vector from the concatenation of 2 or more
/// vectors.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre The entire register \p Res (and no more) must be covered by the input
/// registers.
/// \pre The type of all source operands must be identical.
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildConcatVectors(const DstOp &Res,
ArrayRef<Register> Ops);
MachineInstrBuilder buildInsert(const DstOp &Res, const SrcOp &Src,
const SrcOp &Op, unsigned Index);
/// Build and insert either a G_INTRINSIC (if \p HasSideEffects is false) or
/// G_INTRINSIC_W_SIDE_EFFECTS instruction. Its first operand will be the
/// result register definition unless \p Reg is NoReg (== 0). The second
/// operand will be the intrinsic's ID.
///
/// Callers are expected to add the required definitions and uses afterwards.
///
/// \pre setBasicBlock or setMI must have been called.
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildIntrinsic(Intrinsic::ID ID, ArrayRef<Register> Res,
bool HasSideEffects);
MachineInstrBuilder buildIntrinsic(Intrinsic::ID ID, ArrayRef<DstOp> Res,
bool HasSideEffects);
/// Build and insert \p Res = G_FPTRUNC \p Op
///
/// G_FPTRUNC converts a floating-point value into one with a smaller type.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p Res must be a generic virtual register with scalar or vector type.
/// \pre \p Op must be a generic virtual register with scalar or vector type.
/// \pre \p Res must be smaller than \p Op
///
/// \return The newly created instruction.
MachineInstrBuilder
buildFPTrunc(const DstOp &Res, const SrcOp &Op,
std::optional<unsigned> Flags = std::nullopt);
/// Build and insert \p Res = G_TRUNC \p Op
///
/// G_TRUNC extracts the low bits of a type. For a vector type each element is
/// truncated independently before being packed into the destination.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p Res must be a generic virtual register with scalar or vector type.
/// \pre \p Op must be a generic virtual register with scalar or vector type.
/// \pre \p Res must be smaller than \p Op
///
/// \return The newly created instruction.
MachineInstrBuilder buildTrunc(const DstOp &Res, const SrcOp &Op);
/// Build and insert a \p Res = G_ICMP \p Pred, \p Op0, \p Op1
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p Res must be a generic virtual register with scalar or
/// vector type. Typically this starts as s1 or <N x s1>.
/// \pre \p Op0 and Op1 must be generic virtual registers with the
/// same number of elements as \p Res. If \p Res is a scalar,
/// \p Op0 must be either a scalar or pointer.
/// \pre \p Pred must be an integer predicate.
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildICmp(CmpInst::Predicate Pred, const DstOp &Res,
const SrcOp &Op0, const SrcOp &Op1);
/// Build and insert a \p Res = G_FCMP \p Pred\p Op0, \p Op1
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p Res must be a generic virtual register with scalar or
/// vector type. Typically this starts as s1 or <N x s1>.
/// \pre \p Op0 and Op1 must be generic virtual registers with the
/// same number of elements as \p Res (or scalar, if \p Res is
/// scalar).
/// \pre \p Pred must be a floating-point predicate.
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildFCmp(CmpInst::Predicate Pred, const DstOp &Res,
const SrcOp &Op0, const SrcOp &Op1,
std::optional<unsigned> Flags = std::nullopt);
/// Build and insert a \p Res = G_SELECT \p Tst, \p Op0, \p Op1
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p Res, \p Op0 and \p Op1 must be generic virtual registers
/// with the same type.
/// \pre \p Tst must be a generic virtual register with scalar, pointer or
/// vector type. If vector then it must have the same number of
/// elements as the other parameters.
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildSelect(const DstOp &Res, const SrcOp &Tst,
const SrcOp &Op0, const SrcOp &Op1,
std::optional<unsigned> Flags = std::nullopt);
/// Build and insert \p Res = G_INSERT_VECTOR_ELT \p Val,
/// \p Elt, \p Idx
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p Res and \p Val must be a generic virtual register
// with the same vector type.
/// \pre \p Elt and \p Idx must be a generic virtual register
/// with scalar type.
///
/// \return The newly created instruction.
MachineInstrBuilder buildInsertVectorElement(const DstOp &Res,
const SrcOp &Val,
const SrcOp &Elt,
const SrcOp &Idx);
/// Build and insert \p Res = G_EXTRACT_VECTOR_ELT \p Val, \p Idx
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p Res must be a generic virtual register with scalar type.
/// \pre \p Val must be a generic virtual register with vector type.
///
/// \return The newly created instruction.
MachineInstrBuilder buildExtractVectorElementConstant(const DstOp &Res,
const SrcOp &Val,
const int Idx) {
return buildExtractVectorElement(Res, Val,
buildConstant(LLT::scalar(64), Idx));
}
/// Build and insert \p Res = G_EXTRACT_VECTOR_ELT \p Val, \p Idx
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p Res must be a generic virtual register with scalar type.
/// \pre \p Val must be a generic virtual register with vector type.
/// \pre \p Idx must be a generic virtual register with scalar type.
///
/// \return The newly created instruction.
MachineInstrBuilder buildExtractVectorElement(const DstOp &Res,
const SrcOp &Val,
const SrcOp &Idx);
/// Build and insert `OldValRes<def>, SuccessRes<def> =
/// G_ATOMIC_CMPXCHG_WITH_SUCCESS Addr, CmpVal, NewVal, MMO`.
///
/// Atomically replace the value at \p Addr with \p NewVal if it is currently
/// \p CmpVal otherwise leaves it unchanged. Puts the original value from \p
/// Addr in \p Res, along with an s1 indicating whether it was replaced.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p OldValRes must be a generic virtual register of scalar type.
/// \pre \p SuccessRes must be a generic virtual register of scalar type. It
/// will be assigned 0 on failure and 1 on success.
/// \pre \p Addr must be a generic virtual register with pointer type.
/// \pre \p OldValRes, \p CmpVal, and \p NewVal must be generic virtual
/// registers of the same type.
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder
buildAtomicCmpXchgWithSuccess(Register OldValRes, Register SuccessRes,
Register Addr, Register CmpVal, Register NewVal,
MachineMemOperand &MMO);
/// Build and insert `OldValRes<def> = G_ATOMIC_CMPXCHG Addr, CmpVal, NewVal,
/// MMO`.
///
/// Atomically replace the value at \p Addr with \p NewVal if it is currently
/// \p CmpVal otherwise leaves it unchanged. Puts the original value from \p
/// Addr in \p Res.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p OldValRes must be a generic virtual register of scalar type.
/// \pre \p Addr must be a generic virtual register with pointer type.
/// \pre \p OldValRes, \p CmpVal, and \p NewVal must be generic virtual
/// registers of the same type.
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildAtomicCmpXchg(Register OldValRes, Register Addr,
Register CmpVal, Register NewVal,
MachineMemOperand &MMO);
/// Build and insert `OldValRes<def> = G_ATOMICRMW_<Opcode> Addr, Val, MMO`.
///
/// Atomically read-modify-update the value at \p Addr with \p Val. Puts the
/// original value from \p Addr in \p OldValRes. The modification is
/// determined by the opcode.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p OldValRes must be a generic virtual register.
/// \pre \p Addr must be a generic virtual register with pointer type.
/// \pre \p OldValRes, and \p Val must be generic virtual registers of the
/// same type.
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildAtomicRMW(unsigned Opcode, const DstOp &OldValRes,
const SrcOp &Addr, const SrcOp &Val,
MachineMemOperand &MMO);
/// Build and insert `OldValRes<def> = G_ATOMICRMW_XCHG Addr, Val, MMO`.
///
/// Atomically replace the value at \p Addr with \p Val. Puts the original
/// value from \p Addr in \p OldValRes.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p OldValRes must be a generic virtual register.
/// \pre \p Addr must be a generic virtual register with pointer type.
/// \pre \p OldValRes, and \p Val must be generic virtual registers of the
/// same type.
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildAtomicRMWXchg(Register OldValRes, Register Addr,
Register Val, MachineMemOperand &MMO);
/// Build and insert `OldValRes<def> = G_ATOMICRMW_ADD Addr, Val, MMO`.
///
/// Atomically replace the value at \p Addr with the addition of \p Val and
/// the original value. Puts the original value from \p Addr in \p OldValRes.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p OldValRes must be a generic virtual register.
/// \pre \p Addr must be a generic virtual register with pointer type.
/// \pre \p OldValRes, and \p Val must be generic virtual registers of the
/// same type.
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildAtomicRMWAdd(Register OldValRes, Register Addr,
Register Val, MachineMemOperand &MMO);
/// Build and insert `OldValRes<def> = G_ATOMICRMW_SUB Addr, Val, MMO`.
///
/// Atomically replace the value at \p Addr with the subtraction of \p Val and
/// the original value. Puts the original value from \p Addr in \p OldValRes.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p OldValRes must be a generic virtual register.
/// \pre \p Addr must be a generic virtual register with pointer type.
/// \pre \p OldValRes, and \p Val must be generic virtual registers of the
/// same type.
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildAtomicRMWSub(Register OldValRes, Register Addr,
Register Val, MachineMemOperand &MMO);
/// Build and insert `OldValRes<def> = G_ATOMICRMW_AND Addr, Val, MMO`.
///
/// Atomically replace the value at \p Addr with the bitwise and of \p Val and
/// the original value. Puts the original value from \p Addr in \p OldValRes.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p OldValRes must be a generic virtual register.
/// \pre \p Addr must be a generic virtual register with pointer type.
/// \pre \p OldValRes, and \p Val must be generic virtual registers of the
/// same type.
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildAtomicRMWAnd(Register OldValRes, Register Addr,
Register Val, MachineMemOperand &MMO);
/// Build and insert `OldValRes<def> = G_ATOMICRMW_NAND Addr, Val, MMO`.
///
/// Atomically replace the value at \p Addr with the bitwise nand of \p Val
/// and the original value. Puts the original value from \p Addr in \p
/// OldValRes.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p OldValRes must be a generic virtual register.
/// \pre \p Addr must be a generic virtual register with pointer type.
/// \pre \p OldValRes, and \p Val must be generic virtual registers of the
/// same type.
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildAtomicRMWNand(Register OldValRes, Register Addr,
Register Val, MachineMemOperand &MMO);
/// Build and insert `OldValRes<def> = G_ATOMICRMW_OR Addr, Val, MMO`.
///
/// Atomically replace the value at \p Addr with the bitwise or of \p Val and
/// the original value. Puts the original value from \p Addr in \p OldValRes.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p OldValRes must be a generic virtual register.
/// \pre \p Addr must be a generic virtual register with pointer type.
/// \pre \p OldValRes, and \p Val must be generic virtual registers of the
/// same type.
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildAtomicRMWOr(Register OldValRes, Register Addr,
Register Val, MachineMemOperand &MMO);
/// Build and insert `OldValRes<def> = G_ATOMICRMW_XOR Addr, Val, MMO`.
///
/// Atomically replace the value at \p Addr with the bitwise xor of \p Val and
/// the original value. Puts the original value from \p Addr in \p OldValRes.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p OldValRes must be a generic virtual register.
/// \pre \p Addr must be a generic virtual register with pointer type.
/// \pre \p OldValRes, and \p Val must be generic virtual registers of the
/// same type.
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildAtomicRMWXor(Register OldValRes, Register Addr,
Register Val, MachineMemOperand &MMO);
/// Build and insert `OldValRes<def> = G_ATOMICRMW_MAX Addr, Val, MMO`.
///
/// Atomically replace the value at \p Addr with the signed maximum of \p
/// Val and the original value. Puts the original value from \p Addr in \p
/// OldValRes.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p OldValRes must be a generic virtual register.
/// \pre \p Addr must be a generic virtual register with pointer type.
/// \pre \p OldValRes, and \p Val must be generic virtual registers of the
/// same type.
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildAtomicRMWMax(Register OldValRes, Register Addr,
Register Val, MachineMemOperand &MMO);
/// Build and insert `OldValRes<def> = G_ATOMICRMW_MIN Addr, Val, MMO`.
///
/// Atomically replace the value at \p Addr with the signed minimum of \p
/// Val and the original value. Puts the original value from \p Addr in \p
/// OldValRes.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p OldValRes must be a generic virtual register.
/// \pre \p Addr must be a generic virtual register with pointer type.
/// \pre \p OldValRes, and \p Val must be generic virtual registers of the
/// same type.
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildAtomicRMWMin(Register OldValRes, Register Addr,
Register Val, MachineMemOperand &MMO);
/// Build and insert `OldValRes<def> = G_ATOMICRMW_UMAX Addr, Val, MMO`.
///
/// Atomically replace the value at \p Addr with the unsigned maximum of \p
/// Val and the original value. Puts the original value from \p Addr in \p
/// OldValRes.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p OldValRes must be a generic virtual register.
/// \pre \p Addr must be a generic virtual register with pointer type.
/// \pre \p OldValRes, and \p Val must be generic virtual registers of the
/// same type.
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildAtomicRMWUmax(Register OldValRes, Register Addr,
Register Val, MachineMemOperand &MMO);
/// Build and insert `OldValRes<def> = G_ATOMICRMW_UMIN Addr, Val, MMO`.
///
/// Atomically replace the value at \p Addr with the unsigned minimum of \p
/// Val and the original value. Puts the original value from \p Addr in \p
/// OldValRes.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p OldValRes must be a generic virtual register.
/// \pre \p Addr must be a generic virtual register with pointer type.
/// \pre \p OldValRes, and \p Val must be generic virtual registers of the
/// same type.
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildAtomicRMWUmin(Register OldValRes, Register Addr,
Register Val, MachineMemOperand &MMO);
/// Build and insert `OldValRes<def> = G_ATOMICRMW_FADD Addr, Val, MMO`.
MachineInstrBuilder buildAtomicRMWFAdd(
const DstOp &OldValRes, const SrcOp &Addr, const SrcOp &Val,
MachineMemOperand &MMO);
/// Build and insert `OldValRes<def> = G_ATOMICRMW_FSUB Addr, Val, MMO`.
MachineInstrBuilder buildAtomicRMWFSub(
const DstOp &OldValRes, const SrcOp &Addr, const SrcOp &Val,
MachineMemOperand &MMO);
/// Build and insert `OldValRes<def> = G_ATOMICRMW_FMAX Addr, Val, MMO`.
///
/// Atomically replace the value at \p Addr with the floating point maximum of
/// \p Val and the original value. Puts the original value from \p Addr in \p
/// OldValRes.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p OldValRes must be a generic virtual register.
/// \pre \p Addr must be a generic virtual register with pointer type.
/// \pre \p OldValRes, and \p Val must be generic virtual registers of the
/// same type.
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildAtomicRMWFMax(
const DstOp &OldValRes, const SrcOp &Addr, const SrcOp &Val,
MachineMemOperand &MMO);
/// Build and insert `OldValRes<def> = G_ATOMICRMW_FMIN Addr, Val, MMO`.
///
/// Atomically replace the value at \p Addr with the floating point minimum of
/// \p Val and the original value. Puts the original value from \p Addr in \p
/// OldValRes.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p OldValRes must be a generic virtual register.
/// \pre \p Addr must be a generic virtual register with pointer type.
/// \pre \p OldValRes, and \p Val must be generic virtual registers of the
/// same type.
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildAtomicRMWFMin(
const DstOp &OldValRes, const SrcOp &Addr, const SrcOp &Val,
MachineMemOperand &MMO);
/// Build and insert `G_FENCE Ordering, Scope`.
MachineInstrBuilder buildFence(unsigned Ordering, unsigned Scope);
/// Build and insert \p Dst = G_FREEZE \p Src
MachineInstrBuilder buildFreeze(const DstOp &Dst, const SrcOp &Src) {
return buildInstr(TargetOpcode::G_FREEZE, {Dst}, {Src});
}
/// Build and insert \p Res = G_BLOCK_ADDR \p BA
///
/// G_BLOCK_ADDR computes the address of a basic block.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p Res must be a generic virtual register of a pointer type.
///
/// \return The newly created instruction.
MachineInstrBuilder buildBlockAddress(Register Res, const BlockAddress *BA);
/// Build and insert \p Res = G_ADD \p Op0, \p Op1
///
/// G_ADD sets \p Res to the sum of integer parameters \p Op0 and \p Op1,
/// truncated to their width.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p Res, \p Op0 and \p Op1 must be generic virtual registers
/// with the same (scalar or vector) type).
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildAdd(const DstOp &Dst, const SrcOp &Src0,
const SrcOp &Src1,
std::optional<unsigned> Flags = std::nullopt) {
return buildInstr(TargetOpcode::G_ADD, {Dst}, {Src0, Src1}, Flags);
}
/// Build and insert \p Res = G_SUB \p Op0, \p Op1
///
/// G_SUB sets \p Res to the difference of integer parameters \p Op0 and
/// \p Op1, truncated to their width.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p Res, \p Op0 and \p Op1 must be generic virtual registers
/// with the same (scalar or vector) type).
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildSub(const DstOp &Dst, const SrcOp &Src0,
const SrcOp &Src1,
std::optional<unsigned> Flags = std::nullopt) {
return buildInstr(TargetOpcode::G_SUB, {Dst}, {Src0, Src1}, Flags);
}
/// Build and insert \p Res = G_MUL \p Op0, \p Op1
///
/// G_MUL sets \p Res to the product of integer parameters \p Op0 and \p Op1,
/// truncated to their width.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p Res, \p Op0 and \p Op1 must be generic virtual registers
/// with the same (scalar or vector) type).
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildMul(const DstOp &Dst, const SrcOp &Src0,
const SrcOp &Src1,
std::optional<unsigned> Flags = std::nullopt) {
return buildInstr(TargetOpcode::G_MUL, {Dst}, {Src0, Src1}, Flags);
}
MachineInstrBuilder buildUMulH(const DstOp &Dst, const SrcOp &Src0,
const SrcOp &Src1,
std::optional<unsigned> Flags = std::nullopt) {
return buildInstr(TargetOpcode::G_UMULH, {Dst}, {Src0, Src1}, Flags);
}
MachineInstrBuilder buildSMulH(const DstOp &Dst, const SrcOp &Src0,
const SrcOp &Src1,
std::optional<unsigned> Flags = std::nullopt) {
return buildInstr(TargetOpcode::G_SMULH, {Dst}, {Src0, Src1}, Flags);
}
/// Build and insert \p Res = G_UREM \p Op0, \p Op1
MachineInstrBuilder buildURem(const DstOp &Dst, const SrcOp &Src0,
const SrcOp &Src1,
std::optional<unsigned> Flags = std::nullopt) {
return buildInstr(TargetOpcode::G_UREM, {Dst}, {Src0, Src1}, Flags);
}
MachineInstrBuilder buildFMul(const DstOp &Dst, const SrcOp &Src0,
const SrcOp &Src1,
std::optional<unsigned> Flags = std::nullopt) {
return buildInstr(TargetOpcode::G_FMUL, {Dst}, {Src0, Src1}, Flags);
}
MachineInstrBuilder
buildFMinNum(const DstOp &Dst, const SrcOp &Src0, const SrcOp &Src1,
std::optional<unsigned> Flags = std::nullopt) {
return buildInstr(TargetOpcode::G_FMINNUM, {Dst}, {Src0, Src1}, Flags);
}
MachineInstrBuilder
buildFMaxNum(const DstOp &Dst, const SrcOp &Src0, const SrcOp &Src1,
std::optional<unsigned> Flags = std::nullopt) {
return buildInstr(TargetOpcode::G_FMAXNUM, {Dst}, {Src0, Src1}, Flags);
}
MachineInstrBuilder
buildFMinNumIEEE(const DstOp &Dst, const SrcOp &Src0, const SrcOp &Src1,
std::optional<unsigned> Flags = std::nullopt) {
return buildInstr(TargetOpcode::G_FMINNUM_IEEE, {Dst}, {Src0, Src1}, Flags);
}
MachineInstrBuilder
buildFMaxNumIEEE(const DstOp &Dst, const SrcOp &Src0, const SrcOp &Src1,
std::optional<unsigned> Flags = std::nullopt) {
return buildInstr(TargetOpcode::G_FMAXNUM_IEEE, {Dst}, {Src0, Src1}, Flags);
}
MachineInstrBuilder buildShl(const DstOp &Dst, const SrcOp &Src0,
const SrcOp &Src1,
std::optional<unsigned> Flags = std::nullopt) {
return buildInstr(TargetOpcode::G_SHL, {Dst}, {Src0, Src1}, Flags);
}
MachineInstrBuilder buildLShr(const DstOp &Dst, const SrcOp &Src0,
const SrcOp &Src1,
std::optional<unsigned> Flags = std::nullopt) {
return buildInstr(TargetOpcode::G_LSHR, {Dst}, {Src0, Src1}, Flags);
}
MachineInstrBuilder buildAShr(const DstOp &Dst, const SrcOp &Src0,
const SrcOp &Src1,
std::optional<unsigned> Flags = std::nullopt) {
return buildInstr(TargetOpcode::G_ASHR, {Dst}, {Src0, Src1}, Flags);
}
/// Build and insert \p Res = G_AND \p Op0, \p Op1
///
/// G_AND sets \p Res to the bitwise and of integer parameters \p Op0 and \p
/// Op1.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p Res, \p Op0 and \p Op1 must be generic virtual registers
/// with the same (scalar or vector) type).
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildAnd(const DstOp &Dst, const SrcOp &Src0,
const SrcOp &Src1) {
return buildInstr(TargetOpcode::G_AND, {Dst}, {Src0, Src1});
}
/// Build and insert \p Res = G_OR \p Op0, \p Op1
///
/// G_OR sets \p Res to the bitwise or of integer parameters \p Op0 and \p
/// Op1.
///
/// \pre setBasicBlock or setMI must have been called.
/// \pre \p Res, \p Op0 and \p Op1 must be generic virtual registers
/// with the same (scalar or vector) type).
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildOr(const DstOp &Dst, const SrcOp &Src0,
const SrcOp &Src1,
std::optional<unsigned> Flags = std::nullopt) {
return buildInstr(TargetOpcode::G_OR, {Dst}, {Src0, Src1}, Flags);
}
/// Build and insert \p Res = G_XOR \p Op0, \p Op1
MachineInstrBuilder buildXor(const DstOp &Dst, const SrcOp &Src0,
const SrcOp &Src1) {
return buildInstr(TargetOpcode::G_XOR, {Dst}, {Src0, Src1});
}
/// Build and insert a bitwise not,
/// \p NegOne = G_CONSTANT -1
/// \p Res = G_OR \p Op0, NegOne
MachineInstrBuilder buildNot(const DstOp &Dst, const SrcOp &Src0) {
auto NegOne = buildConstant(Dst.getLLTTy(*getMRI()), -1);
return buildInstr(TargetOpcode::G_XOR, {Dst}, {Src0, NegOne});
}
/// Build and insert integer negation
/// \p Zero = G_CONSTANT 0
/// \p Res = G_SUB Zero, \p Op0
MachineInstrBuilder buildNeg(const DstOp &Dst, const SrcOp &Src0) {
auto Zero = buildConstant(Dst.getLLTTy(*getMRI()), 0);
return buildInstr(TargetOpcode::G_SUB, {Dst}, {Zero, Src0});
}
/// Build and insert \p Res = G_CTPOP \p Op0, \p Src0
MachineInstrBuilder buildCTPOP(const DstOp &Dst, const SrcOp &Src0) {
return buildInstr(TargetOpcode::G_CTPOP, {Dst}, {Src0});
}
/// Build and insert \p Res = G_CTLZ \p Op0, \p Src0
MachineInstrBuilder buildCTLZ(const DstOp &Dst, const SrcOp &Src0) {
return buildInstr(TargetOpcode::G_CTLZ, {Dst}, {Src0});
}
/// Build and insert \p Res = G_CTLZ_ZERO_UNDEF \p Op0, \p Src0
MachineInstrBuilder buildCTLZ_ZERO_UNDEF(const DstOp &Dst, const SrcOp &Src0) {
return buildInstr(TargetOpcode::G_CTLZ_ZERO_UNDEF, {Dst}, {Src0});
}
/// Build and insert \p Res = G_CTTZ \p Op0, \p Src0
MachineInstrBuilder buildCTTZ(const DstOp &Dst, const SrcOp &Src0) {
return buildInstr(TargetOpcode::G_CTTZ, {Dst}, {Src0});
}
/// Build and insert \p Res = G_CTTZ_ZERO_UNDEF \p Op0, \p Src0
MachineInstrBuilder buildCTTZ_ZERO_UNDEF(const DstOp &Dst, const SrcOp &Src0) {
return buildInstr(TargetOpcode::G_CTTZ_ZERO_UNDEF, {Dst}, {Src0});
}
/// Build and insert \p Dst = G_BSWAP \p Src0
MachineInstrBuilder buildBSwap(const DstOp &Dst, const SrcOp &Src0) {
return buildInstr(TargetOpcode::G_BSWAP, {Dst}, {Src0});
}
/// Build and insert \p Res = G_FADD \p Op0, \p Op1
MachineInstrBuilder buildFAdd(const DstOp &Dst, const SrcOp &Src0,
const SrcOp &Src1,
std::optional<unsigned> Flags = std::nullopt) {
return buildInstr(TargetOpcode::G_FADD, {Dst}, {Src0, Src1}, Flags);
}
/// Build and insert \p Res = G_STRICT_FADD \p Op0, \p Op1
MachineInstrBuilder
buildStrictFAdd(const DstOp &Dst, const SrcOp &Src0, const SrcOp &Src1,
std::optional<unsigned> Flags = std::nullopt) {
return buildInstr(TargetOpcode::G_STRICT_FADD, {Dst}, {Src0, Src1}, Flags);
}
/// Build and insert \p Res = G_FSUB \p Op0, \p Op1
MachineInstrBuilder buildFSub(const DstOp &Dst, const SrcOp &Src0,
const SrcOp &Src1,
std::optional<unsigned> Flags = std::nullopt) {
return buildInstr(TargetOpcode::G_FSUB, {Dst}, {Src0, Src1}, Flags);
}
/// Build and insert \p Res = G_FDIV \p Op0, \p Op1
MachineInstrBuilder buildFDiv(const DstOp &Dst, const SrcOp &Src0,
const SrcOp &Src1,
std::optional<unsigned> Flags = std::nullopt) {
return buildInstr(TargetOpcode::G_FDIV, {Dst}, {Src0, Src1}, Flags);
}
/// Build and insert \p Res = G_FMA \p Op0, \p Op1, \p Op2
MachineInstrBuilder buildFMA(const DstOp &Dst, const SrcOp &Src0,
const SrcOp &Src1, const SrcOp &Src2,
std::optional<unsigned> Flags = std::nullopt) {
return buildInstr(TargetOpcode::G_FMA, {Dst}, {Src0, Src1, Src2}, Flags);
}
/// Build and insert \p Res = G_FMAD \p Op0, \p Op1, \p Op2
MachineInstrBuilder buildFMAD(const DstOp &Dst, const SrcOp &Src0,
const SrcOp &Src1, const SrcOp &Src2,
std::optional<unsigned> Flags = std::nullopt) {
return buildInstr(TargetOpcode::G_FMAD, {Dst}, {Src0, Src1, Src2}, Flags);
}
/// Build and insert \p Res = G_FNEG \p Op0
MachineInstrBuilder buildFNeg(const DstOp &Dst, const SrcOp &Src0,
std::optional<unsigned> Flags = std::nullopt) {
return buildInstr(TargetOpcode::G_FNEG, {Dst}, {Src0}, Flags);
}
/// Build and insert \p Res = G_FABS \p Op0
MachineInstrBuilder buildFAbs(const DstOp &Dst, const SrcOp &Src0,
std::optional<unsigned> Flags = std::nullopt) {
return buildInstr(TargetOpcode::G_FABS, {Dst}, {Src0}, Flags);
}
/// Build and insert \p Dst = G_FCANONICALIZE \p Src0
MachineInstrBuilder
buildFCanonicalize(const DstOp &Dst, const SrcOp &Src0,
std::optional<unsigned> Flags = std::nullopt) {
return buildInstr(TargetOpcode::G_FCANONICALIZE, {Dst}, {Src0}, Flags);
}
/// Build and insert \p Dst = G_INTRINSIC_TRUNC \p Src0
MachineInstrBuilder
buildIntrinsicTrunc(const DstOp &Dst, const SrcOp &Src0,
std::optional<unsigned> Flags = std::nullopt) {
return buildInstr(TargetOpcode::G_INTRINSIC_TRUNC, {Dst}, {Src0}, Flags);
}
/// Build and insert \p Res = GFFLOOR \p Op0, \p Op1
MachineInstrBuilder
buildFFloor(const DstOp &Dst, const SrcOp &Src0,
std::optional<unsigned> Flags = std::nullopt) {
return buildInstr(TargetOpcode::G_FFLOOR, {Dst}, {Src0}, Flags);
}
/// Build and insert \p Dst = G_FLOG \p Src
MachineInstrBuilder buildFLog(const DstOp &Dst, const SrcOp &Src,
std::optional<unsigned> Flags = std::nullopt) {
return buildInstr(TargetOpcode::G_FLOG, {Dst}, {Src}, Flags);
}
/// Build and insert \p Dst = G_FLOG2 \p Src
MachineInstrBuilder buildFLog2(const DstOp &Dst, const SrcOp &Src,
std::optional<unsigned> Flags = std::nullopt) {
return buildInstr(TargetOpcode::G_FLOG2, {Dst}, {Src}, Flags);
}
/// Build and insert \p Dst = G_FEXP2 \p Src
MachineInstrBuilder buildFExp2(const DstOp &Dst, const SrcOp &Src,
std::optional<unsigned> Flags = std::nullopt) {
return buildInstr(TargetOpcode::G_FEXP2, {Dst}, {Src}, Flags);
}
/// Build and insert \p Dst = G_FPOW \p Src0, \p Src1
MachineInstrBuilder buildFPow(const DstOp &Dst, const SrcOp &Src0,
const SrcOp &Src1,
std::optional<unsigned> Flags = std::nullopt) {
return buildInstr(TargetOpcode::G_FPOW, {Dst}, {Src0, Src1}, Flags);
}
/// Build and insert \p Res = G_FCOPYSIGN \p Op0, \p Op1
MachineInstrBuilder buildFCopysign(const DstOp &Dst, const SrcOp &Src0,
const SrcOp &Src1) {
return buildInstr(TargetOpcode::G_FCOPYSIGN, {Dst}, {Src0, Src1});
}
/// Build and insert \p Res = G_UITOFP \p Src0
MachineInstrBuilder buildUITOFP(const DstOp &Dst, const SrcOp &Src0) {
return buildInstr(TargetOpcode::G_UITOFP, {Dst}, {Src0});
}
/// Build and insert \p Res = G_SITOFP \p Src0
MachineInstrBuilder buildSITOFP(const DstOp &Dst, const SrcOp &Src0) {
return buildInstr(TargetOpcode::G_SITOFP, {Dst}, {Src0});
}
/// Build and insert \p Res = G_FPTOUI \p Src0
MachineInstrBuilder buildFPTOUI(const DstOp &Dst, const SrcOp &Src0) {
return buildInstr(TargetOpcode::G_FPTOUI, {Dst}, {Src0});
}
/// Build and insert \p Res = G_FPTOSI \p Src0
MachineInstrBuilder buildFPTOSI(const DstOp &Dst, const SrcOp &Src0) {
return buildInstr(TargetOpcode::G_FPTOSI, {Dst}, {Src0});
}
/// Build and insert \p Res = G_SMIN \p Op0, \p Op1
MachineInstrBuilder buildSMin(const DstOp &Dst, const SrcOp &Src0,
const SrcOp &Src1) {
return buildInstr(TargetOpcode::G_SMIN, {Dst}, {Src0, Src1});
}
/// Build and insert \p Res = G_SMAX \p Op0, \p Op1
MachineInstrBuilder buildSMax(const DstOp &Dst, const SrcOp &Src0,
const SrcOp &Src1) {
return buildInstr(TargetOpcode::G_SMAX, {Dst}, {Src0, Src1});
}
/// Build and insert \p Res = G_UMIN \p Op0, \p Op1
MachineInstrBuilder buildUMin(const DstOp &Dst, const SrcOp &Src0,
const SrcOp &Src1) {
return buildInstr(TargetOpcode::G_UMIN, {Dst}, {Src0, Src1});
}
/// Build and insert \p Res = G_UMAX \p Op0, \p Op1
MachineInstrBuilder buildUMax(const DstOp &Dst, const SrcOp &Src0,
const SrcOp &Src1) {
return buildInstr(TargetOpcode::G_UMAX, {Dst}, {Src0, Src1});
}
/// Build and insert \p Dst = G_ABS \p Src
MachineInstrBuilder buildAbs(const DstOp &Dst, const SrcOp &Src) {
return buildInstr(TargetOpcode::G_ABS, {Dst}, {Src});
}
/// Build and insert \p Res = G_JUMP_TABLE \p JTI
///
/// G_JUMP_TABLE sets \p Res to the address of the jump table specified by
/// the jump table index \p JTI.
///
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildJumpTable(const LLT PtrTy, unsigned JTI);
/// Build and insert \p Res = G_VECREDUCE_SEQ_FADD \p ScalarIn, \p VecIn
///
/// \p ScalarIn is the scalar accumulator input to start the sequential
/// reduction operation of \p VecIn.
MachineInstrBuilder buildVecReduceSeqFAdd(const DstOp &Dst,
const SrcOp &ScalarIn,
const SrcOp &VecIn) {
return buildInstr(TargetOpcode::G_VECREDUCE_SEQ_FADD, {Dst},
{ScalarIn, {VecIn}});
}
/// Build and insert \p Res = G_VECREDUCE_SEQ_FMUL \p ScalarIn, \p VecIn
///
/// \p ScalarIn is the scalar accumulator input to start the sequential
/// reduction operation of \p VecIn.
MachineInstrBuilder buildVecReduceSeqFMul(const DstOp &Dst,
const SrcOp &ScalarIn,
const SrcOp &VecIn) {
return buildInstr(TargetOpcode::G_VECREDUCE_SEQ_FMUL, {Dst},
{ScalarIn, {VecIn}});
}
/// Build and insert \p Res = G_VECREDUCE_FADD \p Src
///
/// \p ScalarIn is the scalar accumulator input to the reduction operation of
/// \p VecIn.
MachineInstrBuilder buildVecReduceFAdd(const DstOp &Dst,
const SrcOp &ScalarIn,
const SrcOp &VecIn) {
return buildInstr(TargetOpcode::G_VECREDUCE_FADD, {Dst}, {ScalarIn, VecIn});
}
/// Build and insert \p Res = G_VECREDUCE_FMUL \p Src
///
/// \p ScalarIn is the scalar accumulator input to the reduction operation of
/// \p VecIn.
MachineInstrBuilder buildVecReduceFMul(const DstOp &Dst,
const SrcOp &ScalarIn,
const SrcOp &VecIn) {
return buildInstr(TargetOpcode::G_VECREDUCE_FMUL, {Dst}, {ScalarIn, VecIn});
}
/// Build and insert \p Res = G_VECREDUCE_FMAX \p Src
MachineInstrBuilder buildVecReduceFMax(const DstOp &Dst, const SrcOp &Src) {
return buildInstr(TargetOpcode::G_VECREDUCE_FMAX, {Dst}, {Src});
}
/// Build and insert \p Res = G_VECREDUCE_FMIN \p Src
MachineInstrBuilder buildVecReduceFMin(const DstOp &Dst, const SrcOp &Src) {
return buildInstr(TargetOpcode::G_VECREDUCE_FMIN, {Dst}, {Src});
}
/// Build and insert \p Res = G_VECREDUCE_ADD \p Src
MachineInstrBuilder buildVecReduceAdd(const DstOp &Dst, const SrcOp &Src) {
return buildInstr(TargetOpcode::G_VECREDUCE_ADD, {Dst}, {Src});
}
/// Build and insert \p Res = G_VECREDUCE_MUL \p Src
MachineInstrBuilder buildVecReduceMul(const DstOp &Dst, const SrcOp &Src) {
return buildInstr(TargetOpcode::G_VECREDUCE_MUL, {Dst}, {Src});
}
/// Build and insert \p Res = G_VECREDUCE_AND \p Src
MachineInstrBuilder buildVecReduceAnd(const DstOp &Dst, const SrcOp &Src) {
return buildInstr(TargetOpcode::G_VECREDUCE_AND, {Dst}, {Src});
}
/// Build and insert \p Res = G_VECREDUCE_OR \p Src
MachineInstrBuilder buildVecReduceOr(const DstOp &Dst, const SrcOp &Src) {
return buildInstr(TargetOpcode::G_VECREDUCE_OR, {Dst}, {Src});
}
/// Build and insert \p Res = G_VECREDUCE_XOR \p Src
MachineInstrBuilder buildVecReduceXor(const DstOp &Dst, const SrcOp &Src) {
return buildInstr(TargetOpcode::G_VECREDUCE_XOR, {Dst}, {Src});
}
/// Build and insert \p Res = G_VECREDUCE_SMAX \p Src
MachineInstrBuilder buildVecReduceSMax(const DstOp &Dst, const SrcOp &Src) {
return buildInstr(TargetOpcode::G_VECREDUCE_SMAX, {Dst}, {Src});
}
/// Build and insert \p Res = G_VECREDUCE_SMIN \p Src
MachineInstrBuilder buildVecReduceSMin(const DstOp &Dst, const SrcOp &Src) {
return buildInstr(TargetOpcode::G_VECREDUCE_SMIN, {Dst}, {Src});
}
/// Build and insert \p Res = G_VECREDUCE_UMAX \p Src
MachineInstrBuilder buildVecReduceUMax(const DstOp &Dst, const SrcOp &Src) {
return buildInstr(TargetOpcode::G_VECREDUCE_UMAX, {Dst}, {Src});
}
/// Build and insert \p Res = G_VECREDUCE_UMIN \p Src
MachineInstrBuilder buildVecReduceUMin(const DstOp &Dst, const SrcOp &Src) {
return buildInstr(TargetOpcode::G_VECREDUCE_UMIN, {Dst}, {Src});
}
/// Build and insert G_MEMCPY or G_MEMMOVE
MachineInstrBuilder buildMemTransferInst(unsigned Opcode, const SrcOp &DstPtr,
const SrcOp &SrcPtr,
const SrcOp &Size,
MachineMemOperand &DstMMO,
MachineMemOperand &SrcMMO) {
auto MIB = buildInstr(
Opcode, {}, {DstPtr, SrcPtr, Size, SrcOp(INT64_C(0) /*isTailCall*/)});
MIB.addMemOperand(&DstMMO);
MIB.addMemOperand(&SrcMMO);
return MIB;
}
MachineInstrBuilder buildMemCpy(const SrcOp &DstPtr, const SrcOp &SrcPtr,
const SrcOp &Size, MachineMemOperand &DstMMO,
MachineMemOperand &SrcMMO) {
return buildMemTransferInst(TargetOpcode::G_MEMCPY, DstPtr, SrcPtr, Size,
DstMMO, SrcMMO);
}
/// Build and insert \p Dst = G_SBFX \p Src, \p LSB, \p Width.
MachineInstrBuilder buildSbfx(const DstOp &Dst, const SrcOp &Src,
const SrcOp &LSB, const SrcOp &Width) {
return buildInstr(TargetOpcode::G_SBFX, {Dst}, {Src, LSB, Width});
}
/// Build and insert \p Dst = G_UBFX \p Src, \p LSB, \p Width.
MachineInstrBuilder buildUbfx(const DstOp &Dst, const SrcOp &Src,
const SrcOp &LSB, const SrcOp &Width) {
return buildInstr(TargetOpcode::G_UBFX, {Dst}, {Src, LSB, Width});
}
/// Build and insert \p Dst = G_ROTR \p Src, \p Amt
MachineInstrBuilder buildRotateRight(const DstOp &Dst, const SrcOp &Src,
const SrcOp &Amt) {
return buildInstr(TargetOpcode::G_ROTR, {Dst}, {Src, Amt});
}
/// Build and insert \p Dst = G_ROTL \p Src, \p Amt
MachineInstrBuilder buildRotateLeft(const DstOp &Dst, const SrcOp &Src,
const SrcOp &Amt) {
return buildInstr(TargetOpcode::G_ROTL, {Dst}, {Src, Amt});
}
/// Build and insert \p Dst = G_BITREVERSE \p Src
MachineInstrBuilder buildBitReverse(const DstOp &Dst, const SrcOp &Src) {
return buildInstr(TargetOpcode::G_BITREVERSE, {Dst}, {Src});
}
virtual MachineInstrBuilder
buildInstr(unsigned Opc, ArrayRef<DstOp> DstOps, ArrayRef<SrcOp> SrcOps,
std::optional<unsigned> Flags = std::nullopt);
};
} // End namespace llvm.
#endif // LLVM_CODEGEN_GLOBALISEL_MACHINEIRBUILDER_H
| [
"swiftshader-scoped@luci-project-accounts.iam.gserviceaccount.com"
] | swiftshader-scoped@luci-project-accounts.iam.gserviceaccount.com |
12e692b5eaca5dafb252cb9c567aa1a28681cf0a | 9415903a8d1bc8d6c0595a72bf4743f91a3bb494 | /ProctRadish/Classes/Card.h | 1d50d31880d5de0991ad3c6f07113d6df9321c01 | [] | no_license | 137428/ProtectCarrot | 67ddf582d3e610212573fb173d7da57a7326afa7 | 6aa1c5063c14af913febcf5c1cbf7b54435a3983 | refs/heads/master | 2023-01-08T14:59:50.292290 | 2020-11-07T07:36:42 | 2020-11-07T07:36:50 | 310,550,728 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 389 | h | #ifndef __CARD_H__
#define __CARD_H__
#include "cocos2d.h"
#include "DataClass.h"
USING_NS_CC;
class CCard : public Sprite
{
public:
CCard();
~CCard();
virtual bool initWithData(SCardDt* pCard);
static CCard* createWithData(SCardDt* pCard);
void setSprite(int nMoney);
CC_SYNTHESIZE(int, m_nArmsID, ArmsID);
CC_SYNTHESIZE(int, m_nMoney, Money);
private:
string m_strName;
};
#endif | [
"2095409978@qq.com"
] | 2095409978@qq.com |
24f666f2dbb14c62226dca55f77536db7731fdb3 | 83ed0c5d2f8b7392c74a14f1e44926fcf1d8e701 | /svgview.cpp | df0e2a30709ebd53dfbd39a1baa70daaa1f9a4ea | [
"MIT"
] | permissive | lgg-awesome/Scribbler | 23748458d2e356af8a05da2051e338dd5c7c12b4 | 07e0209d824d9694c726299a612ee6c6306236d5 | refs/heads/master | 2021-09-23T13:49:08.632716 | 2018-09-23T09:34:06 | 2018-09-23T09:34:06 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 29,945 | cpp | #include "svgview.h"
SvgView::SvgView(QWidget *parent) : QGraphicsView(parent)
{
currentScaleFactor = 1.0;
areBordersHidden = false;
maxScaleFactor = 1.5;
minScaleFactor = 0.05;
itemsToRemove = 0;
setTransformationAnchor(QGraphicsView::AnchorUnderMouse);
setDragMode(ScrollHandDrag);
setRenderHints(QPainter::SmoothPixmapTransform | QPainter::HighQualityAntialiasing);
limitScale(0.3);
scene = new QGraphicsScene();
setScene(scene);
centerOn(0.0, 0.0);
}
SvgView::~SvgView()
{
delete scene;
}
void SvgView::wheelEvent(QWheelEvent *event)
{
qreal factor = qPow(1.2, event->delta() / 240.0);
limitScale(factor);
event->accept();
}
void SvgView::limitScale(qreal factor)
{
qreal newFactor = currentScaleFactor * factor;
if (newFactor < maxScaleFactor && newFactor > minScaleFactor)
{
currentScaleFactor = newFactor;
scale(factor, factor);
}
}
int SvgView::renderText(const QStringRef &text)
{
prepareSceneToRender();
loadHyphenRules();
drawMarking();
drawMargins();
int endOfSheet = 0;
//Sequentially add the symbols to the scene
for (int currentSymbolNumber = 0; currentSymbolNumber < text.length(); currentSymbolNumber++)
{
QChar symbol = text.at(currentSymbolNumber);
randomizeLetterSpacing();
if (!font.contains(symbol))
{
processUnknownSymbol(symbol);
endOfSheet++;
if (cursor.x() > currentMarginsRect.bottomRight().x() - (fontSize + currentLetterSpacing) * dpmm)
{
cursorToNewLine();
storedWordItems.push_back(QVector<QGraphicsSvgItem *>());
storedSymbolData.push_back(QVector<SymbolData>());
}
if (cursor.y() > currentMarginsRect.bottomRight().y() - fontSize * dpmm)
break;
continue;
}
QGraphicsSvgItem *symbolItem = new QGraphicsSvgItem();
SvgData data = font.values(symbol).at(qrand() % font.values(symbol).size());
symbolData = data.symbolData;
symbolItem->setSharedRenderer(data.renderer);
symbolItem->setScale(data.scale);
symbolBoundingSize = symbolItem->boundingRect().size() * symbolItem->scale();
qreal symbolWidth = symbolBoundingSize.width() * symbolData.limits.width();
preventGoingBeyondRightMargin(symbolWidth, text, currentSymbolNumber);
//rendering stops by the end of sheet
if (cursor.y() > currentMarginsRect.bottomRight().y() - fontSize * dpmm)
{
delete symbolItem;
break;
}
QPointF symbolItemPos = cursor;
symbolItemPos.rx() -= symbolBoundingSize.width() * symbolData.limits.left();
symbolItemPos.ry() -= symbolBoundingSize.height() * symbolData.limits.top();
symbolItemPos += symbolPositionRandomValue();
symbolItem->setPos(symbolItemPos);
scene->addItem(symbolItem);
previousSymbolCursor = cursor;
previousSymbolData = symbolData;
previousSymbolWidth = symbolWidth;
cursor.rx() += symbolWidth + currentLetterSpacing * dpmm;
endOfSheet++;
if (symbol.isLetter())
{
storedSymbolData.last().push_back(symbolData);
storedWordItems.last().push_back(symbolItem);
}
else
{
storedWordItems.push_back(QVector<QGraphicsSvgItem *>());
storedSymbolData.push_back(QVector<SymbolData>());
}
}
removeLastSymbols();
endOfSheet -= itemsToRemove;
connectLetters();
return endOfSheet;
}
void SvgView::removeLastSymbols()
{
uint itemsCount = scene->items().size();
if (itemsCount < itemsToRemove)
return;
for (uint i = 0; i < itemsToRemove; i++)
{
while (storedSymbolData.last().isEmpty())
storedSymbolData.removeLast();
while (storedWordItems.last().isEmpty())
storedWordItems.removeLast();
scene->removeItem(storedWordItems.last().last());
storedSymbolData.last().removeLast();
storedWordItems.last().removeLast();
}
}
void SvgView::prepareSceneToRender()
{
scene->clear();
storedSymbolData.clear();
storedWordItems.clear();
storedWordItems.push_back(QVector<QGraphicsSvgItem *>());
storedSymbolData.push_back(QVector<SymbolData>());
itemsToRemove = 0;
currentMarginsRect = changedVerticalMargins();
scene->addRect(sheetRect);
scene->addRect(currentMarginsRect, QPen(Qt::darkGray));
if (hideMarginsRect)
scene->items(Qt::AscendingOrder).at(1)->setVisible(false);
if (useSeed)
qsrand(seed);
else
qsrand(QTime::currentTime().msec());
hideBorders(areBordersHidden);
randomizeMargins();
cursor = QPointF(currentMarginsRect.x(), currentMarginsRect.y());
}
bool SvgView::preventGoingBeyondRightMargin(qreal symbolWidth, QStringRef text, int currentSymbolIndex)
{
if (cursor.x() > (currentMarginsRect.x() + currentMarginsRect.width() - symbolWidth))
{
bool hyphenateHappened = hyphenate(text, currentSymbolIndex);
bool wrapWordHappened = false;
if (!hyphenateHappened)
wrapWordHappened = wrapWords(text, currentSymbolIndex);
if (!hyphenateHappened && !wrapWordHappened &&
!text.at(currentSymbolIndex).isPunct())
{
cursorToNewLine();
storedWordItems.push_back(QVector<QGraphicsSvgItem *>());
storedSymbolData.push_back(QVector<SymbolData>());
}
return true;
}
return false;
}
bool SvgView::wrapWords(QStringRef text, int currentSymbolIndex)
{
int previousSymbolIndex = currentSymbolIndex - 1;
if (!wordWrap ||
previousSymbolIndex < 0 || previousSymbolIndex >= text.size() ||
!(text.at(currentSymbolIndex).isLetterOrNumber() || text.at(currentSymbolIndex).isPunct()) ||
!(text.at(previousSymbolIndex).isLetterOrNumber() || text.at(previousSymbolIndex).isPunct()))
return false;
//wrap all the last letters
int lastNonLetter = text.toString().lastIndexOf(QRegularExpression("[^\\p{L}]"), currentSymbolIndex);
int symbolsToWrap = currentSymbolIndex - lastNonLetter - 1;
if (wrapLastSymbols(symbolsToWrap))
{
cursor.rx() = previousSymbolCursor.x() + previousSymbolWidth;
cursor.ry() += (fontSize + lineSpacing) * dpmm;
if (cursor.y() > currentMarginsRect.bottomRight().y() - (lineSpacing + fontSize) * dpmm)
itemsToRemove = symbolsToWrap;
return true;
}
return false;
}
bool SvgView::hyphenate(QStringRef text, int currentSymbolIndex)
{
int previousSymbolIndex = currentSymbolIndex - 1;
if (!hyphenateWords || previousSymbolIndex < 0 ||
previousSymbolIndex >= text.size() ||
!text.at(currentSymbolIndex).isLetterOrNumber() ||
!text.at(previousSymbolIndex).isLetterOrNumber() ||
cursor.y() - previousSymbolCursor.y() > 0.0000001)
return false;
//find word boundary
int lastNonLetter = text.toString().lastIndexOf(QRegularExpression("[^\\p{L}]"), currentSymbolIndex);
int nextNonLetter = text.toString().indexOf(QRegularExpression("[^\\p{L}]"), currentSymbolIndex);
QString word;
//select a word
if (nextNonLetter > 0)
word = text.mid(lastNonLetter + 1, nextNonLetter - lastNonLetter).toString();
else
word = text.mid(lastNonLetter + 1, text.size() - 1).toString();
QString hypher = "\\1-\\2";
QString hyphenWord = word;
//divide word into syllables with hyphens
for (QRegularExpression &rule : hyphenRules)
hyphenWord.replace(rule, hypher);
int currentSymbolInWord = currentSymbolIndex - lastNonLetter - 1;
//find new position of current letter
for (int i = 0; i <= currentSymbolInWord && currentSymbolInWord < hyphenWord.size(); i++)
if (hyphenWord.at(i) == '-')
currentSymbolInWord++;
//find hyphen, which is nearest to current letter
qreal indexOfLastHyphen = hyphenWord.lastIndexOf('-', currentSymbolInWord);
qreal symbolsToWrap = currentSymbolInWord - indexOfLastHyphen - 1;
//generate hyphens item and hyphenate
if (indexOfLastHyphen > 0 && symbolsToWrap >= 0)
{
QGraphicsSvgItem *hyphen = generateHyphen(symbolsToWrap);
if (!wrapLastSymbols(symbolsToWrap))
{
randomizeMargins();
previousSymbolCursor.rx() = currentMarginsRect.x() - previousSymbolWidth;
previousSymbolCursor.ry() += (fontSize + lineSpacing) * dpmm;
storedWordItems.push_back(QVector<QGraphicsSvgItem *>());
storedSymbolData.push_back(QVector<SymbolData>());
}
if (hyphen != nullptr)
scene->addItem(hyphen);
}
else
return false;
cursor.rx() = previousSymbolCursor.x() + previousSymbolWidth;
cursor.ry() = previousSymbolCursor.y();
if (cursor.y() > currentMarginsRect.bottomRight().y() - (lineSpacing + fontSize) * dpmm)
itemsToRemove = symbolsToWrap;
return true;
}
bool SvgView::wrapLastSymbols(int symbolsToWrap)
{
if (symbolsToWrap <= 0 || symbolsToWrap >= scene->items().size())
return false;
//find the first item to wrap and it's position
int itemsCount = scene->items().size();
int itemsToWrap = symbolsToWrap; //TODO: consider missing items
QGraphicsItem * firstItemToWrap = scene->items(Qt::AscendingOrder)[itemsCount - itemsToWrap];
qreal firstWrapItemPosX = firstItemToWrap->pos().x();
/*if (firstWrapItemPosX == currentMarginsRect.x())
return false;*/
randomizeMargins();
//this is how much you need to move symbols to the left
qreal leftOffset = firstWrapItemPosX - currentMarginsRect.x();
if (storedSymbolData.last().size() - symbolsToWrap >= 0) //TODO: consider missing items and get rid of this check
{
SymbolData firstItemToWrapData = storedSymbolData.last().at(storedSymbolData.last().size() - symbolsToWrap);
leftOffset += firstItemToWrap->boundingRect().size().width() * firstItemToWrap->scale() * firstItemToWrapData.limits.left();
}
previousSymbolCursor.rx() -= leftOffset;
previousSymbolCursor.ry() += (fontSize + lineSpacing) * dpmm;
storedWordItems.push_back(QVector<QGraphicsSvgItem *>());
storedSymbolData.push_back(QVector<SymbolData>());
//transfer symbols in a new column to half of
//the wrapped word were not connected with the line
for (int i = itemsToWrap; i > 0; i--)
{
int size = storedWordItems.size();
int wordSize = storedWordItems.at(size - 2).size();
if (wordSize <= i)
break;
storedWordItems.last().push_back(storedWordItems[size - 2].takeAt(wordSize - i));
storedSymbolData.last().push_back(storedSymbolData[size - 2].takeAt(wordSize - i));
}
//wrap items
for (int i = itemsToWrap; i > 0; i--)
{
QPointF pos = scene->items(Qt::AscendingOrder)[itemsCount - i]->pos();
pos.rx() -= leftOffset;
pos.ry() += (fontSize + lineSpacing) * dpmm;
scene->items(Qt::AscendingOrder)[itemsCount - i]->setPos(pos);
}
return true;
}
QGraphicsSvgItem * SvgView::generateHyphen(int symbolsToWrap)
{
if (!font.contains('-'))
return nullptr;
symbolsToWrap++;
if (symbolsToWrap <= 0)
return nullptr;
QGraphicsSvgItem *hyphen = new QGraphicsSvgItem();
//prepare hyphens item
SvgData data = font.values('-').at(qrand() % font.values('-').size());
hyphen->setSharedRenderer(data.renderer);
hyphen->setScale(data.scale);
SymbolData hyphenData = data.symbolData;
//calculate hyphens position
QSizeF hyphenBoundingSize = hyphen->boundingRect().size() * hyphen->scale();
QGraphicsItem* nearestLetter = scene->items(Qt::AscendingOrder).at(scene->items().size() - symbolsToWrap);
QPointF hyphenPos = cursor;
hyphenPos.ry() -= hyphenBoundingSize.height() * hyphenData.limits.top();
hyphenPos.rx() = nearestLetter->pos().x() + nearestLetter->boundingRect().width() * nearestLetter->scale();
if (storedSymbolData.last().size() - symbolsToWrap >= 0) //TODO: consider missing items and get rid of this check
{
SymbolData nearestLetterData = storedSymbolData.last().at(storedSymbolData.last().size() - symbolsToWrap);
hyphenPos.rx() -= nearestLetter->boundingRect().width() * nearestLetter->scale() * (1.0 - nearestLetterData.limits.right());
}
hyphen->setPos(hyphenPos);
return hyphen;
}
void SvgView::connectLetters()
{
if (!connectingLetters)
return;
for (int currentWord = 0; currentWord < storedWordItems.size(); currentWord++)
{
for (int currentSymbol = 1; currentSymbol < storedWordItems.at(currentWord).size(); currentSymbol++)
{
QGraphicsSvgItem * currentLetter = storedWordItems.at(currentWord).at(currentSymbol);
QGraphicsSvgItem * previousLetter = storedWordItems.at(currentWord).at(currentSymbol - 1);
//calculate boudingRects; pL means previous letter; cL - current letter
QSizeF pLBoundingRect, cLBoundingRect;
pLBoundingRect.setWidth(previousLetter->boundingRect().width() * previousLetter->scale());
pLBoundingRect.setHeight(previousLetter->boundingRect().height() * previousLetter->scale());
cLBoundingRect.setWidth(currentLetter->boundingRect().width() * currentLetter->scale());
cLBoundingRect.setHeight(currentLetter->boundingRect().height() * currentLetter->scale());
SymbolData pLSymbolData = storedSymbolData.at(currentWord).at(currentSymbol - 1);
SymbolData cLSymbolData = storedSymbolData.at(currentWord).at(currentSymbol);
//calculate coordinates of points
QPointF inPoint, outPoint;
outPoint.rx() = previousLetter->pos().x() +
pLSymbolData.outPoint.x() * pLBoundingRect.width();
outPoint.ry() = previousLetter->pos().y() +
pLSymbolData.outPoint.y() * pLBoundingRect.height();
inPoint.rx() = currentLetter->pos().x() +
cLSymbolData.inPoint.x() * cLBoundingRect.width();
inPoint.ry() = currentLetter->pos().y() +
cLSymbolData.inPoint.y() * cLBoundingRect.height();
//prepare a pen and draw the line
QPen pen(fontColor);
pen.setWidth(penWidth * dpmm);
pen.setCapStyle(Qt::RoundCap);
scene->addLine(outPoint.x(), outPoint.y(), inPoint.x(), inPoint.y(), pen);
}
}
}
void SvgView::processUnknownSymbol(const QChar &symbol)
{
switch (symbol.toLatin1())
{
case '\t':
cursor.rx() += wordSpacing * dpmm * spacesInTab - currentLetterSpacing * dpmm;
break;
case '\n':
cursorToNewLine();
break;
case ' ':
cursor.rx() += (wordSpacing - currentLetterSpacing) * dpmm;
break;
default:
cursor.rx() += (fontSize + currentLetterSpacing) * dpmm;
break;
}
storedWordItems.push_back(QVector<QGraphicsSvgItem *>());
storedSymbolData.push_back(QVector<SymbolData>());
}
QImage SvgView::saveRenderToImage()
{
QImage image(scene->sceneRect().size().toSize(), QImage::Format_ARGB32_Premultiplied);
QPainter painter(&image);
painter.setRenderHint(QPainter::Antialiasing);
scene->render(&painter);
return image;
}
void SvgView::loadFont(QString fontpath)
{
if (fontpath.isEmpty())
{
QSettings settings("Settings.ini", QSettings::IniFormat);
settings.beginGroup("Settings");
fontpath = settings.value("last-used-font", QString()).toString();
settings.endGroup();
}
if (fontpath.isEmpty())
return;
QSettings fontSettings(fontpath, QSettings::IniFormat);
fontSettings.beginGroup("Font");
fontSettings.setIniCodec(QTextCodec::codecForName("UTF-8"));
if (fontSettings.allKeys().size() == 0)
{
fontSettings.endGroup();
return;
}
//clear the loaded font
for (SvgData &data : font.values())
{
delete data.renderer;
data.renderer = nullptr;
}
font.clear();
QString fontDirectory = QFileInfo(fontpath).path() + '/';
//load the data of symbols except the data for capital (uppercase) letters
for (const QString &key : fontSettings.childKeys())
for (SymbolData symbolData : fontSettings.value(key).value<QList<SymbolData>>())
{
symbolData.fileName = fontDirectory + symbolData.fileName;
if (key == "slash")
insertSymbol('/', symbolData);
else if (key == "backslash")
insertSymbol('\\', symbolData);
else
insertSymbol(key.at(0), symbolData);
}
//Load uppercase letters.
//It's a dirty hack, which helps to distinguish uppercase and lowercase
//letters on a freaking case-insensetive Windows
fontSettings.beginGroup("UpperCase");
for (const QString &key : fontSettings.childKeys())
for (SymbolData symbolData : fontSettings.value(key).value<QList<SymbolData>>())
{
symbolData.fileName = fontDirectory + symbolData.fileName;
insertSymbol(key.at(0), symbolData);
}
fontSettings.endGroup();
fontSettings.endGroup();
QSettings settings("Settings.ini", QSettings::IniFormat);
settings.beginGroup("Settings");
settings.setValue("last-used-font", QVariant(fontpath));
settings.endGroup();
}
void SvgView::insertSymbol(QChar key, SymbolData &symbolData)
{
QSvgRenderer *renderer = new QSvgRenderer(symbolData.fileName);
qreal symbolHeight = renderer->defaultSize().height() * symbolData.limits.height();
qreal scale = fontSize * dpmm / symbolHeight;
//start SVG editing
QDomDocument doc("SVG");
QFile file(symbolData.fileName);
if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
return;
if (!doc.setContent(&file))
{
file.close();
return;
}
file.close();
QDomElement svgElement = doc.elementsByTagName("svg").item(0).toElement();
scaleViewBox(svgElement); //scale viewBox to avoid the cut lines with an increase in the width of the line
//get necessary SVG nodes
QStringList viewBox = svgElement.attribute("viewBox").split(" ");
qreal dotsPerUnits = renderer->defaultSize().height() / viewBox.at(3).toDouble();
qreal newPenWidth = penWidth * dpmm / scale / dotsPerUnits;
QDomNodeList pathList = doc.elementsByTagName("path");
QDomNodeList styleList = doc.elementsByTagName("style");
//change necessary attributes; they can be in "style" nodes or in "path" nodes
if (!styleList.isEmpty())
{
QDomElement element = styleList.item(0).toElement();
QString style = element.text();
changeAttribute(style, "stroke-width", QString("%1").arg(newPenWidth));
if (useCustomFontColor)
changeAttribute(style, "stroke", fontColor.name(QColor::HexRgb));
if (roundLines)
{
changeAttribute(style, "stroke-linecap", "round");
changeAttribute(style, "stroke-linejoin", "round");
}
QDomElement newElement = doc.createElement("style");
QDomCDATASection newText = doc.createCDATASection(style);
newElement.appendChild(newText);
newElement.setAttribute("type", element.attribute("type", ""));
element.parentNode().replaceChild(newElement, element);
}
else
for (int i = 0; i < pathList.count(); i++)
{
QDomElement element = pathList.at(i).toElement();
QString style = element.attribute("style", "");
changeAttribute(style, "stroke-width", QString("%1").arg(newPenWidth));
if (useCustomFontColor)
changeAttribute(style, "stroke", fontColor.name(QColor::HexRgb));
if (roundLines)
{
changeAttribute(style, "stroke-linecap", "round");
changeAttribute(style, "stroke-linejoin", "round");
}
element.setAttribute("style", style);
}
//load changed symbol
renderer->load(doc.toString(0).replace(">\n<tspan", "><tspan").toUtf8());
font.insert(key, {symbolData, scale, renderer});
}
void SvgView::changeAttribute(QString &attribute, QString parameter, QString newValue)
{
if (attribute.contains(QRegularExpression(parameter + ":")))
{
int index = attribute.indexOf(parameter + ":");
int endSign = attribute.indexOf(QRegularExpression(";|}"), index);
int valueBegin = index + parameter.size() + 1;
attribute.remove(valueBegin, endSign - valueBegin);
attribute.insert(valueBegin, newValue);
}
else
{
int semicolon = attribute.lastIndexOf(QRegularExpression(";"));
int endSign = attribute.lastIndexOf(QRegularExpression(";|}"));
attribute.insert(semicolon > endSign ? semicolon : endSign,
(attribute.isEmpty() ? "" : ";") + parameter + ":" + newValue);
}
}
void SvgView::scaleViewBox(QDomElement &svgElement)
{
QStringList viewBoxValues = svgElement.attribute("viewBox").split(" ");
if (viewBoxValues.isEmpty())
return;
qreal width = viewBoxValues.at(2).toDouble() - viewBoxValues.at(0).toDouble();
qreal height = viewBoxValues.at(3).toDouble() - viewBoxValues.at(1).toDouble();
QString viewBox = QString("%1 %2 %3 %4")
.arg(static_cast<qreal>(viewBoxValues.at(0).toDouble() - width / 2))
.arg(static_cast<qreal>(viewBoxValues.at(1).toDouble() - height / 2))
.arg(static_cast<qreal>(viewBoxValues.at(2).toDouble() + width))
.arg(static_cast<qreal>(viewBoxValues.at(3).toDouble() + height));
svgElement.setAttribute("viewBox", viewBox);
}
void SvgView::loadSettingsFromFile()
{
QSettings settings("Settings.ini", QSettings::IniFormat);
settings.beginGroup("Settings");
dpi = settings.value("dpi").toInt();
dpmm = dpi / 25.4;
letterSpacing = settings.value("letter-spacing").toDouble();
lineSpacing = settings.value("line-spacing").toDouble();
wordSpacing = settings.value("word-spacing").toDouble();
spacesInTab = settings.value("spaces-in-tab").toInt();
fontSize = settings.value("font-size").toDouble();
penWidth = settings.value("pen-width").toDouble();
roundLines = settings.value("round-lines").toBool();
useSeed = settings.value("use-seed").toBool();
seed = settings.value("seed").toInt();
wordWrap = settings.value("wrap-words").toBool();
useCustomFontColor = settings.value("use-custom-font-color").toBool();
connectingLetters = settings.value("connect-letters").toBool();
hyphenateWords = settings.value("hyphenate-words").toBool();
sheetRect = QRectF(0, 0,
settings.value("sheet-width").toInt() * dpmm,
settings.value("sheet-height").toInt() * dpmm);
marginsRect = QRectF(sheetRect.topLeft() + QPointF(settings.value("left-margin").toInt() * dpmm,
settings.value("top-margin").toInt() * dpmm),
sheetRect.bottomRight() - QPointF(settings.value("right-margin").toInt() * dpmm,
settings.value("bottom-margin").toInt() * dpmm));
hideMarginsRect = settings.value("hide-margins").toBool();
fontColor = QColor(settings.value("font-color").toString());
leftMarginRandomValue = settings.value("left-margin-random-value").toDouble();
leftMarginRandomEnabled = settings.value("left-margin-random-enabled").toBool();
symbolJumpRandomValue = settings.value("symbol-jump-random-value").toDouble();
symbolJumpRandomEnabled = settings.value("symbol-jump-random-enabled").toBool();
letterSpacingRandomValue = settings.value("letter-spacing-random-value").toDouble();
letterSpacingRandomEnabled = settings.value("letter-spacing-random-enabled").toBool();
markingEnabled = settings.value("marking-enabled").toBool();
isMarkingLines = settings.value("is-marking-lines").toBool();
markingColor = QColor(settings.value("marking-color").toString());
markingCheckSize = settings.value("marking-check-size").toDouble();
markingLineSize = settings.value("marking-line-size").toDouble();
markingPenWidth = settings.value("marking-pen-width").toDouble();
drawLeftMargins = settings.value("draw-left-margins").toBool();
drawRightMargins = settings.value("draw-right-margins").toBool();
leftMarginsIndent = settings.value("left-margins-indent").toDouble();
rightMarginsIndent = settings.value("right-margins-indent").toDouble();
marginsColor = QColor(settings.value("margins-color").toString());
loadFont(settings.value("last-used-font", "Font/DefaultFont.ini").toString());
settings.endGroup();
scene->setSceneRect(sheetRect);
renderText();
}
void SvgView::loadHyphenRules()
{
hyphenRules.clear();
//load variables with their values first
QMap<QString, QString> variables;
QSettings settings("hyphenationRules.ini", QSettings::IniFormat);
settings.beginGroup("Variables");
for (const QString &name : settings.childKeys())
variables.insert(name, QString::fromUtf8(settings.value(name).toString().toLatin1()));
//than load rules
settings.endGroup();
settings.beginGroup("Rules");
for (const QString &key : settings.childKeys())
{
QString rule = settings.value(key).toString();
//and replace variables on their values
for (QString &variable : variables.uniqueKeys())
rule.replace(variable, variables[variable]);
hyphenRules.push_back(QRegularExpression(rule));
}
settings.endGroup();
}
void SvgView::hideBorders(bool hide)
{
areBordersHidden = hide;
scene->items(Qt::AscendingOrder).at(0)->setVisible(!hide); //sheetRect
if (!hideMarginsRect)
scene->items(Qt::AscendingOrder).at(1)->setVisible(!hide); //marginsRect
}
void SvgView::changeLeftRightMargins(bool change)
{
changeMargins = change;
}
QRectF SvgView::changedVerticalMargins()
{
QRectF changedMarginsRect;
if (changeMargins)
changedMarginsRect = QRectF(QPointF(sheetRect.topRight().x() - marginsRect.topRight().x(),
marginsRect.topLeft().y()),
QPointF(sheetRect.bottomRight().x() - marginsRect.bottomLeft().x(),
marginsRect.bottomRight().y()));
else
changedMarginsRect = marginsRect;
return changedMarginsRect;
}
void SvgView::randomizeMargins()
{
currentMarginsRect = changedVerticalMargins();
if (!leftMarginRandomEnabled || leftMarginRandomValue == 0)
return;
qreal random = qrand() % uint(leftMarginRandomValue * dpmm);
if (qrand() % 2)
random = -random;
currentMarginsRect.setLeft(currentMarginsRect.x() + (leftMarginRandomValue * dpmm) + random);
}
void SvgView::cursorToNewLine()
{
randomizeMargins();
cursor.rx() = currentMarginsRect.x();
cursor.ry() += (fontSize + lineSpacing) * dpmm;
}
QPointF SvgView::symbolPositionRandomValue()
{
QPointF randomPos(0.0, 0.0);
if (!symbolJumpRandomEnabled || symbolJumpRandomValue == 0)
return randomPos;
qreal randomY = qrand() % uint(symbolJumpRandomValue * dpmm);
if (qrand() % 2)
randomY = -randomY;
randomPos.setY(randomY);
return randomPos;
}
void SvgView::randomizeLetterSpacing()
{
currentLetterSpacing = letterSpacing;
if (!letterSpacingRandomEnabled || letterSpacingRandomValue == 0)
return;
qreal random = qrand() % uint(letterSpacingRandomValue * dpmm);
if (qrand() % 2)
random = -random;
currentLetterSpacing += random;
}
void SvgView::drawMarking()
{
if (!markingEnabled)
return;
qreal width = markingPenWidth * dpmm;
qreal lineSize = markingLineSize * dpmm;
qreal checkSize = markingCheckSize * dpmm;
//y is under the first line of text
qreal y = marginsRect.top() + fontSize * dpmm + width;
QPen pen;
pen.setColor(markingColor);
pen.setWidth(width);
if (isMarkingLines)
{
for (; y <= currentMarginsRect.bottom(); y += lineSize)
scene->addLine(0.0, y, sceneRect().right(), y, pen);
}
else
{
while (y > checkSize * 2)
y -= checkSize;
for (; y <= sceneRect().bottom(); y += checkSize)
{
scene->addLine(0.0, y - checkSize, sceneRect().right(), y - checkSize, pen);
scene->addLine(0.0, y, sceneRect().right(), y, pen);
}
for (qreal x = sceneRect().left(); x < sceneRect().right(); x += checkSize)
scene->addLine(x, 0.0, x, sceneRect().bottom(), pen);
}
}
void SvgView::drawMargins()
{
if (!(drawLeftMargins || drawRightMargins))
return;
QPen pen;
pen.setColor(marginsColor);
pen.setWidth(markingPenWidth * dpmm * 2);
qreal leftX, rightX;
if (changeMargins)
{
rightX = rightMarginsIndent * dpmm;
leftX = sceneRect().right() - leftMarginsIndent * dpmm;
}
else
{
rightX = sceneRect().right() - rightMarginsIndent * dpmm;
leftX = leftMarginsIndent * dpmm;
}
if (drawLeftMargins)
scene->addLine(leftX, 0.0, leftX, sceneRect().bottom(), pen);
if (drawRightMargins)
scene->addLine(rightX, 0.0, rightX, sceneRect().bottom(), pen);
}
| [
"alextopchiy@gmail.com"
] | alextopchiy@gmail.com |
7d548216a3b305dfc606a9a4c2cee4da37597a61 | 9e9d8d8599f653401c863a4c3ccb73051d474ae2 | /OOP244-Workshop6/at_home/at_home/at_home/Contact.h | 0b82048ee5d39c052cb6151852a0035fe8a4411a | [] | no_license | mon369/OOP244 | f897f8e4ddd5ca4927cdf367a06fb7b8cc103289 | f9b3ebf133cce93d1373f3c1dc3ff13ec552842f | refs/heads/master | 2021-07-09T21:06:52.123476 | 2017-10-02T21:42:33 | 2017-10-02T21:42:33 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 927 | h | #ifndef H_CONTACT_H
#define H_CONTACT_H
// TODO: add namespace here
namespace communication
{
const int areaCodeLength = 3;
const int numberLength = 7;
const int numberCode1Length = 3;
const int numberCode2Length = 4;
class Contact
{
char m_name[21];
long long* m_phoneNumbers;
int m_noOfPhoneNumbers;
public:
// TODO: add the default constructor here
Contact();
// TODO: add the constructor with parameters here
Contact(const char*, const long long*, const int);
// TODO: add the destructor here
~Contact();
// TODO: add the display function here
void display() const;
// TODO: add the isEmpty function here
bool isEmpty() const;
// TODO: addPhoneNumber
void addPhoneNumber(const long long);
public:
Contact(const Contact& other);
Contact& operator=(const Contact& other);
private:
bool isValidPhoneNumber(const long long);
int arraySize;
void resizeArray();
};
}
#endif | [
"abelinocencio@live.com"
] | abelinocencio@live.com |
f2d25c8ce1602b865453e7fbb8da74b801832570 | dca5c3d6234dcae89ccb0ceabaec9c67a5de4aa6 | /c++_concurrency/ch4/main.cpp | 5fe62bb8e31fa6ec171ebfac75a0b2a45bb7f625 | [] | no_license | gameworld/cpp | ec72b719c087e4744795fe9ec6fb12a36b1bd13b | 7bcb0a291f19d363eec5da97f950d2f530568dda | refs/heads/master | 2016-09-05T17:17:50.977088 | 2015-08-03T16:20:52 | 2015-08-03T16:20:52 | 40,135,076 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 593 | cpp |
#include "threadsafequeue.h"
#include <thread>
#include <iostream>
#include <chrono>
void push_func(threadsafe_queue<int> &c)
{
int i=0;
while(1)
{
//std::this_thread::sleep_for(std::chrono::seconds(1));
c.push(i++);
}
}
int main()
{
threadsafe_queue<int> tqueue;
std::thread t(push_func,std::ref(tqueue));
std::thread t2(push_func,std::ref(tqueue));
std::thread t3(push_func,std::ref(tqueue));
std::thread t4(push_func,std::ref(tqueue));
while(1)
{
int c;
tqueue.wait_and_pop(c) ;
std::cout<<c<<std::endl;
}
t.join();
t2.join();
t3.join();
t4.join();
}
| [
"fighter@fighter-PU450CD"
] | fighter@fighter-PU450CD |
d9718f06350f26db8d77ca7d7d33cf8827986f06 | 694b8cd53264a5195f4b3bb0d6ff66e2d4964067 | /main/wconnect/bthost/brew/statext/src/OEMBTExtSD.h | 4383ce18d56f876bbfcd786ad2f61ef4ac7a2f3b | [] | no_license | liuguilin129/1110 | d15a6d4714980252ba595fb9444d66be213d0b7e | eb22bb81efcb6cfe7493c8136c35b2b48fe728cb | refs/heads/master | 2020-06-15T02:02:45.545932 | 2016-11-30T12:07:42 | 2016-11-30T12:07:42 | 75,183,270 | 0 | 0 | null | 2016-11-30T12:06:10 | 2016-11-30T12:06:10 | null | WINDOWS-1252 | C++ | false | false | 4,806 | h | #ifndef _OEMBTEXTSD_H_
#define _OEMBTEXTSD_H_
/*===========================================================================
FILE: OEMBTExtSD.h
SERVICES: BlueTooth SD QCT extension
GENERAL DESCRIPTION: BREW interface to the Bluetooth SD
PUBLIC CLASSES: Not Applicable
INITIALIZATION AND SEQUENCING REQUIREMENTS: N/A
Copyright © 2004, 2005 QUALCOMM Incorporated.
All Rights Reserved.
QUALCOMM Proprietary/GTDR
===========================================================================*/
/*===========================================================================
Function: OEMBTExtSD_Init()
Description:
This is called from AEE when an app tries to create an instance of a
class ID associated with this module.
Parameters:
IBTExtSD *pParent: Pointer to the IBTExtSD structure allocated by AEE
Return Value: AEE_SUCCESS if object created and initialized
ENOMEMORY if unable to create object
EFAILED if unable to initialize object
Componts: None
Side Effects: Allocates APP memory for an object
===========================================================================*/
int OEMBTExtSD_Init( IBTExtSD *pParent );
// IBase (see AEE.h)
uint32 OEMBTExtSD_Release( IBTExtSD* po );
// IBTEXTSD_DiscoverDevices (see AEEBTExtSD.h)
int OEMBTExtSD_DiscoverDevices( IBTExtSD* po,
AEEBTServiceClass svcCls,
const AEEBTBDAddr*,
AEEBTDeviceRecord* pDevRec,
uint8 uMaxNumRe );
// IBTEXTSD_StopDeviceDiscovery (see AEEBTExtSD.h)
int OEMBTExtSD_StopDeviceDiscovery(IBTExtSD* po );
// IBTEXTSD_SetDiscoverable (see AEEBTExtSD.h)
int OEMBTExtSD_SetDiscoverable( IBTExtSD* po, boolean discoverable );
// IBTExtSD_GetDeviceName (see AEEBTExtSD.h)
int OEMBTExtSD_GetDeviceName( IBTExtSD* po, const AEEBTBDAddr*,
AECHAR* pDevName, uint8 uMaxLen );
// IBTEXTSD_BrowseService (see AEEBTExtSD.h)
int OEMBTExtSD_BrowseService( IBTExtSD* po, const AEEBTBDAddr*,
AEEBTBrowseRecord*, uint8 );
// IBTEXTSD_SearchService (see AEEBTExtSD.h)
int OEMBTExtSD_SearchService( IBTExtSD* po, const AEEBTBDAddr*,
const AEEBTSearchPattern*,
AEEBTServiceRecord*, uint8 );
// IBTEXTSD_RegisterService (see AEEBTExtSD.h)
int OEMBTExtSD_RegisterService( IBTExtSD* po, uint16 uuid,
uint16 version, uint8 scn,
const AECHAR* svcName );
// IBTEXTSD_RegisterCustomService (see AEEBTExtSD.h)
int OEMBTExtSD_RegisterCustomService( IBTExtSD* po,
const AEEBTUuidList* pCustomSvc,
uint16 version, uint8 scn, uint16 psm,
const AECHAR* svcName);
// IBTEXTSD_UnregisterService (see AEEBTExtSD.h)
int OEMBTExtSD_UnregisterService( IBTExtSD* po, uint16 uuid );
// IBTEXTSD_UnregisterCustomService (see AEEBTExtSD.h)
int OEMBTExtSD_UnregisterCustomService( IBTExtSD* po,
const AEEBTUUID128* pCustomUUID);
// IBTEXTSD_SetLimitedDiscoverable (see AEEBTExtSD.h)
int OEMBTExtSD_SetLimitedDiscoverable( IBTExtSD* po, AEEBTLIAC uLIAC );
// IBTEXTSD_GetDiscoverableMode (see AEEBTExtSD.h)
int OEMBTExtSD_GetDiscoverableMode( IBTExtSD* po );
// IBTEXTSD_AddServiceRecord (see AEEBTExtSD.h)
int OEMBTExtSD_AddServiceRecord( IBTExtSD* po,
uint16 uuid,
const AEEBTServiceRecord* pSvcRec );
// IBTEXTSD_AddServiceAttribute (see AEEBTExtSD.h)
int OEMBTExtSD_AddServiceAttribute( IBTExtSD* po, uint32 uSvcRecHandle,
const AEEBTServiceAttribute* pSvcAttr );
// IBTEXTSD_UpdateServiceAttribute (see AEEBTExtSD.h)
int OEMBTExtSD_UpdateServiceAttribute( IBTExtSD* po, uint32 uSvcRecHandle,
const AEEBTServiceAttribute* pSvcAttr ) ;
// IBTEXTSD_ServiceDBEnumInit (see AEEBTExtSD.h)
int OEMBTExtSD_ServiceDBEnumInit( IBTExtSD* po );
// IBTEXTSD_ServiceDBEnumNext (see AEEBTExtSD.h)
int OEMBTExtSD_ServiceDBEnumNext( IBTExtSD* po, AEEBTServiceRecord* pSvcRec );
// IBTEXTSD_GetDeviceNameCancel (see AEEBTExtSD.h)
int OEMBTExtSD_GetDeviceNameCancel( IBTExtSD* po, const AEEBTBDAddr* pBDAddr );
// IBTEXTSD_BrowseServiceCancel(see AEEBTExtSD.h)
int OEMBTExtSD_BrowseServiceCancel( IBTExtSD* po, const AEEBTBDAddr* pBDAddr );
#endif /* _OEMBTEXTSD_H_ */
| [
"jiaoyuhai@3f3bbce5-bc85-8142-9eb1-77d090cfebd4"
] | jiaoyuhai@3f3bbce5-bc85-8142-9eb1-77d090cfebd4 |
ff542eaba2c4722ef48409b121845eab9d75e62d | f58613c182158db46eb0d6cdb5dd462264e9cb1a | /genfile/src/SNPFilteringSNPDataSource.cpp | c0918c95ea046d69a043d7f8e87b37aa98edf57b | [
"BSL-1.0"
] | permissive | gavinband/bingwa | 989afa0c73657163fd51a25e253f0f51e2d60569 | d52e166b3bb6bc32cd32ba63bf8a4a147275eca1 | refs/heads/master | 2022-04-16T22:48:11.354125 | 2019-05-17T22:30:35 | 2019-05-17T22:30:35 | 254,956,845 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,395 | cpp |
// Copyright Gavin Band 2008 - 2012.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include "genfile/Error.hpp"
#include "genfile/SNPDataSource.hpp"
#include "genfile/VariantIdentifyingDataTest.hpp"
#include "genfile/SNPFilteringSNPDataSource.hpp"
#include "genfile/get_set.hpp"
namespace genfile {
// Create a SNPFilteringSNPDataSource from the given source and the given sample indices.
std::auto_ptr< SNPFilteringSNPDataSource > SNPFilteringSNPDataSource::create(
SNPDataSource::UniquePtr source,
IndexList const& indices_of_snps_to_include
) {
return SNPFilteringSNPDataSource::UniquePtr(
new SNPFilteringSNPDataSource( source, indices_of_snps_to_include )
) ;
}
SNPFilteringSNPDataSource::SNPFilteringSNPDataSource(
SNPDataSource::UniquePtr source,
IndexList indices_of_snps_to_include
):
m_source( source )
{
std::sort( indices_of_snps_to_include.begin(), indices_of_snps_to_include.end() ) ;
for( std::size_t i = 0; i < m_source->total_number_of_snps(); ++i ) {
if( !std::binary_search( indices_of_snps_to_include.begin(), indices_of_snps_to_include.end(), i )) {
m_indices_of_excluded_snps.insert( i ) ;
}
}
m_source->reset_to_start() ;
}
SNPFilteringSNPDataSource::operator bool() const {
return (*m_source) ;
}
SNPDataSource::Metadata SNPFilteringSNPDataSource::get_metadata() const {
return m_source->get_metadata() ;
}
unsigned int SNPFilteringSNPDataSource::number_of_samples() const {
return m_source->number_of_samples() ;
}
void SNPFilteringSNPDataSource::get_sample_ids( GetSampleIds getter ) const {
return m_source->get_sample_ids( getter ) ;
}
SNPDataSource::OptionalSnpCount SNPFilteringSNPDataSource::total_number_of_snps() const {
if( m_source->total_number_of_snps() ) {
return *m_source->total_number_of_snps() - m_indices_of_excluded_snps.size() ;
}
else {
return OptionalSnpCount() ;
}
}
SNPDataSource::OptionalSnpCount SNPFilteringSNPDataSource::total_number_of_snps_before_filtering() const {
if( m_source->total_number_of_snps() ) {
return *m_source->total_number_of_snps() ;
}
else {
return OptionalSnpCount() ;
}
}
std::string SNPFilteringSNPDataSource::get_source_spec() const {
return "snp-filtered:" + m_source->get_source_spec() ;
}
SNPDataSource const& SNPFilteringSNPDataSource::get_parent_source() const {
return (*m_source) ;
}
SNPDataSource const& SNPFilteringSNPDataSource::get_base_source() const {
return m_source->get_base_source() ;
}
void SNPFilteringSNPDataSource::reset_to_start_impl() {
m_source->reset_to_start() ;
}
void SNPFilteringSNPDataSource::get_snp_identifying_data_impl(
VariantIdentifyingData* result
) {
VariantIdentifyingData variant ;
while( (*m_source) && m_indices_of_excluded_snps.find( m_source->number_of_snps_read() ) != m_indices_of_excluded_snps.end() ) {
m_source->get_snp_identifying_data( &variant ) ;
m_source->ignore_snp_probability_data() ;
}
m_source->get_snp_identifying_data( result ) ;
}
VariantDataReader::UniquePtr SNPFilteringSNPDataSource::read_variant_data_impl() {
return m_source->read_variant_data() ;
}
void SNPFilteringSNPDataSource::ignore_snp_probability_data_impl() {
m_source->ignore_snp_probability_data() ;
}
}
| [
"gavin.band@well.ox.ac.uk"
] | gavin.band@well.ox.ac.uk |
309c07d3fd68a90f9da5f4be3f2856aee11e64d5 | 52505166e409b44caf7a0b144ef0c453b586fcee | /performance-eval/FlexNLP/s1_i_time/sim_model/src/compute.cc | 2535b37f5b88c0a0f9eebec485694dfec0d18878 | [] | no_license | yuex1994/ASPDAC-tandem | fb090975c65edbdda68c19a8d7e7a5f0ff96bcb8 | decdabc5743c2116d1fc0e339e434b9e13c430a8 | refs/heads/master | 2023-08-28T04:37:30.011721 | 2021-08-07T13:19:23 | 2021-08-07T13:19:30 | 419,089,461 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 60,793 | cc | #include <iomanip>
#include <flex.h>
#define ILATOR_VERBOSE_PARENT
static int instr_cntr = 0;
void flex::LogInstrSequence(const std::string& instr_name) {
instr_log << "Instr No." << std::setw(5) << instr_cntr << '\t';
instr_log << instr_name << " is activated\n";
instr_cntr++;
}
static bool g_initialized = false;
void flex::compute() {
if (!g_initialized) {
setup_initial_condition();
g_initialized = true;
}
#ifdef RUN_TANDEM
e_inst = NO_INST;
#endif
// std::cout << "compute" << std::endl;
// flex_if_axi_wr = flex_if_axi_wr_in.read();
// flex_if_axi_rd = flex_if_axi_rd_in.read();
// flex_addr_in = flex_addr_in_in.read();
// flex_data_in_0 = flex_data_in_0_in.read();
// flex_data_in_1 = flex_data_in_1_in.read();
// flex_data_in_2 = flex_data_in_2_in.read();
// flex_data_in_3 = flex_data_in_3_in.read();
// flex_data_in_4 = flex_data_in_4_in.read();
// flex_data_in_5 = flex_data_in_5_in.read();
// flex_data_in_6 = flex_data_in_6_in.read();
// flex_data_in_7 = flex_data_in_7_in.read();
// flex_data_in_8 = flex_data_in_8_in.read();
// flex_data_in_9 = flex_data_in_9_in.read();
// flex_data_in_10 = flex_data_in_10_in.read();
// flex_data_in_11 = flex_data_in_11_in.read();
// flex_data_in_12 = flex_data_in_12_in.read();
// flex_data_in_13 = flex_data_in_13_in.read();
// flex_data_in_14 = flex_data_in_14_in.read();
// flex_data_in_15 = flex_data_in_15_in.read();
// std::cout << "wr: " << flex_if_axi_wr << std::endl;
// std::cout << "rd: " << flex_if_axi_rd << std::endl;
// std::cout << "flex_addr_in: " << flex_addr_in << std::endl;
if (decode_flex_CONFIG_GB_ATTENTION()) {
update_flex_CONFIG_GB_ATTENTION();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("CONFIG_GB_ATTENTION");
#endif
#ifdef RUN_TANDEM
e_inst = CONFIG_GB_ATTENTION;
#endif
}
if (decode_flex_CONFIG_GB_CONTROL()) {
update_flex_CONFIG_GB_CONTROL();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("CONFIG_GB_CONTROL");
#endif
#ifdef RUN_TANDEM
e_inst = CONFIG_GB_CONTROL;
#endif
}
if (decode_flex_CONFIG_GB_CORE_MEM_MNGR_LARGE()) {
update_flex_CONFIG_GB_CORE_MEM_MNGR_LARGE();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("CONFIG_GB_CORE_MEM_MNGR_LARGE");
#endif
#ifdef RUN_TANDEM
e_inst = CONFIG_GB_CORE_MEM_MNGR_LARGE;
#endif
}
if (decode_flex_CONFIG_GB_CORE_MEM_MNGR_SMALL()) {
update_flex_CONFIG_GB_CORE_MEM_MNGR_SMALL();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("CONFIG_GB_CORE_MEM_MNGR_SMALL");
#endif
#ifdef RUN_TANDEM
e_inst = CONFIG_GB_CORE_MEM_MNGR_SMALL;
#endif
}
if (decode_flex_CONFIG_GB_LAYER_NORM()) {
update_flex_CONFIG_GB_LAYER_NORM();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("CONFIG_GB_LAYER_NORM");
#endif
#ifdef RUN_TANDEM
e_inst = CONFIG_GB_LAYER_NORM;
#endif
}
if (decode_flex_CONFIG_GB_LAYER_REDUCE()) {
update_flex_CONFIG_GB_LAYER_REDUCE();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("CONFIG_GB_LAYER_REDUCE");
#endif
#ifdef RUN_TANDEM
e_inst = CONFIG_GB_LAYER_REDUCE;
#endif
}
if (decode_flex_CONFIG_GB_ZERO_PADDING()) {
update_flex_CONFIG_GB_ZERO_PADDING();
#ifdef ILATOR_VERBOSE
LogInstrSequence("CONFIG_GB_ZERO_PADDING");
#endif
#ifdef RUN_TANDEM
e_inst = CONFIG_GB_ZERO_PADDING;
#endif
}
if (decode_flex_PE0_CONFIG_ACT_MNGR()) {
update_flex_PE0_CONFIG_ACT_MNGR();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("PE0_CONFIG_ACT_MNGR");
#endif
#ifdef RUN_TANDEM
e_inst = PE0_CONFIG_ACT_MNGR;
#endif
}
if (decode_flex_PE0_CONFIG_ACT_VECTOR_0_15()) {
update_flex_PE0_CONFIG_ACT_VECTOR_0_15();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("PE0_CONFIG_ACT_VECTOR_0_15");
#endif
#ifdef RUN_TANDEM
e_inst = PE0_CONFIG_ACT_VECTOR_0_15;
#endif
}
if (decode_flex_PE0_CONFIG_ACT_VECTOR_16_31()) {
update_flex_PE0_CONFIG_ACT_VECTOR_16_31();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("PE0_CONFIG_ACT_VECTOR_16_31");
#endif
#ifdef RUN_TANDEM
e_inst = PE0_CONFIG_ACT_VECTOR_16_31;
#endif
}
if (decode_flex_PE0_CONFIG_CLUSTER_TABLE_FIRST()) {
update_flex_PE0_CONFIG_CLUSTER_TABLE_FIRST();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("PE0_CONFIG_CLUSTER_TABLE_FIRST");
#endif
#ifdef RUN_TANDEM
e_inst = PE0_CONFIG_CLUSTER_TABLE_FIRST;
#endif
}
if (decode_flex_PE0_CONFIG_CLUSTER_TABLE_SECOND()) {
update_flex_PE0_CONFIG_CLUSTER_TABLE_SECOND();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("PE0_CONFIG_CLUSTER_TABLE_SECOND");
#endif
#ifdef RUN_TANDEM
e_inst = PE0_CONFIG_CLUSTER_TABLE_SECOND;
#endif
}
if (decode_flex_PE0_CONFIG_MEM_MNGR_FIRST()) {
update_flex_PE0_CONFIG_MEM_MNGR_FIRST();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("PE0_CONFIG_MEM_MNGR_FIRST");
#endif
#ifdef RUN_TANDEM
e_inst = PE0_CONFIG_MEM_MNGR_FIRST;
#endif
}
if (decode_flex_PE0_CONFIG_MEM_MNGR_SECOND()) {
update_flex_PE0_CONFIG_MEM_MNGR_SECOND();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("PE0_CONFIG_MEM_MNGR_SECOND");
#endif
#ifdef RUN_TANDEM
e_inst = PE0_CONFIG_MEM_MNGR_SECOND;
#endif
}
if (decode_flex_PE0_CONFIG_RNN_LAYER_SIZING()) {
update_flex_PE0_CONFIG_RNN_LAYER_SIZING();
#ifdef ILATOR_VERBOSE_PARENT
// instr_log << "is_valid: " << flex_pe0_rnn_layer_sizing_is_valid << "\n";
// instr_log << "is_zero_first: " << flex_pe0_rnn_layer_sizing_is_zero_first << "\n";
// instr_log << "is_cluster: " << flex_pe0_rnn_layer_sizing_is_cluster << "\n";
LogInstrSequence("PE0_CONFIG_RNN_LAYER_SIZING");
#endif
#ifdef RUN_TANDEM
e_inst = PE0_CONFIG_RNN_LAYER_SIZING;
#endif
}
if (decode_flex_PE1_CONFIG_ACT_MNGR()) {
update_flex_PE1_CONFIG_ACT_MNGR();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("PE1_CONFIG_ACT_MNGR");
#endif
#ifdef RUN_TANDEM
e_inst = PE1_CONFIG_ACT_MNGR;
#endif
}
if (decode_flex_PE1_CONFIG_ACT_VECTOR_0_15()) {
update_flex_PE1_CONFIG_ACT_VECTOR_0_15();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("PE1_CONFIG_ACT_VECTOR_0_15");
#endif
#ifdef RUN_TANDEM
e_inst = PE1_CONFIG_ACT_VECTOR_0_15;
#endif
}
if (decode_flex_PE1_CONFIG_ACT_VECTOR_16_31()) {
update_flex_PE1_CONFIG_ACT_VECTOR_16_31();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("PE1_CONFIG_ACT_VECTOR_16_31");
#endif
#ifdef RUN_TANDEM
e_inst = PE1_CONFIG_ACT_VECTOR_16_31;
#endif
}
if (decode_flex_PE1_CONFIG_CLUSTER_TABLE_FIRST()) {
update_flex_PE1_CONFIG_CLUSTER_TABLE_FIRST();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("PE1_CONFIG_CLUSTER_TABLE_FIRST");
#endif
#ifdef RUN_TANDEM
e_inst = PE1_CONFIG_CLUSTER_TABLE_FIRST;
#endif
}
if (decode_flex_PE1_CONFIG_CLUSTER_TABLE_SECOND()) {
update_flex_PE1_CONFIG_CLUSTER_TABLE_SECOND();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("PE1_CONFIG_CLUSTER_TABLE_SECOND");
#endif
#ifdef RUN_TANDEM
e_inst = PE1_CONFIG_CLUSTER_TABLE_SECOND;
#endif
}
if (decode_flex_PE1_CONFIG_MEM_MNGR_FIRST()) {
update_flex_PE1_CONFIG_MEM_MNGR_FIRST();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("PE1_CONFIG_MEM_MNGR_FIRST");
#endif
#ifdef RUN_TANDEM
e_inst = PE1_CONFIG_MEM_MNGR_FIRST;
#endif
}
if (decode_flex_PE1_CONFIG_MEM_MNGR_SECOND()) {
update_flex_PE1_CONFIG_MEM_MNGR_SECOND();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("PE1_CONFIG_MEM_MNGR_SECOND");
#endif
#ifdef RUN_TANDEM
e_inst = PE1_CONFIG_MEM_MNGR_SECOND;
#endif
}
if (decode_flex_PE1_CONFIG_RNN_LAYER_SIZING()) {
update_flex_PE1_CONFIG_RNN_LAYER_SIZING();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("PE1_CONFIG_RNN_LAYER_SIZING");
#endif
#ifdef RUN_TANDEM
e_inst = PE1_CONFIG_RNN_LAYER_SIZING;
#endif
}
if (decode_flex_PE2_CONFIG_ACT_MNGR()) {
update_flex_PE2_CONFIG_ACT_MNGR();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("PE2_CONFIG_ACT_MNGR");
#endif
#ifdef RUN_TANDEM
e_inst = PE2_CONFIG_ACT_MNGR;
#endif
}
if (decode_flex_PE2_CONFIG_ACT_VECTOR_0_15()) {
update_flex_PE2_CONFIG_ACT_VECTOR_0_15();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("PE2_CONFIG_ACT_VECTOR_0_15");
#endif
#ifdef RUN_TANDEM
e_inst = PE2_CONFIG_ACT_VECTOR_0_15;
#endif
}
if (decode_flex_PE2_CONFIG_ACT_VECTOR_16_31()) {
update_flex_PE2_CONFIG_ACT_VECTOR_16_31();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("PE2_CONFIG_ACT_VECTOR_16_31");
#endif
#ifdef RUN_TANDEM
e_inst = PE2_CONFIG_ACT_VECTOR_16_31;
#endif
}
if (decode_flex_PE2_CONFIG_CLUSTER_TABLE_FIRST()) {
update_flex_PE2_CONFIG_CLUSTER_TABLE_FIRST();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("PE2_CONFIG_CLUSTER_TABLE_FIRST");
#endif
#ifdef RUN_TANDEM
e_inst = PE2_CONFIG_CLUSTER_TABLE_FIRST;
#endif
}
if (decode_flex_PE2_CONFIG_CLUSTER_TABLE_SECOND()) {
update_flex_PE2_CONFIG_CLUSTER_TABLE_SECOND();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("PE2_CONFIG_CLUSTER_TABLE_SECOND");
#endif
#ifdef RUN_TANDEM
e_inst = PE2_CONFIG_CLUSTER_TABLE_SECOND;
#endif
}
if (decode_flex_PE2_CONFIG_MEM_MNGR_FIRST()) {
update_flex_PE2_CONFIG_MEM_MNGR_FIRST();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("PE2_CONFIG_MEM_MNGR_FIRST");
#endif
#ifdef RUN_TANDEM
e_inst = PE2_CONFIG_MEM_MNGR_FIRST;
#endif
}
if (decode_flex_PE2_CONFIG_MEM_MNGR_SECOND()) {
update_flex_PE2_CONFIG_MEM_MNGR_SECOND();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("PE2_CONFIG_MEM_MNGR_SECOND");
#endif
#ifdef RUN_TANDEM
e_inst = PE2_CONFIG_MEM_MNGR_SECOND;
#endif
}
if (decode_flex_PE2_CONFIG_RNN_LAYER_SIZING()) {
update_flex_PE2_CONFIG_RNN_LAYER_SIZING();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("PE2_CONFIG_RNN_LAYER_SIZING");
#endif
#ifdef RUN_TANDEM
e_inst = PE2_CONFIG_RNN_LAYER_SIZING;
#endif
}
if (decode_flex_PE3_CONFIG_ACT_MNGR()) {
update_flex_PE3_CONFIG_ACT_MNGR();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("PE3_CONFIG_ACT_MNGR");
#endif
#ifdef RUN_TANDEM
e_inst = PE3_CONFIG_ACT_MNGR;
#endif
}
if (decode_flex_PE3_CONFIG_ACT_VECTOR_0_15()) {
update_flex_PE3_CONFIG_ACT_VECTOR_0_15();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("PE3_CONFIG_ACT_VECTOR_0_15");
#endif
#ifdef RUN_TANDEM
e_inst = PE3_CONFIG_ACT_VECTOR_0_15;
#endif
}
if (decode_flex_PE3_CONFIG_ACT_VECTOR_16_31()) {
update_flex_PE3_CONFIG_ACT_VECTOR_16_31();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("PE3_CONFIG_ACT_VECTOR_16_31");
#endif
#ifdef RUN_TANDEM
e_inst = PE3_CONFIG_ACT_VECTOR_16_31;
#endif
}
if (decode_flex_PE3_CONFIG_CLUSTER_TABLE_FIRST()) {
update_flex_PE3_CONFIG_CLUSTER_TABLE_FIRST();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("PE3_CONFIG_CLUSTER_TABLE_FIRST");
#endif
#ifdef RUN_TANDEM
e_inst = PE3_CONFIG_CLUSTER_TABLE_FIRST;
#endif
}
if (decode_flex_PE3_CONFIG_CLUSTER_TABLE_SECOND()) {
update_flex_PE3_CONFIG_CLUSTER_TABLE_SECOND();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("PE3_CONFIG_CLUSTER_TABLE_SECOND");
#endif
#ifdef RUN_TANDEM
e_inst = PE3_CONFIG_CLUSTER_TABLE_SECOND;
#endif
}
if (decode_flex_PE3_CONFIG_MEM_MNGR_FIRST()) {
update_flex_PE3_CONFIG_MEM_MNGR_FIRST();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("PE3_CONFIG_MEM_MNGR_FIRST");
#endif
#ifdef RUN_TANDEM
e_inst = PE3_CONFIG_MEM_MNGR_FIRST;
#endif
}
if (decode_flex_PE3_CONFIG_MEM_MNGR_SECOND()) {
update_flex_PE3_CONFIG_MEM_MNGR_SECOND();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("PE3_CONFIG_MEM_MNGR_SECOND");
#endif
#ifdef RUN_TANDEM
e_inst = PE3_CONFIG_MEM_MNGR_SECOND;
#endif
}
if (decode_flex_PE3_CONFIG_RNN_LAYER_SIZING()) {
update_flex_PE3_CONFIG_RNN_LAYER_SIZING();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("PE3_CONFIG_RNN_LAYER_SIZING");
#endif
#ifdef RUN_TANDEM
e_inst = PE3_CONFIG_RNN_LAYER_SIZING;
#endif
}
if (decode_flex_GB_CORE_STORE_LARGE()) {
update_flex_GB_CORE_STORE_LARGE();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("GB_CORE_STORE_LARGE");
#endif
#ifdef RUN_TANDEM
e_inst = GB_CORE_STORE_LARGE;
#endif
}
if (decode_flex_GB_CORE_STORE_SMALL()) {
update_flex_GB_CORE_STORE_SMALL();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("GB_CORE_STORE_SMALL");
#endif
#ifdef RUN_TANDEM
e_inst = GB_CORE_STORE_SMALL;
#endif
}
if (decode_flex_PE0_CORE_STORE_WEIGHT_BUFFER()) {
update_flex_PE0_CORE_STORE_WEIGHT_BUFFER();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("PE0_CORE_STORE_WEIGHT_BUFFER");
#endif
#ifdef RUN_TANDEM
e_inst = PE0_CORE_STORE_WEIGHT_BUFFER;
#endif
}
if (decode_flex_PE0_CORE_STORE_INPUT_BUFFER()) {
update_flex_PE0_CORE_STORE_INPUT_BUFFER();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("PE0_CORE_STORE_INPUT_BUFFER");
#endif
#ifdef RUN_TANDEM
e_inst = PE0_CORE_STORE_INPUT_BUFFER;
#endif
}
if (decode_flex_PE0_ACT_STORE_BUFFER()) {
update_flex_PE0_ACT_STORE_BUFFER();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("PE0_ACT_STORE_BUFFER");
#endif
#ifdef RUN_TANDEM
e_inst = PE0_ACT_STORE_BUFFER;
#endif
}
if (decode_flex_PE1_CORE_STORE_WEIGHT_BUFFER()) {
update_flex_PE1_CORE_STORE_WEIGHT_BUFFER();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("PE1_CORE_STORE_WEIGHT_BUFFER");
#endif
#ifdef RUN_TANDEM
e_inst = PE1_CORE_STORE_WEIGHT_BUFFER;
#endif
}
if (decode_flex_PE1_CORE_STORE_INPUT_BUFFER()) {
update_flex_PE1_CORE_STORE_INPUT_BUFFER();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("PE1_CORE_STORE_INPUT_BUFFER");
#endif
#ifdef RUN_TANDEM
e_inst = PE1_CORE_STORE_INPUT_BUFFER;
#endif
}
if (decode_flex_PE1_ACT_STORE_BUFFER()) {
update_flex_PE1_ACT_STORE_BUFFER();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("PE1_ACT_STORE_BUFFER");
#endif
#ifdef RUN_TANDEM
e_inst = PE1_ACT_STORE_BUFFER;
#endif
}
if (decode_flex_PE2_CORE_STORE_WEIGHT_BUFFER()) {
update_flex_PE2_CORE_STORE_WEIGHT_BUFFER();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("PE2_CORE_STORE_WEIGHT_BUFFER");
#endif
#ifdef RUN_TANDEM
e_inst = PE2_CORE_STORE_WEIGHT_BUFFER;
#endif
}
if (decode_flex_PE2_CORE_STORE_INPUT_BUFFER()) {
update_flex_PE2_CORE_STORE_INPUT_BUFFER();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("PE2_CORE_STORE_INPUT_BUFFER");
#endif
#ifdef RUN_TANDEM
e_inst = PE2_CORE_STORE_INPUT_BUFFER;
#endif
}
if (decode_flex_PE2_ACT_STORE_BUFFER()) {
update_flex_PE2_ACT_STORE_BUFFER();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("PE2_ACT_STORE_BUFFER");
#endif
#ifdef RUN_TANDEM
e_inst = PE2_ACT_STORE_BUFFER;
#endif
}
if (decode_flex_PE3_CORE_STORE_WEIGHT_BUFFER()) {
update_flex_PE3_CORE_STORE_WEIGHT_BUFFER();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("PE3_CORE_STORE_WEIGHT_BUFFER");
#endif
#ifdef RUN_TANDEM
e_inst = PE3_CORE_STORE_WEIGHT_BUFFER;
#endif
}
if (decode_flex_PE3_CORE_STORE_INPUT_BUFFER()) {
update_flex_PE3_CORE_STORE_INPUT_BUFFER();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("PE3_CORE_STORE_INPUT_BUFFER");
#endif
#ifdef RUN_TANDEM
e_inst = PE3_CORE_STORE_INPUT_BUFFER;
#endif
}
if (decode_flex_PE3_ACT_STORE_BUFFER()) {
update_flex_PE3_ACT_STORE_BUFFER();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("PE3_ACT_STORE_BUFFER");
#endif
#ifdef RUN_TANDEM
e_inst = PE3_ACT_STORE_BUFFER;
#endif
}
if (decode_flex_GB_ATTENTION_START()) {
update_flex_GB_ATTENTION_START();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("GB_ATTENTION_START");
#endif
#ifdef RUN_TANDEM
e_inst = GB_ATTENTION_START;
#endif
}
if (decode_flex_GB_CONTROL_START()) {
update_flex_GB_CONTROL_START();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("GB_CONTROL_START");
#endif
#ifdef RUN_TANDEM
e_inst = GB_CONTROL_START;
#endif
}
if (decode_flex_GB_LAYER_NORM_START()) {
update_flex_GB_LAYER_NORM_START();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("GB_LAYER_NORM_START");
#endif
#ifdef RUN_TANDEM
e_inst = GB_LAYER_NORM_START;
#endif
}
if (decode_flex_GB_LAYER_REDUCE_START()) {
update_flex_GB_LAYER_REDUCE_START();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("GB_LAYER_REDUCE_START");
#endif
#ifdef RUN_TANDEM
e_inst = GB_LAYER_REDUCE_START;
#endif
}
if (decode_flex_GB_ZEROPADDING_START()) {
update_flex_GB_ZEROPADDING_START();
#ifdef ILATOR_VERBOSE_PARENT
LogInstrSequence("GB_ZEROPADDING_START");
#endif
#ifdef RUN_TANDEM
e_inst = GB_ZEROPADDING_START;
#endif
}
while (1) {
int schedule_counter = 0;
if (decode_PE0_CORE_RUN_MAC_CHILD_PE0_core_run_mac_data_nc()) {
update_PE0_CORE_RUN_MAC_CHILD_PE0_core_run_mac_data_nc();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE0_core_run_mac_data_nc");
#endif
}
if (decode_PE0_CORE_RUN_MAC_CHILD_PE0_core_run_mac_data_c()) {
update_PE0_CORE_RUN_MAC_CHILD_PE0_core_run_mac_data_c();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE0_core_run_mac_data_c");
#endif
}
if (decode_PE0_CORE_RUN_MAC_CHILD_PE0_core_run_mac_mul()) {
update_PE0_CORE_RUN_MAC_CHILD_PE0_core_run_mac_mul();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE0_core_run_mac_mul");
#endif
}
if (decode_PE0_CORE_RUN_MAC_CHILD_PE0_core_run_mac_out_0()) {
update_PE0_CORE_RUN_MAC_CHILD_PE0_core_run_mac_out_0();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE0_core_run_mac_out_0");
#endif
}
if (decode_PE0_CORE_RUN_MAC_CHILD_PE0_core_run_mac_out_1()) {
update_PE0_CORE_RUN_MAC_CHILD_PE0_core_run_mac_out_1();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE0_core_run_mac_out_1");
#endif
}
if (decode_PE0_CORE_RUN_MAC_CHILD_PE0_core_run_mac_out_2()) {
update_PE0_CORE_RUN_MAC_CHILD_PE0_core_run_mac_out_2();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE0_core_run_mac_out_2");
#endif
}
if (decode_PE0_CORE_RUN_MAC_CHILD_PE0_core_run_mac_out_3()) {
update_PE0_CORE_RUN_MAC_CHILD_PE0_core_run_mac_out_3();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE0_core_run_mac_out_3");
#endif
}
if (decode_PE0_CORE_RUN_MAC_CHILD_PE0_core_run_mac_out_4()) {
update_PE0_CORE_RUN_MAC_CHILD_PE0_core_run_mac_out_4();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE0_core_run_mac_out_4");
#endif
}
if (decode_PE0_CORE_RUN_MAC_CHILD_PE0_core_run_mac_out_5()) {
update_PE0_CORE_RUN_MAC_CHILD_PE0_core_run_mac_out_5();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE0_core_run_mac_out_5");
#endif
}
if (decode_PE0_CORE_RUN_MAC_CHILD_PE0_core_run_mac_out_6()) {
update_PE0_CORE_RUN_MAC_CHILD_PE0_core_run_mac_out_6();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE0_core_run_mac_out_6");
#endif
}
if (decode_PE0_CORE_RUN_MAC_CHILD_PE0_core_run_mac_out_7()) {
update_PE0_CORE_RUN_MAC_CHILD_PE0_core_run_mac_out_7();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE0_core_run_mac_out_7");
#endif
}
if (decode_PE0_CORE_RUN_MAC_CHILD_PE0_core_run_mac_out_8()) {
update_PE0_CORE_RUN_MAC_CHILD_PE0_core_run_mac_out_8();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE0_core_run_mac_out_8");
#endif
}
if (decode_PE0_CORE_RUN_MAC_CHILD_PE0_core_run_mac_out_9()) {
update_PE0_CORE_RUN_MAC_CHILD_PE0_core_run_mac_out_9();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE0_core_run_mac_out_9");
#endif
}
if (decode_PE0_CORE_RUN_MAC_CHILD_PE0_core_run_mac_out_10()) {
update_PE0_CORE_RUN_MAC_CHILD_PE0_core_run_mac_out_10();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE0_core_run_mac_out_10");
#endif
}
if (decode_PE0_CORE_RUN_MAC_CHILD_PE0_core_run_mac_out_11()) {
update_PE0_CORE_RUN_MAC_CHILD_PE0_core_run_mac_out_11();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE0_core_run_mac_out_11");
#endif
}
if (decode_PE0_CORE_RUN_MAC_CHILD_PE0_core_run_mac_out_12()) {
update_PE0_CORE_RUN_MAC_CHILD_PE0_core_run_mac_out_12();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE0_core_run_mac_out_12");
#endif
}
if (decode_PE0_CORE_RUN_MAC_CHILD_PE0_core_run_mac_out_13()) {
update_PE0_CORE_RUN_MAC_CHILD_PE0_core_run_mac_out_13();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE0_core_run_mac_out_13");
#endif
}
if (decode_PE0_CORE_RUN_MAC_CHILD_PE0_core_run_mac_out_14()) {
update_PE0_CORE_RUN_MAC_CHILD_PE0_core_run_mac_out_14();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE0_core_run_mac_out_14");
#endif
}
if (decode_PE0_CORE_RUN_MAC_CHILD_PE0_core_run_mac_out_15()) {
update_PE0_CORE_RUN_MAC_CHILD_PE0_core_run_mac_out_15();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE0_core_run_mac_out_15");
#endif
}
if (decode_PE0_CORE_CHILD_PE0_core_read_gb()) {
update_PE0_CORE_CHILD_PE0_core_read_gb();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE0_core_read_gb");
#endif
}
if (decode_PE0_CORE_CHILD_PE0_core_is_start()) {
update_PE0_CORE_CHILD_PE0_core_is_start();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE0_core_is_start");
#endif
}
if (decode_PE0_CORE_CHILD_PE0_core_prep()) {
update_PE0_CORE_CHILD_PE0_core_prep();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE0_core_prep");
#endif
}
if (decode_PE0_CORE_CHILD_PE0_core_mac()) {
update_PE0_CORE_CHILD_PE0_core_mac();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE0_core_mac");
#endif
}
if (decode_PE0_CORE_CHILD_PE0_core_bias()) {
update_PE0_CORE_CHILD_PE0_core_bias();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE0_core_bias");
#endif
}
if (decode_PE0_CORE_CHILD_PE0_core_out()) {
update_PE0_CORE_CHILD_PE0_core_out();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE0_core_out");
#endif
}
if (decode_PE1_CORE_RUN_MAC_CHILD_PE1_core_run_mac_data_nc()) {
update_PE1_CORE_RUN_MAC_CHILD_PE1_core_run_mac_data_nc();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE1_core_run_mac_data_nc");
#endif
}
if (decode_PE1_CORE_RUN_MAC_CHILD_PE1_core_run_mac_data_c()) {
update_PE1_CORE_RUN_MAC_CHILD_PE1_core_run_mac_data_c();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE1_core_run_mac_data_c");
#endif
}
if (decode_PE1_CORE_RUN_MAC_CHILD_PE1_core_run_mac_mul()) {
update_PE1_CORE_RUN_MAC_CHILD_PE1_core_run_mac_mul();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE1_core_run_mac_mul");
#endif
}
if (decode_PE1_CORE_RUN_MAC_CHILD_PE1_core_run_mac_out_0()) {
update_PE1_CORE_RUN_MAC_CHILD_PE1_core_run_mac_out_0();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE1_core_run_mac_out_0");
#endif
}
if (decode_PE1_CORE_RUN_MAC_CHILD_PE1_core_run_mac_out_1()) {
update_PE1_CORE_RUN_MAC_CHILD_PE1_core_run_mac_out_1();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE1_core_run_mac_out_1");
#endif
}
if (decode_PE1_CORE_RUN_MAC_CHILD_PE1_core_run_mac_out_2()) {
update_PE1_CORE_RUN_MAC_CHILD_PE1_core_run_mac_out_2();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE1_core_run_mac_out_2");
#endif
}
if (decode_PE1_CORE_RUN_MAC_CHILD_PE1_core_run_mac_out_3()) {
update_PE1_CORE_RUN_MAC_CHILD_PE1_core_run_mac_out_3();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE1_core_run_mac_out_3");
#endif
}
if (decode_PE1_CORE_RUN_MAC_CHILD_PE1_core_run_mac_out_4()) {
update_PE1_CORE_RUN_MAC_CHILD_PE1_core_run_mac_out_4();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE1_core_run_mac_out_4");
#endif
}
if (decode_PE1_CORE_RUN_MAC_CHILD_PE1_core_run_mac_out_5()) {
update_PE1_CORE_RUN_MAC_CHILD_PE1_core_run_mac_out_5();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE1_core_run_mac_out_5");
#endif
}
if (decode_PE1_CORE_RUN_MAC_CHILD_PE1_core_run_mac_out_6()) {
update_PE1_CORE_RUN_MAC_CHILD_PE1_core_run_mac_out_6();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE1_core_run_mac_out_6");
#endif
}
if (decode_PE1_CORE_RUN_MAC_CHILD_PE1_core_run_mac_out_7()) {
update_PE1_CORE_RUN_MAC_CHILD_PE1_core_run_mac_out_7();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE1_core_run_mac_out_7");
#endif
}
if (decode_PE1_CORE_RUN_MAC_CHILD_PE1_core_run_mac_out_8()) {
update_PE1_CORE_RUN_MAC_CHILD_PE1_core_run_mac_out_8();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE1_core_run_mac_out_8");
#endif
}
if (decode_PE1_CORE_RUN_MAC_CHILD_PE1_core_run_mac_out_9()) {
update_PE1_CORE_RUN_MAC_CHILD_PE1_core_run_mac_out_9();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE1_core_run_mac_out_9");
#endif
}
if (decode_PE1_CORE_RUN_MAC_CHILD_PE1_core_run_mac_out_10()) {
update_PE1_CORE_RUN_MAC_CHILD_PE1_core_run_mac_out_10();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE1_core_run_mac_out_10");
#endif
}
if (decode_PE1_CORE_RUN_MAC_CHILD_PE1_core_run_mac_out_11()) {
update_PE1_CORE_RUN_MAC_CHILD_PE1_core_run_mac_out_11();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE1_core_run_mac_out_11");
#endif
}
if (decode_PE1_CORE_RUN_MAC_CHILD_PE1_core_run_mac_out_12()) {
update_PE1_CORE_RUN_MAC_CHILD_PE1_core_run_mac_out_12();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE1_core_run_mac_out_12");
#endif
}
if (decode_PE1_CORE_RUN_MAC_CHILD_PE1_core_run_mac_out_13()) {
update_PE1_CORE_RUN_MAC_CHILD_PE1_core_run_mac_out_13();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE1_core_run_mac_out_13");
#endif
}
if (decode_PE1_CORE_RUN_MAC_CHILD_PE1_core_run_mac_out_14()) {
update_PE1_CORE_RUN_MAC_CHILD_PE1_core_run_mac_out_14();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE1_core_run_mac_out_14");
#endif
}
if (decode_PE1_CORE_RUN_MAC_CHILD_PE1_core_run_mac_out_15()) {
update_PE1_CORE_RUN_MAC_CHILD_PE1_core_run_mac_out_15();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE1_core_run_mac_out_15");
#endif
}
if (decode_PE1_CORE_CHILD_PE1_core_read_gb()) {
update_PE1_CORE_CHILD_PE1_core_read_gb();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE1_core_read_gb");
#endif
}
if (decode_PE1_CORE_CHILD_PE1_core_is_start()) {
update_PE1_CORE_CHILD_PE1_core_is_start();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE1_core_is_start");
#endif
}
if (decode_PE1_CORE_CHILD_PE1_core_prep()) {
update_PE1_CORE_CHILD_PE1_core_prep();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE1_core_prep");
#endif
}
if (decode_PE1_CORE_CHILD_PE1_core_mac()) {
update_PE1_CORE_CHILD_PE1_core_mac();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE1_core_mac");
#endif
}
if (decode_PE1_CORE_CHILD_PE1_core_bias()) {
update_PE1_CORE_CHILD_PE1_core_bias();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE1_core_bias");
#endif
}
if (decode_PE1_CORE_CHILD_PE1_core_out()) {
update_PE1_CORE_CHILD_PE1_core_out();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE1_core_out");
#endif
}
if (decode_PE2_CORE_RUN_MAC_CHILD_PE2_core_run_mac_data_nc()) {
update_PE2_CORE_RUN_MAC_CHILD_PE2_core_run_mac_data_nc();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE2_core_run_mac_data_nc");
#endif
}
if (decode_PE2_CORE_RUN_MAC_CHILD_PE2_core_run_mac_data_c()) {
update_PE2_CORE_RUN_MAC_CHILD_PE2_core_run_mac_data_c();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE2_core_run_mac_data_c");
#endif
}
if (decode_PE2_CORE_RUN_MAC_CHILD_PE2_core_run_mac_mul()) {
update_PE2_CORE_RUN_MAC_CHILD_PE2_core_run_mac_mul();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE2_core_run_mac_mul");
#endif
}
if (decode_PE2_CORE_RUN_MAC_CHILD_PE2_core_run_mac_out_0()) {
update_PE2_CORE_RUN_MAC_CHILD_PE2_core_run_mac_out_0();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE2_core_run_mac_out_0");
#endif
}
if (decode_PE2_CORE_RUN_MAC_CHILD_PE2_core_run_mac_out_1()) {
update_PE2_CORE_RUN_MAC_CHILD_PE2_core_run_mac_out_1();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE2_core_run_mac_out_1");
#endif
}
if (decode_PE2_CORE_RUN_MAC_CHILD_PE2_core_run_mac_out_2()) {
update_PE2_CORE_RUN_MAC_CHILD_PE2_core_run_mac_out_2();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE2_core_run_mac_out_2");
#endif
}
if (decode_PE2_CORE_RUN_MAC_CHILD_PE2_core_run_mac_out_3()) {
update_PE2_CORE_RUN_MAC_CHILD_PE2_core_run_mac_out_3();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE2_core_run_mac_out_3");
#endif
}
if (decode_PE2_CORE_RUN_MAC_CHILD_PE2_core_run_mac_out_4()) {
update_PE2_CORE_RUN_MAC_CHILD_PE2_core_run_mac_out_4();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE2_core_run_mac_out_4");
#endif
}
if (decode_PE2_CORE_RUN_MAC_CHILD_PE2_core_run_mac_out_5()) {
update_PE2_CORE_RUN_MAC_CHILD_PE2_core_run_mac_out_5();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE2_core_run_mac_out_5");
#endif
}
if (decode_PE2_CORE_RUN_MAC_CHILD_PE2_core_run_mac_out_6()) {
update_PE2_CORE_RUN_MAC_CHILD_PE2_core_run_mac_out_6();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE2_core_run_mac_out_6");
#endif
}
if (decode_PE2_CORE_RUN_MAC_CHILD_PE2_core_run_mac_out_7()) {
update_PE2_CORE_RUN_MAC_CHILD_PE2_core_run_mac_out_7();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE2_core_run_mac_out_7");
#endif
}
if (decode_PE2_CORE_RUN_MAC_CHILD_PE2_core_run_mac_out_8()) {
update_PE2_CORE_RUN_MAC_CHILD_PE2_core_run_mac_out_8();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE2_core_run_mac_out_8");
#endif
}
if (decode_PE2_CORE_RUN_MAC_CHILD_PE2_core_run_mac_out_9()) {
update_PE2_CORE_RUN_MAC_CHILD_PE2_core_run_mac_out_9();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE2_core_run_mac_out_9");
#endif
}
if (decode_PE2_CORE_RUN_MAC_CHILD_PE2_core_run_mac_out_10()) {
update_PE2_CORE_RUN_MAC_CHILD_PE2_core_run_mac_out_10();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE2_core_run_mac_out_10");
#endif
}
if (decode_PE2_CORE_RUN_MAC_CHILD_PE2_core_run_mac_out_11()) {
update_PE2_CORE_RUN_MAC_CHILD_PE2_core_run_mac_out_11();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE2_core_run_mac_out_11");
#endif
}
if (decode_PE2_CORE_RUN_MAC_CHILD_PE2_core_run_mac_out_12()) {
update_PE2_CORE_RUN_MAC_CHILD_PE2_core_run_mac_out_12();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE2_core_run_mac_out_12");
#endif
}
if (decode_PE2_CORE_RUN_MAC_CHILD_PE2_core_run_mac_out_13()) {
update_PE2_CORE_RUN_MAC_CHILD_PE2_core_run_mac_out_13();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE2_core_run_mac_out_13");
#endif
}
if (decode_PE2_CORE_RUN_MAC_CHILD_PE2_core_run_mac_out_14()) {
update_PE2_CORE_RUN_MAC_CHILD_PE2_core_run_mac_out_14();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE2_core_run_mac_out_14");
#endif
}
if (decode_PE2_CORE_RUN_MAC_CHILD_PE2_core_run_mac_out_15()) {
update_PE2_CORE_RUN_MAC_CHILD_PE2_core_run_mac_out_15();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE2_core_run_mac_out_15");
#endif
}
if (decode_PE2_CORE_CHILD_PE2_core_read_gb()) {
update_PE2_CORE_CHILD_PE2_core_read_gb();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE2_core_read_gb");
#endif
}
if (decode_PE2_CORE_CHILD_PE2_core_is_start()) {
update_PE2_CORE_CHILD_PE2_core_is_start();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE2_core_is_start");
#endif
}
if (decode_PE2_CORE_CHILD_PE2_core_prep()) {
update_PE2_CORE_CHILD_PE2_core_prep();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE2_core_prep");
#endif
}
if (decode_PE2_CORE_CHILD_PE2_core_mac()) {
update_PE2_CORE_CHILD_PE2_core_mac();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE2_core_mac");
#endif
}
if (decode_PE2_CORE_CHILD_PE2_core_bias()) {
update_PE2_CORE_CHILD_PE2_core_bias();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE2_core_bias");
#endif
}
if (decode_PE2_CORE_CHILD_PE2_core_out()) {
update_PE2_CORE_CHILD_PE2_core_out();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE2_core_out");
#endif
}
if (decode_PE3_CORE_RUN_MAC_CHILD_PE3_core_run_mac_data_nc()) {
update_PE3_CORE_RUN_MAC_CHILD_PE3_core_run_mac_data_nc();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE3_core_run_mac_data_nc");
#endif
}
if (decode_PE3_CORE_RUN_MAC_CHILD_PE3_core_run_mac_data_c()) {
update_PE3_CORE_RUN_MAC_CHILD_PE3_core_run_mac_data_c();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE3_core_run_mac_data_c");
#endif
}
if (decode_PE3_CORE_RUN_MAC_CHILD_PE3_core_run_mac_mul()) {
update_PE3_CORE_RUN_MAC_CHILD_PE3_core_run_mac_mul();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE3_core_run_mac_mul");
#endif
}
if (decode_PE3_CORE_RUN_MAC_CHILD_PE3_core_run_mac_out_0()) {
update_PE3_CORE_RUN_MAC_CHILD_PE3_core_run_mac_out_0();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE3_core_run_mac_out_0");
#endif
}
if (decode_PE3_CORE_RUN_MAC_CHILD_PE3_core_run_mac_out_1()) {
update_PE3_CORE_RUN_MAC_CHILD_PE3_core_run_mac_out_1();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE3_core_run_mac_out_1");
#endif
}
if (decode_PE3_CORE_RUN_MAC_CHILD_PE3_core_run_mac_out_2()) {
update_PE3_CORE_RUN_MAC_CHILD_PE3_core_run_mac_out_2();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE3_core_run_mac_out_2");
#endif
}
if (decode_PE3_CORE_RUN_MAC_CHILD_PE3_core_run_mac_out_3()) {
update_PE3_CORE_RUN_MAC_CHILD_PE3_core_run_mac_out_3();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE3_core_run_mac_out_3");
#endif
}
if (decode_PE3_CORE_RUN_MAC_CHILD_PE3_core_run_mac_out_4()) {
update_PE3_CORE_RUN_MAC_CHILD_PE3_core_run_mac_out_4();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE3_core_run_mac_out_4");
#endif
}
if (decode_PE3_CORE_RUN_MAC_CHILD_PE3_core_run_mac_out_5()) {
update_PE3_CORE_RUN_MAC_CHILD_PE3_core_run_mac_out_5();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE3_core_run_mac_out_5");
#endif
}
if (decode_PE3_CORE_RUN_MAC_CHILD_PE3_core_run_mac_out_6()) {
update_PE3_CORE_RUN_MAC_CHILD_PE3_core_run_mac_out_6();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE3_core_run_mac_out_6");
#endif
}
if (decode_PE3_CORE_RUN_MAC_CHILD_PE3_core_run_mac_out_7()) {
update_PE3_CORE_RUN_MAC_CHILD_PE3_core_run_mac_out_7();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE3_core_run_mac_out_7");
#endif
}
if (decode_PE3_CORE_RUN_MAC_CHILD_PE3_core_run_mac_out_8()) {
update_PE3_CORE_RUN_MAC_CHILD_PE3_core_run_mac_out_8();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE3_core_run_mac_out_8");
#endif
}
if (decode_PE3_CORE_RUN_MAC_CHILD_PE3_core_run_mac_out_9()) {
update_PE3_CORE_RUN_MAC_CHILD_PE3_core_run_mac_out_9();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE3_core_run_mac_out_9");
#endif
}
if (decode_PE3_CORE_RUN_MAC_CHILD_PE3_core_run_mac_out_10()) {
update_PE3_CORE_RUN_MAC_CHILD_PE3_core_run_mac_out_10();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE3_core_run_mac_out_10");
#endif
}
if (decode_PE3_CORE_RUN_MAC_CHILD_PE3_core_run_mac_out_11()) {
update_PE3_CORE_RUN_MAC_CHILD_PE3_core_run_mac_out_11();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE3_core_run_mac_out_11");
#endif
}
if (decode_PE3_CORE_RUN_MAC_CHILD_PE3_core_run_mac_out_12()) {
update_PE3_CORE_RUN_MAC_CHILD_PE3_core_run_mac_out_12();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE3_core_run_mac_out_12");
#endif
}
if (decode_PE3_CORE_RUN_MAC_CHILD_PE3_core_run_mac_out_13()) {
update_PE3_CORE_RUN_MAC_CHILD_PE3_core_run_mac_out_13();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE3_core_run_mac_out_13");
#endif
}
if (decode_PE3_CORE_RUN_MAC_CHILD_PE3_core_run_mac_out_14()) {
update_PE3_CORE_RUN_MAC_CHILD_PE3_core_run_mac_out_14();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE3_core_run_mac_out_14");
#endif
}
if (decode_PE3_CORE_RUN_MAC_CHILD_PE3_core_run_mac_out_15()) {
update_PE3_CORE_RUN_MAC_CHILD_PE3_core_run_mac_out_15();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE3_core_run_mac_out_15");
#endif
}
if (decode_PE3_CORE_CHILD_PE3_core_read_gb()) {
update_PE3_CORE_CHILD_PE3_core_read_gb();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE3_core_read_gb");
#endif
}
if (decode_PE3_CORE_CHILD_PE3_core_is_start()) {
update_PE3_CORE_CHILD_PE3_core_is_start();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE3_core_is_start");
#endif
}
if (decode_PE3_CORE_CHILD_PE3_core_prep()) {
update_PE3_CORE_CHILD_PE3_core_prep();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE3_core_prep");
#endif
}
if (decode_PE3_CORE_CHILD_PE3_core_mac()) {
update_PE3_CORE_CHILD_PE3_core_mac();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE3_core_mac");
#endif
}
if (decode_PE3_CORE_CHILD_PE3_core_bias()) {
update_PE3_CORE_CHILD_PE3_core_bias();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE3_core_bias");
#endif
}
if (decode_PE3_CORE_CHILD_PE3_core_out()) {
update_PE3_CORE_CHILD_PE3_core_out();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE3_core_out");
#endif
}
if (decode_PE0_ACT_CHILD_PE0_act_child_initiate()) {
update_PE0_ACT_CHILD_PE0_act_child_initiate();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE0_act_child_initiate");
#endif
}
if (decode_PE0_ACT_CHILD_PE0_act_child_fetch()) {
update_PE0_ACT_CHILD_PE0_act_child_fetch();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE0_act_child_fetch");
#endif
}
if (decode_PE0_ACT_CHILD_PE0_act_child_do_incr()) {
update_PE0_ACT_CHILD_PE0_act_child_do_incr();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE0_act_child_do_incr");
#endif
}
if (decode_PE0_ACT_CHILD_PE0_act_child_send_done()) {
update_PE0_ACT_CHILD_PE0_act_child_send_done();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE0_act_child_send_done");
#endif
}
if (decode_PE0_ACT_CHILD_PE0_act_child_op_load_zero()) {
update_PE0_ACT_CHILD_PE0_act_child_op_load_zero();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE0_act_child_op_load_zero");
#endif
}
if (decode_PE0_ACT_CHILD_PE0_act_child_op_load()) {
update_PE0_ACT_CHILD_PE0_act_child_op_load();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE0_act_child_op_load");
#endif
}
if (decode_PE0_ACT_CHILD_PE0_act_child_op_store()) {
update_PE0_ACT_CHILD_PE0_act_child_op_store();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE0_act_child_op_store");
#endif
}
if (decode_PE0_ACT_CHILD_PE0_act_child_op_inpe()) {
update_PE0_ACT_CHILD_PE0_act_child_op_inpe();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE0_act_child_op_inpe");
#endif
}
if (decode_PE0_ACT_CHILD_PE0_act_child_op_outgb()) {
update_PE0_ACT_CHILD_PE0_act_child_op_outgb();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE0_act_child_op_outgb");
#endif
}
if (decode_PE0_ACT_CHILD_PE0_act_child_op_copy()) {
update_PE0_ACT_CHILD_PE0_act_child_op_copy();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE0_act_child_op_copy");
#endif
}
if (decode_PE0_ACT_CHILD_PE0_act_child_op_eadd()) {
update_PE0_ACT_CHILD_PE0_act_child_op_eadd();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE0_act_child_op_eadd");
#endif
}
if (decode_PE0_ACT_CHILD_PE0_act_child_op_emul()) {
update_PE0_ACT_CHILD_PE0_act_child_op_emul();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE0_act_child_op_emul");
#endif
}
if (decode_PE0_ACT_CHILD_PE0_act_child_op_sigm()) {
update_PE0_ACT_CHILD_PE0_act_child_op_sigm();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE0_act_child_op_sigm");
#endif
}
if (decode_PE0_ACT_CHILD_PE0_act_child_op_tanh()) {
update_PE0_ACT_CHILD_PE0_act_child_op_tanh();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE0_act_child_op_tanh");
#endif
}
if (decode_PE0_ACT_CHILD_PE0_act_child_op_relu()) {
update_PE0_ACT_CHILD_PE0_act_child_op_relu();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE0_act_child_op_relu");
#endif
}
if (decode_PE0_ACT_CHILD_PE0_act_child_op_onex()) {
update_PE0_ACT_CHILD_PE0_act_child_op_onex();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE0_act_child_op_onex");
#endif
}
if (decode_PE0_ACT_CHILD_PE0_act_child_reg_store()) {
update_PE0_ACT_CHILD_PE0_act_child_reg_store();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE0_act_child_reg_store");
#endif
}
if (decode_PE1_ACT_CHILD_PE1_act_child_initiate()) {
update_PE1_ACT_CHILD_PE1_act_child_initiate();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE1_act_child_initiate");
#endif
}
if (decode_PE1_ACT_CHILD_PE1_act_child_fetch()) {
update_PE1_ACT_CHILD_PE1_act_child_fetch();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE1_act_child_fetch");
#endif
}
if (decode_PE1_ACT_CHILD_PE1_act_child_do_incr()) {
update_PE1_ACT_CHILD_PE1_act_child_do_incr();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE1_act_child_do_incr");
#endif
}
if (decode_PE1_ACT_CHILD_PE1_act_child_send_done()) {
update_PE1_ACT_CHILD_PE1_act_child_send_done();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE1_act_child_send_done");
#endif
}
if (decode_PE1_ACT_CHILD_PE1_act_child_op_load_zero()) {
update_PE1_ACT_CHILD_PE1_act_child_op_load_zero();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE1_act_child_op_load_zero");
#endif
}
if (decode_PE1_ACT_CHILD_PE1_act_child_op_load()) {
update_PE1_ACT_CHILD_PE1_act_child_op_load();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE1_act_child_op_load");
#endif
}
if (decode_PE1_ACT_CHILD_PE1_act_child_op_store()) {
update_PE1_ACT_CHILD_PE1_act_child_op_store();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE1_act_child_op_store");
#endif
}
if (decode_PE1_ACT_CHILD_PE1_act_child_op_inpe()) {
update_PE1_ACT_CHILD_PE1_act_child_op_inpe();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE1_act_child_op_inpe");
#endif
}
if (decode_PE1_ACT_CHILD_PE1_act_child_op_outgb()) {
update_PE1_ACT_CHILD_PE1_act_child_op_outgb();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE1_act_child_op_outgb");
#endif
}
if (decode_PE1_ACT_CHILD_PE1_act_child_op_copy()) {
update_PE1_ACT_CHILD_PE1_act_child_op_copy();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE1_act_child_op_copy");
#endif
}
if (decode_PE1_ACT_CHILD_PE1_act_child_op_eadd()) {
update_PE1_ACT_CHILD_PE1_act_child_op_eadd();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE1_act_child_op_eadd");
#endif
}
if (decode_PE1_ACT_CHILD_PE1_act_child_op_emul()) {
update_PE1_ACT_CHILD_PE1_act_child_op_emul();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE1_act_child_op_emul");
#endif
}
if (decode_PE1_ACT_CHILD_PE1_act_child_op_sigm()) {
update_PE1_ACT_CHILD_PE1_act_child_op_sigm();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE1_act_child_op_sigm");
#endif
}
if (decode_PE1_ACT_CHILD_PE1_act_child_op_tanh()) {
update_PE1_ACT_CHILD_PE1_act_child_op_tanh();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE1_act_child_op_tanh");
#endif
}
if (decode_PE1_ACT_CHILD_PE1_act_child_op_relu()) {
update_PE1_ACT_CHILD_PE1_act_child_op_relu();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE1_act_child_op_relu");
#endif
}
if (decode_PE1_ACT_CHILD_PE1_act_child_op_onex()) {
update_PE1_ACT_CHILD_PE1_act_child_op_onex();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE1_act_child_op_onex");
#endif
}
if (decode_PE1_ACT_CHILD_PE1_act_child_reg_store()) {
update_PE1_ACT_CHILD_PE1_act_child_reg_store();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE1_act_child_reg_store");
#endif
}
if (decode_PE2_ACT_CHILD_PE2_act_child_initiate()) {
update_PE2_ACT_CHILD_PE2_act_child_initiate();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE2_act_child_initiate");
#endif
}
if (decode_PE2_ACT_CHILD_PE2_act_child_fetch()) {
update_PE2_ACT_CHILD_PE2_act_child_fetch();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE2_act_child_fetch");
#endif
}
if (decode_PE2_ACT_CHILD_PE2_act_child_do_incr()) {
update_PE2_ACT_CHILD_PE2_act_child_do_incr();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE2_act_child_do_incr");
#endif
}
if (decode_PE2_ACT_CHILD_PE2_act_child_send_done()) {
update_PE2_ACT_CHILD_PE2_act_child_send_done();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE2_act_child_send_done");
#endif
}
if (decode_PE2_ACT_CHILD_PE2_act_child_op_load_zero()) {
update_PE2_ACT_CHILD_PE2_act_child_op_load_zero();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE2_act_child_op_load_zero");
#endif
}
if (decode_PE2_ACT_CHILD_PE2_act_child_op_load()) {
update_PE2_ACT_CHILD_PE2_act_child_op_load();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE2_act_child_op_load");
#endif
}
if (decode_PE2_ACT_CHILD_PE2_act_child_op_store()) {
update_PE2_ACT_CHILD_PE2_act_child_op_store();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE2_act_child_op_store");
#endif
}
if (decode_PE2_ACT_CHILD_PE2_act_child_op_inpe()) {
update_PE2_ACT_CHILD_PE2_act_child_op_inpe();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE2_act_child_op_inpe");
#endif
}
if (decode_PE2_ACT_CHILD_PE2_act_child_op_outgb()) {
update_PE2_ACT_CHILD_PE2_act_child_op_outgb();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE2_act_child_op_outgb");
#endif
}
if (decode_PE2_ACT_CHILD_PE2_act_child_op_copy()) {
update_PE2_ACT_CHILD_PE2_act_child_op_copy();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE2_act_child_op_copy");
#endif
}
if (decode_PE2_ACT_CHILD_PE2_act_child_op_eadd()) {
update_PE2_ACT_CHILD_PE2_act_child_op_eadd();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE2_act_child_op_eadd");
#endif
}
if (decode_PE2_ACT_CHILD_PE2_act_child_op_emul()) {
update_PE2_ACT_CHILD_PE2_act_child_op_emul();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE2_act_child_op_emul");
#endif
}
if (decode_PE2_ACT_CHILD_PE2_act_child_op_sigm()) {
update_PE2_ACT_CHILD_PE2_act_child_op_sigm();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE2_act_child_op_sigm");
#endif
}
if (decode_PE2_ACT_CHILD_PE2_act_child_op_tanh()) {
update_PE2_ACT_CHILD_PE2_act_child_op_tanh();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE2_act_child_op_tanh");
#endif
}
if (decode_PE2_ACT_CHILD_PE2_act_child_op_relu()) {
update_PE2_ACT_CHILD_PE2_act_child_op_relu();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE2_act_child_op_relu");
#endif
}
if (decode_PE2_ACT_CHILD_PE2_act_child_op_onex()) {
update_PE2_ACT_CHILD_PE2_act_child_op_onex();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE2_act_child_op_onex");
#endif
}
if (decode_PE2_ACT_CHILD_PE2_act_child_reg_store()) {
update_PE2_ACT_CHILD_PE2_act_child_reg_store();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE2_act_child_reg_store");
#endif
}
if (decode_PE3_ACT_CHILD_PE3_act_child_initiate()) {
update_PE3_ACT_CHILD_PE3_act_child_initiate();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE3_act_child_initiate");
#endif
}
if (decode_PE3_ACT_CHILD_PE3_act_child_fetch()) {
update_PE3_ACT_CHILD_PE3_act_child_fetch();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE3_act_child_fetch");
#endif
}
if (decode_PE3_ACT_CHILD_PE3_act_child_do_incr()) {
update_PE3_ACT_CHILD_PE3_act_child_do_incr();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE3_act_child_do_incr");
#endif
}
if (decode_PE3_ACT_CHILD_PE3_act_child_send_done()) {
update_PE3_ACT_CHILD_PE3_act_child_send_done();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE3_act_child_send_done");
#endif
}
if (decode_PE3_ACT_CHILD_PE3_act_child_op_load_zero()) {
update_PE3_ACT_CHILD_PE3_act_child_op_load_zero();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE3_act_child_op_load_zero");
#endif
}
if (decode_PE3_ACT_CHILD_PE3_act_child_op_load()) {
update_PE3_ACT_CHILD_PE3_act_child_op_load();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE3_act_child_op_load");
#endif
}
if (decode_PE3_ACT_CHILD_PE3_act_child_op_store()) {
update_PE3_ACT_CHILD_PE3_act_child_op_store();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE3_act_child_op_store");
#endif
}
if (decode_PE3_ACT_CHILD_PE3_act_child_op_inpe()) {
update_PE3_ACT_CHILD_PE3_act_child_op_inpe();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE3_act_child_op_inpe");
#endif
}
if (decode_PE3_ACT_CHILD_PE3_act_child_op_outgb()) {
update_PE3_ACT_CHILD_PE3_act_child_op_outgb();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE3_act_child_op_outgb");
#endif
}
if (decode_PE3_ACT_CHILD_PE3_act_child_op_copy()) {
update_PE3_ACT_CHILD_PE3_act_child_op_copy();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE3_act_child_op_copy");
#endif
}
if (decode_PE3_ACT_CHILD_PE3_act_child_op_eadd()) {
update_PE3_ACT_CHILD_PE3_act_child_op_eadd();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE3_act_child_op_eadd");
#endif
}
if (decode_PE3_ACT_CHILD_PE3_act_child_op_emul()) {
update_PE3_ACT_CHILD_PE3_act_child_op_emul();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE3_act_child_op_emul");
#endif
}
if (decode_PE3_ACT_CHILD_PE3_act_child_op_sigm()) {
update_PE3_ACT_CHILD_PE3_act_child_op_sigm();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE3_act_child_op_sigm");
#endif
}
if (decode_PE3_ACT_CHILD_PE3_act_child_op_tanh()) {
update_PE3_ACT_CHILD_PE3_act_child_op_tanh();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE3_act_child_op_tanh");
#endif
}
if (decode_PE3_ACT_CHILD_PE3_act_child_op_relu()) {
update_PE3_ACT_CHILD_PE3_act_child_op_relu();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE3_act_child_op_relu");
#endif
}
if (decode_PE3_ACT_CHILD_PE3_act_child_op_onex()) {
update_PE3_ACT_CHILD_PE3_act_child_op_onex();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE3_act_child_op_onex");
#endif
}
if (decode_PE3_ACT_CHILD_PE3_act_child_reg_store()) {
update_PE3_ACT_CHILD_PE3_act_child_reg_store();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("PE3_act_child_reg_store");
#endif
}
if (decode_GB_ATTENTION_CHILD_gb_attention_child_idle()) {
update_GB_ATTENTION_CHILD_gb_attention_child_idle();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_attention_child_idle");
#endif
}
if (decode_GB_ATTENTION_CHILD_gb_attention_child_prep()) {
update_GB_ATTENTION_CHILD_gb_attention_child_prep();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_attention_child_prep");
#endif
}
if (decode_GB_ATTENTION_CHILD_gb_attention_child_bmm_rd()) {
update_GB_ATTENTION_CHILD_gb_attention_child_bmm_rd();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_attention_child_bmm_rd");
#endif
}
if (decode_GB_ATTENTION_CHILD_gb_attention_child_bmm_tp()) {
update_GB_ATTENTION_CHILD_gb_attention_child_bmm_tp();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_attention_child_bmm_tp");
#endif
}
if (decode_GB_ATTENTION_CHILD_gb_attention_child_bmm_mv()) {
update_GB_ATTENTION_CHILD_gb_attention_child_bmm_mv();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_attention_child_bmm_mv");
#endif
}
if (decode_GB_ATTENTION_CHILD_gb_attention_child_bmm_next()) {
update_GB_ATTENTION_CHILD_gb_attention_child_bmm_next();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_attention_child_bmm_next");
#endif
}
if (decode_GB_ATTENTION_CHILD_gb_attention_child_next_shift()) {
update_GB_ATTENTION_CHILD_gb_attention_child_next_shift();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_attention_child_next_shift");
#endif
}
if (decode_GB_ATTENTION_CHILD_gb_attention_child_next_max()) {
update_GB_ATTENTION_CHILD_gb_attention_child_next_max();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_attention_child_next_max");
#endif
}
if (decode_GB_ATTENTION_CHILD_gb_attention_child_next_wr()) {
update_GB_ATTENTION_CHILD_gb_attention_child_next_wr();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_attention_child_next_wr");
#endif
}
if (decode_GB_ATTENTION_CHILD_gb_attention_child_sfm1_rd()) {
update_GB_ATTENTION_CHILD_gb_attention_child_sfm1_rd();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_attention_child_sfm1_rd");
#endif
}
if (decode_GB_ATTENTION_CHILD_gb_attention_child_sfm1_comp()) {
update_GB_ATTENTION_CHILD_gb_attention_child_sfm1_comp();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_attention_child_sfm1_comp");
#endif
}
if (decode_GB_ATTENTION_CHILD_gb_attention_sfm2_rd()) {
update_GB_ATTENTION_CHILD_gb_attention_sfm2_rd();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_attention_sfm2_rd");
#endif
}
if (decode_GB_ATTENTION_CHILD_gb_attention_sfm2_comp0()) {
update_GB_ATTENTION_CHILD_gb_attention_sfm2_comp0();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_attention_sfm2_comp0");
#endif
}
if (decode_GB_ATTENTION_CHILD_gb_attention_sfm2_comp1()) {
update_GB_ATTENTION_CHILD_gb_attention_sfm2_comp1();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_attention_sfm2_comp1");
#endif
}
if (decode_GB_ATTENTION_CHILD_gb_attention_sfm2_comp2()) {
update_GB_ATTENTION_CHILD_gb_attention_sfm2_comp2();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_attention_sfm2_comp2");
#endif
}
if (decode_GB_ATTENTION_CHILD_gb_attention_sfm2_comp3()) {
update_GB_ATTENTION_CHILD_gb_attention_sfm2_comp3();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_attention_sfm2_comp3");
#endif
}
if (decode_GB_ATTENTION_CHILD_gb_attention_sfm3()) {
update_GB_ATTENTION_CHILD_gb_attention_sfm3();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_attention_sfm3");
#endif
}
if (decode_GB_ATTENTION_CHILD_gb_attention_child_out1()) {
update_GB_ATTENTION_CHILD_gb_attention_child_out1();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_attention_child_out1");
#endif
}
if (decode_GB_ATTENTION_CHILD_gb_attention_child_out2()) {
update_GB_ATTENTION_CHILD_gb_attention_child_out2();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_attention_child_out2");
#endif
}
if (decode_GB_ATTENTION_CHILD_gb_attention_child_fin()) {
update_GB_ATTENTION_CHILD_gb_attention_child_fin();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_attention_child_fin");
#endif
}
if (decode_Child_GB_Control_gb_control_child_prep()) {
update_Child_GB_Control_gb_control_child_prep();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_control_child_prep");
#endif
}
if (decode_Child_GB_Control_gb_control_child_send_prep()) {
update_Child_GB_Control_gb_control_child_send_prep();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_control_child_send_prep");
#endif
}
if (decode_Child_GB_Control_gb_control_child_send()) {
update_Child_GB_Control_gb_control_child_send();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_control_child_send");
#endif
}
if (decode_Child_GB_Control_gb_control_child_pe_start()) {
update_Child_GB_Control_gb_control_child_pe_start();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_control_child_pe_start");
#endif
}
if (decode_Child_GB_Control_gb_control_child_recv()) {
update_Child_GB_Control_gb_control_child_recv();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_control_child_recv");
#endif
}
if (decode_Child_GB_Control_gb_control_child_recv_next()) {
update_Child_GB_Control_gb_control_child_recv_next();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_control_child_recv_next");
#endif
}
if (decode_Child_GB_Control_gb_control_child_send_back_prep()) {
update_Child_GB_Control_gb_control_child_send_back_prep();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_control_child_send_back_prep");
#endif
}
if (decode_Child_GB_Control_gb_control_child_send_back()) {
update_Child_GB_Control_gb_control_child_send_back();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_control_child_send_back");
#endif
}
if (decode_Child_GB_Control_gb_control_child_next()) {
update_Child_GB_Control_gb_control_child_next();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_control_child_next");
#endif
}
if (decode_Child_GBLayerNorm_gb_layer_norm_timestep_level_op()) {
update_Child_GBLayerNorm_gb_layer_norm_timestep_level_op();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_layer_norm_timestep_level_op");
#endif
}
if (decode_Child_GBLayerNorm_gb_layer_norm_sum_vector_level_prep()) {
update_Child_GBLayerNorm_gb_layer_norm_sum_vector_level_prep();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_layer_norm_sum_vector_level_prep");
#endif
}
if (decode_Child_GBLayerNorm_gb_layer_norm_sum_byte_op()) {
update_Child_GBLayerNorm_gb_layer_norm_sum_byte_op();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_layer_norm_sum_byte_op");
#endif
}
if (decode_Child_GBLayerNorm_gb_layer_norm_mean_op()) {
update_Child_GBLayerNorm_gb_layer_norm_mean_op();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_layer_norm_mean_op");
#endif
}
if (decode_Child_GBLayerNorm_gb_layer_norm_norm_vector_prep()) {
update_Child_GBLayerNorm_gb_layer_norm_norm_vector_prep();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_layer_norm_norm_vector_prep");
#endif
}
if (decode_Child_GBLayerNorm_gb_layer_norm_norm_byte_op()) {
update_Child_GBLayerNorm_gb_layer_norm_norm_byte_op();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_layer_norm_norm_byte_op");
#endif
}
if (decode_Child_GBLayerNorm_gb_layer_norm_child_next()) {
update_Child_GBLayerNorm_gb_layer_norm_child_next();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_layer_norm_child_next");
#endif
}
if (decode_GB_LAYER_REDUCE_gb_layer_reduce_prep()) {
update_GB_LAYER_REDUCE_gb_layer_reduce_prep();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_layer_reduce_prep");
#endif
}
if (decode_GB_LAYER_REDUCE_gb_layer_reduce_timestep_level_op()) {
update_GB_LAYER_REDUCE_gb_layer_reduce_timestep_level_op();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_layer_reduce_timestep_level_op");
#endif
}
if (decode_GB_LAYER_REDUCE_gb_layer_reduce_vector_level_op()) {
update_GB_LAYER_REDUCE_gb_layer_reduce_vector_level_op();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_layer_reduce_vector_level_op");
#endif
}
if (decode_GB_LAYER_REDUCE_gb_layer_reduce_byte_level_op()) {
update_GB_LAYER_REDUCE_gb_layer_reduce_byte_level_op();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_layer_reduce_byte_level_op");
#endif
}
if (decode_GB_LAYER_REDUCE_gb_layer_reduce_done()) {
update_GB_LAYER_REDUCE_gb_layer_reduce_done();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_layer_reduce_done");
#endif
}
if (decode_Child_GBZeroPadding_gb_zero_padding_child_prep()) {
update_Child_GBZeroPadding_gb_zero_padding_child_prep();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_zero_padding_child_prep");
#endif
}
if (decode_Child_GBZeroPadding_gb_zero_padding_child_timestep()) {
update_Child_GBZeroPadding_gb_zero_padding_child_timestep();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_zero_padding_child_timestep");
#endif
}
if (decode_Child_GBZeroPadding_gb_zero_padding_child_vector()) {
update_Child_GBZeroPadding_gb_zero_padding_child_vector();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_zero_padding_child_vector");
#endif
}
if (decode_Child_GBZeroPadding_gb_zero_padding_child_byte()) {
update_Child_GBZeroPadding_gb_zero_padding_child_byte();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_zero_padding_child_byte");
#endif
}
if (decode_Child_GBZeroPadding_gb_zero_padding_child_state_next()) {
update_Child_GBZeroPadding_gb_zero_padding_child_state_next();
schedule_counter++;
#ifdef ILATOR_VERBOSE
LogInstrSequence("gb_zero_padding_child_state_next");
#endif
}
if (schedule_counter == 0) {
break;
}
}
}
| [
"anonymizeddac2020submission@gmail.com"
] | anonymizeddac2020submission@gmail.com |
729db8b634a047dbfbf25dabf85360aa0f90751b | db2ab59ca17e04c7d3f03c559f22acccf346ab42 | /codeforces/eco.cpp | afc0e46d219d54da9ec750063b3455139ec29d27 | [] | no_license | ashsek/Competetive-Codes | 274821d8054b2278e1583bb1415d9ea2dc0a6828 | 9e700de53334b38f26dbad65235b83884c933ba2 | refs/heads/master | 2021-06-12T04:34:43.904710 | 2021-01-08T05:35:58 | 2021-01-08T05:35:58 | 115,346,203 | 0 | 0 | null | 2019-10-19T03:47:49 | 2017-12-25T15:09:30 | HTML | UTF-8 | C++ | false | false | 1,909 | cpp | #include <bits/stdc++.h>
// #include <boost/multiprecision/cpp_int.hpp>
// using boost::multiprecision::cpp_int;
using namespace std;
#pragma GCC optimize "-O3"
#define watch(x) cout << (#x) << " is " << (x) << endl
#define rep(i,a,b) for(int i=a;i<b;i++)
#define repd(i,a,b) for(int i=a-1;i>=b;i--)
#define nl cout<<endl;
#define test() lli t;cin>>t;while(t--)
#define sp(n) setprecision(n)
#define lli long long int
#define ulli unsigned long long int
#define ld long double
#define uld unsigned long double
#define S string
#define C char
#define elif else if
#define pb push_back
#define pp pop_back
#define plli pair<lli,lli>
#define vlli vector<lli>
#define vulli vector<ulli>
#define vld vector<ld>
#define vs vector<string>
#define bs binary_search
#define ub upper_bound
#define lb lower_bound
#define vsort(v) sort(v.begin(),v.end())
#define max1 1000001 //10^6 + 1
#define max2 10000001 //10^7 + 1
#define max3 1000000007 //10^9 + 7
#define inf 1000000009 //10^9 + 9
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
// freopen("input.txt", "r", stdin); // redirects standard input
// freopen("output.txt", "w", stdout); // redirects standard output
lli n;
cin >> n;
const lli j = 1234567, k = 123456, l = 1234,z=0;
int flag = 0;
for (int i = 0; i <= max(n/j,z); ++i)
{
for (int q = 0; q <= max(n/k,z); ++q)
{
lli p;
// for (int p = 0; p <= max(n/l,z) ; ++p)
// {
p = abs((n - i*j - q*k)/l);
if(p*l + i*j + q*k == n){ flag = 1;
// watch(p);
break;
}
// break;}
// }
}
}
if(flag) cout << "YES\n";
else cout << "NO\n";
return 0;
}
| [
"ashwinsekhari@gmail.com"
] | ashwinsekhari@gmail.com |
0030e16d1d315a0ede933b35720cee9435630abf | ad822f849322c5dcad78d609f28259031a96c98e | /SDK/Hazard_Spiker_2_functions.cpp | 4c0e46d406e3043f5d0002b0a3c948bc4510a7d5 | [] | no_license | zH4x-SDK/zAstroneer-SDK | 1cdc9c51b60be619202c0258a0dd66bf96898ac4 | 35047f506eaef251a161792fcd2ddd24fe446050 | refs/heads/main | 2023-07-24T08:20:55.346698 | 2021-08-27T13:33:33 | 2021-08-27T13:33:33 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 10,597 | cpp |
#include "../SDK.h"
// Name: Astroneer-SDK, Version: 1.0.0
#ifdef _MSC_VER
#pragma pack(push, 0x8)
#endif
namespace SDK
{
//---------------------------------------------------------------------------
// Functions
//---------------------------------------------------------------------------
// Function Hazard_Spiker_2.Hazard_Spiker_1_C.HandleOnDeformationEvent
// (Public, HasOutParms, BlueprintCallable, BlueprintEvent)
// Parameters:
// struct FDeformationParams DeformationParams (BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ReferenceParm)
void AHazard_Spiker_1_C::HandleOnDeformationEvent(struct FDeformationParams* DeformationParams)
{
static auto fn = UObject::FindObject<UFunction>("Function Hazard_Spiker_2.Hazard_Spiker_1_C.HandleOnDeformationEvent");
AHazard_Spiker_1_C_HandleOnDeformationEvent_Params params;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
if (DeformationParams != nullptr)
*DeformationParams = params.DeformationParams;
}
// Function Hazard_Spiker_2.Hazard_Spiker_1_C.UserConstructionScript
// (Event, Public, BlueprintCallable, BlueprintEvent)
void AHazard_Spiker_1_C::UserConstructionScript()
{
static auto fn = UObject::FindObject<UFunction>("Function Hazard_Spiker_2.Hazard_Spiker_1_C.UserConstructionScript");
AHazard_Spiker_1_C_UserConstructionScript_Params params;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function Hazard_Spiker_2.Hazard_Spiker_1_C.ReceiveTick
// (Event, Public, BlueprintEvent)
// Parameters:
// float DeltaSeconds (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData)
void AHazard_Spiker_1_C::ReceiveTick(float DeltaSeconds)
{
static auto fn = UObject::FindObject<UFunction>("Function Hazard_Spiker_2.Hazard_Spiker_1_C.ReceiveTick");
AHazard_Spiker_1_C_ReceiveTick_Params params;
params.DeltaSeconds = DeltaSeconds;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function Hazard_Spiker_2.Hazard_Spiker_1_C.BndEvt__Capsule_K2Node_ComponentBoundEvent_261_ComponentBeginOverlapSignature__DelegateSignature
// (HasOutParms, BlueprintEvent)
// Parameters:
// class UPrimitiveComponent* OverlappedComponent (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData)
// class AActor* OtherActor (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData)
// class UPrimitiveComponent* OtherComp (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData)
// int OtherBodyIndex (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData)
// bool bFromSweep (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData)
// struct FHitResult SweepResult (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ReferenceParm, IsPlainOldData)
void AHazard_Spiker_1_C::BndEvt__Capsule_K2Node_ComponentBoundEvent_261_ComponentBeginOverlapSignature__DelegateSignature(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
static auto fn = UObject::FindObject<UFunction>("Function Hazard_Spiker_2.Hazard_Spiker_1_C.BndEvt__Capsule_K2Node_ComponentBoundEvent_261_ComponentBeginOverlapSignature__DelegateSignature");
AHazard_Spiker_1_C_BndEvt__Capsule_K2Node_ComponentBoundEvent_261_ComponentBeginOverlapSignature__DelegateSignature_Params params;
params.OverlappedComponent = OverlappedComponent;
params.OtherActor = OtherActor;
params.OtherComp = OtherComp;
params.OtherBodyIndex = OtherBodyIndex;
params.bFromSweep = bFromSweep;
params.SweepResult = SweepResult;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function Hazard_Spiker_2.Hazard_Spiker_1_C.BndEvt__ProximityCapsule_K2Node_ComponentBoundEvent_270_ComponentEndOverlapSignature__DelegateSignature
// (BlueprintEvent)
// Parameters:
// class UPrimitiveComponent* OverlappedComponent (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData)
// class AActor* OtherActor (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData)
// class UPrimitiveComponent* OtherComp (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData)
// int OtherBodyIndex (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData)
void AHazard_Spiker_1_C::BndEvt__ProximityCapsule_K2Node_ComponentBoundEvent_270_ComponentEndOverlapSignature__DelegateSignature(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int OtherBodyIndex)
{
static auto fn = UObject::FindObject<UFunction>("Function Hazard_Spiker_2.Hazard_Spiker_1_C.BndEvt__ProximityCapsule_K2Node_ComponentBoundEvent_270_ComponentEndOverlapSignature__DelegateSignature");
AHazard_Spiker_1_C_BndEvt__ProximityCapsule_K2Node_ComponentBoundEvent_270_ComponentEndOverlapSignature__DelegateSignature_Params params;
params.OverlappedComponent = OverlappedComponent;
params.OtherActor = OtherActor;
params.OtherComp = OtherComp;
params.OtherBodyIndex = OtherBodyIndex;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function Hazard_Spiker_2.Hazard_Spiker_1_C.BndEvt__TerrainPhysics_K2Node_ComponentBoundEvent_1_Signal__DelegateSignature
// (BlueprintEvent)
void AHazard_Spiker_1_C::BndEvt__TerrainPhysics_K2Node_ComponentBoundEvent_1_Signal__DelegateSignature()
{
static auto fn = UObject::FindObject<UFunction>("Function Hazard_Spiker_2.Hazard_Spiker_1_C.BndEvt__TerrainPhysics_K2Node_ComponentBoundEvent_1_Signal__DelegateSignature");
AHazard_Spiker_1_C_BndEvt__TerrainPhysics_K2Node_ComponentBoundEvent_1_Signal__DelegateSignature_Params params;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function Hazard_Spiker_2.Hazard_Spiker_1_C.ReceiveBeginPlay
// (Event, Protected, BlueprintEvent)
void AHazard_Spiker_1_C::ReceiveBeginPlay()
{
static auto fn = UObject::FindObject<UFunction>("Function Hazard_Spiker_2.Hazard_Spiker_1_C.ReceiveBeginPlay");
AHazard_Spiker_1_C_ReceiveBeginPlay_Params params;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function Hazard_Spiker_2.Hazard_Spiker_1_C.MULTI Spawn Seeds
// (Net, NetMulticast, BlueprintCallable, BlueprintEvent)
void AHazard_Spiker_1_C::MULTI_Spawn_Seeds()
{
static auto fn = UObject::FindObject<UFunction>("Function Hazard_Spiker_2.Hazard_Spiker_1_C.MULTI Spawn Seeds");
AHazard_Spiker_1_C_MULTI_Spawn_Seeds_Params params;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function Hazard_Spiker_2.Hazard_Spiker_1_C.ReceiveEndPlay
// (Event, Public, BlueprintEvent)
// Parameters:
// TEnumAsByte<EEndPlayReason> EndPlayReason (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData)
void AHazard_Spiker_1_C::ReceiveEndPlay(TEnumAsByte<EEndPlayReason> EndPlayReason)
{
static auto fn = UObject::FindObject<UFunction>("Function Hazard_Spiker_2.Hazard_Spiker_1_C.ReceiveEndPlay");
AHazard_Spiker_1_C_ReceiveEndPlay_Params params;
params.EndPlayReason = EndPlayReason;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function Hazard_Spiker_2.Hazard_Spiker_1_C.DestroyFinished
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// class UParticleSystemComponent* PSystem (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData)
void AHazard_Spiker_1_C::DestroyFinished(class UParticleSystemComponent* PSystem)
{
static auto fn = UObject::FindObject<UFunction>("Function Hazard_Spiker_2.Hazard_Spiker_1_C.DestroyFinished");
AHazard_Spiker_1_C_DestroyFinished_Params params;
params.PSystem = PSystem;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function Hazard_Spiker_2.Hazard_Spiker_1_C.Destroy Particle
// (BlueprintCallable, BlueprintEvent)
void AHazard_Spiker_1_C::Destroy_Particle()
{
static auto fn = UObject::FindObject<UFunction>("Function Hazard_Spiker_2.Hazard_Spiker_1_C.Destroy Particle");
AHazard_Spiker_1_C_Destroy_Particle_Params params;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function Hazard_Spiker_2.Hazard_Spiker_1_C.BndEvt__Deformable_K2Node_ComponentBoundEvent_7_OnDeformed__DelegateSignature
// (HasOutParms, BlueprintEvent)
// Parameters:
// struct FDeformationParams DeformationParams (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ReferenceParm)
void AHazard_Spiker_1_C::BndEvt__Deformable_K2Node_ComponentBoundEvent_7_OnDeformed__DelegateSignature(const struct FDeformationParams& DeformationParams)
{
static auto fn = UObject::FindObject<UFunction>("Function Hazard_Spiker_2.Hazard_Spiker_1_C.BndEvt__Deformable_K2Node_ComponentBoundEvent_7_OnDeformed__DelegateSignature");
AHazard_Spiker_1_C_BndEvt__Deformable_K2Node_ComponentBoundEvent_7_OnDeformed__DelegateSignature_Params params;
params.DeformationParams = DeformationParams;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function Hazard_Spiker_2.Hazard_Spiker_1_C.ExecuteUbergraph_Hazard_Spiker_2
// (HasDefaults)
// Parameters:
// int EntryPoint (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData)
void AHazard_Spiker_1_C::ExecuteUbergraph_Hazard_Spiker_2(int EntryPoint)
{
static auto fn = UObject::FindObject<UFunction>("Function Hazard_Spiker_2.Hazard_Spiker_1_C.ExecuteUbergraph_Hazard_Spiker_2");
AHazard_Spiker_1_C_ExecuteUbergraph_Hazard_Spiker_2_Params params;
params.EntryPoint = EntryPoint;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
}
#ifdef _MSC_VER
#pragma pack(pop)
#endif
| [
"zp2kshield@gmail.com"
] | zp2kshield@gmail.com |
94caaeffcf3a3a3a8b5e2fe563efc2e40e4bc41b | 23ba9a4885136c8fd097255141aa13c694e928fb | /PaperHome/main.cpp | fc7288e54f19c769d04d8713162061efc01a44b0 | [] | no_license | mzatielr/PaperHome | 36119f7bce5758b1c61410b8fc2c2fb032a1afcc | 47a3f758d86f244d7f091688cc27efa77d00c59b | refs/heads/master | 2020-03-30T10:23:17.856792 | 2018-10-13T16:59:21 | 2018-10-13T16:59:21 | 151,115,316 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 586 | cpp | #include "defs.h"
#include "PaperHomeConsts.h"
#include "WinSockInfo.h"
#include "Communicator.h"
int main() {
try
{
printf("Starting PaperHome\n");
WinSockInfo wsa_info;
Communicator commicator;
while (true) {
try {
Sleep(PaperHomeConsts::PaperHomeTryToConnectInterval);
commicator.tryConnect(PaperHomeConsts::PaperHomeServerIP, PaperHomeConsts::PaperHomeServerPort);
}
catch (std::exception& exception) {
printf("Caught exception: %s\n", exception.what());
}
}
}
catch (...) {
printf("Unhandled exception has been thrown\n");
}
return 0;
} | [
"mordehaizai@gmail.com"
] | mordehaizai@gmail.com |
001060ed77109985cd1b9b5927e7d09cd3cbeca9 | 190cfe853208fa287aa2539f1dd4e729f5235091 | /HospitalFee/FMOutpatientCostSynthesisbyLine.h | 8718f9af5f5caf6f613e7bee01100fa901a148c3 | [] | no_license | smithgold53/HMSReportForms | d8cacb7de1509995b46be16bc5a99ca9104dbea1 | 7f426de1a3f8b7bad956c62ba61306a3969accf2 | refs/heads/master | 2020-05-18T09:24:39.420731 | 2015-05-06T09:47:03 | 2015-05-06T09:47:03 | 34,946,969 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,534 | h | #ifndef FMOUTPATIENTCOSTSYNTHESISBYLINE_H
#define FMOUTPATIENTCOSTSYNTHESISBYLINE_H
//////////////////////////////////////////////////////////////////////////////////////////////////////////
// Copyright(C) Viet Nam Medical Software Join Stock Company. 2005-2010.
// All rights reserved.
// This program is protected by Viet nam and international treaties.
// Unauthorized reproduction or distribution of this program,
// or any portion of it, may result in severe civil and criminal penalties,
// and will be prosecuted to the maximum extent possible under the law.
// This file is a part of the GUI(Graphical User Interface) class library.
// (c) 2006-2008 Hay Hoang Van, All rights reserved.
// CONTACT INFORMATION:
// Email : hayhv@vimes.com.vn or hayhv@yahoo.com
// Website: http://www.vimes.com.vn
/////////////////////////////////////////////////////////////////////////////////////////////////////////
// Ban quyen cua Cong Ty Co Phan Phan Mem Y Te Viet Nam 2005-2010.
// Do Cuc Ban Quyen, Bo VHTT nuoc Cong hoa xa hoi chu nghia Viet Nam cap.
// Chuong trinh phan mem nay duoc Luat phap Viet Nam va quoc te bao ho.
// San xuat, su dung hoac phan phoi trai phep toan bo hoac mot phan cua phan men nay se
// chiu cac hinh phat va hinh su hoac dan su, co the len den muc toi da dung theo Luat qui dinh.
// File nay la mot phan cua thu vien lap trinh(GUI). Ban quyen cua Hoang Van Hay. 2006-2008
// THONG TIN LIEN HE:
// Email : hayhv@vimes.com.vn hoac hayhv@yahoo.com
// Website: http://www.vimes.com.vn
//////////////////////////////////////////////////////////////////////////////////////////////////////////
#include "GuiUtils.h"
#include "GuiView.h"
#include "DbField.h"
class CFMOutpatientCostSynthesisbyLine : public CGuiView{
protected:
public:
CGuiGroupBox m_wndOutpatientCostSynthesis;
CGuiLabel m_wndYearLabel;
CGuiNumberCtrl m_wndYear;
CGuiLabel m_wndReportPeriodLabel;
CGuiComboBox m_wndReportPeriod;
CGuiLabel m_wndFromDateLabel;
CGuiDateTimeCtrl m_wndFromDate;
CGuiLabel m_wndToDateLabel;
CGuiDateTimeCtrl m_wndToDate;
CGuiButton m_wndPrintPreview;
CGuiButton m_wndExport;
long m_nYear;
CString m_szReportPeriodKey;
CString m_szFromDate;
CString m_szToDate;
//void OnYearChange();
//void OnYearSetfocus();
//void OnYearKillfocus();
int OnYearCheckValue();
void OnReportPeriodSelectChange(int nOldItemSel, int nNewItemSel);
void OnReportPeriodSelendok();
//void OnReportPeriodSetfocus();
//void OnReportPeriodKillfocus();
long OnReportPeriodLoadData();
void OnReportPeriodAddNew();
//void OnFromDateChange();
//void OnFromDateSetfocus();
//void OnFromDateKillfocus();
int OnFromDateCheckValue();
//void OnToDateChange();
//void OnToDateSetfocus();
//void OnToDateKillfocus();
int OnToDateCheckValue();
void OnPrintPreviewSelect();
void OnExportSelect();
CFMOutpatientCostSynthesisbyLine(CWnd *pParent);
~CFMOutpatientCostSynthesisbyLine();
void OnCreateComponents();
void OnInitializeComponents();
void OnSetWindowEvents();
void OnDoDataExchange(CDataExchange* pDX);
void GetDataToScreen();
void GetScreenToData();
void SetDefaultValues();
int SetMode(int nMode);
int OnAddFMOutpatientCostSynthesisbyLine();
int OnEditFMOutpatientCostSynthesisbyLine();
int OnDeleteFMOutpatientCostSynthesisbyLine();
int OnSaveFMOutpatientCostSynthesisbyLine();
int OnCancelFMOutpatientCostSynthesisbyLine();
int OnFMOutpatientCostSynthesisbyLineListLoadData();
CString GetQueryString();
};
#endif
| [
"smithgold53@gmail.com"
] | smithgold53@gmail.com |
4cbfe3dce04a2f8305140e4e0c2523a3e8927560 | 23886a9bfee4dff5d7fa7951d791b3b105fd000d | /libbulletc/src/btBroadphaseProxy_wrap.cpp | 94650236b4c321f548d7251e0c3d731305548d50 | [
"Zlib"
] | permissive | RainsSoft/BulletSharpPInvoke | a4edf1a52e5dc9c055380a249c579abf062a2048 | 5c4bf014557c704e13f6133cf791dc120be8789d | refs/heads/master | 2021-01-15T23:11:39.635346 | 2015-08-29T06:13:38 | 2015-08-29T06:13:38 | 41,657,848 | 1 | 0 | null | 2015-08-31T05:39:57 | 2015-08-31T05:39:57 | null | UTF-8 | C++ | false | false | 4,843 | cpp | #include <BulletCollision/BroadphaseCollision/btBroadphaseProxy.h>
#include <BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h>
#include "conversion.h"
#include "btBroadphaseProxy_wrap.h"
btBroadphaseProxy* btBroadphaseProxy_new()
{
return new btBroadphaseProxy();
}
btBroadphaseProxy* btBroadphaseProxy_new2(const btScalar* aabbMin, const btScalar* aabbMax, void* userPtr, short collisionFilterGroup, short collisionFilterMask)
{
VECTOR3_CONV(aabbMin);
VECTOR3_CONV(aabbMax);
return new btBroadphaseProxy(VECTOR3_USE(aabbMin), VECTOR3_USE(aabbMax), userPtr, collisionFilterGroup, collisionFilterMask);
}
btBroadphaseProxy* btBroadphaseProxy_new3(const btScalar* aabbMin, const btScalar* aabbMax, void* userPtr, short collisionFilterGroup, short collisionFilterMask, void* multiSapParentProxy)
{
VECTOR3_CONV(aabbMin);
VECTOR3_CONV(aabbMax);
return new btBroadphaseProxy(VECTOR3_USE(aabbMin), VECTOR3_USE(aabbMax), userPtr, collisionFilterGroup, collisionFilterMask, multiSapParentProxy);
}
void btBroadphaseProxy_getAabbMax(btBroadphaseProxy* obj, btScalar* value)
{
VECTOR3_OUT(&obj->m_aabbMax, value);
}
void btBroadphaseProxy_getAabbMin(btBroadphaseProxy* obj, btScalar* value)
{
VECTOR3_OUT(&obj->m_aabbMin, value);
}
void* btBroadphaseProxy_getClientObject(btBroadphaseProxy* obj)
{
return obj->m_clientObject;
}
short btBroadphaseProxy_getCollisionFilterGroup(btBroadphaseProxy* obj)
{
return obj->m_collisionFilterGroup;
}
short btBroadphaseProxy_getCollisionFilterMask(btBroadphaseProxy* obj)
{
return obj->m_collisionFilterMask;
}
void* btBroadphaseProxy_getMultiSapParentProxy(btBroadphaseProxy* obj)
{
return obj->m_multiSapParentProxy;
}
int btBroadphaseProxy_getUid(btBroadphaseProxy* obj)
{
return obj->getUid();
}
int btBroadphaseProxy_getUniqueId(btBroadphaseProxy* obj)
{
return obj->m_uniqueId;
}
bool btBroadphaseProxy_isCompound(int proxyType)
{
return btBroadphaseProxy::isCompound(proxyType);
}
bool btBroadphaseProxy_isConcave(int proxyType)
{
return btBroadphaseProxy::isConcave(proxyType);
}
bool btBroadphaseProxy_isConvex(int proxyType)
{
return btBroadphaseProxy::isConvex(proxyType);
}
bool btBroadphaseProxy_isConvex2d(int proxyType)
{
return btBroadphaseProxy::isConvex2d(proxyType);
}
bool btBroadphaseProxy_isInfinite(int proxyType)
{
return btBroadphaseProxy::isInfinite(proxyType);
}
bool btBroadphaseProxy_isNonMoving(int proxyType)
{
return btBroadphaseProxy::isNonMoving(proxyType);
}
bool btBroadphaseProxy_isPolyhedral(int proxyType)
{
return btBroadphaseProxy::isPolyhedral(proxyType);
}
bool btBroadphaseProxy_isSoftBody(int proxyType)
{
return btBroadphaseProxy::isSoftBody(proxyType);
}
void btBroadphaseProxy_setAabbMax(btBroadphaseProxy* obj, const btScalar* value)
{
VECTOR3_IN(value, &obj->m_aabbMax);
}
void btBroadphaseProxy_setAabbMin(btBroadphaseProxy* obj, const btScalar* value)
{
VECTOR3_IN(value, &obj->m_aabbMin);
}
void btBroadphaseProxy_setClientObject(btBroadphaseProxy* obj, void* value)
{
obj->m_clientObject = value;
}
void btBroadphaseProxy_setCollisionFilterGroup(btBroadphaseProxy* obj, short value)
{
obj->m_collisionFilterGroup = value;
}
void btBroadphaseProxy_setCollisionFilterMask(btBroadphaseProxy* obj, short value)
{
obj->m_collisionFilterMask = value;
}
void btBroadphaseProxy_setMultiSapParentProxy(btBroadphaseProxy* obj, void* value)
{
obj->m_multiSapParentProxy = value;
}
void btBroadphaseProxy_setUniqueId(btBroadphaseProxy* obj, int value)
{
obj->m_uniqueId = value;
}
void btBroadphaseProxy_delete(btBroadphaseProxy* obj)
{
delete obj;
}
btBroadphasePair* btBroadphasePair_new()
{
return new btBroadphasePair();
}
btBroadphasePair* btBroadphasePair_new2(const btBroadphasePair* other)
{
return new btBroadphasePair(*other);
}
btBroadphasePair* btBroadphasePair_new3(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1)
{
return new btBroadphasePair(*proxy0, *proxy1);
}
btCollisionAlgorithm* btBroadphasePair_getAlgorithm(btBroadphasePair* obj)
{
return obj->m_algorithm;
}
btBroadphaseProxy* btBroadphasePair_getPProxy0(btBroadphasePair* obj)
{
return obj->m_pProxy0;
}
btBroadphaseProxy* btBroadphasePair_getPProxy1(btBroadphasePair* obj)
{
return obj->m_pProxy1;
}
void btBroadphasePair_setAlgorithm(btBroadphasePair* obj, btCollisionAlgorithm* value)
{
obj->m_algorithm = value;
}
void btBroadphasePair_setPProxy0(btBroadphasePair* obj, btBroadphaseProxy* value)
{
obj->m_pProxy0 = value;
}
void btBroadphasePair_setPProxy1(btBroadphasePair* obj, btBroadphaseProxy* value)
{
obj->m_pProxy1 = value;
}
void btBroadphasePair_delete(btBroadphasePair* obj)
{
delete obj;
}
| [
"andres.traks@gmail.com"
] | andres.traks@gmail.com |
a11e3ae720e0d812d39e59318d8834e528e28951 | 9cf2ad2c42bb19b9529ffdcadadaee4a26d86f41 | /bullet3/src/BulletCollision/BroadphaseCollision/btBroadphaseProxy.h | 30246a3f19bb2d63bae783c48f8111f03345d743 | [] | no_license | ccour004/android-sdl2-gradle-template | 9baff97c70b33870a7c80e95530a845bd20a4a22 | f8e6099e529a47185d3d6765cd2c7ba11e49b08e | refs/heads/master | 2021-01-21T15:30:30.239412 | 2017-05-23T01:56:15 | 2017-05-23T01:56:15 | 91,843,203 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,715 | h | /*
Bullet Continuous Collision Detection and Physics Library
Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/
This software is provided 'as-is', without any express or implied warranty.
In no event will the authors be held liable for any damages arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it freely,
subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
#ifndef BT_BROADPHASE_PROXY_H
#define BT_BROADPHASE_PROXY_H
#include "../../LinearMath/btScalar.h" //for SIMD_FORCE_INLINE
#include "../../LinearMath/btVector3.h"
#include "../../LinearMath/btAlignedAllocator.h"
/// btDispatcher uses these types
/// IMPORTANT NOTE:The types are ordered polyhedral, implicit convex and concave
/// to facilitate type checking
/// CUSTOM_POLYHEDRAL_SHAPE_TYPE,CUSTOM_CONVEX_SHAPE_TYPE and CUSTOM_CONCAVE_SHAPE_TYPE can be used to extend Bullet without modifying source code
enum BroadphaseNativeTypes
{
// polyhedral convex shapes
BOX_SHAPE_PROXYTYPE,
TRIANGLE_SHAPE_PROXYTYPE,
TETRAHEDRAL_SHAPE_PROXYTYPE,
CONVEX_TRIANGLEMESH_SHAPE_PROXYTYPE,
CONVEX_HULL_SHAPE_PROXYTYPE,
CONVEX_POINT_CLOUD_SHAPE_PROXYTYPE,
CUSTOM_POLYHEDRAL_SHAPE_TYPE,
//implicit convex shapes
IMPLICIT_CONVEX_SHAPES_START_HERE,
SPHERE_SHAPE_PROXYTYPE,
MULTI_SPHERE_SHAPE_PROXYTYPE,
CAPSULE_SHAPE_PROXYTYPE,
CONE_SHAPE_PROXYTYPE,
CONVEX_SHAPE_PROXYTYPE,
CYLINDER_SHAPE_PROXYTYPE,
UNIFORM_SCALING_SHAPE_PROXYTYPE,
MINKOWSKI_SUM_SHAPE_PROXYTYPE,
MINKOWSKI_DIFFERENCE_SHAPE_PROXYTYPE,
BOX_2D_SHAPE_PROXYTYPE,
CONVEX_2D_SHAPE_PROXYTYPE,
CUSTOM_CONVEX_SHAPE_TYPE,
//concave shapes
CONCAVE_SHAPES_START_HERE,
//keep all the convex shapetype below here, for the check IsConvexShape in broadphase proxy!
TRIANGLE_MESH_SHAPE_PROXYTYPE,
SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE,
///used for demo integration FAST/Swift collision library and Bullet
FAST_CONCAVE_MESH_PROXYTYPE,
//terrain
TERRAIN_SHAPE_PROXYTYPE,
///Used for GIMPACT Trimesh integration
GIMPACT_SHAPE_PROXYTYPE,
///Multimaterial mesh
MULTIMATERIAL_TRIANGLE_MESH_PROXYTYPE,
EMPTY_SHAPE_PROXYTYPE,
STATIC_PLANE_PROXYTYPE,
CUSTOM_CONCAVE_SHAPE_TYPE,
CONCAVE_SHAPES_END_HERE,
COMPOUND_SHAPE_PROXYTYPE,
SOFTBODY_SHAPE_PROXYTYPE,
HFFLUID_SHAPE_PROXYTYPE,
HFFLUID_BUOYANT_CONVEX_SHAPE_PROXYTYPE,
INVALID_SHAPE_PROXYTYPE,
MAX_BROADPHASE_COLLISION_TYPES
};
///The btBroadphaseProxy is the main class that can be used with the Bullet broadphases.
///It stores collision shape type information, collision filter information and a client object, typically a btCollisionObject or btRigidBody.
ATTRIBUTE_ALIGNED16(struct) btBroadphaseProxy
{
BT_DECLARE_ALIGNED_ALLOCATOR();
///optional filtering to cull potential collisions
enum CollisionFilterGroups
{
DefaultFilter = 1,
StaticFilter = 2,
KinematicFilter = 4,
DebrisFilter = 8,
SensorTrigger = 16,
CharacterFilter = 32,
AllFilter = -1 //all bits sets: DefaultFilter | StaticFilter | KinematicFilter | DebrisFilter | SensorTrigger
};
//Usually the client btCollisionObject or Rigidbody class
void* m_clientObject;
int m_collisionFilterGroup;
int m_collisionFilterMask;
int m_uniqueId;//m_uniqueId is introduced for paircache. could get rid of this, by calculating the address offset etc.
btVector3 m_aabbMin;
btVector3 m_aabbMax;
SIMD_FORCE_INLINE int getUid() const
{
return m_uniqueId;
}
//used for memory pools
btBroadphaseProxy() :m_clientObject(0)
{
}
btBroadphaseProxy(const btVector3& aabbMin,const btVector3& aabbMax,void* userPtr, int collisionFilterGroup, int collisionFilterMask)
:m_clientObject(userPtr),
m_collisionFilterGroup(collisionFilterGroup),
m_collisionFilterMask(collisionFilterMask),
m_aabbMin(aabbMin),
m_aabbMax(aabbMax)
{
}
static SIMD_FORCE_INLINE bool isPolyhedral(int proxyType)
{
return (proxyType < IMPLICIT_CONVEX_SHAPES_START_HERE);
}
static SIMD_FORCE_INLINE bool isConvex(int proxyType)
{
return (proxyType < CONCAVE_SHAPES_START_HERE);
}
static SIMD_FORCE_INLINE bool isNonMoving(int proxyType)
{
return (isConcave(proxyType) && !(proxyType==GIMPACT_SHAPE_PROXYTYPE));
}
static SIMD_FORCE_INLINE bool isConcave(int proxyType)
{
return ((proxyType > CONCAVE_SHAPES_START_HERE) &&
(proxyType < CONCAVE_SHAPES_END_HERE));
}
static SIMD_FORCE_INLINE bool isCompound(int proxyType)
{
return (proxyType == COMPOUND_SHAPE_PROXYTYPE);
}
static SIMD_FORCE_INLINE bool isSoftBody(int proxyType)
{
return (proxyType == SOFTBODY_SHAPE_PROXYTYPE);
}
static SIMD_FORCE_INLINE bool isInfinite(int proxyType)
{
return (proxyType == STATIC_PLANE_PROXYTYPE);
}
static SIMD_FORCE_INLINE bool isConvex2d(int proxyType)
{
return (proxyType == BOX_2D_SHAPE_PROXYTYPE) || (proxyType == CONVEX_2D_SHAPE_PROXYTYPE);
}
}
;
class btCollisionAlgorithm;
struct btBroadphaseProxy;
///The btBroadphasePair class contains a pair of aabb-overlapping objects.
///A btDispatcher can search a btCollisionAlgorithm that performs exact/narrowphase collision detection on the actual collision shapes.
ATTRIBUTE_ALIGNED16(struct) btBroadphasePair
{
btBroadphasePair ()
:
m_pProxy0(0),
m_pProxy1(0),
m_algorithm(0),
m_internalInfo1(0)
{
}
BT_DECLARE_ALIGNED_ALLOCATOR();
btBroadphasePair(const btBroadphasePair& other)
: m_pProxy0(other.m_pProxy0),
m_pProxy1(other.m_pProxy1),
m_algorithm(other.m_algorithm),
m_internalInfo1(other.m_internalInfo1)
{
}
btBroadphasePair(btBroadphaseProxy& proxy0,btBroadphaseProxy& proxy1)
{
//keep them sorted, so the std::set operations work
if (proxy0.m_uniqueId < proxy1.m_uniqueId)
{
m_pProxy0 = &proxy0;
m_pProxy1 = &proxy1;
}
else
{
m_pProxy0 = &proxy1;
m_pProxy1 = &proxy0;
}
m_algorithm = 0;
m_internalInfo1 = 0;
}
btBroadphaseProxy* m_pProxy0;
btBroadphaseProxy* m_pProxy1;
mutable btCollisionAlgorithm* m_algorithm;
union { void* m_internalInfo1; int m_internalTmpValue;};//don't use this data, it will be removed in future version.
};
/*
//comparison for set operation, see Solid DT_Encounter
SIMD_FORCE_INLINE bool operator<(const btBroadphasePair& a, const btBroadphasePair& b)
{
return a.m_pProxy0 < b.m_pProxy0 ||
(a.m_pProxy0 == b.m_pProxy0 && a.m_pProxy1 < b.m_pProxy1);
}
*/
class btBroadphasePairSortPredicate
{
public:
bool operator() ( const btBroadphasePair& a, const btBroadphasePair& b ) const
{
const int uidA0 = a.m_pProxy0 ? a.m_pProxy0->m_uniqueId : -1;
const int uidB0 = b.m_pProxy0 ? b.m_pProxy0->m_uniqueId : -1;
const int uidA1 = a.m_pProxy1 ? a.m_pProxy1->m_uniqueId : -1;
const int uidB1 = b.m_pProxy1 ? b.m_pProxy1->m_uniqueId : -1;
return uidA0 > uidB0 ||
(a.m_pProxy0 == b.m_pProxy0 && uidA1 > uidB1) ||
(a.m_pProxy0 == b.m_pProxy0 && a.m_pProxy1 == b.m_pProxy1 && a.m_algorithm > b.m_algorithm);
}
};
SIMD_FORCE_INLINE bool operator==(const btBroadphasePair& a, const btBroadphasePair& b)
{
return (a.m_pProxy0 == b.m_pProxy0) && (a.m_pProxy1 == b.m_pProxy1);
}
#endif //BT_BROADPHASE_PROXY_H
| [
"ccour004@gmail.com"
] | ccour004@gmail.com |
b71162fcf5db57b41790d59ffbd4ea75b4be9abe | 3184a7e2c590f2018e8c79a111bf2530681a9d60 | /src/rpcblockchain.cpp | b48d21dec7071754a3c1a0faf0f694a4c657e531 | [
"MIT"
] | permissive | CryptoHelp/Teddycoin | 73011bfbf2d848772c9d9405eff2d61b27025778 | 9ff6d11ba54a6fe1a6080a42c0273e16cbedb285 | refs/heads/master | 2021-01-14T10:52:32.778378 | 2014-07-03T07:35:47 | 2014-07-03T07:35:47 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 10,268 | cpp | // Copyright (c) 2010 Satoshi Nakamoto
// Copyright (c) 2009-2012 The Bitcoin developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "main.h"
#include "bitcoinrpc.h"
using namespace json_spirit;
using namespace std;
extern void TxToJSON(const CTransaction& tx, const uint256 hashBlock, json_spirit::Object& entry);
extern enum Checkpoints::CPMode CheckpointsMode;
double GetDifficulty(const CBlockIndex* blockindex)
{
// Floating point number that is a multiple of the minimum difficulty,
// minimum difficulty = 1.0.
if (blockindex == NULL)
{
if (pindexBest == NULL)
return 1.0;
else
blockindex = GetLastBlockIndex(pindexBest, false);
}
int nShift = (blockindex->nBits >> 24) & 0xff;
double dDiff =
(double)0x0000ffff / (double)(blockindex->nBits & 0x00ffffff);
while (nShift < 29)
{
dDiff *= 256.0;
nShift++;
}
while (nShift > 29)
{
dDiff /= 256.0;
nShift--;
}
return dDiff;
}
double GetPoWMHashPS()
{
if (pindexBest->nHeight >= LAST_POW_BLOCK)
return 0;
int nPoWInterval = 72;
int64_t nTargetSpacingWorkMin = 30, nTargetSpacingWork = 30;
CBlockIndex* pindex = pindexGenesisBlock;
CBlockIndex* pindexPrevWork = pindexGenesisBlock;
while (pindex)
{
if (pindex->IsProofOfWork())
{
int64_t nActualSpacingWork = pindex->GetBlockTime() - pindexPrevWork->GetBlockTime();
nTargetSpacingWork = ((nPoWInterval - 1) * nTargetSpacingWork + nActualSpacingWork + nActualSpacingWork) / (nPoWInterval + 1);
nTargetSpacingWork = max(nTargetSpacingWork, nTargetSpacingWorkMin);
pindexPrevWork = pindex;
}
pindex = pindex->pnext;
}
return GetDifficulty() * 4294.967296 / nTargetSpacingWork;
}
double GetPoSKernelPS()
{
int nPoSInterval = 72;
double dStakeKernelsTriedAvg = 0;
int nStakesHandled = 0, nStakesTime = 0;
CBlockIndex* pindex = pindexBest;;
CBlockIndex* pindexPrevStake = NULL;
while (pindex && nStakesHandled < nPoSInterval)
{
if (pindex->IsProofOfStake())
{
dStakeKernelsTriedAvg += GetDifficulty(pindex) * 4294967296.0;
nStakesTime += pindexPrevStake ? (pindexPrevStake->nTime - pindex->nTime) : 0;
pindexPrevStake = pindex;
nStakesHandled++;
}
pindex = pindex->pprev;
}
return nStakesTime ? dStakeKernelsTriedAvg / nStakesTime : 0;
}
Object blockToJSON(const CBlock& block, const CBlockIndex* blockindex, bool fPrintTransactionDetail)
{
Object result;
result.push_back(Pair("hash", block.GetHash().GetHex()));
CMerkleTx txGen(block.vtx[0]);
txGen.SetMerkleBranch(&block);
result.push_back(Pair("confirmations", (int)txGen.GetDepthInMainChain()));
result.push_back(Pair("size", (int)::GetSerializeSize(block, SER_NETWORK, PROTOCOL_VERSION)));
result.push_back(Pair("height", blockindex->nHeight));
result.push_back(Pair("version", block.nVersion));
result.push_back(Pair("merkleroot", block.hashMerkleRoot.GetHex()));
result.push_back(Pair("mint", ValueFromAmount(blockindex->nMint)));
result.push_back(Pair("time", (boost::int64_t)block.GetBlockTime()));
result.push_back(Pair("nonce", (boost::uint64_t)block.nNonce));
result.push_back(Pair("bits", HexBits(block.nBits)));
result.push_back(Pair("difficulty", GetDifficulty(blockindex)));
result.push_back(Pair("blocktrust", leftTrim(blockindex->GetBlockTrust().GetHex(), '0')));
result.push_back(Pair("chaintrust", leftTrim(blockindex->nChainTrust.GetHex(), '0')));
if (blockindex->pprev)
result.push_back(Pair("previousblockhash", blockindex->pprev->GetBlockHash().GetHex()));
if (blockindex->pnext)
result.push_back(Pair("nextblockhash", blockindex->pnext->GetBlockHash().GetHex()));
result.push_back(Pair("flags", strprintf("%s%s", blockindex->IsProofOfStake()? "proof-of-stake" : "proof-of-work", blockindex->GeneratedStakeModifier()? " stake-modifier": "")));
result.push_back(Pair("proofhash", blockindex->IsProofOfStake()? blockindex->hashProofOfStake.GetHex() : blockindex->GetBlockHash().GetHex()));
result.push_back(Pair("entropybit", (int)blockindex->GetStakeEntropyBit()));
result.push_back(Pair("modifier", strprintf("%016"PRIx64, blockindex->nStakeModifier)));
result.push_back(Pair("modifierchecksum", strprintf("%08x", blockindex->nStakeModifierChecksum)));
Array txinfo;
BOOST_FOREACH (const CTransaction& tx, block.vtx)
{
if (fPrintTransactionDetail)
{
Object entry;
entry.push_back(Pair("txid", tx.GetHash().GetHex()));
TxToJSON(tx, 0, entry);
txinfo.push_back(entry);
}
else
txinfo.push_back(tx.GetHash().GetHex());
}
result.push_back(Pair("tx", txinfo));
if (block.IsProofOfStake())
result.push_back(Pair("signature", HexStr(block.vchBlockSig.begin(), block.vchBlockSig.end())));
return result;
}
Value getbestblockhash(const Array& params, bool fHelp)
{
if (fHelp || params.size() != 0)
throw runtime_error(
"getbestblockhash\n"
"Returns the hash of the best block in the longest block chain.");
return hashBestChain.GetHex();
}
Value getblockcount(const Array& params, bool fHelp)
{
if (fHelp || params.size() != 0)
throw runtime_error(
"getblockcount\n"
"Returns the number of blocks in the longest block chain.");
return nBestHeight;
}
Value getdifficulty(const Array& params, bool fHelp)
{
if (fHelp || params.size() != 0)
throw runtime_error(
"getdifficulty\n"
"Returns the difficulty as a multiple of the minimum difficulty.");
Object obj;
obj.push_back(Pair("proof-of-work", GetDifficulty()));
obj.push_back(Pair("proof-of-stake", GetDifficulty(GetLastBlockIndex(pindexBest, true))));
obj.push_back(Pair("search-interval", (int)nLastCoinStakeSearchInterval));
return obj;
}
Value settxfee(const Array& params, bool fHelp)
{
if (fHelp || params.size() < 1 || params.size() > 1 || AmountFromValue(params[0]) < MIN_TX_FEE)
throw runtime_error(
"settxfee <amount>\n"
"<amount> is a real and is rounded to the nearest 0.01");
nTransactionFee = AmountFromValue(params[0]);
nTransactionFee = (nTransactionFee / CENT) * CENT; // round to cent
return true;
}
Value getrawmempool(const Array& params, bool fHelp)
{
if (fHelp || params.size() != 0)
throw runtime_error(
"getrawmempool\n"
"Returns all transaction ids in memory pool.");
vector<uint256> vtxid;
mempool.queryHashes(vtxid);
Array a;
BOOST_FOREACH(const uint256& hash, vtxid)
a.push_back(hash.ToString());
return a;
}
Value getblockhash(const Array& params, bool fHelp)
{
if (fHelp || params.size() != 1)
throw runtime_error(
"getblockhash <index>\n"
"Returns hash of block in best-block-chain at <index>.");
int nHeight = params[0].get_int();
if (nHeight < 0 || nHeight > nBestHeight)
throw runtime_error("Block number out of range.");
CBlockIndex* pblockindex = FindBlockByHeight(nHeight);
return pblockindex->phashBlock->GetHex();
}
Value getblock(const Array& params, bool fHelp)
{
if (fHelp || params.size() < 1 || params.size() > 2)
throw runtime_error(
"getblock <hash> [txinfo]\n"
"txinfo optional to print more detailed tx info\n"
"Returns details of a block with given block-hash.");
std::string strHash = params[0].get_str();
uint256 hash(strHash);
if (mapBlockIndex.count(hash) == 0)
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
CBlock block;
CBlockIndex* pblockindex = mapBlockIndex[hash];
block.ReadFromDisk(pblockindex, true);
return blockToJSON(block, pblockindex, params.size() > 1 ? params[1].get_bool() : false);
}
Value getblockbynumber(const Array& params, bool fHelp)
{
if (fHelp || params.size() < 1 || params.size() > 2)
throw runtime_error(
"getblock <number> [txinfo]\n"
"txinfo optional to print more detailed tx info\n"
"Returns details of a block with given block-number.");
int nHeight = params[0].get_int();
if (nHeight < 0 || nHeight > nBestHeight)
throw runtime_error("Block number out of range.");
CBlock block;
CBlockIndex* pblockindex = mapBlockIndex[hashBestChain];
while (pblockindex->nHeight > nHeight)
pblockindex = pblockindex->pprev;
uint256 hash = *pblockindex->phashBlock;
pblockindex = mapBlockIndex[hash];
block.ReadFromDisk(pblockindex, true);
return blockToJSON(block, pblockindex, params.size() > 1 ? params[1].get_bool() : false);
}
// Teddycoin: get information of sync-checkpoint
Value getcheckpoint(const Array& params, bool fHelp)
{
if (fHelp || params.size() != 0)
throw runtime_error(
"getcheckpoint\n"
"Show info of synchronized checkpoint.\n");
Object result;
CBlockIndex* pindexCheckpoint;
result.push_back(Pair("synccheckpoint", Checkpoints::hashSyncCheckpoint.ToString().c_str()));
pindexCheckpoint = mapBlockIndex[Checkpoints::hashSyncCheckpoint];
result.push_back(Pair("height", pindexCheckpoint->nHeight));
result.push_back(Pair("timestamp", DateTimeStrFormat(pindexCheckpoint->GetBlockTime()).c_str()));
// Check that the block satisfies synchronized checkpoint
if (CheckpointsMode == Checkpoints::STRICT)
result.push_back(Pair("policy", "strict"));
if (CheckpointsMode == Checkpoints::ADVISORY)
result.push_back(Pair("policy", "advisory"));
if (CheckpointsMode == Checkpoints::PERMISSIVE)
result.push_back(Pair("policy", "permissive"));
if (mapArgs.count("-checkpointkey"))
result.push_back(Pair("checkpointmaster", true));
return result;
}
| [
"teddydevteam@gmail.com"
] | teddydevteam@gmail.com |
d34cb46f511367c42b1efb7a2c1e15b6c1b778ff | eae49d07232b13b0250000671f9d0e8dbff9c1b5 | /dlib/matrix/matrix_data_layout.h | 86a7e72f93db3d7cd9734d876a6a580183a2cd68 | [
"BSL-1.0"
] | permissive | carolladeira/MAPD | d2dcc05af633ead8505aab883ac62b92650528d1 | c3e15f1fb16f79f2d8d772d9d03370c81b3b4fd7 | refs/heads/master | 2022-11-30T02:18:42.105310 | 2020-08-06T13:55:25 | 2020-08-06T13:55:25 | 250,655,440 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 37,395 | h | // Copyright (C) 2006 Davis E. King (davis@dlib.net)
// License: Boost Software License See LICENSE.txt for the full license.
#ifndef DLIB_MATRIx_DATA_LAYOUT_
#define DLIB_MATRIx_DATA_LAYOUT_
#include "../algs.h"
#include "matrix_fwd.h"
#include "matrix_data_layout_abstract.h"
#ifdef MATLAB_MEX_FILE
#include <mex.h>
#endif
// GCC 4.8 gives false alarms about some matrix operations going out of bounds. Disable
// these false warnings.
#if defined(__GNUC__) && ((__GNUC__ >= 4 && __GNUC_MINOR__ >= 8) || (__GNUC__ > 4))
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Warray-bounds"
#endif
namespace dlib
{
// ----------------------------------------------------------------------------------------
/*!
A matrix layout object is any object that contains a templated class called "layout"
with an interface identical to one below:
(Note that all the template arguments are just the template arguments from the dlib::matrix
object and the member functions are defined identically to the ones with the same
signatures inside the matrix object.)
struct matrix_layout
{
template <
typename T,
long num_rows,
long num_cols,
typename mem_manager
>
class layout
{
public:
T& operator() (
long r,
long c
);
const T& operator() (
long r,
long c
);
T& operator() (
long i
);
const T& operator() (
long i
) const;
void swap(
layout& item
);
long nr (
) const;
long nc (
) const;
void set_size (
long nr_,
long nc_
);
};
};
!*/
// ----------------------------------------------------------------------------------------
struct row_major_layout
{
// if a matrix is bigger than this many bytes then don't put it on the stack
const static size_t max_stack_based_size = 256;
// this is a hack to avoid a compile time error in visual studio 8. I would just
// use sizeof(T) and be done with it but that won't compile. The idea here
// is to avoid using the stack allocation of the layout object if it
// is going to contain another matrix and also avoid asking for the sizeof()
// the contained matrix.
template <typename T>
struct get_sizeof_helper
{
const static std::size_t val = sizeof(T);
};
template <typename T, long NR, long NC, typename mm, typename l>
struct get_sizeof_helper<matrix<T,NR,NC,mm,l> >
{
const static std::size_t val = 1000000;
};
template <
typename T,
long num_rows,
long num_cols,
typename mem_manager,
int val = static_switch <
// when the sizes are all non zero and small
(num_rows*num_cols*get_sizeof_helper<T>::val <= max_stack_based_size) && (num_rows != 0 && num_cols != 0),
// when the sizes are all non zero and big
(num_rows*num_cols*get_sizeof_helper<T>::val > max_stack_based_size) && (num_rows != 0 && num_cols != 0),
num_rows == 0 && num_cols != 0,
num_rows != 0 && num_cols == 0,
num_rows == 0 && num_cols == 0
>::value
>
class layout ;
/*!
WHAT THIS OBJECT REPRESENTS
This object represents the actual allocation of space for a matrix.
Small matrices allocate all their data on the stack and bigger ones
use a memory_manager to get their memory.
!*/
// ------------------------------------------------------------------------------------
template <
typename T,
long num_rows,
long num_cols,
typename mem_manager
>
class layout<T,num_rows,num_cols,mem_manager,1> : noncopyable // when the sizes are all non zero and small
{
public:
const static long NR = num_rows;
const static long NC = num_cols;
layout() {}
T& operator() (
long r,
long c
) { return *(data+r*num_cols + c); }
const T& operator() (
long r,
long c
) const { return *(data+r*num_cols + c); }
T& operator() (
long i
) { return data[i]; }
const T& operator() (
long i
) const { return data[i]; }
void swap(
layout& item
)
{
for (long r = 0; r < num_rows; ++r)
{
for (long c = 0; c < num_cols; ++c)
{
exchange((*this)(r,c),item(r,c));
}
}
}
long nr (
) const { return num_rows; }
long nc (
) const { return num_cols; }
void set_size (
long ,
long
)
{
}
#ifdef MATLAB_MEX_FILE
void _private_set_mxArray ( mxArray* ) { DLIB_CASSERT(false, "This function should never be called."); }
mxArray* _private_release_mxArray(){DLIB_CASSERT(false, "This function should never be called."); }
void _private_mark_non_persistent() {DLIB_CASSERT(false, "This function should never be called."); }
bool _private_is_persistent() const { return true; }
#endif
private:
T data[num_rows*num_cols];
};
// ------------------------------------------------------------------------------------
template <
typename T,
long num_rows,
long num_cols,
typename mem_manager
>
class layout<T,num_rows,num_cols,mem_manager,2> : noncopyable // when the sizes are all non zero and big
{
public:
const static long NR = num_rows;
const static long NC = num_cols;
layout (
) { data = pool.allocate_array(num_rows*num_cols); }
~layout ()
{ pool.deallocate_array(data); }
T& operator() (
long r,
long c
) { return data[r*num_cols + c]; }
const T& operator() (
long r,
long c
) const { return data[r*num_cols + c]; }
T& operator() (
long i
) { return data[i]; }
const T& operator() (
long i
) const { return data[i]; }
void swap(
layout& item
)
{
std::swap(item.data,data);
pool.swap(item.pool);
}
long nr (
) const { return num_rows; }
long nc (
) const { return num_cols; }
void set_size (
long ,
long
)
{
}
#ifdef MATLAB_MEX_FILE
void _private_set_mxArray ( mxArray* ) { DLIB_CASSERT(false, "This function should never be called."); }
mxArray* _private_release_mxArray(){DLIB_CASSERT(false, "This function should never be called."); }
void _private_mark_non_persistent() {DLIB_CASSERT(false, "This function should never be called."); }
bool _private_is_persistent() const { return true; }
#endif
private:
T* data;
typename mem_manager::template rebind<T>::other pool;
};
// ------------------------------------------------------------------------------------
template <
typename T,
long num_rows,
long num_cols,
typename mem_manager
>
class layout<T,num_rows,num_cols,mem_manager,3> : noncopyable // when num_rows == 0 && num_cols != 0,
{
public:
const static long NR = num_rows;
const static long NC = num_cols;
layout (
):data(0), nr_(0) { }
~layout ()
{
if (data)
pool.deallocate_array(data);
}
T& operator() (
long r,
long c
) { return data[r*num_cols + c]; }
const T& operator() (
long r,
long c
) const { return data[r*num_cols + c]; }
T& operator() (
long i
) { return data[i]; }
const T& operator() (
long i
) const { return data[i]; }
void swap(
layout& item
)
{
std::swap(item.data,data);
std::swap(item.nr_,nr_);
pool.swap(item.pool);
}
long nr (
) const { return nr_; }
long nc (
) const { return num_cols; }
void set_size (
long nr,
long nc
)
{
if (data)
{
pool.deallocate_array(data);
}
data = pool.allocate_array(nr*nc);
nr_ = nr;
}
#ifdef MATLAB_MEX_FILE
void _private_set_mxArray ( mxArray* ) { DLIB_CASSERT(false, "This function should never be called."); }
mxArray* _private_release_mxArray(){DLIB_CASSERT(false, "This function should never be called."); }
void _private_mark_non_persistent() {DLIB_CASSERT(false, "This function should never be called."); }
bool _private_is_persistent() const { return true; }
#endif
private:
T* data;
long nr_;
typename mem_manager::template rebind<T>::other pool;
};
// ------------------------------------------------------------------------------------
template <
typename T,
long num_rows,
long num_cols,
typename mem_manager
>
class layout<T,num_rows,num_cols,mem_manager,4> : noncopyable // when num_rows != 0 && num_cols == 0
{
public:
const static long NR = num_rows;
const static long NC = num_cols;
layout (
):data(0), nc_(0) { }
~layout ()
{
if (data)
{
pool.deallocate_array(data);
}
}
T& operator() (
long r,
long c
) { return data[r*nc_ + c]; }
const T& operator() (
long r,
long c
) const { return data[r*nc_ + c]; }
T& operator() (
long i
) { return data[i]; }
const T& operator() (
long i
) const { return data[i]; }
void swap(
layout& item
)
{
std::swap(item.data,data);
std::swap(item.nc_,nc_);
pool.swap(item.pool);
}
long nr (
) const { return num_rows; }
long nc (
) const { return nc_; }
void set_size (
long nr,
long nc
)
{
if (data)
{
pool.deallocate_array(data);
}
data = pool.allocate_array(nr*nc);
nc_ = nc;
}
#ifdef MATLAB_MEX_FILE
void _private_set_mxArray ( mxArray* ) { DLIB_CASSERT(false, "This function should never be called."); }
mxArray* _private_release_mxArray(){DLIB_CASSERT(false, "This function should never be called."); }
void _private_mark_non_persistent() {DLIB_CASSERT(false, "This function should never be called."); }
bool _private_is_persistent() const { return true; }
#endif
private:
T* data;
long nc_;
typename mem_manager::template rebind<T>::other pool;
};
// ------------------------------------------------------------------------------------
template <
typename T,
long num_rows,
long num_cols,
typename mem_manager
>
class layout<T,num_rows,num_cols,mem_manager,5> : noncopyable // when num_rows == 0 && num_cols == 0
{
public:
const static long NR = num_rows;
const static long NC = num_cols;
layout (
):data(0), nr_(0), nc_(0) { }
~layout ()
{
if (data)
{
pool.deallocate_array(data);
}
}
T& operator() (
long r,
long c
) { return data[r*nc_ + c]; }
const T& operator() (
long r,
long c
) const { return data[r*nc_ + c]; }
T& operator() (
long i
) { return data[i]; }
const T& operator() (
long i
) const { return data[i]; }
void swap(
layout& item
)
{
std::swap(item.data,data);
std::swap(item.nc_,nc_);
std::swap(item.nr_,nr_);
pool.swap(item.pool);
}
long nr (
) const { return nr_; }
long nc (
) const { return nc_; }
void set_size (
long nr,
long nc
)
{
if (data)
{
pool.deallocate_array(data);
}
data = pool.allocate_array(nr*nc);
nr_ = nr;
nc_ = nc;
}
#ifdef MATLAB_MEX_FILE
void _private_set_mxArray ( mxArray* ) { DLIB_CASSERT(false, "This function should never be called."); }
mxArray* _private_release_mxArray(){DLIB_CASSERT(false, "This function should never be called."); }
void _private_mark_non_persistent() {DLIB_CASSERT(false, "This function should never be called."); }
bool _private_is_persistent() const { return true; }
#endif
private:
T* data;
long nr_;
long nc_;
typename mem_manager::template rebind<T>::other pool;
};
};
// ----------------------------------------------------------------------------------------
struct column_major_layout
{
// if a matrix is bigger than this many bytes then don't put it on the stack
const static size_t max_stack_based_size = 256;
// this is a hack to avoid a compile time error in visual studio 8. I would just
// use sizeof(T) and be done with it but that won't compile. The idea here
// is to avoid using the stack allocation of the layout object if it
// is going to contain another matrix and also avoid asking for the sizeof()
// the contained matrix.
template <typename T>
struct get_sizeof_helper
{
const static std::size_t val = sizeof(T);
};
template <typename T, long NR, long NC, typename mm, typename l>
struct get_sizeof_helper<matrix<T,NR,NC,mm,l> >
{
const static std::size_t val = 1000000;
};
template <
typename T,
long num_rows,
long num_cols,
typename mem_manager,
int val = static_switch <
// when the sizes are all non zero and small
(num_rows*num_cols*get_sizeof_helper<T>::val <= max_stack_based_size) && (num_rows != 0 && num_cols != 0),
// when the sizes are all non zero and big
(num_rows*num_cols*get_sizeof_helper<T>::val > max_stack_based_size) && (num_rows != 0 && num_cols != 0),
num_rows == 0 && num_cols != 0,
num_rows != 0 && num_cols == 0,
num_rows == 0 && num_cols == 0
>::value
>
class layout ;
/*!
WHAT THIS OBJECT REPRESENTS
This object represents the actual allocation of space for a matrix.
Small matrices allocate all their data on the stack and bigger ones
use a memory_manager to get their memory.
!*/
// ------------------------------------------------------------------------------------
template <
typename T,
long num_rows,
long num_cols,
typename mem_manager
>
class layout<T,num_rows,num_cols,mem_manager,1> : noncopyable // when the sizes are all non zero and small
{
public:
const static long NR = num_rows;
const static long NC = num_cols;
layout() {}
T& operator() (
long r,
long c
) { return *(data+c*num_rows + r); }
const T& operator() (
long r,
long c
) const { return *(data+c*num_rows + r); }
T& operator() (
long i
) { return data[i]; }
const T& operator() (
long i
) const { return data[i]; }
void swap(
layout& item
)
{
for (long r = 0; r < num_rows; ++r)
{
for (long c = 0; c < num_cols; ++c)
{
exchange((*this)(r,c),item(r,c));
}
}
}
long nr (
) const { return num_rows; }
long nc (
) const { return num_cols; }
void set_size (
long,
long
)
{
}
#ifdef MATLAB_MEX_FILE
void _private_set_mxArray ( mxArray* ) { DLIB_CASSERT(false, "This function should never be called."); }
mxArray* _private_release_mxArray(){DLIB_CASSERT(false, "This function should never be called."); }
void _private_mark_non_persistent() {DLIB_CASSERT(false, "This function should never be called."); }
bool _private_is_persistent() const { return true; }
#endif
private:
T data[num_cols*num_rows];
};
// ------------------------------------------------------------------------------------
template <
typename T,
long num_rows,
long num_cols,
typename mem_manager
>
class layout<T,num_rows,num_cols,mem_manager,2> : noncopyable // when the sizes are all non zero and big
{
public:
const static long NR = num_rows;
const static long NC = num_cols;
layout (
) { data = pool.allocate_array(num_rows*num_cols); }
~layout ()
{ pool.deallocate_array(data); }
T& operator() (
long r,
long c
) { return data[c*num_rows + r]; }
const T& operator() (
long r,
long c
) const { return data[c*num_rows + r]; }
T& operator() (
long i
) { return data[i]; }
const T& operator() (
long i
) const { return data[i]; }
void swap(
layout& item
)
{
std::swap(item.data,data);
pool.swap(item.pool);
}
long nr (
) const { return num_rows; }
long nc (
) const { return num_cols; }
void set_size (
long ,
long
)
{
}
#ifdef MATLAB_MEX_FILE
void _private_set_mxArray ( mxArray* ) { DLIB_CASSERT(false, "This function should never be called."); }
mxArray* _private_release_mxArray(){DLIB_CASSERT(false, "This function should never be called."); }
void _private_mark_non_persistent() {DLIB_CASSERT(false, "This function should never be called."); }
bool _private_is_persistent() const { return true; }
#endif
private:
T* data;
typename mem_manager::template rebind<T>::other pool;
};
// ------------------------------------------------------------------------------------
template <
typename T,
long num_rows,
long num_cols,
typename mem_manager
>
class layout<T,num_rows,num_cols,mem_manager,3> : noncopyable // when num_rows == 0 && num_cols != 0,
{
public:
const static long NR = num_rows;
const static long NC = num_cols;
layout (
):data(0), nr_(0) { }
~layout ()
{
if (data)
pool.deallocate_array(data);
}
T& operator() (
long r,
long c
) { return data[c*nr_ + r]; }
const T& operator() (
long r,
long c
) const { return data[c*nr_ + r]; }
T& operator() (
long i
) { return data[i]; }
const T& operator() (
long i
) const { return data[i]; }
void swap(
layout& item
)
{
std::swap(item.data,data);
std::swap(item.nr_,nr_);
pool.swap(item.pool);
}
long nr (
) const { return nr_; }
long nc (
) const { return num_cols; }
void set_size (
long nr,
long nc
)
{
if (data)
{
pool.deallocate_array(data);
}
data = pool.allocate_array(nr*nc);
nr_ = nr;
}
#ifdef MATLAB_MEX_FILE
void _private_set_mxArray ( mxArray* ) { DLIB_CASSERT(false, "This function should never be called."); }
mxArray* _private_release_mxArray(){DLIB_CASSERT(false, "This function should never be called."); }
void _private_mark_non_persistent() {DLIB_CASSERT(false, "This function should never be called."); }
bool _private_is_persistent() const { return true; }
#endif
private:
T* data;
long nr_;
typename mem_manager::template rebind<T>::other pool;
};
// ------------------------------------------------------------------------------------
template <
typename T,
long num_rows,
long num_cols,
typename mem_manager
>
class layout<T,num_rows,num_cols,mem_manager,4> : noncopyable // when num_rows != 0 && num_cols == 0
{
public:
const static long NR = num_rows;
const static long NC = num_cols;
layout (
):data(0), nc_(0) { }
~layout ()
{
if (data)
{
pool.deallocate_array(data);
}
}
T& operator() (
long r,
long c
) { return data[c*num_rows + r]; }
const T& operator() (
long r,
long c
) const { return data[c*num_rows + r]; }
T& operator() (
long i
) { return data[i]; }
const T& operator() (
long i
) const { return data[i]; }
void swap(
layout& item
)
{
std::swap(item.data,data);
std::swap(item.nc_,nc_);
pool.swap(item.pool);
}
long nr (
) const { return num_rows; }
long nc (
) const { return nc_; }
void set_size (
long nr,
long nc
)
{
if (data)
{
pool.deallocate_array(data);
}
data = pool.allocate_array(nr*nc);
nc_ = nc;
}
#ifdef MATLAB_MEX_FILE
void _private_set_mxArray ( mxArray* ) { DLIB_CASSERT(false, "This function should never be called."); }
mxArray* _private_release_mxArray(){DLIB_CASSERT(false, "This function should never be called."); }
void _private_mark_non_persistent() {DLIB_CASSERT(false, "This function should never be called."); }
bool _private_is_persistent() const { return true; }
#endif
private:
T* data;
long nc_;
typename mem_manager::template rebind<T>::other pool;
};
// ------------------------------------------------------------------------------------
template <
typename T,
long num_rows,
long num_cols,
typename mem_manager
>
class layout<T,num_rows,num_cols,mem_manager,5> : noncopyable // when num_rows == 0 && num_cols == 0
{
public:
const static long NR = num_rows;
const static long NC = num_cols;
layout (
):data(0), nr_(0), nc_(0) { }
~layout ()
{
if (data)
{
pool.deallocate_array(data);
}
}
T& operator() (
long r,
long c
) { return data[c*nr_ + r]; }
const T& operator() (
long r,
long c
) const { return data[c*nr_ + r]; }
T& operator() (
long i
) { return data[i]; }
const T& operator() (
long i
) const { return data[i]; }
void swap(
layout& item
)
{
std::swap(item.data,data);
std::swap(item.nc_,nc_);
std::swap(item.nr_,nr_);
pool.swap(item.pool);
}
#ifdef MATLAB_MEX_FILE
void _private_set_mxArray ( mxArray* ) { DLIB_CASSERT(false, "This function should never be called."); }
mxArray* _private_release_mxArray(){DLIB_CASSERT(false, "This function should never be called."); }
void _private_mark_non_persistent() {DLIB_CASSERT(false, "This function should never be called."); }
bool _private_is_persistent() const { return true; }
#endif
long nr (
) const { return nr_; }
long nc (
) const { return nc_; }
void set_size (
long nr,
long nc
)
{
if (data)
{
pool.deallocate_array(data);
}
data = pool.allocate_array(nr*nc);
nr_ = nr;
nc_ = nc;
}
private:
T* data;
long nr_;
long nc_;
typename mem_manager::template rebind<T>::other pool;
};
#ifdef MATLAB_MEX_FILE
template <
long num_rows,
long num_cols
>
class layout<double,num_rows,num_cols,default_memory_manager,5> : noncopyable // when num_rows == 0 && num_cols == 0
{
public:
const static long NR = num_rows;
const static long NC = num_cols;
layout (
): data(0), nr_(0), nc_(0), make_persistent(true),set_by_private_set_mxArray(false),mem(0) { }
~layout ()
{
if (!set_by_private_set_mxArray && mem)
{
mxDestroyArray(mem);
mem = 0;
data = 0;
}
}
double& operator() (
long r,
long c
) { return data[c*nr_ + r]; }
const double& operator() (
long r,
long c
) const { return data[c*nr_ + r]; }
double& operator() (
long i
) { return data[i]; }
const double& operator() (
long i
) const { return data[i]; }
void _private_set_mxArray (
mxArray* mem_
)
{
// We don't own the pointer, so make note of that so we won't try to free
// it.
set_by_private_set_mxArray = true;
mem = mem_;
data = mxGetPr(mem);
nr_ = mxGetM(mem);
nc_ = mxGetN(mem);
}
mxArray* _private_release_mxArray()
{
DLIB_CASSERT(!make_persistent,"");
mxArray* temp = mem;
mem = 0;
set_by_private_set_mxArray = false;
data = 0;
nr_ = 0;
nc_ = 0;
return temp;
}
void _private_mark_non_persistent()
{
DLIB_CASSERT(mem == 0,"You can't convert a persistent matlab array to non-persistent.");
make_persistent = false;
}
bool _private_is_persistent() const
{
return make_persistent;
}
void swap(
layout& item
)
{
std::swap(item.make_persistent,make_persistent);
std::swap(item.set_by_private_set_mxArray,set_by_private_set_mxArray);
std::swap(item.mem,mem);
std::swap(item.data,data);
std::swap(item.nc_,nc_);
std::swap(item.nr_,nr_);
}
long nr (
) const { return nr_; }
long nc (
) const { return nc_; }
void set_size (
long nr,
long nc
)
{
if (!set_by_private_set_mxArray && mem)
{
mxDestroyArray(mem);
mem = 0;
data = 0;
}
set_by_private_set_mxArray = false;
mem = mxCreateDoubleMatrix(nr, nc, mxREAL);
if (mem == 0)
throw std::bad_alloc();
if (make_persistent)
mexMakeArrayPersistent(mem);
data = mxGetPr(mem);
nr_ = nr;
nc_ = nc;
}
private:
double* data;
long nr_;
long nc_;
bool make_persistent;
bool set_by_private_set_mxArray;
mxArray* mem;
};
template <
long num_rows,
long num_cols
>
class layout<float,num_rows,num_cols,default_memory_manager,5> : noncopyable // when num_rows == 0 && num_cols == 0
{
public:
const static long NR = num_rows;
const static long NC = num_cols;
layout (
): data(0), nr_(0), nc_(0), make_persistent(true),set_by_private_set_mxArray(false),mem(0) { }
~layout ()
{
if (!set_by_private_set_mxArray && mem)
{
mxDestroyArray(mem);
mem = 0;
data = 0;
}
}
float& operator() (
long r,
long c
) { return data[c*nr_ + r]; }
const float& operator() (
long r,
long c
) const { return data[c*nr_ + r]; }
float& operator() (
long i
) { return data[i]; }
const float& operator() (
long i
) const { return data[i]; }
void _private_set_mxArray (
mxArray* mem_
)
{
// We don't own the pointer, so make note of that so we won't try to free
// it.
set_by_private_set_mxArray = true;
mem = mem_;
data = (float*)mxGetData(mem);
nr_ = mxGetM(mem);
nc_ = mxGetN(mem);
}
mxArray* _private_release_mxArray()
{
DLIB_CASSERT(!make_persistent,"");
mxArray* temp = mem;
mem = 0;
set_by_private_set_mxArray = false;
data = 0;
nr_ = 0;
nc_ = 0;
return temp;
}
void _private_mark_non_persistent()
{
DLIB_CASSERT(mem == 0,"You can't convert a persistent matlab array to non-persistent.");
make_persistent = false;
}
bool _private_is_persistent() const
{
return make_persistent;
}
void swap(
layout& item
)
{
std::swap(item.make_persistent,make_persistent);
std::swap(item.set_by_private_set_mxArray,set_by_private_set_mxArray);
std::swap(item.mem,mem);
std::swap(item.data,data);
std::swap(item.nc_,nc_);
std::swap(item.nr_,nr_);
}
long nr (
) const { return nr_; }
long nc (
) const { return nc_; }
void set_size (
long nr,
long nc
)
{
if (!set_by_private_set_mxArray && mem)
{
mxDestroyArray(mem);
mem = 0;
data = 0;
}
set_by_private_set_mxArray = false;
mem = mxCreateNumericMatrix(nr, nc, mxSINGLE_CLASS, mxREAL);
if (mem == 0)
throw std::bad_alloc();
if (make_persistent)
mexMakeArrayPersistent(mem);
data = (float*)mxGetData(mem);
nr_ = nr;
nc_ = nc;
}
private:
float* data;
long nr_;
long nc_;
bool make_persistent;
bool set_by_private_set_mxArray;
mxArray* mem;
};
#endif
};
// ----------------------------------------------------------------------------------------
}
#if defined(__GNUC__) && ((__GNUC__ >= 4 && __GNUC_MINOR__ >= 8) || (__GNUC__ > 4))
#pragma GCC diagnostic pop
#endif
#endif // DLIB_MATRIx_DATA_LAYOUT_
| [
"carolladeira2@hotmail.com"
] | carolladeira2@hotmail.com |
b450fdeccd8295f4b032a76e171d3ff4b9729854 | d7c8eef037c29bfc28fdae98776413d2022db612 | /632. 最小区间.cpp | 5bdb693cb831f2b655f52ad75f554f0929e11fc7 | [] | no_license | Stayaccept/LeetCode | 0d3e83240ab9a3e51e8e153a2fd33f4f6ca43e8a | 1b5a3afd54583ea9945342832fde1d8b053ad96c | refs/heads/master | 2020-03-29T15:22:22.544462 | 2019-12-23T15:25:19 | 2019-12-23T15:25:19 | 150,060,048 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,135 | cpp | /*
* @lc app=leetcode.cn id=632 lang=cpp
*
* [632] 最小区间
*/
// @lc code=start
class Solution {
public:
int p[3505];
struct node{
int u,id;
friend bool operator<(node a,node b){
return a.u>b.u;
}
};
priority_queue<node> qu;
vector<int> smallestRange(vector<vector<int>>& nums) {
vector<int> ans;
int i,u,v,le,re,tmp,tmp_l,tmp_r;
re=-100005;
for(i=0;i<nums.size();i++){
p[i]=1;
qu.push((node){nums[i][0],i});
re=max(re,nums[i][0]);
}
le=qu.top().u;
tmp_l=le,tmp_r=re,tmp=re-le;
while(1){
u=qu.top().u;
v=qu.top().id;
qu.pop();
if(p[v]>=nums[v].size())
break;
qu.push((node){nums[v][p[v]],v});
le=qu.top().u;
re=max(re,nums[v][p[v]]);
p[v]++;
if(re-le<tmp){
tmp=re-le;
tmp_l=le,tmp_r=re;
}
}
ans.push_back(tmp_l);
ans.push_back(tmp_r);
return ans;
}
};
// @lc code=end
| [
"noreply@github.com"
] | noreply@github.com |
5003357d9fa1b32b50b186ffe8fd65ea6fbefa42 | 32b8db47c9335f65aeb39848c928c3b64fc8a52e | /tgame-client-classes-20160829/game/evolution/EvolutionCell.h | 3495a60c5dfb2a039139c9b256d0b51398417ef1 | [] | no_license | mengtest/backup-1 | 763dedbb09d662b0940a2cedffb4b9fd1f7fb35d | d9f34e5bc08fe88485ac82f8e9aa09b994bb0e54 | refs/heads/master | 2020-05-04T14:29:30.181303 | 2016-12-13T02:28:23 | 2016-12-13T02:28:23 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,468 | h | #ifndef EvolutionCell_h__
#define EvolutionCell_h__
#include "basic/BaseLayout.h"
class EvolutionCell: public UIWidget
{
public:
enum CellStat {
CELL_DARK,
CELL_NEXT,
CELL_LIGHT
};
public:
EvolutionCell();
virtual ~EvolutionCell();
virtual void setStat(CellStat stat);
protected:
CellStat m_eStat;
};
class EvolutionStarCell: public EvolutionCell
{
public:
enum StarColor {
STAR_GREEN,
STAR_BLUE,
STAR_PURPLE,
STAR_YELLOW,
STAR_RED,
};
public:
EvolutionStarCell();
virtual ~EvolutionStarCell();
/*static EvolutionStarCell* create(UILayout *pRefLayout);
bool initWithLayout(UILayout *pRefLayout);*/
static EvolutionStarCell* create();
virtual bool init();
// override start
virtual void setStat(CellStat stat);
// override end
void setColor(StarColor color);
private:
UIImageView *m_pStarImg;
unsigned int m_uColor;
};
class EvolutionSkillCell: public EvolutionCell
{
public:
EvolutionSkillCell();
virtual ~EvolutionSkillCell();
/*static EvolutionSkillCell* create(UILayout *pRefLayout);
bool initWithLayout(UILayout *pRefLayout);*/
static EvolutionSkillCell* create();
virtual bool init();
// override start
virtual void setStat(CellStat stat);
// override end
void setSkill(unsigned int uSkillID);
private:
UIImageView *m_pBgIconImg;
UIImageView *m_pSkillIconImg;
};
#endif // EvolutionCell_h__ | [
"1027718562@qq.com"
] | 1027718562@qq.com |
249da288dc226448db61ac8e59d83fd6a7f236ef | c0f3c24d18b55e9a20770f8cb2085585d35ac648 | /barre/barrerectangle.cpp | 7a01e701cc0e58001ff40f64fb1131a2ab2dbba2 | [] | no_license | Bouvet-Paul/ApprendreCpp | 16e69f9b81b353240617a1bab75bf391ce005231 | 5c89c135021e0ada7ab9c1a1d9d64b67e263a680 | refs/heads/master | 2023-08-14T21:36:07.933972 | 2021-09-22T08:49:32 | 2021-09-22T08:49:32 | 404,615,278 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 445 | cpp | #include "barrerectangle.h"
#include <iostream>
using namespace std;
BarreRectangle::BarreRectangle(string _reference, float _longueur, float _densite, string _nomAlliage, float _largeur):
Barre(_reference, _longueur, _densite, _nomAlliage),
largeur(_largeur)
{
cout << "constructeur de la classe barreRectangle" << endl ;
}
BarreRectangle::~BarreRectangle(){
cout << "Destructeur de la classe barreRectangle" << endl;
}
| [
"polobasket12@gmail.com"
] | polobasket12@gmail.com |
1da96016e9c3ffb3588af63d7866d04aa5fab748 | ec6caae2562da59ca9a71407e7d9e08dbe3b2867 | /Stock/ChildFrm.h | 74d9e95a41cc34fa3b15d868c8c9d63a7dfab0d0 | [] | no_license | renyi534/stock_view | 54cd36fe82d433f8d25487bd681ebc9026457082 | 8d1d027984b680f7df32e8011849e3a22cdee228 | refs/heads/master | 2016-09-05T19:53:05.076791 | 2012-07-20T15:15:09 | 2012-07-20T15:15:09 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,344 | h | // ChildFrm.h : interface of the CChildFrame class
//
/////////////////////////////////////////////////////////////////////////////
#if !defined(AFX_CHILDFRM_H__F8262907_9D66_430B_81D1_9A9E5AA1739A__INCLUDED_)
#define AFX_CHILDFRM_H__F8262907_9D66_430B_81D1_9A9E5AA1739A__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
class CChildFrame : public CMDIChildWnd
{
DECLARE_DYNCREATE(CChildFrame)
public:
CChildFrame();
// Attributes
public:
// Operations
public:
// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CChildFrame)
virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
//}}AFX_VIRTUAL
// Implementation
public:
virtual ~CChildFrame();
#ifdef _DEBUG
virtual void AssertValid() const;
virtual void Dump(CDumpContext& dc) const;
#endif
// Generated message map functions
protected:
//{{AFX_MSG(CChildFrame)
// NOTE - the ClassWizard will add and remove member functions here.
// DO NOT EDIT what you see in these blocks of generated code!
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
/////////////////////////////////////////////////////////////////////////////
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_CHILDFRM_H__F8262907_9D66_430B_81D1_9A9E5AA1739A__INCLUDED_)
| [
"renyi533@hotmail.com"
] | renyi533@hotmail.com |
f16031a29dda0e929dd54e6f90fab52eca997b59 | dd8106cf8685979560b1309d8468bb5018f5ef30 | /engine/src/cetech/resource_compiler/private/builddb.cc | dced1c890c213017a6fe71e03fe32c95e7ff12ce | [
"CC0-1.0",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | gitter-badger/cetech | b3433b41425216e0d15118101e6a016e28ca5706 | 2939194a82546c7cc8480717cc60dc2d49619527 | refs/heads/master | 2021-01-14T08:36:31.840039 | 2015-11-30T21:21:48 | 2015-11-30T21:21:48 | 47,177,915 | 0 | 0 | null | 2015-12-01T09:03:13 | 2015-12-01T09:03:12 | null | UTF-8 | C++ | false | false | 5,500 | cc | #include <cstdint>
#include "cetech/resource_compiler/private/builddb.h"
#include "cetech/log/log.h"
#include "celib/defines.h"
#include "sqlite3/sqlite3.h"
#include "cetech/filesystem/filesystem.h"
namespace cetech {
struct SQLiteSTMT {
sqlite3* _db;
sqlite3_stmt* _stmt;
SQLiteSTMT(sqlite3 * db, const char* sql) : _db(db) {
_db = db;
sqlite3_prepare_v2(db, sql, -1, &_stmt, NULL);
}
~SQLiteSTMT() {
sqlite3_finalize(_stmt);
}
SQLiteSTMT& bind_text(int num,
const char* text) {
sqlite3_bind_text(_stmt, num, text, -1, SQLITE_TRANSIENT);
return *this;
}
SQLiteSTMT& bind_int(int num,
int value) {
sqlite3_bind_int(_stmt, num, value);
return *this;
}
SQLiteSTMT& bind_int64(int num,
int64_t value) {
sqlite3_bind_int64(_stmt, num, value);
return *this;
}
const char* get_column_text(int num) {
return (const char*)sqlite3_column_text(_stmt, num);
}
int get_column_int(int num) {
return sqlite3_column_int(_stmt, num);
}
int64_t get_column_int64(int num) {
return sqlite3_column_int64(_stmt, num);
}
int step() {
int rc;
bool run = false;
do {
rc = sqlite3_step(_stmt);
switch (rc) {
case SQLITE_LOCKED:
sqlite3_reset(_stmt);
run = true;
continue;
case SQLITE_BUSY:
run = true;
continue;
case SQLITE_ROW:
case SQLITE_DONE:
run = false;
break;
default:
log::error("BuildDB", "SQL error '%s' (%d): %s", sqlite3_sql(
_stmt), rc, sqlite3_errmsg(_db));
run = false;
break;
}
} while (run);
return rc;
}
};
BuildDB::BuildDB() {}
BuildDB::~BuildDB() {
close();
};
void BuildDB::open(const char* db_path) {
sqlite3_open_v2(db_path,
&_db,
SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_SHAREDCACHE | SQLITE_OPEN_NOMUTEX,
NULL );
}
void BuildDB::close() {
sqlite3_close(_db);
}
void BuildDB::set_file(const char* filename,
time_t mtime) {
SQLiteSTMT(_db,
"INSERT OR REPLACE INTO files VALUES(NULL, ?1, ?2);"
).bind_text(1, filename).bind_int64(2, mtime).step();
}
void BuildDB::set_file_depend(const char* filename,
const char* depend_on) {
SQLiteSTMT(_db,
"INSERT INTO file_dependency (filename, depend_on) SELECT ?1, ?2 WHERE NOT EXISTS(SELECT 1 FROM file_dependency WHERE filename = ?1 AND depend_on = ?2);"
).bind_text(1, filename).bind_text(2, depend_on).step();
}
bool BuildDB::need_compile(StringId64_t root,
const char* filename) {
bool compile = true;
SQLiteSTMT stmt(_db,
"SELECT\n"
" file_dependency.depend_on, files.mtime\n"
"FROM\n"
" file_dependency\n"
"JOIN\n"
" files on files.filename == file_dependency.depend_on\n"
"WHERE\n"
" file_dependency.filename = ?1\n");
stmt.bind_text(1, filename);
while (stmt.step() == SQLITE_ROW) {
compile = false;
time_t actual_mtime = filesystem::file_mtime(root, stmt.get_column_text(0));
time_t last_mtime = stmt.get_column_int64(1);
if (actual_mtime != last_mtime) {
compile = true;
break;
}
}
return compile;
}
bool BuildDB::init_db() {
// Create files table
{
SQLiteSTMT query(_db,
"CREATE TABLE IF NOT EXISTS files (\n"
"id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,\n"
"filename TEXT UNIQUE NOT NULL,\n"
"mtime INTEGER NOT NULL\n"
");");
if (query.step() != SQLITE_DONE) {
return false;
}
}
{
// Create file_dependency table
SQLiteSTMT query(_db,
"CREATE TABLE IF NOT EXISTS file_dependency (\n"
"id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,\n"
"filename TEXT NOT NULL,\n"
"depend_on TEXT NOT NULL\n"
");");
if (query.step() != SQLITE_DONE) {
return false;
}
}
return true;
}
}
| [
"o.voves@gmail.com"
] | o.voves@gmail.com |
c939bc0e35da4ec9d289eff639ba6e6f14464a15 | ec37ee79c6b57758119c5ebea120da8712f53dc5 | /Practice questions/PointersToPointers.cpp | 08e2c457515a3cee252add6dc2901cc2e7923821 | [] | no_license | rakhi2207/C-Learning | 76a063560270efbb68de95ab911aeabe22d58462 | f576121685b1503c9ab4276c4ec480297f93a1fc | refs/heads/master | 2023-06-25T08:07:41.130542 | 2021-07-25T11:11:35 | 2021-07-25T11:11:35 | 374,215,501 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 275 | cpp | #include<iostream>
using namespace std;
int main()
{
int **p,*q,a;
a=10;
q=&a;
p=&q;
cout<<a<<"\n";
cout<<&a<<"\n";
cout<<q<<"\n";
cout<<*q<<"\n";
cout<<&q<<"\n";
cout<<p<<"\n";
cout<<*p<<"\n";
cout<<**p<<"\n";
return 0;
} | [
"jharakhi1211@gmail.com"
] | jharakhi1211@gmail.com |
b16ddc22188b12d6cfea5a8d2421d224d1d77f6e | 80dc00aebfb7e8a748e26e978f99bbb224d3845c | /EMProject/CommandTable.cpp | 143ba6681abdb65143af1db53c3903d07b25a649 | [] | no_license | NTUST-CSIE-Engineering-Mathematics-Team/Engineering-Mathematics-Project | 3e80c0970866ea3dbbff033baf1fc8b753ec3ca9 | 776bf7725be9586b8c3e3a1833e930fb5698b92d | refs/heads/master | 2021-01-16T18:02:16.960553 | 2014-04-10T08:49:23 | 2014-04-10T08:49:23 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 447 | cpp | #include "CommandTable.h"
using namespace em::intrprt::cmd;
CommandTable::CommandTable(array<Command^>^ commands) : ConstantTable(createKeys(commands), commands) {
}
CommandTable::~CommandTable() {
}
array<String^>^ CommandTable::createKeys(array<Command^>^ commands) {
array<String^>^ keys = gcnew array<String^>(commands->Length);
for (int i = 0; i < commands->Length; i++) {
keys[i] = commands[i]->commandLiteral;
}
return keys;
} | [
"maeglin89273@gmail.com"
] | maeglin89273@gmail.com |
fb8217986b249106fc2e4698518b9237e875dbef | 867a94c4b137da3f08014854cd68cec2ca42ab78 | /Trees/leftView.cpp | f189c76eba9912e46993d333e8e2112ca4ccdcd2 | [] | no_license | sakshistar/LeetcodeSolutions | 9391bdf6ebd7b4c86a75358c51f43374423a618e | 13ff8e61caf6c0bcff32a964c81060e1c28497a5 | refs/heads/master | 2022-12-29T20:13:28.083884 | 2020-10-23T13:31:01 | 2020-10-23T13:31:01 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 423 | cpp | void leftView(Node *root)
{
// Your code here
queue<Node*> q;
if(root==NULL) return ;
q.push(root);
while(!q.empty()){
int n=q.size();
for(int i=0;i<n;i++){
Node* f=q.front();
q.pop();
if(i==0){
cout << f->data << " ";
}
if(f->left) q.push(f->left);
if(f->right) q.push(f->right);
}
}
}
| [
"nishantc.co.17@nsiit.net.in"
] | nishantc.co.17@nsiit.net.in |
ad3fbdfc974526d166cd624fd4192f8203b18b49 | 17aa3adf597cc4d33bb712a160a6754cc3503d3c | /topology/sourcefile/ParticleObject.h | a696e035b01540e415b6a934ce035ef3770a8106 | [] | no_license | qingerqingting/ihep | 9318c8d5b77fb5bdb02bff2591c5bc849ddb1270 | c7d40e840732a2e1303c0b5d6ad3b72987c175e1 | refs/heads/master | 2021-01-22T10:09:03.125693 | 2017-09-04T07:50:05 | 2017-09-04T07:50:05 | 102,332,605 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 695 | h | #ifndef ParticleObject_h
#define ParticleObject_h 1
#include <string>
#include <fstream>
#include <vector>
class ParticleObject
{
public:
ParticleObject();
~ParticleObject();
std::string GetParName(int ) const;
double GetParMass(int ) const;
private:
std::ifstream parListFile;
struct MyParticle
{
std::string col1;
std::string col2;
std::string ParType;
std::string ParName;
int ParId;
double ParMass;
double ParWidth;
double ParDm;
int Par3Charge;
int Par2Spin;
double ParLifeTime;
int ParLundKC;
};
MyParticle aMyParticle;
std::vector<MyParticle> Vparticle;
};
#endif
| [
"729258078@qq.com"
] | 729258078@qq.com |
12b152631391cb946ae511f986e0045f3fb91b03 | 4636812cd9de422639d8fab6f63696364bb0db03 | /labs_first_course_2019-2020/lab4/P12/Source.cpp | 2d5a96bcab7069b1f51673a19aec0398f7f0066a | [] | no_license | Andrey2528/Program_c-plus-plus | 506fe990e3cb387ce9ebc311fe2f235615b06864 | c0297cdf3124f1469664f4e8d81754cd579d4f91 | refs/heads/main | 2023-02-24T16:27:16.611488 | 2021-01-28T12:16:03 | 2021-01-28T12:16:03 | 333,746,725 | 0 | 0 | null | null | null | null | WINDOWS-1251 | C++ | false | false | 212 | cpp | /*12. Поясніть чому еквівалентні наступні оператори :
a) if (x) x = 0; і if (x!= 0) x = 0;
b) if (!x) x = 1; і if (x == 0) x = 1;*/
//Жуков Андрій 10.10.2019
| [
"andreys20.2016@ukr.net"
] | andreys20.2016@ukr.net |
621d24b5cc6a8408110e800dba415f642d89cb69 | 67e6870300fa50f02b175f58dd435e313d08452b | /PRGQUEUE.CPP | 39efc4d5a1a07ff1074e49e2289a577a204e1a05 | [] | no_license | MANEESHAPR535/DS-lab | 0a9070e44dadb3fe177c90558829449c417534bf | 9da5694742f95c9924f8df1195cbf8919b39a256 | refs/heads/main | 2023-03-02T10:21:21.645635 | 2021-02-08T12:38:16 | 2021-02-08T12:38:16 | 330,363,007 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,539 | cpp | #include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#define sz 5
int front=-1,rear=-1;
void enqueue(int *q)
{
if(front==(rear+1)%sz)
{
printf("\n queue is full \n");
return;
}
if(front==-1)
front=0;
rear=(rear+1)%sz;
printf(" \n enter the element want to insert:");
scanf("%d",&q[rear]);
}
void dequeue(int *q)
{
if(front==-1)
{
printf("\n queue is empty") ;
return;
}
printf("\n deleted element is %d \n",q[front]);
if (front==rear)
front=rear=-1;
else
front=(front+1)%sz;
return;
}
void search(int *q)
{
int f,x,pos;
if(front==-1)
{
printf("\n queue is empty");
return;
}
printf("\n enter the element want tosearch:\n");
scanf("%d",&x);
f=front;
pos=1;
while(1)
{
if(q[f]==x)
{
printf("\n element found at location:%d \n",pos);
break;
}
if(f==rear)
{
printf(" \n element not found \n");
break;
}
f=(f+1)%sz;
pos=pos+1;
}
}
void display(int *q)
{
int f;
if(front==-1)
{
printf("\n queue is empty");
return;
}
f=front;
while(1)
{
printf(" \n the elements are :%d \n",q[f]);
if(f==rear)
break;
f=(f+1)%sz;
}
}
void main()
{
int choice,q[sz];
clrscr();
while(1)
{
printf("**********MENU********");
printf("\n 1.insert \n 2.delete \n 3.search \n 4.display \n 5.exit\n ");
printf("\n enter the choice:");
scanf(" \n %d",&choice);
switch(choice)
{
case 1:enqueue(q);
break;
case 2:dequeue(q);
break;
case 3:search(q);
break;
case 4:display(q);
break;
case 5:
exit(1);
default:
printf("\n please given a valid choice");
break;
}
}
} | [
"noreply@github.com"
] | noreply@github.com |
3ac17fb3d315946cf8b9f91cb60943dc9231eada | 082948f59374775195affa69f06b26ccbad6ec63 | /Clairewd’sMessage.cpp | 9f8780f0c5e348c46ebfd3bed7c3cc65f18cd915 | [] | no_license | Udun00/everydayText | 082c661d8c29c7251763548ee7e90c1ade219245 | 5681947124fe4cbbcf033ff15af1c789e3362949 | refs/heads/main | 2023-06-04T16:58:19.195166 | 2021-06-16T13:34:36 | 2021-06-16T13:34:36 | 372,553,952 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,406 | cpp | /*
题目：https://vjudge.net/contest/441568#problem/D
思路：题目相当于给出了一个转变字符串和信息字符串，利用信息前缀和后缀kmp匹配，找到最长的匹配长度，未匹配的字符串转变回去放在信息字符串后面，输出信息字符串
*/
//代码实现
#include<stdio.h>
#include<string.h>
int next[1000010];
char s[1000010];
char t[30];
void get_next()
{
next[0]=0;
int i=0,j=0;
int len=strlen(s);
for(int i=1;i<len;i++)
{
j=next[i-1];
while(j>0&&s[i]!=s[j])
{
j=next[j-1];
}
if(s[i]==s[j])
{
next[i]=j+1;
}
else
next[i]=0;
}
}
int kmp()
{
get_next();
int len=strlen(s);
int j=0;
for(int i=(len+1)/2;i<len;i++)
{
while(j>0&&t[s[i]-'a']!=s[j])
{
j=next[j-1];
}
if(t[s[i]-'a']==s[j])
{
j++;
}
}
return j;
}
int main()
{
int y;
scanf("%d",&y);
while(y--)
{
scanf("%s",t);
getchar();
scanf("%s",s);
int len=strlen(s);
int sum=kmp();
int c=len;
for(int i=sum;i<len-sum;i++)
{
s[c++]=strchr(t,s[i])-t+'a';//转回去，strchr函数，在t字符串找到第一次出现s[i]的位置
}
s[c]='\0';
printf("%s\n",s);
}
}
| [
"noreply@github.com"
] | noreply@github.com |
8767e7d5bdc0a794d5d74f9bc7e2473e1e36ea0b | 8e58c645b241773ac78ea542d30145d7943b5739 | /ui/ImageLabel.cpp | 91e54863c5807d9dc56ce5e8c8e8aa835d756abe | [] | no_license | PuddingZJU/QGrabCut | 4354e1a38019de5d65d674ae6eef423f5abc3c4a | 40bfe98ae1e8b619bbb840f758ea22faf35bec5e | refs/heads/master | 2023-04-02T17:28:09.891564 | 2014-05-27T02:32:10 | 2014-05-27T02:32:10 | null | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 5,405 | cpp | #include <QPainter>
#include <QPoint>
#include <QScrollBar>
#include <QSlider>
#include <QScrollBar>
#include "ImageLabel.h"
#include "ParamWidget.h"
#include "QGrabCut.h"
/// ImageLabel function
ImageLabel::~ImageLabel()
{
}
ImageLabel::ImageLabel(QImage *img): ImageWidget(img)
{
}
void ImageLabel::release()
{
obj_points.clear();
obj_rects.clear();
bkg_rects.clear();
bkg_points.clear();
seeds.clear();
}
void ImageLabel::mouseMoveEvent( QMouseEvent * event)
{
const QPoint &pos = event->globalPos();
if (left_mouse_pressed)
{
QScrollArea *scroll_area = dynamic_cast<QScrollArea *>((this->parentWidget()->parentWidget()));
/// 移动滚动条
QScrollBar *_scroll_bar = scroll_area->horizontalScrollBar();
QScrollBar *_v_scroll_bar = scroll_area->verticalScrollBar();
_scroll_bar->setValue(_scroll_bar->value() - pos.x() + move_pos.x());
_v_scroll_bar->setValue(_v_scroll_bar->value() - pos.y() + move_pos.y());
move_pos = pos;
}
else if (right_mouse_pressed)
{
if (!response_right_mouse) return;
/// 依赖于QGrabCut
QGrabCut* parent = dynamic_cast<QGrabCut*>(this->nativeParentWidget());
QComboBox *combo_box_obj = parent->param_widget->ui.comboBox_obj;
QComboBox *combo_box_bkg = parent->param_widget->ui.comboBox_bkg;
SeedRecord seed_record;
DotPoint &point = seed_record.point;
point.line_width = parent->line_width;
point.scale = this->scale;
DotRect &rect = seed_record.rect;
rect.scale = this->scale;
if (parent->obj_paint)
{
seed_record.category = SC_Obj;
if (combo_box_obj->currentIndex() == 0)
{
seed_record.type = ST_Point;
point.color = parent->obj_color;
///加入开始按下的那个点
point.local_pos = press_pos_local;
seeds.push_back(seed_record);
point.local_pos = event->pos();
seeds.push_back(seed_record);
}
else if (combo_box_obj->currentIndex() == 1)
{
if (!has_record_rect)
{
seed_record.type = ST_Rect;
rect.color = parent->obj_color;
rect.local_rect.setTopLeft(press_pos_local);
rect.local_rect.setBottomRight(event->pos());
seeds.push_back(seed_record);
has_record_rect = true;
}
else
{
SeedRecord &tmp_record = seeds[seeds.size() - 1];
tmp_record.rect.local_rect.setBottomRight(event->pos());
}
}
}
/// 背景
else
{
seed_record.category = SC_Bkg;
if ( combo_box_bkg->currentIndex() == 0)
{
seed_record.type = ST_Point;
point.color = parent->bkg_color;
point.local_pos = event->pos();
seeds.push_back(seed_record);
}
else if (combo_box_bkg->currentIndex() == 1)
{
if (!has_record_rect)
{
seed_record.type = ST_Rect;
rect.color = parent->bkg_color;
rect.local_rect.setTopLeft(press_pos_local);
rect.local_rect.setBottomRight(event->pos());
seeds.push_back(seed_record);
has_record_rect = true;
}
else
{
SeedRecord &tmp_record = seeds[seeds.size() - 1];
tmp_record.rect.local_rect.setBottomRight(event->pos());
}
}
}
this->repaint();
}
}
void ImageLabel::paintEvent(QPaintEvent *event)
{
QLabel::paintEvent(event);
DrawPoints(this);
}
void ImageLabel::DrawPoints(QPaintDevice * device)
{
QPainter painter(device);
painter.setRenderHint(QPainter::Antialiasing, true);
QGrabCut* parent = dynamic_cast<QGrabCut*>(this->nativeParentWidget());
for (int ii = 0; ii < seeds.size(); ii++)
{
SeedRecord &seed_record = seeds[ii];
if (seed_record.type == ST_Point)
{
painter.setPen(QPen(seed_record.point.color, seed_record.point.line_width * scale/seed_record.point.scale, Qt::SolidLine, Qt::RoundCap));
painter.drawPoint(seed_record.point.local_pos * scale/seed_record.point.scale);
}
else if (seed_record.type == ST_Rect)
{
painter.setBrush(QBrush(seed_record.rect.color, Qt::SolidPattern));
painter.setPen(QPen(seed_record.rect.color, 1, Qt::SolidLine, Qt::RoundCap));
QRect tmp_rect;
tmp_rect.setTopLeft(seed_record.rect.local_rect.topLeft() * scale/seed_record.rect.scale);
tmp_rect.setBottomRight(seed_record.rect.local_rect.bottomRight() * scale/seed_record.rect.scale);
painter.drawRect(tmp_rect);
}
}
}
QImage ImageLabel::make_mask_image()
{
QImage paint_image(image.size(), QImage::Format_RGB32);
paint_image.fill(0xFF7F7F7F);
QPainter painter(&paint_image);
painter.setRenderHint(QPainter::Antialiasing, true);
for (int ii = 0; ii < seeds.size(); ii++)
{
SeedRecord &seed_record = seeds[ii];
if (seed_record.category == SC_Bkg)
{
painter.setPen(QPen(QColor(0, 0, 0), seed_record.point.line_width/seed_record.point.scale, Qt::SolidLine, Qt::RoundCap));
painter.setBrush(QBrush(QColor(0, 0, 0), Qt::SolidPattern));
}
else if (seed_record.category == SC_Obj)
{
painter.setPen(QPen(QColor(0xFF, 0xFF, 0xFF), seed_record.point.line_width/seed_record.point.scale, Qt::SolidLine, Qt::RoundCap));
painter.setBrush(QBrush(QColor(0xFF, 0xFF, 0xFF), Qt::SolidPattern));
}
if (seed_record.type == ST_Point)
{
painter.drawPoint(seed_record.point.local_pos/seed_record.point.scale);
}
else if (seed_record.type == ST_Rect)
{
QRect tmp_rect;
tmp_rect.setTopLeft(seed_record.rect.local_rect.topLeft()/seed_record.rect.scale);
tmp_rect.setBottomRight(seed_record.rect.local_rect.bottomRight()/seed_record.rect.scale);
painter.drawRect(tmp_rect);
}
}
return paint_image;
} | [
"leonroxas@gmail.com"
] | leonroxas@gmail.com |
e2aa7ebdf08e17713c5c23d692bf9fbc5aee5413 | 407a7e8a3178f43ee7b074c7a69071deeee07f2a | /P2/software/fuentes/AGE-posicion.cpp | a5046bebcfdc8be8cdf33a93e2f0cd6df7b44e9b | [
"MIT"
] | permissive | dcabezas98/MH | db025ce2bfc5d757f72ec7891302b3b470f2a8da | 98ced0552d6736004225aaafb5facd385a9a28d2 | refs/heads/main | 2023-05-27T02:51:04.233126 | 2021-06-15T18:24:49 | 2021-06-15T18:24:49 | 344,588,856 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,269 | cpp | #include <iostream>
#include <vector>
#include <stdlib.h> // srand y rand
#include <algorithm> // sort y random_shuffle
#include <time.h>
using namespace std;
int EVALS=0; // Llamadas a evaluación
const int LIMIT=100000; // Límite de evaluaciones
const int CHROMOSOMES=50; // Nº cromosomas
float PROB_MUT=0.1; // Hay que partir por n (nº genes por cromosoma) luego
/* Parámetros del problema, fijos durante toda la ejecución*/
unsigned n=0; // Número de posibles elementos (número de genes)
unsigned m=0; // Tam. soluciones (número de genes a 1)
// random generator function:
int rndGen (int i) { return rand()%i;}
// Lee la entrada y la almacena en una matriz
void readInput (vector<vector<double>> &mat) {
unsigned i, j;
double f;
int s = mat.size();
int iter = s*(s-1)/2;
for (int k=0; k<iter; k++) {
cin >> i >> j >> f;
mat[i][j] = mat[j][i] = f;
}
}
/********** Evaluación ***************/
// Contribución de un elemento
double singleContribution(vector<int> &solution, vector<vector<double> > &mat, int elem) {
double result = 0;
vector<int>::iterator it;
for (it = solution.begin(); it != solution.end(); it++) {
result += mat[ elem ][ *it ];
}
return result;
}
// Variedad de una solución
double evaluateSolution(vector<int> &solution, vector<vector<double> > &mat) {
double fitness = 0;
vector<int>::iterator it;
for (it = solution.begin(); it != solution.end(); it++) {
fitness += singleContribution(solution, mat, *it);
}
return fitness /= 2; // Las cuenta doble
}
class Solution {
public:
vector<int> s;
double fitness;
void operator = (const Solution &sol) {
s=sol.s;
fitness=sol.fitness;
}
void evaluate(vector<vector<double> > &mat) {
fitness = evaluateSolution(s, mat);
}
void mutate() { // Muta un gen aleatorio
int elem_out = rand()%m; // Índice del elemento que saco
int elem_in;
do {
elem_in = rand()%n; // Elemento que meto
} while(find(s.begin(),s.end(),elem_in)!=s.end()); // Si ya está, cogemos otro
s[elem_out]=elem_in; // En la posición del que saco, pongo el que entra
}
};
// Cruze basado en posición
Solution positionCross(const Solution &sol1, const Solution &sol2, vector<vector<double> > &mat){
Solution child;
bool inS1, inS2;
vector<int> aux(n); // Elementos selecionados en un padre y no en el otro
unsigned n_aux=0;
for(unsigned i = 0; i<n; i++){
inS1=find(sol1.s.begin(),sol1.s.end(),i)!=sol1.s.end();
inS2=find(sol2.s.begin(),sol2.s.end(),i)!=sol2.s.end();
if (inS1 && inS2) // Está en los dos padres
child.s.push_back(i);
else if (!inS1 && !inS2){} // No está en ninguno
else { // Está en uno de ellos
aux[n_aux]=i;
n_aux++;
}
}
for (unsigned i = 0; i < n-n_aux; i++){ // Elimino los espacios no utilizados
aux.pop_back();
}
random_shuffle(aux.begin(),aux.end(),rndGen); // Relleno con aleatorios
while (child.s.size()<m){
child.s.push_back(aux.back());
aux.pop_back();
}
return child;
}
// Genera solución aleatoria
vector<int> randomSol(){
vector<int> selected;
vector<int> elements;
for (unsigned i=0; i<n; i++) {
elements.push_back(i);
}
random_shuffle(elements.begin(),elements.end(),rndGen);
while (selected.size()<m){
selected.push_back(elements.back());
elements.pop_back();
}
return selected;
}
class Population {
public:
vector<Solution> v;
Population(bool first=false) {
v.resize(CHROMOSOMES);
if (first){ // La primera población de todas
for (int i = 0; i < CHROMOSOMES; i++){
v[i].s=randomSol();
// v[i].fitness=evaluateSolution(v[i].s);
}
}
}
void operator = (const Population &pop) {
v=pop.v;
}
void evaluate(vector<vector<double> > &mat) {
for (unsigned i=0;i<CHROMOSOMES; i++){
v[i].evaluate(mat);
}
}
int binTournament(){ // Devuelve el mejor índice de dos aleatorios
int s1 = rand()%CHROMOSOMES;
int s2 = rand()%CHROMOSOMES;
return v[s1].fitness>v[s2].fitness ? s1 : s2;
}
void selection(int &parent1, int &parent2){
parent1=binTournament();
parent2=binTournament();
}
int bestSol(){ // Índice mejor solución
int best_index=0;
for(unsigned i = 1; i < CHROMOSOMES; i++){
if(v[i].fitness>v[best_index].fitness)
best_index=i;
}
return best_index;
}
void worst2Sol(unsigned &worst_index, unsigned &second_worst_index){ // Índices de las dos peores soluciones
worst_index=0;
for(unsigned i = 1; i < CHROMOSOMES; i++){
if(v[i].fitness<v[worst_index].fitness)
worst_index=i;
}
second_worst_index= worst_index==0 ? 1 : 0;
for(unsigned i = 1; i < CHROMOSOMES; i++){
if(v[i].fitness<v[second_worst_index].fitness && i!=worst_index)
second_worst_index=i;
}
}
void replacement(const Solution &child1, const Solution &child2){
unsigned w1=0, w2=0;
worst2Sol(w1,w2);
//cout << w1 << " " << w2 << endl;
/* Hay que quedarse con las dos mejores de las 4 */
if(child1.fitness>v[w2].fitness){
v[w1]=v[w2];
v[w2]=child1;
}else if (child1.fitness>v[w1].fitness)
v[w1]=child1;
if(child2.fitness>v[w1].fitness)
v[w1]=child2;
}
void cross(int p1, int p2, Solution &c1, Solution &c2, vector<vector<double> > &mat){
c1 = positionCross(v[p1], v[p2], mat);
c2 = positionCross(v[p1], v[p2], mat);
}
};
void age(vector<vector<double> > &mat) {
clock_t t_start, t_total;
t_start = clock();
Population population(true); // Primera población
population.evaluate(mat); // Evaluación de todos
EVALS+=CHROMOSOMES;
int p1, p2; // Índices de los padres
Solution c1, c2; // Hijos
float prob_mut_chrom = PROB_MUT*n; // Probabilidad de mutación por cromosoma
float x; // Para ver si se muta
while(EVALS<LIMIT){
population.selection(p1,p2);
population.cross(p1,p2,c1,c2, mat);
x=static_cast<float>(rand())/static_cast<float>(RAND_MAX); // Número aleatorio en [0,1]
if (x<prob_mut_chrom)
c1.mutate();
x=static_cast<float>(rand())/static_cast<float>(RAND_MAX); // Número aleatorio en [0,1]
if (x<prob_mut_chrom)
c2.mutate();
c1.evaluate(mat);
c2.evaluate(mat);
EVALS+=2;
population.replacement(c1,c2);
//cout << population.v[population.bestSol()].fitness << endl;
}
t_total = clock() - t_start;
// output: Diversidad - Tiempo
double diversity = population.v[population.bestSol()].fitness; // Fitness de la mejor solución
cout << diversity << "\t" << (double) t_total / CLOCKS_PER_SEC << endl;
}
/******************* MAIN **********************/
int main( int argc, char *argv[] ) {
cin >> n >> m; // Leemos los parámetros n y m
PROB_MUT/=n; // La probabilidad de mutación va dividida por n (nº de genes por cromosoma)
vector<double> v (n, 0); // Vector de ceros con n componentes
vector<vector<double > > mat (n, v); // Matriz de nxn ceros
readInput(mat); // Leemos la entrada
cout << fixed;
srand(stoi(argv[1])); // SEED as parameter
age(mat);
} | [
"dxabezas@gmail.com"
] | dxabezas@gmail.com |
19c5eeefdb7009f2f0744ff67827111a0a333a3f | 90646db14c522b842a6a7a5517fb43f38a7ee3ed | /gef_abertay/samples/animation_playback/motion_clip_player.cpp | 0744211c53ad7c0720a2a1b4d6a30f5748b9af1b | [] | no_license | AlbanFl/GeometryGame | 531ac3ecdcd448ca28f2a934421caaaaee5cab56 | 779e57db1192388c42784bc278ec88c649ec46ff | refs/heads/master | 2021-01-19T16:34:01.350076 | 2017-04-17T09:32:03 | 2017-04-17T09:32:03 | 88,271,177 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,495 | cpp | #include "motion_clip_player.h"
#include <animation/animation.h>
#include <system/debug_log.h>
MotionClipPlayer::MotionClipPlayer() :
clip_(NULL),
anim_time_(0.0f),
playback_speed_(1.0f),
looping_(false)
{
}
bool MotionClipPlayer::Update(const float delta_time, const gef::SkeletonPose& bind_pose)
{
bool finished = false;
if (clip_)
{
// update the animation playback time
anim_time_ += delta_time*playback_speed_;
// check to see if the playback has reached the end of the animation
if(anim_time_ > clip_->duration())
{
// if the animation is looping then wrap the playback time round to the beginning of the animation
// other wise set the playback time to the end of the animation and flag that we have reached the end
if(looping_)
anim_time_ = std::fmodf(anim_time_, clip_->duration());
else
{
anim_time_ = clip_->duration();
finished = true;
}
}
// add the clip start time to the playback time to calculate the final time
// that will be used to sample the animation data
float time = anim_time_+clip_->start_time();
// sample the animation data at the calculated time
// any bones that don't have animation data are set to the bind pose
pose_.SetPoseFromAnim(*clip_, bind_pose, time);
}
else
{
// no animation associated with this player
// just set the pose to the bind pose
pose_ = bind_pose;
}
// return true if we have reached the end of the animation, always false when playback is looped
return finished;
} | [
"alban.flandin@gmail.com"
] | alban.flandin@gmail.com |
1d24e640c7f26e89eb1b40d0414f0ce785c3e20c | 643e735e5bc6ece28ed925976cd9d50ce1cd9d13 | /ScrapCalc/Shared/Libraries/chilkat-9.5.0-ios/cpp_include/CkXml.h | f7a4a88771a9ac335cbbcf5b3a1a0f1684ab8348 | [
"MIT"
] | permissive | hamza1216/metalcalc-ios | 20c1cb2a8c2609233ed929d1b816f2d797efd153 | 57f83a0a614ca4d024e706d253df3246c0e3a301 | refs/heads/main | 2023-07-10T00:47:06.695060 | 2021-08-04T22:11:31 | 2021-08-04T22:11:31 | 392,833,018 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 38,609 | h | // CkXml.h: interface for the CkXml class.
//
//////////////////////////////////////////////////////////////////////
// This header is generated for Chilkat v9.5.0
#ifndef _CkXml_H
#define _CkXml_H
#include "chilkatDefs.h"
#include "CkString.h"
#include "CkMultiByteBase.h"
class CkByteData;
#ifndef __sun__
#pragma pack (push, 8)
#endif
// CLASS: CkXml
class CK_VISIBLE_PUBLIC CkXml : public CkMultiByteBase
{
private:
// Don't allow assignment or copying these objects.
CkXml(const CkXml &);
CkXml &operator=(const CkXml &);
public:
CkXml(void);
virtual ~CkXml(void);
static CkXml *createNew(void);
void CK_VISIBLE_PRIVATE inject(void *impl);
// May be called when finished with the object to free/dispose of any
// internal resources held by the object.
void dispose(void);
// BEGIN PUBLIC INTERFACE
// ----------------------
// Properties
// ----------------------
// When True, causes an XML node's content to be encapsulated in a CDATA section.
bool get_Cdata(void);
// When True, causes an XML node's content to be encapsulated in a CDATA section.
void put_Cdata(bool newVal);
// The content of the XML node. It is the text between the open and close tags, not
// including child nodes. For example:
// _LT_tag1_GT_This is the content_LT_/tag1_GT_
//
// _LT_tag2_GT__LT_child1_GT_abc_LT_/child1_GT__LT_child2_GT_abc_LT_/child2_GT_This is the content_LT_/tag2_GT_
// Because the child nodes are not included, the content of "tag1" and "tag2" are
// both equal to "This is the content".
void get_Content(CkString &str);
// The content of the XML node. It is the text between the open and close tags, not
// including child nodes. For example:
// _LT_tag1_GT_This is the content_LT_/tag1_GT_
//
// _LT_tag2_GT__LT_child1_GT_abc_LT_/child1_GT__LT_child2_GT_abc_LT_/child2_GT_This is the content_LT_/tag2_GT_
// Because the child nodes are not included, the content of "tag1" and "tag2" are
// both equal to "This is the content".
const char *content(void);
// The content of the XML node. It is the text between the open and close tags, not
// including child nodes. For example:
// _LT_tag1_GT_This is the content_LT_/tag1_GT_
//
// _LT_tag2_GT__LT_child1_GT_abc_LT_/child1_GT__LT_child2_GT_abc_LT_/child2_GT_This is the content_LT_/tag2_GT_
// Because the child nodes are not included, the content of "tag1" and "tag2" are
// both equal to "This is the content".
void put_Content(const char *newVal);
// Set/get the content as an integer.
int get_ContentInt(void);
// Set/get the content as an integer.
void put_ContentInt(int newVal);
// The DOCTYPE declaration (if any) for the XML document.
void get_DocType(CkString &str);
// The DOCTYPE declaration (if any) for the XML document.
const char *docType(void);
// The DOCTYPE declaration (if any) for the XML document.
void put_DocType(const char *newVal);
// If true, then the XML declaration is emitted for methods (such as GetXml or
// SaveXml) where the XML is written to a file or string. The default value of this
// property is true. If set to false, the XML declaration is not emitted. (The
// XML declaration is the 1st line of an XML document starting with "_AMP_?xml
// ...".
bool get_EmitXmlDecl(void);
// If true, then the XML declaration is emitted for methods (such as GetXml or
// SaveXml) where the XML is written to a file or string. The default value of this
// property is true. If set to false, the XML declaration is not emitted. (The
// XML declaration is the 1st line of an XML document starting with "_AMP_?xml
// ...".
void put_EmitXmlDecl(bool newVal);
// This is the encoding attribute in the XML declaration, such as "utf-8" or
// "iso-8859-1". The default is "utf-8". This property can be set from any node in
// the XML document and when set, causes the encoding property to be added to the
// XML declaration. Setting this property does not cause the document to be
// converted to a different encoding.
//
// Calling any of the LoadXml* methods causes this property to be set to the
// charset found within the XML, if any. If no charset is specified within the
// loaded XML, then the LoadXml method resets this property to its default value of
// "utf-8".
//
void get_Encoding(CkString &str);
// This is the encoding attribute in the XML declaration, such as "utf-8" or
// "iso-8859-1". The default is "utf-8". This property can be set from any node in
// the XML document and when set, causes the encoding property to be added to the
// XML declaration. Setting this property does not cause the document to be
// converted to a different encoding.
//
// Calling any of the LoadXml* methods causes this property to be set to the
// charset found within the XML, if any. If no charset is specified within the
// loaded XML, then the LoadXml method resets this property to its default value of
// "utf-8".
//
const char *encoding(void);
// This is the encoding attribute in the XML declaration, such as "utf-8" or
// "iso-8859-1". The default is "utf-8". This property can be set from any node in
// the XML document and when set, causes the encoding property to be added to the
// XML declaration. Setting this property does not cause the document to be
// converted to a different encoding.
//
// Calling any of the LoadXml* methods causes this property to be set to the
// charset found within the XML, if any. If no charset is specified within the
// loaded XML, then the LoadXml method resets this property to its default value of
// "utf-8".
//
void put_Encoding(const char *newVal);
// The number of attributes. For example, the following node has 2 attributes:
// _LT_tag attr1="value1" attr2="value2"> This is the content_LT_/tag>
int get_NumAttributes(void);
// The number of direct child nodes contained under this XML node.
int get_NumChildren(void);
// If true (or 1 for ActiveX), then all Sort* methods use case insensitive sorting.
bool get_SortCaseInsensitive(void);
// If true (or 1 for ActiveX), then all Sort* methods use case insensitive sorting.
void put_SortCaseInsensitive(bool newVal);
// This is the standalone attribute in the XML declaration. This property can be
// set from any node in the XML document. A value of true adds a standalone="yes"
// to the XML declaration:
// _LT_?xml ... standalone="yes">
bool get_Standalone(void);
// This is the standalone attribute in the XML declaration. This property can be
// set from any node in the XML document. A value of true adds a standalone="yes"
// to the XML declaration:
// _LT_?xml ... standalone="yes">
void put_Standalone(bool newVal);
// The XML node's tag.
void get_Tag(CkString &str);
// The XML node's tag.
const char *tag(void);
// The XML node's tag.
void put_Tag(const char *newVal);
// Each tree (or XML document) has a unique TreeId. This is the ID of the tree, and
// can be used to determine if two Xml objects belong to the same tree.
int get_TreeId(void);
// ----------------------
// Methods
// ----------------------
// Accumulates the content of all nodes having a specific tag into a single result
// string. SkipTags specifies a set of tags whose are to be avoided. The skipTags
// are formatted as a string of tags delimited by vertical bar characters. All
// nodes in sub-trees rooted with a tag appearing in skipTags are not included in
// the result.
bool AccumulateTagContent(const char *tag, const char *skipTags, CkString &outStr);
// Accumulates the content of all nodes having a specific tag into a single result
// string. SkipTags specifies a set of tags whose are to be avoided. The skipTags
// are formatted as a string of tags delimited by vertical bar characters. All
// nodes in sub-trees rooted with a tag appearing in skipTags are not included in
// the result.
const char *accumulateTagContent(const char *tag, const char *skipTags);
// Adds an attribute to the calling node in the XML document. Returns True for
// success, and False for failure.
bool AddAttribute(const char *name, const char *value);
// Adds an integer attribute to a node.
bool AddAttributeInt(const char *name, int value);
// Adds an entire subtree as a child. If the child was a subtree within another Xml
// document then the subtree is effectively transferred from one XML document to
// another.
bool AddChildTree(const CkXml &tree);
// Adds an attribute to an XML node. If an attribute having the specified name
// already exists, the value is updated.
void AddOrUpdateAttribute(const char *name, const char *value);
// Adds an integer attribute to an XML node. If an attribute having the specified
// name already exists, the value is updated.
void AddOrUpdateAttributeI(const char *name, int value);
// Adds a style sheet declaration to the XML document. The styleSheet should be a string
// such as:
// _LT_?xml-stylesheet href="mystyle.css" title="Compact" type="text/css"?>
void AddStyleSheet(const char *styleSheet);
// Adds an integer amount to an integer attribute's value. If the attribute does
// not yet exist, this method behaves the same as AddOrUpdateAttributeI.
void AddToAttribute(const char *name, int amount);
// Adds an integer value to the content of a child node.
void AddToChildContent(const char *tag, int amount);
// Adds an integer amount to the node's content.
void AddToContent(int amount);
// Appends text to the content of an XML node
bool AppendToContent(const char *str);
// Sets the node's content with 8bit data that is in a specified multibyte
// character encoding such as utf-8, shift-jis, big5, etc. The data is first
// B-encoded and the content is set to be the B-encoded string. For example, if
// called with "Big5"for the charset, you would get a string that looks something
// like this: "=?Big5?B?pHCtsw==?=". The data is Base64-encoded and stored between
// the last pair of "?" delimiters. Use the DecodeContent method to retrieve the
// byte data from a B encoded string.
bool BEncodeContent(const char *charset, const CkByteData &inData);
// Return true if a child having a specific tag contains content that matches a
// wildcarded pattern.
bool ChildContentMatches(const char *tag, const char *pattern, bool caseSensitive);
// Follows a series of commands to navigate through an XML document to return a
// piece of data or update the caller's reference to a new XML document node.
//
// Note: This method not related to the XPath (XML Path) standard in any way.
//
// The pathCmd is formatted as a series of commands separated by vertical bar
// characters, and terminated with a return-command:
// command|command|command|...|returnCommand
//
// A command can be any of the following:
// TagName -- Navigate to the 1st direct child with the given tag.
// TagName[n] -- Navigate to the Nth direct child with the given tag.
// .. -- Navigate up to the parent
// TagName{Content} -- Navigate to the 1st direct child with the given tag
// having the exact content.
// /T/TagName -- Traverse the XML DOM tree (rooted at the caller) and navigate
// to the 1st node having the given tag.
// /C/TagName,ContentPattern -- Traverse the XML DOM tree (rooted at the
// caller) and navigate to the 1st node having the given tag with content that
// matches the ContentPattern. ContentPattern may use one or more asterisk ('*")
// characters to represent 0 or more of any character.
// /C/ContentPattern -- Traverse the XML DOM tree (rooted at the caller) and
// navigate to the 1st node having any tag with content that matches the
// ContentPattern. ContentPattern may use one or more asterisk ('*") characters to
// represent 0 or more of any character.
// /A/TagName,AttrName,AttrValuePattern -- Traverse the XML DOM tree (rooted at
// the caller) and navigate to the 1st node having the given tag, and attribute,
// with the attribute value that matches the AttrValuePattern. AttrValuePattern may
// use one or more asterisk ('*") characters to represent 0 or more of any
// character.
// The returnCommand can be any of the following:
// * -- Return the Content of the node.
// (AttrName) -- Return the value of the given attribute.
// $ -- Update the caller's internal reference to be the node (arrived at by
// following the series of commands). Returns an empty string.
//
bool ChilkatPath(const char *pathCmd, CkString &outStr);
// Follows a series of commands to navigate through an XML document to return a
// piece of data or update the caller's reference to a new XML document node.
//
// Note: This method not related to the XPath (XML Path) standard in any way.
//
// The pathCmd is formatted as a series of commands separated by vertical bar
// characters, and terminated with a return-command:
// command|command|command|...|returnCommand
//
// A command can be any of the following:
// TagName -- Navigate to the 1st direct child with the given tag.
// TagName[n] -- Navigate to the Nth direct child with the given tag.
// .. -- Navigate up to the parent
// TagName{Content} -- Navigate to the 1st direct child with the given tag
// having the exact content.
// /T/TagName -- Traverse the XML DOM tree (rooted at the caller) and navigate
// to the 1st node having the given tag.
// /C/TagName,ContentPattern -- Traverse the XML DOM tree (rooted at the
// caller) and navigate to the 1st node having the given tag with content that
// matches the ContentPattern. ContentPattern may use one or more asterisk ('*")
// characters to represent 0 or more of any character.
// /C/ContentPattern -- Traverse the XML DOM tree (rooted at the caller) and
// navigate to the 1st node having any tag with content that matches the
// ContentPattern. ContentPattern may use one or more asterisk ('*") characters to
// represent 0 or more of any character.
// /A/TagName,AttrName,AttrValuePattern -- Traverse the XML DOM tree (rooted at
// the caller) and navigate to the 1st node having the given tag, and attribute,
// with the attribute value that matches the AttrValuePattern. AttrValuePattern may
// use one or more asterisk ('*") characters to represent 0 or more of any
// character.
// The returnCommand can be any of the following:
// * -- Return the Content of the node.
// (AttrName) -- Return the value of the given attribute.
// $ -- Update the caller's internal reference to be the node (arrived at by
// following the series of commands). Returns an empty string.
//
const char *chilkatPath(const char *pathCmd);
// Removes all children, attributes, and content from the XML node. Resets the tag
// name to "unnamed".
bool Clear(void);
// Return true if the node's content matches a wildcarded pattern.
bool ContentMatches(const char *pattern, bool caseSensitive);
// Copies the tag, content, and attributes to the calling node.
void Copy(const CkXml &node);
// Discards the caller's current internal reference and copies the internal
// reference from copyFromNode. Effectively updates the caller node to point to the same
// node in the XML document as copyFromNode.
void CopyRef(CkXml &node);
// Decodes a node's Q or B-encoded content string and returns the byte data.
bool DecodeContent(CkByteData &outData);
// Utility method to decode HTML entities. It accepts a string containing
// (potentially) HTML entities and returns a string with the entities decoded.
bool DecodeEntities(const char *str, CkString &outStr);
// Utility method to decode HTML entities. It accepts a string containing
// (potentially) HTML entities and returns a string with the entities decoded.
const char *decodeEntities(const char *str);
// Decrypts the content of an XML node that was previously 128-bit AES encrypted
// with the EncryptContent method.
bool DecryptContent(const char *password);
// Encrypts the content of the calling XML node using 128-bit CBC AES encryption.
// The base64-encoded encrypted content replaces the original content.
bool EncryptContent(const char *password);
// Removes and returns the Nth child of an XML node. The first child is at index 0.
// The caller is responsible for deleting the object returned by this method.
CkXml *ExtractChildByIndex(int index);
// Removes and returns the first child node having a tag equal to the tagName. The
// attributeName and attrValue may be empty or NULL, in which case the first child
// matching the tag is removed and returned. If attributeName is specified, then
// the first child having a tag equal to tagName, and an attribute with
// attributeName is returned. If attrValue is also specified, then only a child
// having a tag equal to tagName, and an attribute named attributeName, with a
// value equal to attrValue is returned.
// The caller is responsible for deleting the object returned by this method.
CkXml *ExtractChildByName(const char *tag, const char *attrName, const char *attrValue);
// Returns the child having a specified tag.
// The caller is responsible for deleting the object returned by this method.
CkXml *FindChild(const char *tag);
// Updates the Xml object's internal reference to point to a child with a specified
// tag.
bool FindChild2(const char *tag);
// Returns the next record node where the child with a specific tag matches a
// wildcarded pattern. This method makes it easy to iterate over high-level
// records.
// The caller is responsible for deleting the object returned by this method.
CkXml *FindNextRecord(const char *tag, const char *contentPattern);
// First searches for a child having a tag equal to tagName, and if found, returns
// it. Otherwise creates a new child, sets the tag equal to tagName, and
// initializes the Content to empty.
// The caller is responsible for deleting the object returned by this method.
CkXml *FindOrAddNewChild(const char *tag);
// Returns the first child. A program can step through the children by calling
// FirstChild, and then NextSibling repeatedly.
// The caller is responsible for deleting the object returned by this method.
CkXml *FirstChild(void);
// Updates the internal reference of the caller to point to its first child.
bool FirstChild2(void);
// Find and return the value of an attribute having a specified name.
bool GetAttrValue(const char *name, CkString &outStr);
// Find and return the value of an attribute having a specified name.
const char *getAttrValue(const char *name);
// Find and return the value of an attribute having a specified name.
const char *attrValue(const char *name);
// Returns an attribute as an integer.
int GetAttrValueInt(const char *name);
// Returns the name of the Nth attribute of an XML node. The first attribute is at
// index 0.
bool GetAttributeName(int index, CkString &outStr);
// Returns the name of the Nth attribute of an XML node. The first attribute is at
// index 0.
const char *getAttributeName(int index);
// Returns the name of the Nth attribute of an XML node. The first attribute is at
// index 0.
const char *attributeName(int index);
// Returns the value of the Nth attribute of an XML node. The first attribute is at
// index 0.
bool GetAttributeValue(int index, CkString &outStr);
// Returns the value of the Nth attribute of an XML node. The first attribute is at
// index 0.
const char *getAttributeValue(int index);
// Returns the value of the Nth attribute of an XML node. The first attribute is at
// index 0.
const char *attributeValue(int index);
// Returns an attribute as an integer.
int GetAttributeValueInt(int index);
// Returns binary content of an XML node as a byte array. The content may have been
// Zip compressed, AES encrypted, or both. Unzip compression and AES decryption
// flags should be set appropriately.
bool GetBinaryContent(bool unzipFlag, bool decryptFlag, const char *password, CkByteData &outData);
// Returns the Nth child of an XML node
// The caller is responsible for deleting the object returned by this method.
CkXml *GetChild(int index);
// Updates the calling object's internal reference to the Nth child node.
bool GetChild2(int index);
// Returns false if the node's content is "0", otherwise returns true if the
// node contains a non-zero integer.
bool GetChildBoolValue(const char *tag);
// Returns the content of a child having a specified tag.
bool GetChildContent(const char *tag, CkString &outStr);
// Returns the content of a child having a specified tag.
const char *getChildContent(const char *tag);
// Returns the content of a child having a specified tag.
const char *childContent(const char *tag);
// Returns the content of the Nth child node.
bool GetChildContentByIndex(int index, CkString &outStr);
// Returns the content of the Nth child node.
const char *getChildContentByIndex(int index);
// Returns the content of the Nth child node.
const char *childContentByIndex(int index);
// Returns the child having the exact tag and content.
// The caller is responsible for deleting the object returned by this method.
CkXml *GetChildExact(const char *tag, const char *content);
// Returns the child integer content for a given tag.
int GetChildIntValue(const char *tag);
// Returns the tag name of the Nth child node.
bool GetChildTag(int index, CkString &outStr);
// Returns the tag name of the Nth child node.
const char *getChildTag(int index);
// Returns the tag name of the Nth child node.
const char *childTag(int index);
// Returns the tag name of the Nth child node.
bool GetChildTagByIndex(int index, CkString &outStr);
// Returns the tag name of the Nth child node.
const char *getChildTagByIndex(int index);
// Returns the tag name of the Nth child node.
const char *childTagByIndex(int index);
// Finds and returns the XML child node having both a given tag and an attribute
// with a given name and value.
// The caller is responsible for deleting the object returned by this method.
CkXml *GetChildWithAttr(const char *tag, const char *attrName, const char *attrValue);
// Returns the first child found having the exact content specified.
// The caller is responsible for deleting the object returned by this method.
CkXml *GetChildWithContent(const char *content);
// Returns the Xml child object having a tag matching tagName.
// The caller is responsible for deleting the object returned by this method.
CkXml *GetChildWithTag(const char *tag);
// Returns the Nth child having a tag that matches exactly with the tagName. Use
// the NumChildrenHavingTag method to determine how many children have a particular
// tag.
// The caller is responsible for deleting the object returned by this method.
CkXml *GetNthChildWithTag(const char *tag, int n);
// Updates the calling object's internal reference to the Nth child node having a
// specific tag.
bool GetNthChildWithTag2(const char *tag, int n);
// Returns the parent of this XML node, or NULL if the node is the root of the
// tree.
// The caller is responsible for deleting the object returned by this method.
CkXml *GetParent(void);
// Updates the internal reference of the caller to its parent.
bool GetParent2(void);
// Returns the root node of the XML document
// The caller is responsible for deleting the object returned by this method.
CkXml *GetRoot(void);
// Updates the internal reference of the caller to the document root.
void GetRoot2(void);
// Returns a new XML object instance that references the same XML node.
// The caller is responsible for deleting the object returned by this method.
CkXml *GetSelf(void);
// Generate the XML text document for the XML tree rooted at this node. If called
// from the root node of the XML document, then the XML declarator ("_LT_?xml
// version="1.0" encoding="utf-8" ?>") is included at the beginning of the XML.
// Otherwise, it is not included.
bool GetXml(CkString &outStr);
// Generate the XML text document for the XML tree rooted at this node. If called
// from the root node of the XML document, then the XML declarator ("_LT_?xml
// version="1.0" encoding="utf-8" ?>") is included at the beginning of the XML.
// Otherwise, it is not included.
const char *getXml(void);
// Generate the XML text document for the XML tree rooted at this node. If called
// from the root node of the XML document, then the XML declarator ("_LT_?xml
// version="1.0" encoding="utf-8" ?>") is included at the beginning of the XML.
// Otherwise, it is not included.
const char *xml(void);
// Returns true if the node contains attribute with the name and value.
bool HasAttrWithValue(const char *name, const char *value);
// Returns true if the node contains an attribute with the specified name.
bool HasAttribute(const char *name);
// Returns true if the node has a direct child node containing the exact content
// string specified.
bool HasChildWithContent(const char *content);
// Returns true (1 for ActiveX) if the node has a direct child with a given tag.
bool HasChildWithTag(const char *tag);
// Returns true if the node contains a direct child having the exact tag and
// content specified.
bool HasChildWithTagAndContent(const char *tag, const char *content);
// Adds an entire subtree as a child. If the child was a subtree within another Xml
// document then the subtree is effectively transferred from one XML document to
// another. The child tree is inserted in a position after the Nth child (of the
// calling node).
bool InsertChildTreeAfter(int index, const CkXml &tree);
// Adds an entire subtree as a child. If the child was a subtree within another Xml
// document then the subtree is effectively transferred from one XML document to
// another. The child tree is inserted in a position before the Nth child (of the
// calling node).
bool InsertChildTreeBefore(int index, const CkXml &tree);
// Returns the last Xml child node. A node's children can be enumerated by calling
// LastChild and then repeatedly calling PreviousSibling, until a NULL is returned.
// The caller is responsible for deleting the object returned by this method.
CkXml *LastChild(void);
// Updates the internal reference of the caller to its last child.
bool LastChild2(void);
// Loads an XML document from a memory buffer and returns true if successful. The
// contents of the calling node are replaced with the root node of the XML document
// loaded.
bool LoadXml(const char *xmlData);
// Same as LoadXml, but an additional argument controls whether or not
// leading/trailing whitespace is auto-trimmed from each node's content.
bool LoadXml2(const char *xmlData, bool autoTrim);
// Loads an XML document from a file and returns true if successful. The contents
// of the calling node are replaced with the root node of the XML document loaded.
bool LoadXmlFile(const char *fileName);
// Same as LoadXmlFile, but an additional argument controls whether or not
// leading/trailing whitespace is auto-trimmed from each node's content.
bool LoadXmlFile2(const char *fileName, bool autoTrim);
// Creates a new child having tag and content. The new child is created even if a
// child with a tag equal to tagName already exists. (Use FindOrAddNewChild to
// prevent creating children having the same tags.)
// The caller is responsible for deleting the object returned by this method.
CkXml *NewChild(const char *tag, const char *content);
// Creates a new child but does not return the node that is created.
void NewChild2(const char *tag, const char *content);
// Inserts a new child in a position after the Nth child node.
// The caller is responsible for deleting the object returned by this method.
CkXml *NewChildAfter(int index, const char *tag, const char *content);
// Inserts a new child in a position before the Nth child node.
// The caller is responsible for deleting the object returned by this method.
CkXml *NewChildBefore(int index, const char *tag, const char *content);
// Inserts a new child having an integer for content.
void NewChildInt2(const char *tag, int value);
// Returns the nodes next sibling, or NULL if there are no more.
// The caller is responsible for deleting the object returned by this method.
CkXml *NextSibling(void);
// Updates the internal reference of the caller to its next sibling.
bool NextSibling2(void);
// Returns the number of children having a specific tag name.
int NumChildrenHavingTag(const char *tag);
// Returns the Xml object that is the node's previous sibling, or NULL if there are
// no more.
// The caller is responsible for deleting the object returned by this method.
CkXml *PreviousSibling(void);
// Updates the internal reference of the caller to its previous sibling.
bool PreviousSibling2(void);
// Sets the node's content with 8bit data that is in a specified multibyte
// character encoding such as utf-8, shift-jis, big5, etc. The data is first
// Q-encoded and the content is set to be the Q-encoded string. For example, if
// called with "gb2312"for the charset, you would get a string that looks something
// like this: "=?gb2312?Q?=C5=B5=BB=F9?=". Character that are not 7bit are
// represented as "=XX" where XX is the hexidecimal value of the byte. Use the
// DecodeContent method to retrieve the byte data from a Q encoded string.
bool QEncodeContent(const char *charset, const CkByteData &inData);
// Removes all attributes from an XML node. Should always return True.
bool RemoveAllAttributes(void);
// Removes all children from the calling node.
void RemoveAllChildren(void);
// Removes an attribute by name from and XML node.
bool RemoveAttribute(const char *name);
// Removes all direct children with a given tag.
void RemoveChild(const char *tag);
// Removes the Nth child from the calling node.
void RemoveChildByIndex(int index);
// Removes all children having the exact content specified.
void RemoveChildWithContent(const char *content);
// Removes the calling object and its sub-tree from the XML document making it the
// root of its own tree.
void RemoveFromTree(void);
// Saves a node's binary content to a file.
bool SaveBinaryContent(const char *filename, bool unzipFlag, bool decryptFlag, const char *password);
// Generates XML representing the tree or subtree rooted at this node and writes it
// to a file.
bool SaveXml(const char *fileName);
// Returns the first node whose content matches the contentPattern, which is a
// case-sensitive string that can use any number of '*'s to represent 0 or more
// occurances of any character. The search is breadth-first over the sub-tree
// rooted at the caller, and the previous node returned can be passed to the next
// call as afterNode to continue the search after that node.
// The caller is responsible for deleting the object returned by this method.
CkXml *SearchAllForContent(const CkXml *afterPtr, const char *contentPattern);
// Same as SearchAllForContent except the internal reference of the caller is
// updated to point to the search result (instead of returning a new object).
bool SearchAllForContent2(const CkXml *afterPtr, const char *contentPattern);
// Returns the first node having a tag equal to tagName, and an attribute named
// attrName whose value matches valuePattern, which is a case-sensitive string that
// can use any number of '*'s to represent 0 or more occurances of any character.
// The search is breadth-first over the sub-tree rooted at the caller, and the
// previous node returned can be passed to the next call as afterNode to continue
// the search after that node.
// The caller is responsible for deleting the object returned by this method.
CkXml *SearchForAttribute(const CkXml *afterPtr, const char *tag, const char *attr, const char *valuePattern);
// Same as SearchForAttribute except the internal reference of the caller is
// updated to point to the search result (instead of returning a new object).
bool SearchForAttribute2(const CkXml *afterPtr, const char *tag, const char *attr, const char *valuePattern);
// Returns the first node having a tag equal to tagName whose content matches
// contentPattern, which is a case-sensitive string that can use any number of '*'s
// to represent 0 or more occurances of any character. The search is breadth-first
// over the sub-tree rooted at the caller, and the previous node returned can be
// passed to the next call as afterNode to continue the search after that node.
// The caller is responsible for deleting the object returned by this method.
CkXml *SearchForContent(const CkXml *afterPtr, const char *tag, const char *contentPattern);
// Same as SearchForContent except the internal reference of the caller is updated
// to point to the search result (instead of returning a new object).
bool SearchForContent2(const CkXml *afterPtr, const char *tag, const char *contentPattern);
// Returns the first node having a tag equal to tagName. The search is
// breadth-first over the sub-tree rooted at the caller, and the previous node
// returned can be passed to the next call as afterNode to continue the search
// after that node.
// The caller is responsible for deleting the object returned by this method.
CkXml *SearchForTag(const CkXml *afterPtr, const char *tag);
// Same as SearchForTag except the internal reference of the caller is updated to
// point to the search result (instead of returning a new object).
bool SearchForTag2(const CkXml *afterPtr, const char *tag);
// Sets the node's content to a block of binary data with optional Zip compression
// and/or AES encryption. The binary data is automatically converted to base64
// format whenever XML text is generated. If the zipFlag is True, the data is first
// compressed. If the encryptFlag is True, the data is AES encrypted using the
// Rijndael 128-bit symmetric-encryption algorithm.
bool SetBinaryContent(const CkByteData &inData, bool zipFlag, bool encryptFlag, const char *password);
#if !defined(CHILKAT_MONO)
// The same as SetBinaryContent but the data is provided via a pointer and byte
// count.
bool SetBinaryContent2(const unsigned char *pByteData, unsigned long szByteData, bool zipFlag, bool encryptFlag, const char *password);
#endif
// Sets the node's content with binary (or text) data from a file. The file
// contents can be Zip compressed and/or encrypted, and the result is base-64
// encoded.
bool SetBinaryContentFromFile(const char *filename, bool zipFlag, bool encryptFlag, const char *password);
// Sorts the direct child nodes by the value of a specified attribute.
void SortByAttribute(const char *attrName, bool ascending);
// Sorts the direct child nodes by the value of a specified attribute interpreted
// as an integer (not lexicographically as strings).
void SortByAttributeInt(const char *attrName, bool ascending);
// Sorts the direct child nodes by content.
void SortByContent(bool ascending);
// Sorts the direct child nodes by tag.
void SortByTag(bool ascending);
// Sorts the direct child nodes by the content of an attribute in the grandchild
// nodes.
void SortRecordsByAttribute(const char *sortTag, const char *attrName, bool ascending);
// Sorts the direct child nodes by the content of the grandchild nodes.
void SortRecordsByContent(const char *sortTag, bool ascending);
// Sorts the direct child nodes by the content of the grandchild nodes. For sorting
// purposes, the content is interpreted as an integer (not lexicographically as for
// strings).
void SortRecordsByContentInt(const char *sortTag, bool ascending);
// Swaps another node's tag, content, and attributes with this one.
bool SwapNode(const CkXml &node);
// Swaps another node's tag, content, attributes, and children with this one.
bool SwapTree(const CkXml &tree);
// Returns the content of the 1st node found in the sub-tree rooted at the caller
// that has a given tag. (Note: The search for the node having tag ARG is not
// limited to the direct children of the caller.)
bool TagContent(const char *tag, CkString &outStr);
// Returns the content of the 1st node found in the sub-tree rooted at the caller
// that has a given tag. (Note: The search for the node having tag ARG is not
// limited to the direct children of the caller.)
const char *tagContent(const char *tag);
// Returns true if the node's tag equals the specified string.
bool TagEquals(const char *tag);
// Unzip the content of the XML node replacing it's content with the decompressed
// data.
bool UnzipContent(void);
// Unzips and recreates the XML node and the entire subtree, restoring it to the
// state before it was zip compressed.
bool UnzipTree(void);
// Adds an attribute to the node if it doesn't already exist. Otherwise it updates
// the existing attribute with the new value.
bool UpdateAttribute(const char *attrName, const char *attrValue);
// Updates an attribute value. (Call UpdateAttribute if the attribute value is a
// string.)
bool UpdateAttributeInt(const char *attrName, int value);
// Replaces the content of a child node.
void UpdateChildContent(const char *tag, const char *value);
// Replaces the content of a child node where the content is an integer.
void UpdateChildContentInt(const char *tag, int value);
// Applies Zip compression to the content of an XML node and replaces the content
// with base64-encoded compressed data.
bool ZipContent(void);
// Zip compresses the content and entire subtree rooted at the calling XML node and
// replaces the current content with base64-encoded Zip compressed data. The node
// and subtree can be restored by calling UnzipTree. Note that the node name and
// attributes are unaffected.
bool ZipTree(void);
// END PUBLIC INTERFACE
};
#ifndef __sun__
#pragma pack (pop)
#endif
#endif
| [
"hamza.el.kedmiri.1216@gmail.com"
] | hamza.el.kedmiri.1216@gmail.com |
443e1bc2b3d9bb7510464e0feb5ad9c25d61bc4b | 19f94a97c553355e88b8b0f07b19ef38d2fbde48 | /src/Scene/AbstScene.h | 1b9db8290d74a3654482cd7865d7136869a8034b | [] | no_license | sakakiy/of_simpleShootingGame | 18ca63a63010712d065e8fa6f61f9370401f7097 | 5ab96932fed8c79a4e0062ccd26d373c69a9698c | refs/heads/master | 2021-01-23T18:51:14.427376 | 2014-11-09T09:00:28 | 2014-11-09T09:00:28 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 434 | h | //
// AbstScene.h
// simpleShootingGame
//
// Created by 榊原吉伸 on 2014/11/03.
//
//
#ifndef __simpleShootingGame__AbstScene__
#define __simpleShootingGame__AbstScene__
#include <stdio.h>
#include <ofMain.h>
class AbstScene{
protected:
AbstScene **scene;
public:
virtual void setup() = 0;
virtual void update() = 0;
virtual void draw() = 0;
};
#endif /* defined(__simpleShootingGame__AbstScene__) */
| [
"sakura.colonnade@gmail.com"
] | sakura.colonnade@gmail.com |
649d8c797be5b8fe3b4950e9487433267e09c50f | cc7661edca4d5fb2fc226bd6605a533f50a2fb63 | /Assembly-CSharp/PrefabPoolCollection.h | 79ced939ff6c83ac03d8b0d71008df91036e9974 | [
"MIT"
] | permissive | g91/Rust-C-SDK | 698e5b573285d5793250099b59f5453c3c4599eb | d1cce1133191263cba5583c43a8d42d8d65c21b0 | refs/heads/master | 2020-03-27T05:49:01.747456 | 2017-08-23T09:07:35 | 2017-08-23T09:07:35 | 146,053,940 | 1 | 0 | null | 2018-08-25T01:13:44 | 2018-08-25T01:13:44 | null | UTF-8 | C++ | false | false | 234 | h | #pragma once
namespace rust
{
class PrefabPoolCollection : public Object // 0x0
{
public:
System.Collections.Generic.Dictionary<unsigned int,PrefabPool> storage; // 0x10 (size: 0x8, flags: 0x6, type: 0x15)
}; // size = 0x18
}
| [
"info@cvm-solutions.co.uk"
] | info@cvm-solutions.co.uk |
ebcced477415e31157fda2bd0c94cb65277950f1 | b848fc13e9e1dbfe80ac5c6782f10de1d6645736 | /Loki/move.cpp | c78973609003df65debb4a3ab04e95a2de4f6278 | [] | no_license | amanjpro/Loki | 87e0c9a0eb878bb8b7e26513feba2462e145ed3a | 29a75b6e156dc8a98fc79c2960b9da92bcaf8d7a | refs/heads/master | 2023-04-24T07:42:40.676677 | 2021-04-24T19:26:12 | 2021-04-24T19:26:12 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,873 | cpp | #include "move.h"
Move_t* MoveList::operator[](int index) {
if (index >= size() || index < 0) {
return nullptr;
}
return (moveList + index);
}
/*
MOVE REPRESENTATION IS INSPIRED BY STOCKFISH
A move can be stored in a 16 bit unsigned integer.
bit 0..5 -> destination square (0 to 63)
bit 6..11 -> origin square (0 to 63)
bit 12..13 -> promotion piece ((0) knight = 00, (1) bishop = 01, (2) rook = 10, (3) queen = 11)
bit 14..15 -> special move flag ((0) promotion = 00, (1) en-passant = 01, (2) castling = 10, (3) neither = 11)
NOTE: The en-passant flag is only set if the move is a pawn that can do an en-passant capture.
*/
void MoveList::add_move(int toSq, int fromSq, int promPce, int spc) {
moveList[size()].move = ((toSq << 10) | (fromSq << 4) | (promPce << 2) | spc);
moveList[size()].score = 0;
last = &moveList[size() + 1];
}
std::string printMove(int move) {
std::string moveStr = "";
int fromSq = FROMSQ(move);
int toSq = TOSQ(move);
int spc = SPECIAL(move);
int promotion_piece = PROMTO(move);
assert(fromSq >= A1 && fromSq <= H8);
assert(toSq >= A1 && fromSq <= H8);
moveStr += index_to_uci(fromSq) + index_to_uci(toSq);
if (spc == PROMOTION) {
switch (promotion_piece) {
case 0:
moveStr += "n"; break;
case 1:
moveStr += "b"; break;
case 2:
moveStr += "r"; break;
case 3:
moveStr += "q"; break;
default:
break;
}
}
return moveStr;
}
int parseMove(std::string userInput, MoveList* ml) {
if (userInput.length() > 5) { return NOMOVE; }
if (userInput[0] < 'a' || userInput[0] > 'h') { return NOMOVE; }
if (userInput[1] < '1' || userInput[1] > '8') { return NOMOVE; }
if (userInput[2] < 'a' || userInput[2] > 'h') { return NOMOVE; }
if (userInput[3] < '1' || userInput[3] > '8') { return NOMOVE; }
int from = ((userInput[0] - 'a') + (userInput[1] - '1') * 8);
int to = ((userInput[2] - 'a') + (userInput[3] - '1') * 8);
assert(from >= 0 && from <= 63);
assert(to >= 0 && to <= 63);
int move = 0;
int promPce = NO_TYPE;
int spcFlag = 3;
for (int moveNum = 0; moveNum < ml->size(); moveNum++) {
move = (*ml)[moveNum]->move;
if (FROMSQ(move) == from && TOSQ(move) == to) {
spcFlag = SPECIAL(move);
if (spcFlag == PROMOTION) { // promotion
promPce = PROMTO(move);
if (toupper(userInput[4]) == 'N' && promPce == 0) {
return move;
}
else if (toupper(userInput[4]) == 'B' && promPce == 1) {
return move;
}
else if (toupper(userInput[4]) == 'R' && promPce == 2) {
return move;
}
else if (toupper(userInput[4]) == 'Q' && promPce == 3) {
return move;
}
continue;
}
return move;
}
}
return NOMOVE;
}
Move_t MoveList::at(int index) {
assert(moveList + index < last);
return moveList[index];
}
void MoveList::replace(int index, Move_t newMove) {
assert(moveList + index < last);
moveList[index] = newMove;
} | [
"abildskovniels@gmail.com"
] | abildskovniels@gmail.com |
46f89cc5e9bdb5ecde14e65a650a57b20f71b0df | 3ac1b97c9b9700fe9442ba08dcbebea829a9a570 | /texture.cpp | 38c92f20fcbfc76700f4c8010ed1df3a2be19fb8 | [] | no_license | dylanw3000/CS541-Digipen | ff39dba9013515fb07ec471e2cd7ded506bd69a4 | 00b61f24513fdb6d5cec546336cf35eecb1f39f4 | refs/heads/main | 2023-04-19T09:05:12.146328 | 2021-05-07T19:39:43 | 2021-05-07T19:39:43 | 320,053,189 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,752 | cpp | ///////////////////////////////////////////////////////////////////////
// A slight encapsulation of an OpenGL texture. This contains a method
// to read an image file into a texture, and methods to bind a texture
// to a shader for use, and unbind when done.
////////////////////////////////////////////////////////////////////////
#include "math.h"
#include <fstream>
#include <stdlib.h>
#include <glbinding/gl/gl.h>
#include <glbinding/Binding.h>
using namespace gl;
#define GLM_FORCE_RADIANS
#define GLM_SWIZZLE
#include <glm/glm.hpp>
#include "texture.h"
#define STB_IMAGE_IMPLEMENTATION
#define STBI_FAILURE_USERMSG
#include "stb_image.h"
#include <glu.h> // For gluErrorString
#define CHECKERROR {GLenum err = glGetError(); if (err != GL_NO_ERROR) { fprintf(stderr, "OpenGL error (at line texture.cpp:%d): %s\n", __LINE__, gluErrorString(err)); exit(-1);} }
Texture::Texture(const std::string &path) : textureId(0)
{
stbi_set_flip_vertically_on_load(true);
image = stbi_load(path.c_str(), &width, &height, &depth, 4);
depth = 4;
printf("%d %d %d %s\n", depth, width, height, path.c_str());
if (!image) {
printf("\nRead error on file %s:\n %s\n\n", path.c_str(), stbi_failure_reason());
exit(-1); }
// Here we create MIPMAP and set some useful modes for the texture
glGenTextures(1, &textureId); // Get an integer id for this texture from OpenGL
glBindTexture(GL_TEXTURE_2D, textureId);
glTexImage2D(GL_TEXTURE_2D, 0, (GLint)GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, image);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 10);
glGenerateMipmap(GL_TEXTURE_2D);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, (int)GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, (int)GL_LINEAR_MIPMAP_LINEAR);
glBindTexture(GL_TEXTURE_2D, 0);
stbi_image_free(image);
}
// Make a texture availabe to a shader program. The unit parameter is
// a small integer specifying which texture unit should load the
// texture. The name parameter is the sampler2d in the shader program
// which will provide access to the texture.
void Texture::Bind(const int unit, const int programId, const std::string& name)
{
glActiveTexture((gl::GLenum)((int)GL_TEXTURE0 + unit));
glBindTexture(GL_TEXTURE_2D, textureId);
int loc = glGetUniformLocation(programId, name.c_str());
glUniform1i(loc, unit);
}
// Unbind a texture from a texture unit whne no longer needed.
void Texture::Unbind()
{
glBindTexture(GL_TEXTURE_2D, 0);
}
glm::vec3 Texture::GetTexel(float u, float v)
{
int i = int(v*height)*width*depth + int(u*width)*depth;
return glm::vec3(image[i]/127.0, image[i+1]/127.0, image[i+2]/127.0);
}
| [
"dylanw3000@gmail.com"
] | dylanw3000@gmail.com |
4efb891224ee1cfac5c2b40dd80e39b1caee9029 | 1af0bc3634313da229fcf7015abec43981b4162a | /hundredandbelow/82.cpp | e71e9b1cad1b13c5675d5872a706aefbf228af65 | [] | no_license | errai-/euler | b2996e227ede830e8c56252bcce08a92538464df | 054c391d3aee6bcb9ba4dbf24f4ec6cb5b8b55c3 | refs/heads/master | 2022-06-18T09:02:54.573903 | 2018-05-14T08:21:48 | 2018-05-14T08:21:48 | 85,503,541 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,670 | cpp | #include <iostream>
#include <fstream>
#include "82Classes.h"
#include <set>
using std::cout;
using std::endl;
using std::set;
int takeStep( MatrixHolder &matrix, set<Path> &threads ){
Path next( &matrix );
auto iter = threads.begin();
next = *iter;
threads.erase(iter);
cout << "Row: " << next.getRow() << " Col: " << next.getCol() << " Sum: " << next.getSum() << endl;
if (next.isFinal()){
return next.getSum();
}
int newRowR = next.getRow()+1, newRowC = next.getCol();
if ( (newRowR<ROWS) && !( matrix.cellVisited( newRowR, newRowC ) ) ){
Path newRow( &matrix, newRowR, newRowC, next.getSum() );
threads.insert( newRow );
}
int newRowRU = next.getRow()-1;
if ( (newRowRU != -1) && !( matrix.cellVisited( newRowRU, newRowC ) ) ){
Path newRowU( &matrix, newRowRU, newRowC, next.getSum() );
threads.insert( newRowU );
}
int newColR = next.getRow(), newColC = next.getCol()+1;
if ( (newColC<ROWS) && !( matrix.cellVisited( newColR, newColC ) ) ){
Path newCol( &matrix, newColR, newColC, next.getSum() );
threads.insert( newCol );
}
//int newColCU = next.getCol()-1;
//if ( (newColCU != -1) && !( matrix.cellVisited( newColR, newColCU ) ) ){
// Path newColU( &matrix, newColR, newColCU, next.getSum() );
// threads.insert( newColU );
//}
return 0;
}
int main(void){
MatrixHolder matrix;
std::set<Path> threads;
for (int i=0; i!=ROWS; ++i){
threads.insert( Path( &matrix, i, 0, 0 ) );
matrix.cellVisited( i, 0 );
}
int result = 0;
while( !result ){
result = takeStep( matrix, threads );
}
cout << "The shortest path is: " << result << endl;
return 0;
}
| [
"hannu.siikonen@aalto.fi"
] | hannu.siikonen@aalto.fi |
500d2502b765acea623a3d91b628c297cf60800e | beda2ec932340415a5c46306a8a7e3cad1cbc630 | /hw2/main.cpp | ec62e3a56b69e4059581a4cd4e156725822924d8 | [] | no_license | ZakMaks/aip_semestr2 | 68efcbc567136645cae3def95946039a2dd77ae9 | 88f57b9104e9e6ceb93567ec944f314e1cad34eb | refs/heads/main | 2023-05-23T17:50:17.226261 | 2021-06-17T06:40:55 | 2021-06-17T06:40:55 | 342,708,722 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 815 | cpp | #include <iostream> //nomer 2b
#include <fstream>
#include <string>
//Пользователь вводит параметры фигуры. Найти периметр и площадь фигур:
//b. Прямоугольник
int main()
{
int a , b;
std::cout << "Vvedi storonu prumougolnika A " << std::endl;
std::cin >> a;
std::cout << "Vvedi storonu prumougolnika B " << std::endl;
std::cin >> b;
std::cout << " P = " << (a + b)*2 << std::endl;
std::cout << " S = " << a * b << std::endl;
std::getchar();
std::getchar();
std::fstream f("Otvet.txt", std::ios::out); // открываем для записи
f << "P = " << (a + b)*2<< " "<< " S = "<< a * b ;
f.close(); // закрываем файл
return 0;
}
| [
"noreply@github.com"
] | noreply@github.com |
289372ee7a88e51083a41be25fa197d360cbf5c4 | ff84592243606c55a1696c69e92d64db4e4b26f3 | /Assignment2/src/SimpleFactory.cpp | dfc927aa60363853cf2bea62314e3ac0b4a422a6 | [] | no_license | shancezhao/C-plusplus | be0cd93153f8c9392571ecb536885affa40773e2 | 3e4787088133a250361ac3645fd736507b685c72 | refs/heads/master | 2021-04-03T08:17:16.082725 | 2018-03-26T15:42:58 | 2018-03-26T15:42:58 | 120,000,117 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,813 | cpp | /*
* SimpleFactory.cpp
*
* Created on: Feb 9, 2018
* Author: zhaos
*/
#include "SimpleFactory.h"
#include <vector>
#include "Student.h"
#include "Employee.h"
#include "StudentFactory.h"
#include "EmployeeFactory.h"
namespace edu {
namespace neu {
namespace csye6205 {
SimpleFactory::SimpleFactory() {
// TODO Auto-generated constructor stub
}
SimpleFactory::~SimpleFactory() {
// TODO Auto-generated destructor stub
}
Person *SimpleFactory::getObject(int criteria) {
Person *p = (Person*) nullptr;
switch (criteria) {
case 0: // person
p = new Student();
break;
case 1: // student
p = new Employee();
break;
}
return (p);
}
void SimpleFactory::freeObject(Person *p) {
delete p;
return;
}
Person* SimpleFactory::createObject() {
Person *obj_p = nullptr;
obj_p = new Person();
return obj_p;
}
void SimpleFactory::demo() {
cout << "\tSimpleFactory demo starting..." << endl;
SimpleFactory obj;
Person *p0, *p1;
p0 = obj.getObject(0);
p1 = obj.getObject(1);
vector<Person *> v = vector<Person *>();
v.push_back(p0);
v.push_back(p1);
cout <<"\t" << v.size() << " explosive devices to explode." << endl;
for (Person *p : v) {
p->show();
}
obj.freeObject(p0);
obj.freeObject(p1);
cout << "\tSimpleFactory demo done!\n" << endl;
}
void SimpleFactory::demo2() {
cout << "\tdemo2 - Factory Pattern start starting..." << endl;
Person* person;
SimpleFactory obj;
StudentFactory sf;
EmployeeFactory ef;
person = sf.createObject();
person->show();
delete(person);
person = ef.createObject();
person->show();
delete(person);
cout << "\tdemo2 - Factory Pattern done!\n" << endl;
}
} /* namespace csye6205 */
} /* namespace neu */
} /* namespace edu */
| [
"noreply@github.com"
] | noreply@github.com |
7d332f20b8105ebbeaa314e6d5eaf12c167af22f | 8c9b57b4d92f3c31b16bba1ba4d1e87a249b2516 | /BT_C6_8.cpp | da12a8368e8532fa8273797d572ff814a6823334 | [
"Unlicense"
] | permissive | baotap098/BapTap_OOP_C | d5aea06f839003ab4ee518147aa03ca793f79732 | 875f78a79dac27ec93e4d03e1c66ecdc38910266 | refs/heads/master | 2020-03-14T16:37:02.768578 | 2018-05-01T10:41:52 | 2018-05-01T10:41:52 | 131,701,574 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 425 | cpp | #include<iostream>
using namespace std;
class OBJECT{
private:
static unsigned int count;
unsigned int serial;
public:
OBJECT(){
count+=1;
serial = count;
}
void answer();
};
int main(){
OBJECT o1,o2,o3;
o1.answer();
o2.answer();
o3.answer();
system("pause");
return 0;
}
void OBJECT::answer(){
cout<<"I am object number "<<serial<<endl;
}
unsigned int OBJECT::count = 0;
| [
"noreply@github.com"
] | noreply@github.com |
d924e241f0c865f7c4eefe52c0cbc5cdb16896f6 | cab3adf3493b547251a9231d9994276abb5a38ad | /3_array_sort_withoutusingsortingalgo.cpp | e63fe27da80b49a17f95dba6af017976086cc23c | [] | no_license | aviavinashkr/Questions-by-Love-Babbar | d19f0d011cd489ce7231e910ab9ab0d3e85f8f5d | 2cc42040f643d9efa882011fb055054656ecc3a9 | refs/heads/main | 2023-03-21T17:50:54.042223 | 2021-03-09T18:29:31 | 2021-03-09T18:29:31 | 322,270,599 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,015 | cpp | // { Driver Code Starts
#include<bits/stdc++.h>
using namespace std;
// } Driver Code Ends
class Solution
{
public:
void sort012(int a[], int n)
{
int low =0, mid=0 , high =n-1;
while(mid<=high){
if(a[mid]==0){
swap(a[low++],a[mid++]);
continue;
}
if(a[mid]==1){
mid++;
continue;
}
if(a[mid]==2){
swap(a[mid],a[high--]);
continue;
}
}
}
};
// { Driver Code Starts.
int main() {
int t;
cin >> t;
while(t--){
int n;
cin >>n;
int a[n];
for(int i=0;i<n;i++){
cin >> a[i];
}
Solution ob;
ob.sort012(a, n);
for(int i=0;i<n;i++){
cout << a[i] << " ";
}
cout << endl;
}
return 0;
}
// } Driver Code Ends | [
"noreply@github.com"
] | noreply@github.com |
4a12d10c44062f2e041749875d412750a0e4b70e | c3c3b97e824370642f20a0cb408bb054c7b6049c | /BOJ/숌언어/숌언어/main.cpp | 60f3bed508567debd5f62aee3636a38591b423d9 | [] | no_license | chrisais9/algorithm | 00333c0f731ffd5971bf20871e622b48d22617c2 | 2a4fdf8e3f5d3da0b88cd2832d74e8e1dcbe09e9 | refs/heads/master | 2022-06-13T04:57:32.181733 | 2022-06-03T08:35:36 | 2022-06-03T08:35:36 | 136,615,290 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,260 | cpp | #include <iostream>
#include <fstream>
#include <algorithm>
#include <vector>
#include <string>
#include <ctype.h>
#include <memory.h>
using namespace std;
string a;
int n, b[3000], visited[3000], s, e, r;
vector<int> vt[3000];
int valid(char a, char b)
{
int x,y;
if(isupper(a))
{
x=a-'A';
y=b-'a';
return x*26+y+1;
}
else
{
x=a-'a';
y=b-'A';
return x*26+y+26*26+1;
}
}
int dfs(int here)
{
if (visited[here])return 0;
visited[here] = 1;
for (auto next : vt[here])
{
if (!b[next] || dfs(b[next]))
{
b[next] = here;
return 1;
}
}
return 0;
}
int bmatch()
{
int ret = 0;
for (int i = 1; i <= 26 * 26; i++)
{
memset(visited, 0, sizeof(visited));
if (dfs(i))ret++;
}
return ret;
}
int main()
{
int i,x,y;
cin>>a;
n=a.size();
s=valid(a[0],a[1]);
e=valid(a[n-2],a[n-1]);
if(s==e)r=1;
else r=2;
for(i=1;i<n-1;i++)
{
x=valid(a[i-1],a[i]);
y=valid(a[i],a[i+1]);
if(s!=x&&s!=y&&e!=x&&e!=y)
{
vt[x].push_back(y);
vt[y].push_back(x);
}
}
r+=bmatch();
cout<<r;
return 0;
}
| [
"chrisais9@naver.com"
] | chrisais9@naver.com |
121ef2a97e1e6ff0fc033100c191096ddac101e5 | b1846a5bc27ccb4c6c8526dba7aef2eedfc031b7 | /parking/server/node_modules/scrypt/src/node-boilerplate/scrypt_node_sync.cc | c1dbc38143d27ef811e123b16c6c739b884320e6 | [] | no_license | minhaz1/hackumbc | 047e90369a3315333a0b1fffc5410b832338a1c7 | 3ff1b5a0c4e0a2d15a1577e592ceed0addc0a9aa | refs/heads/master | 2021-01-10T20:04:09.641896 | 2013-12-08T20:05:19 | 2013-12-08T20:05:19 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 13,583 | cc | /*
scrypt_node_sync.cc
Copyright (C) 2013 Barry Steyn (http://doctrina.org/Scrypt-Authentication-For-Node.html)
This source code is provided 'as-is', without any express or implied
warranty. In no event will the author be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this source code must not be misrepresented; you must not
claim that you wrote the original source code. If you use this source code
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original source code.
3. This notice may not be removed or altered from any source distribution.
Barry Steyn barry.steyn@gmail.com
*/
#include <node.h>
#include <v8.h>
#include <string>
#include "scrypt_node_sync.h"
#include "scrypt_common.h"
#include "base64.h"
//Scrypt is a C library
extern "C" {
#include "../../scrypt/scrypt-1.1.6/lib/scryptenc/scryptenc.h"
#include "scrypthash.h"
}
using namespace v8;
const size_t maxmem_default = 0;
const double maxmemfrac_default = 0.5;
/*
* Validates JavaScript encryption and decryption function arguments and sets maxmem, maxmemfrac and maxtime
*/
int ValidateCryptoSyncArguments(const Arguments& args, std::string& message, size_t& maxmem, double& maxmemfrac, double& maxtime) {
if (args.Length() < 3) {
message = "Wrong number of arguments: At least three arguments are needed - data, password and max_time";
return 1;
}
for (int i=0; i < args.Length(); i++) {
switch(i) {
case 0:
//Check message is a string
if (!args[i]->IsString()) {
message = "message must be a string";
return 1;
}
if (args[i]->ToString()->Length() == 0) {
message = "message cannot be empty";
return 1;
}
break;
case 1:
//Check password is a string
if (!args[i]->IsString()) {
message = "password must be a string";
return 1;
}
if (args[i]->ToString()->Length() == 0) {
message = "password cannot be empty";
return 1;
}
break;
case 2:
//Check max_time is a number
if (!args[i]->IsNumber()) {
message = "max_time argument must be a number";
return 1;
}
//Check that maxtime is not less than or equal to zero (which would not make much sense)
maxtime = Local<Number>(args[i]->ToNumber())->Value();
if (maxtime <= 0) {
message = "max_time must be greater than 0";
return 1;
}
break;
case 3:
//Set mexmem if possible, else set it to default
if (args[i]->IsNumber()) {
int maxmemArg = Local<Number>(args[i]->ToNumber())->Value();
if (maxmemArg < 0)
maxmem = maxmem_default;
else
maxmem = (size_t)maxmemArg;
}
break;
case 4:
//Set mexmemfrac if possible, else set it to default
if (args[i]->IsNumber()) {
maxmemfrac = Local<Number>(args[i]->ToNumber())->Value();
if (maxmemfrac <=0)
maxmemfrac = maxmemfrac_default;
}
break;
}
}
return 0;
}
/*
* Validates JavaScript function arguments for password hash and sets maxmem, maxmemfrac and maxtime
*/
int ValidateHashSyncArguments(const Arguments& args, std::string& message, size_t& maxmem, double& maxmemfrac, double& maxtime) {
if (args.Length() < 2) {
message = "Wrong number of arguments: At least two arguments are needed - password and max_time";
return 1;
}
for (int i=0; i < args.Length(); i++) {
switch(i) {
case 0:
//Check password is a string
if (!args[i]->IsString()) {
message = "password must be a string";
return 1;
}
if (args[i]->ToString()->Length() == 0) {
message = "password cannot be empty";
return 1;
}
break;
case 1:
//Check max_time is a number
if (!args[i]->IsNumber()) {
message = "maxtime argument must be a number";
return 1;
}
//Check that maxtime is not less than or equal to zero (which would not make much sense)
maxtime = Local<Number>(args[i]->ToNumber())->Value();
if (maxtime <= 0) {
message = "maxtime must be greater than 0";
return 1;
}
break;
case 2:
//Set mexmem if possible, else set it to default
if (args[i]->IsNumber()) {
int maxmemArg = Local<Number>(args[i]->ToNumber())->Value();
if (maxmemArg < 0)
maxmem = maxmem_default;
else
maxmem = (size_t)maxmemArg;
}
break;
case 3:
//Set mexmemfrac if possible, else set it to default
if (args[i]->IsNumber()) {
maxmemfrac = Local<Number>(args[i]->ToNumber())->Value();
if (maxmemfrac <=0)
maxmemfrac = maxmemfrac_default;
}
break;
}
}
return 0;
}
/*
* Validates JavaScript function arguments for verify password hash
*/
int ValidateVerifySyncArguments(const Arguments& args, std::string& message) {
if (args.Length() < 2) {
message = "Wrong number of arguments: Two arguments are needed - hash and the password";
return 1;
}
for (int i=0; i < args.Length(); i++) {
switch(i) {
case 0:
//Check hash is a string
if (!args[i]->IsString()) {
message = "hash must be a string";
return 1;
}
if (args[i]->ToString()->Length() == 0) {
message = "hash cannot be empty";
return 1;
}
break;
case 1:
//Check hash is a string
if (!args[i]->IsString()) {
message = "password must be a string";
return 1;
}
if (args[i]->ToString()->Length() == 0) {
message = "password cannot be empty";
return 1;
}
break;
}
}
return 0;
}
/*
* Password Hash: Function called from JavaScript land.
*/
Handle<Value> HashSync(const Arguments& args) {
HandleScope scope;
size_t maxmem = maxmem_default;
double maxmemfrac = maxmemfrac_default;
double maxtime = 0.0;
std::string validateMessage;
uint8_t outbuf[96]; //Header size for password derivation is fixed
//Validate arguments
if (ValidateHashSyncArguments(args, validateMessage, maxmem, maxmemfrac, maxtime)) {
ThrowException(
Exception::TypeError(String::New(validateMessage.c_str()))
);
return scope.Close(Undefined());
}
//Arguments from JavaScript land
String::Utf8Value password(args[0]->ToString());
//perform scrypt password hash
int result = HashPassword(
(const uint8_t*)*password,
outbuf,
maxmem, maxmemfrac, maxtime
);
if (result) { //There has been an error
ThrowException(
Exception::TypeError(String::New(ScryptErrorDescr(result).c_str()))
);
return scope.Close(Undefined());
} else {
//Base64 encode for storage
int base64EncodedLength = calcBase64EncodedLength(96);
char base64Encode[base64EncodedLength + 1];
base64_encode(outbuf, 96, base64Encode);
Local<String> passwordHash = String::New((const char*)base64Encode, base64EncodedLength);
return scope.Close(passwordHash);
}
}
/*
* Hash Verify: Function called from JavaScript land.
*/
Handle<Value> VerifySync(const Arguments& args) {
HandleScope scope;
std::string validateMessage;
//Validate arguments
if (ValidateVerifySyncArguments(args, validateMessage)) {
ThrowException(
Exception::TypeError(String::New(validateMessage.c_str()))
);
return scope.Close(Undefined());
}
//Arguments from JavaScript land
String::Utf8Value hash(args[0]->ToString());
String::Utf8Value password(args[1]->ToString());
//Hashed password was encoded to base64, so we need to decode it now
int base64DecodedLength = calcBase64DecodedLength(*hash);
unsigned char passwordHash[base64DecodedLength];
base64_decode(*hash, hash.length(), passwordHash);
//perform scrypt password verify
int result = VerifyHash(
passwordHash,
(const uint8_t*)*password
);
if (result) { //Password did not verify
return scope.Close(Local<Value>::New(Boolean::New(false)));
} else {
return scope.Close(Local<Value>::New(Boolean::New(true)));
}
}
/*
* Encryption: Function called from JavaScript land.
*/
Handle<Value> EncryptSync(const Arguments& args) {
HandleScope scope;
size_t maxmem = maxmem_default;
double maxmemfrac = maxmemfrac_default;
double maxtime = 0.0;
std::string validateMessage;
//Validate arguments
if (ValidateCryptoSyncArguments(args, validateMessage, maxmem, maxmemfrac, maxtime)) {
ThrowException(
Exception::TypeError(String::New(validateMessage.c_str()))
);
return scope.Close(Undefined());
}
//Arguments from JavaScript land
String::Utf8Value message(args[0]->ToString());
String::Utf8Value password(args[1]->ToString());
//There is 128 byte header added that stores the hashed password
uint32_t outbufSize = message.length() + 128;
uint8_t outbuf[outbufSize];
//perform scrypt encryption
int result = scryptenc_buf(
(const uint8_t*)*message,
message.length(),
outbuf,
(const uint8_t*)*password,
password.length(),
maxmem, maxmemfrac, maxtime
);
if (result) { //Scrypt error
ThrowException(
Exception::TypeError(String::New(ScryptErrorDescr(result).c_str()))
);
return scope.Close(Undefined());
} else {
int base64EncodedLength = calcBase64EncodedLength(outbufSize);
char base64Encode[base64EncodedLength + 1]; //+1 added for ending null char '\0'
base64_encode(outbuf, outbufSize, base64Encode);
return scope.Close(Local<Value>::New(String::New((const char*)base64Encode, base64EncodedLength)));
}
}
/*
* Decryption: Function called from JavaScript land.
*/
Handle<Value> DecryptSync(const Arguments& args) {
HandleScope scope;
size_t maxmem = maxmem_default;
double maxmemfrac = maxmemfrac_default;
double maxtime = 0.0;
std::string validateMessage;
size_t outbuflen;
//Validate arguments
if (ValidateCryptoSyncArguments(args, validateMessage, maxmem, maxmemfrac, maxtime)) {
ThrowException(
Exception::TypeError(String::New(validateMessage.c_str()))
);
return scope.Close(Undefined());
}
//Arguments passed from JavaScript land
String::Utf8Value message(args[0]->ToString());
String::Utf8Value password(args[1]->ToString());
//When encrypting, output was encoded in base64. So now we need to decode to get to the original
int base64DecodedLength = calcBase64DecodedLength(*message);
unsigned char cipher[base64DecodedLength];
base64_decode(*message, message.length(), cipher);
uint8_t outbuf[base64DecodedLength];
//Scrypt decryption done here
int result = scryptdec_buf(
(const uint8_t*)cipher,
(size_t)base64DecodedLength,
outbuf,
&outbuflen,
(const uint8_t*)*password,
password.length(),
maxmem, maxmemfrac, maxtime
);
if (result) { //There has been a srypt error
ThrowException(
Exception::TypeError(String::New(ScryptErrorDescr(result).c_str()))
);
return scope.Close(Undefined());
} else {
Local<String> plainText = String::New((const char*)outbuf, outbuflen);
return scope.Close(Local<Value>::New(plainText));
}
}
| [
"minhazm@gmail.com"
] | minhazm@gmail.com |
a2828c5ea36b2250893b65c1d0263551a993404d | 5c364c06003ec3d6b9b2a8b91eaab6d0293ff907 | /hdu/第一阶段/线段树学习/luogu4879权值线段树/copy.cpp | cc41fdf622b2f4c5b7b4f5efb1950bdc11b4a5a6 | [] | no_license | majiaoliya/acm | aa3d4b9679ac8f7ace28c2f4b5a21dc2d6421b71 | c0aa06b08547e6d75ea5a4b7db3cfe5e7f9bed83 | refs/heads/master | 2020-09-17T01:51:16.950731 | 2020-04-29T15:02:05 | 2020-04-29T15:02:05 | 223,952,294 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,217 | cpp | #include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;
#define debug(x) cerr << #x << "=" << x << endl;
const int MAXN = 500000 + 10;
int n,m,lover[MAXN],sep[MAXN],a[MAXN];
struct Node{
long long sum;
int cnt;
}tree[MAXN * 4];
void update(int rt) {
tree[rt].sum = tree[rt*2].sum + tree[rt*2+1].sum;
tree[rt].cnt = tree[rt*2].cnt + tree[rt*2+1].cnt;
}
void build(int rt, int l, int r) {
int mid = l+r>>1;
if(l == r) {
if(a[l])
tree[rt].cnt = 1;
tree[rt].sum = a[l];
return;
}
build(rt*2, l, mid);
build(rt*2+1, mid+1, r);
update(rt);
}
void change(int rt, int l, int r, int x, int y) {
if(l == r) {
tree[rt].sum -= y;
return;
}
int mid = l+r>>1;
if(x <= mid) change(rt*2, l, mid, x, y);
else change(rt*2+1, mid+1, r, x, y);//单点只需else 若是区间则需y >= mid + 1
update(rt);
}
void insert(int rt, int l, int r, int x, int y) {
if(l == r) {
tree[rt].sum = y;
tree[rt].cnt = 1;
return;
}
int mid = l+r>>1;
if(x <= mid) insert(rt*2, l, mid, x, y);
else insert(rt*2+1, mid+1, r, x, y);
update(rt);
}
void del(int rt, int l, int r, int k) {
if(l == r) {
tree[rt].cnt = 0;
tree[rt].sum = 0;
return;
}
int mid = l+r>>1;
if(k <= tree[rt*2].cnt) del(rt*2, l, mid, k);
else del(rt*2+1, mid+1, r, k-tree[rt*2].cnt);
update(rt);
}
int main() {
freopen("test", "r", stdin);
scanf("%d %d", &n, &m);
for(int i=1; i<=n; i++) {
scanf("%d", &a[i]);
}
int maxr = MAXN - 10;
build(1, 1, maxr);
for(int i=1; i<=m; i++) {
char ccc;
cin >> ccc;
if(ccc == 'C') {
int x,y;
scanf("%d %d", &x, &y);
change(1, 1, maxr, x, y);
} else if(ccc == 'I') {
int x,y;
scanf("%d %d", &x, &y);
insert(1, 1, maxr, x, y);
} else if(ccc == 'D') {
int x;
scanf("%d", &x);
del(1, 1, maxr, x);
} else if(ccc == 'Q') {
printf("%lld\n", tree[1].sum);
}
}
return 0;
}
| [
"majiao@qq.com"
] | majiao@qq.com |
dc98c39f2ff3561ae1b60e1b781ed95378278a76 | ea8ba7cfc4f4773ed516e094ded4bc36502f93b5 | /branch/old_angsys/angsys_beta3/source/graphics/graphics.shared/source/d3d11/d3d11_surface.cpp | 22fc2629c289d0ae2eecb57d6dbae7807a6c8bb9 | [
"Apache-2.0"
] | permissive | ChuyX3/angsys | 15f896f0b4823b63a14aff8e35a30f344f2c30e8 | 89b2eaee866bcfd11e66efda49b38acc7468c780 | refs/heads/master | 2021-07-07T18:58:39.437477 | 2020-06-29T05:33:08 | 2020-06-29T05:33:08 | 92,321,439 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,788 | cpp | #include "pch.h"
#include "d3d11/d3d11_driver.h"
#if defined _DEBUG
#define new new(__FILE__, __LINE__)
#endif
#if DIRECTX_SUPPORT
using namespace ang;
using namespace ang::graphics;
using namespace ang::graphics::d3d11;
//#define MY_TYPE ang::graphics::d3d11::d3d11_surface
//#include <ang/inline/object_wrapper_specialization.inl>
//#undef MY_TYPE
d3d11_surface::d3d11_surface(d3d11_driver* driver)
: m_parent_driver(driver)
, m_need_update(false)
{
}
ANG_IMPLEMENT_OBJECT_RUNTIME_INFO(ang::graphics::d3d11::d3d11_surface);
ANG_IMPLEMENT_OBJECT_CLASS_INFO(ang::graphics::d3d11::d3d11_surface, object, isurface);
ANG_IMPLEMENT_OBJECT_QUERY_INTERFACE(ang::graphics::d3d11::d3d11_surface, object, isurface);
void d3d11_surface::dispose()
{
close();
}
bool d3d11_surface::create(platform::icore_view_t view)
{
HRESULT hr = S_OK;
d3d11_driver_t driver = m_parent_driver.lock();
if (driver.is_empty())
return false;
graphics::size<float> size = view->core_view_size();
graphics::size<float> scale = view->core_view_scale_factor();
m_current_size = { uint(size.width * scale.width), uint(size.height * scale.height) };
DXGI_SWAP_CHAIN_DESC1 sd;
ZeroMemory(&sd, sizeof(sd));
sd.Width = (uint)m_current_size.width;
sd.Height = (uint)m_current_size.height;
sd.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
sd.SampleDesc.Count = 1;
sd.SampleDesc.Quality = 0;
sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
sd.BufferCount = 3;
#if WINDOWS_PLATFORM == WINDOWS_DESKTOP_PLATFORM
DXGI_SWAP_CHAIN_FULLSCREEN_DESC fsd;
ZeroMemory(&fsd, sizeof(fsd));
fsd.RefreshRate = { 60,1 };
fsd.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_PROGRESSIVE;
fsd.Scaling = DXGI_MODE_SCALING_CENTERED;
fsd.Windowed = TRUE;
HWND wnd = (HWND)view->core_view_handle();
if (IsWindow(wnd))
{
sd.Scaling = DXGI_SCALING_NONE;
sd.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
hr = driver->DXGIFactory()->CreateSwapChainForHwnd
(
driver->D3D11Device(),
wnd,
&sd,
&fsd,
nullptr,
&m_dxgi_swap_chain
);
}
#elif WINDOWS_PLATFORM == WINDOWS_STORE_PLATFORM
IUnknown* cwnd = reinterpret_cast<IUnknown*>(view->core_view_handle());
if (cwnd != null)
{
sd.Scaling = DXGI_SCALING_STRETCH;
sd.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
hr = driver->DXGIFactory()->CreateSwapChainForCoreWindow
(
driver->D3D11Device(),
cwnd,
&sd,
nullptr,
&m_dxgi_swap_chain
);
}
#endif
else
{
sd.Scaling = DXGI_SCALING_STRETCH;
sd.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
hr = driver->DXGIFactory()->CreateSwapChainForComposition
(
driver->D3D11Device(),
&sd,
nullptr,
&m_dxgi_swap_chain
);
}
graphics::icore_context_t context = view->core_context();
if(!context.is_empty())
context->bind_graphic_native_surface(m_dxgi_swap_chain.get());
m_d3d_frame_buffer = new d3d11_frame_buffer(driver.get());
m_d3d_frame_buffer->create(this);
m_view = view;
view->dispatcher()->listen_to(new ang::platform::events::display_size_change_event(this, &d3d11_surface::on_display_size_changed_event));
return true;
}
bool d3d11_surface::update(platform::icore_view_t view, graphics::size<uint> size)
{
HRESULT hr = S_OK;
bool bind = false;
d3d11_driver_t driver = m_parent_driver.lock();
if (driver.is_empty())
return false;
return driver->execute_on_thread_safe([&]()
{
m_current_size = size;
if (m_dxgi_swap_chain.get())
{
if (driver->current_frame_buffer().get() == m_d3d_frame_buffer.get())
{
driver->bind_frame_buffer(nullptr);
bind = true;
}
}
m_d3d_frame_buffer->close();
if (FAILED(m_dxgi_swap_chain->ResizeBuffers(
2, // Double-buffered swap chain.
(uint)maths::round(size.width),
(uint)maths::round(size.height),
DXGI_FORMAT_B8G8R8A8_UNORM,
0
)))
return false;
m_d3d_frame_buffer->create(this);
if (bind) driver->bind_frame_buffer(m_d3d_frame_buffer.get());
return true;
});
}
bool d3d11_surface::close()
{
m_dxgi_swap_chain = null;
m_d3d_frame_buffer = null;
m_view = null;
m_parent_driver = null;
return true;
}
void d3d11_surface::on_display_size_changed_event(objptr, platform::events::idisplay_info_event_args_t args)
{
m_need_update = true;
auto const& display = args->display_info();
m_pending_size.width = (uint)max(display.display_resolution.width * display.display_scale_factor.width, 10.0f);
m_pending_size.height = (uint)max(display.display_resolution.height * display.display_scale_factor.height, 10.0f);
}
void d3d11_surface::update()
{
if (m_need_update)
{
m_need_update = !update(m_view, m_pending_size);
}
}
void d3d11_surface::swap_buffers(bool syncronize)
{
m_dxgi_swap_chain->Present(syncronize ? 1 : 0, 0);
}
iframe_buffer_t d3d11_surface::frame_buffer()const
{
return m_d3d_frame_buffer.get();
}
#endif
| [
"chuyangel.rm@gmail.com"
] | chuyangel.rm@gmail.com |
2563d8b0eebcb9e869b2d6236e6f57705e1634dc | d9975b97e09ae5f5225c04fac385746d44a6a374 | /pylucene-4.9.0-0/build/_lucene/org/apache/lucene/analysis/compound/hyphenation/HyphenationTree.h | 44370b16e3804cea033a730d2ed78318a3be263d | [
"Apache-2.0"
] | permissive | Narabzad/elr_files | 20038214ef0c4f459b0dccba5df0f481183fd83a | 3e623c7d9c98a7d6e5b26e6e4a73f46ff5352614 | refs/heads/master | 2020-06-04T02:01:17.028827 | 2019-06-28T21:55:30 | 2019-06-28T21:55:30 | 191,825,485 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,715 | h | #ifndef org_apache_lucene_analysis_compound_hyphenation_HyphenationTree_H
#define org_apache_lucene_analysis_compound_hyphenation_HyphenationTree_H
#include "org/apache/lucene/analysis/compound/hyphenation/TernaryTree.h"
namespace org {
namespace apache {
namespace lucene {
namespace analysis {
namespace compound {
namespace hyphenation {
class Hyphenation;
class PatternConsumer;
}
}
}
}
}
}
namespace java {
namespace lang {
class Object;
class Class;
class String;
}
namespace util {
class ArrayList;
}
namespace io {
class IOException;
class File;
class PrintStream;
}
}
template<class T> class JArray;
namespace org {
namespace apache {
namespace lucene {
namespace analysis {
namespace compound {
namespace hyphenation {
class HyphenationTree : public ::org::apache::lucene::analysis::compound::hyphenation::TernaryTree {
public:
enum {
mid_init$_54c6a166,
mid_addClass_5fdc3f48,
mid_addException_069f7243,
mid_addPattern_4a264742,
mid_findPattern_97a5258f,
mid_hyphenate_b8db7bec,
mid_hyphenate_bc347fb6,
mid_loadPatterns_c3dacf57,
mid_printStats_1b7c898b,
mid_getValues_b4292e98,
mid_unpackValues_141401b3,
mid_hstrcmp_aa5dc2ed,
mid_searchPatterns_fa7f9f9d,
mid_packValues_5fdc3f57,
max_mid
};
static ::java::lang::Class *class$;
static jmethodID *mids$;
static bool live$;
static jclass initializeClass(bool);
explicit HyphenationTree(jobject obj) : ::org::apache::lucene::analysis::compound::hyphenation::TernaryTree(obj) {
if (obj != NULL)
env->getClass(initializeClass);
}
HyphenationTree(const HyphenationTree& obj) : ::org::apache::lucene::analysis::compound::hyphenation::TernaryTree(obj) {}
HyphenationTree();
void addClass(const ::java::lang::String &) const;
void addException(const ::java::lang::String &, const ::java::util::ArrayList &) const;
void addPattern(const ::java::lang::String &, const ::java::lang::String &) const;
::java::lang::String findPattern(const ::java::lang::String &) const;
::org::apache::lucene::analysis::compound::hyphenation::Hyphenation hyphenate(const ::java::lang::String &, jint, jint) const;
::org::apache::lucene::analysis::compound::hyphenation::Hyphenation hyphenate(const JArray< jchar > &, jint, jint, jint, jint) const;
void loadPatterns(const ::java::io::File &) const;
void printStats(const ::java::io::PrintStream &) const;
};
}
}
}
}
}
}
#include <Python.h>
namespace org {
namespace apache {
namespace lucene {
namespace analysis {
namespace compound {
namespace hyphenation {
extern PyTypeObject PY_TYPE(HyphenationTree);
class t_HyphenationTree {
public:
PyObject_HEAD
HyphenationTree object;
static PyObject *wrap_Object(const HyphenationTree&);
static PyObject *wrap_jobject(const jobject&);
static void install(PyObject *module);
static void initialize(PyObject *module);
};
}
}
}
}
}
}
#endif
| [
"43349991+Narabzad@users.noreply.github.com"
] | 43349991+Narabzad@users.noreply.github.com |
9c12e26910f2b076675b33de62ad4fba04a85a29 | 64d122a36531e5cdd0d0d35de05ba5a712ad9042 | /include/Basso_stlops.h | 8a4bf758e3538d78efb8e100569c27b2c11ea3b6 | [] | no_license | jfchessa/Basso | 593c9c7d2e77ee4325b13ee349ba7f3f38674664 | db1e0f88f13bd719d9f976565d116fa46dd2336e | refs/heads/master | 2021-01-21T04:47:27.438659 | 2016-06-30T03:24:19 | 2016-06-30T03:24:19 | 52,620,497 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,734 | h | #ifndef _BASSO_STLOPS_H_
#define _BASSO_STLOPS_H_
#include "Basso_defs.h"
#include <queue>
#include <list>
#include <set>
#include <map>
namespace Basso
{
using namespace std;
template<class StLTyPe>
void PrintArray1D( const StLTyPe *l, int n, ostream &os=cout )
{
const StLTyPe *ptr = l;
for ( int i=0; i<n; ++i, ++ptr )
os << *ptr << " ";
}
template<class StLTyPe>
void PrintArray2D( const StLTyPe *l, int m, int n, int ldl=-1, ostream &os=cout )
{
if ( ldl<0 ) ldl=n;
const StLTyPe *ptr = l;
for ( int i=0; i<m; ++i, ptr += ldl-n )
{
for ( int j=0; j<n; ++j, ++ptr )
os << setw(10) << *ptr << " ";
os << endl;
}
}
template<class StLTyPe>
void PrintArray( const StLTyPe *l, int n, ostream &os=cout ) { PrintArray1D(l,n,os); }
template<class StLTyPe>
void PrintArray( const StLTyPe *l, int m, int n, int ldl, ostream &os=cout ) { PrintArray2D(l,m,n,ldl,os); }
template<class StLTyPe>
void PrintFortranArray2D( const StLTyPe *l, int m, int n, int ldl=-1, ostream &os=cout )
{
if ( ldl<0 ) ldl=m;
for ( int i=0; i<m; ++i )
{
for ( int j=0; j<n; ++j )
os << setw(10) << l[i+j*ldl] << " ";
os << endl;
}
}
template<class StLTyPe>
void PrintFortranArray( const StLTyPe *l, int m, int n, int ldl=-1, ostream &os=cout ) { PrintFortranArray2D(l,m,n,ldl,os); }
template<class StLTyPe>
void PrintSTL1( const StLTyPe &l, ostream &os=cout )
{
typename StLTyPe::const_iterator itr, eItr=l.end();
--eItr;
os << "{ ";
for ( itr=l.begin(); itr!=eItr; ++itr )
os << *itr << ", ";
os << *itr << " }";
}
template<class LiStTyPe>
ostream& operator << (ostream& os, const list<LiStTyPe> &s)
{
os << "list:";
PrintSTL1(s,os);
return os;
}
template<class SeTTyPe>
ostream& operator << (ostream& os, const set<SeTTyPe> &s)
{
os << "set:";
PrintSTL1(s,os);
return os;
}
template<class VeCtTyPe>
ostream& operator << (ostream& os, const vector<VeCtTyPe> &s)
{
os << "vector:";
PrintSTL1(s,os);
return os;
}
template<class QuETyPe>
ostream& operator << (ostream& os, const queue<QuETyPe> &s)
{
os << "queue:";
PrintSTL1(s,os);
return os;
}
template<class TyPe1, class TyPe2>
ostream& operator << (ostream& os, const map<TyPe1,TyPe2> &l)
{
typename map<TyPe1,TyPe2>::const_iterator itr=l.begin();
os << "map:{ ";
os << itr->first << "->" << itr->second << " ";
for ( ++itr; itr!=l.end(); ++itr )
os << ", " << itr->first << "->" << itr->second;
os << "}";
return os;
}
template<class StLTyPe>
void set2array( const set<StLTyPe> &s, StLTyPe *a )
{
typename set< StLTyPe >::const_iterator sitr;
StLTyPe *aptr=a;
for ( sitr=s.begin(); sitr!=s.end(); ++sitr, ++aptr )
*aptr = *sitr;
}
/** Inserts the n elements in an array a into a set */
template<class StLTyPe>
void array2set( const StLTyPe *a, int n, set<StLTyPe> &s )
{
const StLTyPe *aptr=a;
for ( int i=0; i<n; ++i, ++aptr )
s.insert( *aptr );
}
template<class StLTyPe>
void list2array( const list<StLTyPe> &s, StLTyPe *a )
{
typename std::list<StLTyPe>::const_iterator sitr;
StLTyPe *aptr=a;
for ( sitr=s.begin(); sitr!=s.end(); ++sitr, ++aptr )
*aptr = *sitr;
}
template<class StLTyPe>
void vector2array( const vector<StLTyPe> &s, StLTyPe *a )
{
typename std::vector<StLTyPe>::const_iterator sitr;
StLTyPe *aptr=a;
for ( sitr=s.begin(); sitr!=s.end(); ++sitr, ++aptr )
*aptr = *sitr;
}
template< class T1, class T2 >
void map2array( const map<T1,T2> &s, T1 *a, T2 *b )
{
typename std::map<T1,T2>::const_iterator sitr;
T1 *aptr=a;
T2 *bptr=b;
for ( sitr=s.begin(); sitr!=s.end(); ++sitr, ++aptr, ++bptr )
{
*aptr = sitr->first;
*bptr = sitr->second;
}
}
} // end namespace
#endif
| [
"jfchessa@utep.edu"
] | jfchessa@utep.edu |
249368006e7b5517a1091fe50e6d2d89c23323d1 | 268daced8e4533f6fe57ef6601068e69aa88f198 | /bst.cpp | 915f6dba7edfdb55519436c605ea5e71913da3fe | [] | no_license | fanaticjo/amcat | db06dc6463656a7fef379c173fef93e3715f98a5 | 6f902c06d19f04da63e47bf06927b2698b403430 | refs/heads/master | 2020-04-05T14:34:29.397090 | 2017-07-26T13:13:14 | 2017-07-26T13:13:14 | 94,690,943 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,388 | cpp | #include<queue>
#include<iostream>
using namespace std;
struct bstnode
{
int data;
bstnode *right;
bstnode *left;
};
bstnode *getnode(int x)
{
bstnode *temp=new bstnode();
temp->data=x;
temp->right=NULL;
temp->left=NULL;
}
bstnode *insert(bstnode *root,int data)
{
if(root==NULL)
{
root=getnode(data);
}
else if(data<=root->data)
{
root->left=insert(root->left,data);
}
else
{
root->right=insert(root->right,data);
}
return root;
}
bool search(bstnode *root,int data)
{
if(root==NULL)
{
return false;
}
else if(root->data==data)
{
return true;
}
else if(data<=root->data)
{
return search(root->left,data);
}
else
{
return search(root->right,data);
}
}
bstnode *findmin1(bstnode *root)
{
while(root->left!=NULL)
{
root=root->left;
}
return root;
}
int findmin(bstnode *root)
{
if(root==NULL)
{
cout<<"tree empty";
}
else if(root->left==NULL)
{
return root->data;
}
return findmin(root->left);
}
int findheight(bstnode *root)
{
if(root==NULL)
{
return -1;
}
int left=findheight(root->left);
int right=findheight(root->right);
if(left>right)
{
return left+1;
}
else
return right+1;
}
void levelorder(bstnode *root)
{
if(root==NULL)
{
return;
}
queue<bstnode*> q;
q.push(root);
while(!q.empty())
{
bstnode *current=q.front();
cout<<current->data<<"\t";
if(current->left!=NULL)
{
q.push(current->left);
}
if(current->right!=NULL)
{
q.push(current->right);
}
q.pop();
}
}
bstnode *delete1(bstnode *root,int data)
{
if(root==NULL)
{
return root;
}
else if(data<root->data)
root->left=delete1(root->left,data);
else if(data>root->data)
root->right=delete1(root->right,data);
else
{
if(root->left==NULL && root->right==NULL)
{
delete root;
root=NULL;
}
else if(root->left==NULL)
{
bstnode *temp=root;
root=root->right;
delete root;
root=NULL;
}
else
{
bstnode *temp=findmin1(root->right);
root->data=temp->data;
root->right=delete1(root->right,temp->data);
}
}
return root;
}
int findmax(bstnode *root)
{
if(root==NULL)
{
return 0;
}
if(root->right==NULL)
{
return root->data;
}
return findmax(root->right);
}
bool bstcheck(bstnode *root,int min,int max)
{
if(root==NULL)
{
return true;
}
else if(root->data<min && root->data<max && bstcheck(root,min,root->data) && bstcheck(root,root->data,max))
{
return true;
}
else{
return false;
}
}
bool check(bstnode *root)
{
return bstcheck(root,INT_MIN,INT_MAX);
}
int main()
{
bstnode *root=NULL;
root=insert(root,15);
root=insert(root,10);
root=insert(root,20);
root=insert(root,25);
root=insert(root,8);
root=insert(root,12);
cout<<"enter the number ";
int x;
cin>>x;
if(search(root,x)==true)
{
cout<<"searched";
}
else
{
cout<<"nt";
}
cout<<endl;
cout<<"min";
cout<<findmin(root);
cout<<findmax(root);
cout<<"\nthe height of the tree is "<<findheight(root)<<"\n";
//delete1(root,20);
levelorder(root);
if(check(root)==true)
{
cout<<"true";
}
else
{
cout<<"false";
}
} | [
"noreply@github.com"
] | noreply@github.com |
a8968e307bbd857db4002929fb4d372d84aa73cd | 4846a300d3df6fc6383123ecb32fe7dc6f62ef96 | /DoubleSensor/Li.V1/SetInfo.cpp | b4f7901c7abf23a892042df4f4174320a17af681 | [] | no_license | az86/CamerProjects | d07528ac5aa47c868b2b2064770fac60fefdee0e | a90f53d3224f38e7035492c640e9d3c5a9a45f56 | refs/heads/master | 2021-09-11T01:18:19.514912 | 2018-04-05T14:23:39 | 2018-04-05T14:23:39 | 103,245,474 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 100 | cpp | #include "StdAfx.h"
#include "SetInfo.h"
SetInfo::SetInfo(void)
{
}
SetInfo::~SetInfo(void)
{
}
| [
"m_sunqi@qq.com"
] | m_sunqi@qq.com |
abf57ece93494c3c683c9ec4cda9f6b42931ec50 | 63ebcf1891ed64d114f859f81e7444eb00e499bb | /src/engine/jsonUtil.cpp | f635f8294e166de12d20a8664e929ddc70b4e748 | [] | no_license | ikutoo/MG1906 | a289c02e65afe7ededb0586b2257c1ec04f469e4 | bc4905375474cf7cb2c164b6eb9524bc06d8a9af | refs/heads/master | 2020-06-04T08:54:17.585741 | 2019-08-10T12:32:30 | 2019-08-10T12:32:30 | 191,952,283 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,034 | cpp | #include "jsonUtil.h"
#include "utility.h"
#include "resourceManager.h"
#include "node.h"
#include "sprite.h"
#include "label.h"
using namespace DxEngine;
//*********************************************************************
//FUNCTION:
CJsonReader::CJsonReader(const std::string& vFilename)
{
auto FileContent = Utility::readFileToString(LOCATE_FILE(vFilename));
m_Doc.Parse<0>(FileContent.c_str());
_ASSERTE(!m_Doc.HasParseError());
_ASSERTE(!m_Doc.IsArray());
}
//*********************************************************************
//FUNCTION:
CJsonReader::~CJsonReader()
{
}
//**********************************************************************************************************
//FUNCTION:
std::string CJsonReader::readString(const std::string& vAttributName)
{
const rapidjson::Value &p = m_Doc;
_ASSERTE(p.HasMember(vAttributName.c_str()));
return p[vAttributName.c_str()].GetString();
}
//**********************************************************************************************************
//FUNCTION:
int CJsonReader::readInt(const std::string& vAttributName)
{
const rapidjson::Value &p = m_Doc;
_ASSERTE(p.HasMember(vAttributName.c_str()));
return p[vAttributName.c_str()].GetInt();
}
//**********************************************************************************************************
//FUNCTION:
float CJsonReader::readFloat(const std::string& vAttributName)
{
const rapidjson::Value &p = m_Doc;
_ASSERTE(p.HasMember(vAttributName.c_str()));
return p[vAttributName.c_str()].GetFloat();
}
//**********************************************************************************************************
//FUNCTION:
bool CJsonReader::readBool(const std::string& vAttributName)
{
const rapidjson::Value &p = m_Doc;
_ASSERTE(p.HasMember(vAttributName.c_str()));
return p[vAttributName.c_str()].GetBool();
}
//**********************************************************************************************************
//FUNCTION:
vec2f CJsonReader::parseVec2(const rapidjson::Value& vValue)
{
return vec2f{ vValue["x"].GetFloat(), vValue["y"].GetFloat() };
}
//*********************************************************************
//FUNCTION:
vec2i CJsonReader::readVec2(const std::string& vAttributName)
{
const rapidjson::Value &p = m_Doc;
_ASSERTE(p.HasMember(vAttributName.c_str()));
return vec2i{};
}
//*********************************************************************
//FUNCTION:
CSprite* CJsonReader::readSprite(const std::string& vAttributName)
{
const rapidjson::Value &p = m_Doc;
_ASSERTE(p.HasMember(vAttributName.c_str()));
auto Obj = p[vAttributName.c_str()].GetObject();
CSprite* pSprite = new CSprite;
__fillNode(Obj, pSprite);
if (Obj.HasMember("file")) pSprite->setImageFile(Obj["file"].GetString());
if (Obj.HasMember("rect")) pSprite->setRect(__parseRecti(Obj, "rect"));
if (Obj.HasMember("flip") && Obj["flip"].GetBool()) pSprite->flip();
return pSprite;
}
//*********************************************************************
//FUNCTION:
CLabel* CJsonReader::readLabel(const std::string& vAttributName)
{
const rapidjson::Value &p = m_Doc;
_ASSERTE(p.HasMember(vAttributName.c_str()));
auto Obj = p[vAttributName.c_str()].GetObject();
CLabel* pLabel = new CLabel;
__fillNode(Obj, pLabel);
if (Obj.HasMember("text")) pLabel->setText(Obj["text"].GetString());
if (Obj.HasMember("fontSize")) pLabel->setFontSize(Obj["fontSize"].GetInt());
if (Obj.HasMember("fontColor")) pLabel->setFontColor(__parseVec3i(Obj, "fontColor"));
if (Obj.HasMember("fontType")) pLabel->setFontType(Obj["fontType"].GetInt());
if (Obj.HasMember("edgeColor")) pLabel->setEdgeColor(__parseVec3i(Obj, "edgeColor"));
if (Obj.HasMember("brightness")) pLabel->setBrightness(__parseVec3i(Obj, "brightness"));
return pLabel;
}
//*********************************************************************
//FUNCTION:
SAnimation CJsonReader::readAnimation(const std::string& vAttributName)
{
const rapidjson::Value &p = m_Doc;
_ASSERTE(p.HasMember(vAttributName.c_str()));
auto Obj = p[vAttributName.c_str()].GetObject();
SAnimation Anm = {};
Anm.ImageFile = Obj["image_file"].GetString();
Anm.TotalFrames = Obj["total_frames"].GetInt();
if (Obj.HasMember("loop")) Anm.IsLoop = Obj["loop"].GetBool();
if (Obj.HasMember("loop_begin_frame_id")) Anm.LoopBeginFrame = Obj["loop_begin_frame_id"].GetInt();
if (Obj.HasMember("loop_end_frame_id")) Anm.LoopEndFrame = Obj["loop_end_frame_id"].GetInt();
auto KeyFramesObj = Obj["key_frames"].GetArray();
for (auto iter = KeyFramesObj.begin(); iter != KeyFramesObj.end(); ++iter)
{
auto Obj = (*iter).GetObject();
Anm.KeyFrames.emplace_back(std::make_pair(Obj["frameID"].GetInt(), __parseRecti(Obj, "rect")));
}
return Anm;
}
//*********************************************************************
//FUNCTION:
vec2f CJsonReader::__parseVec2f(TObject& vObject, const std::string& vAttributName)
{
auto Array = vObject[vAttributName.c_str()].GetArray();
_ASSERTE(Array.Size() == 2);
return vec2f{ Array[0].GetFloat(), Array[1].GetFloat() };
}
//*********************************************************************
//FUNCTION:
vec3i CJsonReader::__parseVec3i(TObject& vObject, const std::string& vAttributName)
{
auto Array = vObject[vAttributName.c_str()].GetArray();
_ASSERTE(Array.Size() == 3);
return vec3i{ Array[0].GetInt(), Array[1].GetInt(), Array[2].GetInt() };
}
//*********************************************************************
//FUNCTION:
recti CJsonReader::__parseRecti(TObject& vObject, const std::string& vAttributName)
{
auto Array = vObject[vAttributName.c_str()].GetArray();
_ASSERTE(Array.Size() == 4);
return recti{ Array[0].GetInt(), Array[1].GetInt(), Array[2].GetInt(), Array[3].GetInt() };
}
//*********************************************************************
//FUNCTION:
void CJsonReader::__fillNode(TObject& vObject, CNode* vioNode)
{
if (vObject.HasMember("position")) vioNode->setPosition(__parseVec2f(vObject, "position"));
if (vObject.HasMember("rotation")) vioNode->setRotation(vObject["rotation"].GetFloat());
if (vObject.HasMember("localZ")) vioNode->setLocalZ(vObject["localZ"].GetFloat());
if (vObject.HasMember("scale")) vioNode->setScale(__parseVec2f(vObject, "scale"));
if (vObject.HasMember("brightness")) vioNode->setBrightness(__parseVec3i(vObject, "brightness"));
}
//*********************************************************************
//FUNCTION:
CNode* CJsonReader::getRootNode()
{
auto pRootNode = new CNode;
rapidjson::Value &p = m_Doc;
for (auto iter = p.MemberBegin(); iter != p.MemberEnd(); ++iter)
{
std::string Type = iter->value["type"].GetString();
if (Type == "label") pRootNode->addChild(readLabel(iter->name.GetString()));
else if (Type == "sprite") pRootNode->addChild(readSprite(iter->name.GetString()));
pRootNode->getLastChild()->setName(iter->name.GetString());
}
return pRootNode;
}
//*********************************************************************
//FUNCTION:
CJsonWriter::CJsonWriter(const std::string& vFilename)
{
m_FileName = vFilename;
auto FileContent = Utility::readFileToString(LOCATE_FILE(vFilename));
m_Doc.Parse<0>(FileContent.c_str());
_ASSERTE(!m_Doc.HasParseError());
_ASSERTE(!m_Doc.IsArray());
}
//*********************************************************************
//FUNCTION:
CJsonWriter::~CJsonWriter()
{
}
//**********************************************************************************************************
//FUNCTION:
void CJsonWriter::writeBool(const std::string& vAttributName, bool vValue)
{
rapidjson::Value &p = m_Doc;
_ASSERTE(p.HasMember(vAttributName.c_str()));
p[vAttributName.c_str()].SetBool(vValue);
}
//**********************************************************************************************************
//FUNCTION:
void CJsonWriter::saveFile()
{
rapidjson::StringBuffer Buffer;
rapidjson::Writer<rapidjson::StringBuffer> Writer(Buffer);
m_Doc.Accept(Writer);
Utility::writeStringToFile(m_FileName, Buffer.GetString());
} | [
"1007833641@qq.com"
] | 1007833641@qq.com |
bac9cfc6f945f7766c5a400f6e9110d9a28f3484 | 3f3a18c5631caa1309abe886cede6d221295724d | /dataset_reader/include/dataset_reader/reader.h | 389da6f518c4025a3c6ee7eca63108abc165a298 | [] | no_license | leo-wkd/h20_navigation | 053d21a5438c7e7ea1bbc555a9741afcc451efee | 321b5a9985fdbccbd06d2f065a0ab4cf816ba4c9 | refs/heads/master | 2020-07-20T15:00:46.835752 | 2019-09-05T22:26:01 | 2019-09-05T22:26:01 | 206,664,111 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,728 | h | #ifndef READER
#define READER
#include "ros/ros.h"
#include "sensor_msgs/LaserScan.h"
#include <fstream>
#include <string>
#include <sstream>
#include <tf/transform_broadcaster.h>
#include <nav_msgs/Odometry.h>
/* This program reads a raw log file and publishes the scanner data and the odometry data for gmap.
Current works for intel dataset rawlog 2003
Author: Thomas Vy
Email: thomas.vy@ucalgary.ca
Date: May 31, 2018
Version: 1.0
*/
ros::Publisher pub_Laser; //The publisher for the laser data
ros::Publisher pub_Odom; //The publisher for the odometry data
ros::Time currentTime; //The time the data is published
void sendOdometryData(double x, double y, double theta); //Sends the Odometry data
void sendTransform(); //Sends the transform of the scanner with respect to the base_link
//Starts the map drawing
void start(std::string name)
{
std::ifstream file(name.c_str()); //loads the raw log file.
if(file.is_open()) //Checks if the file can be opened
{
std::cout<<"file"<<std::endl ;
ros::Rate loop_rate(30); //The rate at which it pushes the data. The slower the publishing, the more accurate the map.
std::string line; //The current line of the file.
int seq =0; //The sequence number for the laser message.
while(std::getline(file, line) && ros::ok()) //reads the line of the file and checks if the the file is at the end or the program is killed.
{
std::cout<<"getline"<<std::endl ;
currentTime = ros::Time::now(); //Gets the current time
std::stringstream ss(line); //turns the line into a string stream
std::string firstWord; //first word of the line
ss>>firstWord;
if(firstWord == "FLASER") //Checks if the line is laser data
{
sensor_msgs::LaserScan msg; //The laserscan message
msg.header.seq = seq++;
msg.header.stamp = currentTime;
msg.header.frame_id = "scan"; //Laserscan message on the scan topic
//////////////////////////////////////////////////////////////////////////////////////////
//Scanner and file specifics
int num_of_readings; //Number of points projected
ss>>num_of_readings;
msg.angle_min = -1.5708; //starting_angle of the scanner in radians
msg.angle_max = 1.5708 ; //ending angle of the scanner in radians
msg.angle_increment = 3.14159/num_of_readings; //The angle increment per dot
msg.range_min = 0; //The minimum range of the scanner
msg.range_max = 80; //The maximum range of the scanner
for(int i=0; i<num_of_readings;i++) //Reads the dot ranges and places them in the laserscan message
{
float range;
ss>>range;
msg.ranges.push_back(range);
}
//////////////////////////////////////////////////////////////////////////////////////////
pub_Laser.publish(msg); //publishes laserscan message
sendTransform();
ros::spinOnce();
loop_rate.sleep();
}
else if (firstWord == "ODOM") //Checks if the line is odometry data
{
double x, y, theta; //The pose of the robot
ss>>x;
ss>>y;
ss>>theta;
sendOdometryData(x,y,theta);
sendTransform();
ros::spinOnce();
loop_rate.sleep();
}
}
}
else //The file cannot be opened
{
std::cout<<"could not open the file"<<std::endl;
}
}
//sends odometry data
void sendOdometryData(double x, double y, double theta)
{
static tf::TransformBroadcaster odom_broadcaster; //The broadcaster for the odometry ->baselink transform.
geometry_msgs::TransformStamped odom_trans;
odom_trans.header.stamp = currentTime;
odom_trans.header.frame_id = "odom";
odom_trans.child_frame_id = "base_link";
odom_trans.transform.translation.x = x;
odom_trans.transform.translation.y = y;
odom_trans.transform.translation.z = 0.0; //No transformation in the z direction. Strictly in the x,y direction
odom_trans.transform.rotation = tf::createQuaternionMsgFromYaw(theta);
odom_broadcaster.sendTransform(odom_trans);
//publishing the odometry message
nav_msgs::Odometry odom;
odom.header.stamp = currentTime;
odom.header.frame_id = "odom";
//position
odom.pose.pose.position.x = x;
odom.pose.pose.position.y = y;
odom.pose.pose.position.z = 0.0;
odom.pose.pose.orientation = tf::createQuaternionMsgFromYaw(theta);
//velocity
odom.child_frame_id = "base_link";
odom.twist.twist.linear.x = 0;
odom.twist.twist.linear.y = 0;
odom.twist.twist.angular.z = 0;
pub_Odom.publish(odom);
}
void sendTransform ()
{
static tf::TransformBroadcaster broadcaster_; //The broadcaster for the baselink -> scan transform
broadcaster_.sendTransform(
tf::StampedTransform(
tf::Transform(tf::Quaternion(0, 0, 0, 1), tf::Vector3(0.0, 0.0, 0.0)), //Says the scan is the same position as the baselink.
currentTime, "base_link", "scan" ));
}
#endif | [
"noreply@github.com"
] | noreply@github.com |
366d49d07f3f66be4577882f05703c1da965f6d4 | 396124da20ba58266abb81e40cd335bf7198dac2 | /ku060_solution/.autopilot/db/udp.pp.0.cpp.ap-line.cpp | bb16a6bdfd200588f97ab45db8209e5f702c140c | [] | no_license | Ahrfry/vasado | d6d2f4824f674a845b916b5188b3347b644ccbde | a3bec59220d4a807eeaae831317e446cb08b76ac | refs/heads/master | 2020-08-26T17:59:29.867336 | 2019-10-23T15:48:25 | 2019-10-23T15:48:25 | 153,848,350 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,681,246 | cpp | #pragma line 1 "example/udp.cpp"
#pragma line 1 "example/udp.cpp" 1
#pragma line 1 "<built-in>" 1
#pragma line 1 "<built-in>" 3
#pragma line 155 "<built-in>" 3
#pragma line 1 "<command line>" 1
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/etc/autopilot_ssdm_op.h" 1
/* autopilot_ssdm_op.h*/
/*
#- (c) Copyright 2011-2016 Xilinx, Inc. All rights reserved.
#-
#- This file contains confidential and proprietary information
#- of Xilinx, Inc. and is protected under U.S. and
#- international copyright and other intellectual property
#- laws.
#-
#- DISCLAIMER
#- This disclaimer is not a license and does not grant any
#- rights to the materials distributed herewith. Except as
#- otherwise provided in a valid license issued to you by
#- Xilinx, and to the maximum extent permitted by applicable
#- law: (1) THESE MATERIALS ARE MADE AVAILABLE "AS IS" AND
#- WITH ALL FAULTS, AND XILINX HEREBY DISCLAIMS ALL WARRANTIES
#- AND CONDITIONS, EXPRESS, IMPLIED, OR STATUTORY, INCLUDING
#- BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, NON-
#- INFRINGEMENT, OR FITNESS FOR ANY PARTICULAR PURPOSE; and
#- (2) Xilinx shall not be liable (whether in contract or tort,
#- including negligence, or under any other theory of
#- liability) for any loss or damage of any kind or nature
#- related to, arising under or in connection with these
#- materials, including for any direct, or any indirect,
#- special, incidental, or consequential loss or damage
#- (including loss of data, profits, goodwill, or any type of
#- loss or damage suffered as a result of any action brought
#- by a third party) even if such damage or loss was
#- reasonably foreseeable or Xilinx had been advised of the
#- possibility of the same.
#-
#- CRITICAL APPLICATIONS
#- Xilinx products are not designed or intended to be fail-
#- safe, or for use in any application requiring fail-safe
#- performance, such as life-support or safety devices or
#- systems, Class III medical devices, nuclear facilities,
#- applications related to the deployment of airbags, or any
#- other applications that could lead to death, personal
#- injury, or severe property or environmental damage
#- (individually and collectively, "Critical
#- Applications"). Customer assumes the sole risk and
#- liability of any use of Xilinx products in Critical
#- Applications, subject only to applicable laws and
#- regulations governing limitations on product liability.
#-
#- THIS COPYRIGHT NOTICE AND DISCLAIMER MUST BE RETAINED AS
#- PART OF THIS FILE AT ALL TIMES.
#- ************************************************************************
#pragma empty_line
*
* $Id$
*/
#pragma line 145 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/etc/autopilot_ssdm_op.h"
/*#define AP_SPEC_ATTR __attribute__ ((pure))*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern "C" {
#pragma empty_line
/****** SSDM Intrinsics: OPERATIONS ***/
// Interface operations
#pragma empty_line
//typedef unsigned int __attribute__ ((bitwidth(1))) _uint1_;
typedef bool _uint1_;
#pragma empty_line
void _ssdm_op_IfRead(...) __attribute__ ((nothrow));
void _ssdm_op_IfWrite(...) __attribute__ ((nothrow));
_uint1_ _ssdm_op_IfNbRead(...) __attribute__ ((nothrow));
_uint1_ _ssdm_op_IfNbWrite(...) __attribute__ ((nothrow));
_uint1_ _ssdm_op_IfCanRead(...) __attribute__ ((nothrow));
_uint1_ _ssdm_op_IfCanWrite(...) __attribute__ ((nothrow));
#pragma empty_line
// Stream Intrinsics
void _ssdm_StreamRead(...) __attribute__ ((nothrow));
void _ssdm_StreamWrite(...) __attribute__ ((nothrow));
_uint1_ _ssdm_StreamNbRead(...) __attribute__ ((nothrow));
_uint1_ _ssdm_StreamNbWrite(...) __attribute__ ((nothrow));
_uint1_ _ssdm_StreamCanRead(...) __attribute__ ((nothrow));
_uint1_ _ssdm_StreamCanWrite(...) __attribute__ ((nothrow));
unsigned _ssdm_StreamSize(...) __attribute__ ((nothrow));
#pragma empty_line
// Misc
void _ssdm_op_MemShiftRead(...) __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_Wait(...) __attribute__ ((nothrow));
void _ssdm_op_Poll(...) __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_Return(...) __attribute__ ((nothrow));
#pragma empty_line
/* SSDM Intrinsics: SPECIFICATIONS */
void _ssdm_op_SpecSynModule(...) __attribute__ ((nothrow));
void _ssdm_op_SpecTopModule(...) __attribute__ ((nothrow));
void _ssdm_op_SpecProcessDecl(...) __attribute__ ((nothrow));
void _ssdm_op_SpecProcessDef(...) __attribute__ ((nothrow));
void _ssdm_op_SpecPort(...) __attribute__ ((nothrow));
void _ssdm_op_SpecConnection(...) __attribute__ ((nothrow));
void _ssdm_op_SpecChannel(...) __attribute__ ((nothrow));
void _ssdm_op_SpecSensitive(...) __attribute__ ((nothrow));
void _ssdm_op_SpecModuleInst(...) __attribute__ ((nothrow));
void _ssdm_op_SpecPortMap(...) __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_SpecReset(...) __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_SpecPlatform(...) __attribute__ ((nothrow));
void _ssdm_op_SpecClockDomain(...) __attribute__ ((nothrow));
void _ssdm_op_SpecPowerDomain(...) __attribute__ ((nothrow));
#pragma empty_line
int _ssdm_op_SpecRegionBegin(...) __attribute__ ((nothrow));
int _ssdm_op_SpecRegionEnd(...) __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_SpecLoopName(...) __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_SpecLoopTripCount(...) __attribute__ ((nothrow));
#pragma empty_line
int _ssdm_op_SpecStateBegin(...) __attribute__ ((nothrow));
int _ssdm_op_SpecStateEnd(...) __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_SpecInterface(...) __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_SpecPipeline(...) __attribute__ ((nothrow));
void _ssdm_op_SpecDataflowPipeline(...) __attribute__ ((nothrow));
#pragma empty_line
#pragma empty_line
void _ssdm_op_SpecLatency(...) __attribute__ ((nothrow));
void _ssdm_op_SpecParallel(...) __attribute__ ((nothrow));
void _ssdm_op_SpecProtocol(...) __attribute__ ((nothrow));
void _ssdm_op_SpecOccurrence(...) __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_SpecResource(...) __attribute__ ((nothrow));
void _ssdm_op_SpecResourceLimit(...) __attribute__ ((nothrow));
void _ssdm_op_SpecCHCore(...) __attribute__ ((nothrow));
void _ssdm_op_SpecFUCore(...) __attribute__ ((nothrow));
void _ssdm_op_SpecIFCore(...) __attribute__ ((nothrow));
void _ssdm_op_SpecIPCore(...) __attribute__ ((nothrow));
void _ssdm_op_SpecKeepValue(...) __attribute__ ((nothrow));
void _ssdm_op_SpecMemCore(...) __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_SpecExt(...) __attribute__ ((nothrow));
/*void* _ssdm_op_SpecProcess(...) SSDM_SPEC_ATTR;
void* _ssdm_op_SpecEdge(...) SSDM_SPEC_ATTR; */
#pragma empty_line
/* Presynthesis directive functions */
void _ssdm_SpecArrayDimSize(...) __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_RegionBegin(...) __attribute__ ((nothrow));
void _ssdm_RegionEnd(...) __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_Unroll(...) __attribute__ ((nothrow));
void _ssdm_UnrollRegion(...) __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_InlineAll(...) __attribute__ ((nothrow));
void _ssdm_InlineLoop(...) __attribute__ ((nothrow));
void _ssdm_Inline(...) __attribute__ ((nothrow));
void _ssdm_InlineSelf(...) __attribute__ ((nothrow));
void _ssdm_InlineRegion(...) __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_SpecArrayMap(...) __attribute__ ((nothrow));
void _ssdm_SpecArrayPartition(...) __attribute__ ((nothrow));
void _ssdm_SpecArrayReshape(...) __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_SpecStream(...) __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_SpecExpr(...) __attribute__ ((nothrow));
void _ssdm_SpecExprBalance(...) __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_SpecDependence(...) __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_SpecLoopMerge(...) __attribute__ ((nothrow));
void _ssdm_SpecLoopFlatten(...) __attribute__ ((nothrow));
void _ssdm_SpecLoopRewind(...) __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_SpecFuncInstantiation(...) __attribute__ ((nothrow));
void _ssdm_SpecFuncBuffer(...) __attribute__ ((nothrow));
void _ssdm_SpecFuncExtract(...) __attribute__ ((nothrow));
void _ssdm_SpecConstant(...) __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_DataPack(...) __attribute__ ((nothrow));
void _ssdm_SpecDataPack(...) __attribute__ ((nothrow));
#pragma empty_line
void _ssdm_op_SpecBitsMap(...) __attribute__ ((nothrow));
void _ssdm_op_SpecLicense(...) __attribute__ ((nothrow));
#pragma empty_line
void __xilinx_ip_top(...) __attribute__ ((nothrow));
#pragma empty_line
#pragma empty_line
}
#pragma line 407 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/etc/autopilot_ssdm_op.h"
/*#define _ssdm_op_WaitUntil(X) while (!(X)) _ssdm_op_Wait(1);
#define _ssdm_op_Delayed(X) X */
#pragma line 421 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/etc/autopilot_ssdm_op.h"
// XSIP watermark, do not delete 67d7842dbbe25473c3c32b93c0da8047785f30d78e8a024de1b57352245f9689
#pragma line 6 "<command line>" 2
#pragma line 1 "<built-in>" 2
#pragma line 1 "example/udp.cpp" 2
#pragma line 1 "example/udp.h" 1
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/boost/preprocessor/repetition/enum_params.hpp" 1 3 4
#pragma line 17 "/usr/include/boost/preprocessor/repetition/enum_params.hpp" 3 4
#pragma line 1 "/usr/include/boost/preprocessor/config/config.hpp" 1 3 4
#pragma line 18 "/usr/include/boost/preprocessor/repetition/enum_params.hpp" 2 3 4
#pragma line 1 "/usr/include/boost/preprocessor/punctuation/comma_if.hpp" 1 3 4
#pragma line 17 "/usr/include/boost/preprocessor/punctuation/comma_if.hpp" 3 4
#pragma line 1 "/usr/include/boost/preprocessor/config/config.hpp" 1 3 4
#pragma line 18 "/usr/include/boost/preprocessor/punctuation/comma_if.hpp" 2 3 4
#pragma line 1 "/usr/include/boost/preprocessor/control/if.hpp" 1 3 4
#pragma line 17 "/usr/include/boost/preprocessor/control/if.hpp" 3 4
#pragma line 1 "/usr/include/boost/preprocessor/config/config.hpp" 1 3 4
#pragma line 18 "/usr/include/boost/preprocessor/control/if.hpp" 2 3 4
#pragma line 1 "/usr/include/boost/preprocessor/control/iif.hpp" 1 3 4
#pragma line 15 "/usr/include/boost/preprocessor/control/iif.hpp" 3 4
#pragma line 1 "/usr/include/boost/preprocessor/config/config.hpp" 1 3 4
#pragma line 16 "/usr/include/boost/preprocessor/control/iif.hpp" 2 3 4
#pragma line 19 "/usr/include/boost/preprocessor/control/if.hpp" 2 3 4
#pragma line 1 "/usr/include/boost/preprocessor/logical/bool.hpp" 1 3 4
#pragma line 17 "/usr/include/boost/preprocessor/logical/bool.hpp" 3 4
#pragma line 1 "/usr/include/boost/preprocessor/config/config.hpp" 1 3 4
#pragma line 18 "/usr/include/boost/preprocessor/logical/bool.hpp" 2 3 4
#pragma line 20 "/usr/include/boost/preprocessor/control/if.hpp" 2 3 4
#pragma line 19 "/usr/include/boost/preprocessor/punctuation/comma_if.hpp" 2 3 4
#pragma line 1 "/usr/include/boost/preprocessor/facilities/empty.hpp" 1 3 4
#pragma line 17 "/usr/include/boost/preprocessor/facilities/empty.hpp" 3 4
#pragma line 1 "/usr/include/boost/preprocessor/config/config.hpp" 1 3 4
#pragma line 18 "/usr/include/boost/preprocessor/facilities/empty.hpp" 2 3 4
#pragma line 20 "/usr/include/boost/preprocessor/punctuation/comma_if.hpp" 2 3 4
#pragma line 1 "/usr/include/boost/preprocessor/punctuation/comma.hpp" 1 3 4
#pragma line 21 "/usr/include/boost/preprocessor/punctuation/comma_if.hpp" 2 3 4
#pragma line 19 "/usr/include/boost/preprocessor/repetition/enum_params.hpp" 2 3 4
#pragma line 1 "/usr/include/boost/preprocessor/repetition/repeat.hpp" 1 3 4
#pragma line 17 "/usr/include/boost/preprocessor/repetition/repeat.hpp" 3 4
#pragma line 1 "/usr/include/boost/preprocessor/cat.hpp" 1 3 4
#pragma line 17 "/usr/include/boost/preprocessor/cat.hpp" 3 4
#pragma line 1 "/usr/include/boost/preprocessor/config/config.hpp" 1 3 4
#pragma line 18 "/usr/include/boost/preprocessor/cat.hpp" 2 3 4
#pragma line 18 "/usr/include/boost/preprocessor/repetition/repeat.hpp" 2 3 4
#pragma line 1 "/usr/include/boost/preprocessor/config/config.hpp" 1 3 4
#pragma line 19 "/usr/include/boost/preprocessor/repetition/repeat.hpp" 2 3 4
#pragma line 1 "/usr/include/boost/preprocessor/debug/error.hpp" 1 3 4
#pragma line 15 "/usr/include/boost/preprocessor/debug/error.hpp" 3 4
#pragma line 1 "/usr/include/boost/preprocessor/cat.hpp" 1 3 4
#pragma line 16 "/usr/include/boost/preprocessor/debug/error.hpp" 2 3 4
#pragma line 1 "/usr/include/boost/preprocessor/config/config.hpp" 1 3 4
#pragma line 17 "/usr/include/boost/preprocessor/debug/error.hpp" 2 3 4
#pragma line 20 "/usr/include/boost/preprocessor/repetition/repeat.hpp" 2 3 4
#pragma line 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
#pragma line 12 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 3 4
#pragma line 1 "/usr/include/boost/preprocessor/config/config.hpp" 1 3 4
#pragma line 13 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 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 empty_line
#pragma line 1 "/usr/include/boost/preprocessor/control/iif.hpp" 1 3 4
#pragma line 22 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 2 3 4
#pragma line 21 "/usr/include/boost/preprocessor/repetition/repeat.hpp" 2 3 4
#pragma line 1 "/usr/include/boost/preprocessor/tuple/eat.hpp" 1 3 4
#pragma line 18 "/usr/include/boost/preprocessor/tuple/eat.hpp" 3 4
#pragma line 1 "/usr/include/boost/preprocessor/config/config.hpp" 1 3 4
#pragma line 19 "/usr/include/boost/preprocessor/tuple/eat.hpp" 2 3 4
#pragma line 22 "/usr/include/boost/preprocessor/repetition/repeat.hpp" 2 3 4
#pragma line 20 "/usr/include/boost/preprocessor/repetition/enum_params.hpp" 2 3 4
#pragma line 5 "example/udp.h" 2
#pragma empty_line
#pragma line 1 "/usr/include/linux/if_ether.h" 1 3 4
/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */
/*
* INET An implementation of the TCP/IP protocol suite for the LINUX
* operating system. INET is implemented using the BSD Socket
* interface as the means of communication with the user level.
*
* Global definitions for the Ethernet IEEE 802.3 interface.
*
* Version: @(#)if_ether.h 1.0.1a 02/08/94
*
* Author: Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
* Donald Becker, <becker@super.org>
* Alan Cox, <alan@lxorguk.ukuu.org.uk>
* Steve Whitehouse, <gw7rrm@eeshack3.swan.ac.uk>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version
* 2 of the License, or (at your option) any later version.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/linux/types.h" 1 3 4
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/asm/types.h" 1 3 4
/* SPDX-License-Identifier: GPL-2.0 */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/asm-generic/types.h" 1 3 4
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
#pragma empty_line
#pragma empty_line
/*
* int-ll64 is used everywhere now.
*/
#pragma empty_line
#pragma line 1 "/usr/include/asm-generic/int-ll64.h" 1 3 4
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
/*
* asm-generic/int-ll64.h
*
* Integer declarations for architectures which use "long long"
* for 64-bit types.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/asm/bitsperlong.h" 1 3 4
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
#pragma line 11 "/usr/include/x86_64-linux-gnu/asm/bitsperlong.h" 3 4
#pragma line 1 "/usr/include/asm-generic/bitsperlong.h" 1 3 4
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
#pragma empty_line
#pragma empty_line
#pragma empty_line
/*
* There seems to be no way of detecting this automatically from user
* space, so 64 bit architectures should override this in their
* bitsperlong.h. In particular, an architecture that supports
* both 32 and 64 bit user space must not rely on CONFIG_64BIT
* to decide it, but rather check a compiler provided macro.
*/
#pragma line 12 "/usr/include/x86_64-linux-gnu/asm/bitsperlong.h" 2 3 4
#pragma line 13 "/usr/include/asm-generic/int-ll64.h" 2 3 4
#pragma empty_line
#pragma empty_line
/*
* __xx is ok: it doesn't pollute the POSIX namespace. Use these in the
* header files exported to user space
*/
#pragma empty_line
typedef __signed__ char __s8;
typedef unsigned char __u8;
#pragma empty_line
typedef __signed__ short __s16;
typedef unsigned short __u16;
#pragma empty_line
typedef __signed__ int __s32;
typedef unsigned int __u32;
#pragma empty_line
#pragma empty_line
__extension__ typedef __signed__ long long __s64;
__extension__ typedef unsigned long long __u64;
#pragma line 8 "/usr/include/asm-generic/types.h" 2 3 4
#pragma line 6 "/usr/include/x86_64-linux-gnu/asm/types.h" 2 3 4
#pragma line 6 "/usr/include/linux/types.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/linux/posix_types.h" 1 3 4
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/linux/stddef.h" 1 3 4
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
#pragma line 6 "/usr/include/linux/posix_types.h" 2 3 4
#pragma empty_line
/*
* This allows for 1024 file descriptors: if NR_OPEN is ever grown
* beyond that you'll have to change this too. But 1024 fd's seem to be
* enough even for such "real" unices like OSF/1, so hopefully this is
* one limit that doesn't have to be changed [again].
*
* Note that POSIX wants the FD_CLEAR(fd,fdsetp) defines to be in
* <sys/time.h> (and thus <linux/time.h>) - but this is a more logical
* place for them. Solved by having dummy defines in <sys/time.h>.
*/
#pragma empty_line
/*
* This macro may have been defined in <gnu/types.h>. But we always
* use the one here.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef struct {
unsigned long fds_bits[1024 / (8 * sizeof(long))];
} __kernel_fd_set;
#pragma empty_line
/* Type of a signal handler. */
typedef void (*__kernel_sighandler_t)(int);
#pragma empty_line
/* Type of a SYSV IPC key. */
typedef int __kernel_key_t;
typedef int __kernel_mqd_t;
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/asm/posix_types.h" 1 3 4
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
#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/asm/posix_types_64.h" 1 3 4
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
#pragma empty_line
#pragma empty_line
#pragma empty_line
/*
* This file is generally used by user-level software, so you need to
* be a little careful about namespace pollution etc. Also, we cannot
* assume GCC is being used.
*/
#pragma empty_line
typedef unsigned short __kernel_old_uid_t;
typedef unsigned short __kernel_old_gid_t;
#pragma empty_line
#pragma empty_line
typedef unsigned long __kernel_old_dev_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/asm-generic/posix_types.h" 1 3 4
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/*
* This file is generally used by user-level software, so you need to
* be a little careful about namespace pollution etc.
*
* First the types that are often defined in different ways across
* architectures, so that you can override them.
*/
#pragma empty_line
#pragma empty_line
typedef long __kernel_long_t;
typedef unsigned long __kernel_ulong_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __kernel_ulong_t __kernel_ino_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef unsigned int __kernel_mode_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef int __kernel_pid_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef int __kernel_ipc_pid_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef unsigned int __kernel_uid_t;
typedef unsigned int __kernel_gid_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __kernel_long_t __kernel_suseconds_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef int __kernel_daddr_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef unsigned int __kernel_uid32_t;
typedef unsigned int __kernel_gid32_t;
#pragma line 62 "/usr/include/asm-generic/posix_types.h" 3 4
/*
* Most 32 bit architectures use "unsigned int" size_t,
* and all 64 bit architectures use "unsigned long" size_t.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __kernel_ulong_t __kernel_size_t;
typedef __kernel_long_t __kernel_ssize_t;
typedef __kernel_long_t __kernel_ptrdiff_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef struct {
int val[2];
} __kernel_fsid_t;
#pragma empty_line
#pragma empty_line
/*
* anything below here should be completely generic
*/
typedef __kernel_long_t __kernel_off_t;
typedef long long __kernel_loff_t;
typedef __kernel_long_t __kernel_time_t;
typedef __kernel_long_t __kernel_clock_t;
typedef int __kernel_timer_t;
typedef int __kernel_clockid_t;
typedef char * __kernel_caddr_t;
typedef unsigned short __kernel_uid16_t;
typedef unsigned short __kernel_gid16_t;
#pragma line 19 "/usr/include/x86_64-linux-gnu/asm/posix_types_64.h" 2 3 4
#pragma line 8 "/usr/include/x86_64-linux-gnu/asm/posix_types.h" 2 3 4
#pragma line 37 "/usr/include/linux/posix_types.h" 2 3 4
#pragma line 10 "/usr/include/linux/types.h" 2 3 4
#pragma empty_line
#pragma empty_line
/*
* Below are truly Linux-specific types that should never collide with
* any application/library that wants linux/types.h.
*/
#pragma line 24 "/usr/include/linux/types.h" 3 4
typedef __u16 __le16;
typedef __u16 __be16;
typedef __u32 __le32;
typedef __u32 __be32;
typedef __u64 __le64;
typedef __u64 __be64;
#pragma empty_line
typedef __u16 __sum16;
typedef __u32 __wsum;
#pragma empty_line
/*
* aligned_u64 should be used in defining kernel<->userspace ABIs to avoid
* common 32/64-bit compat problems.
* 64-bit values align to 4-byte boundaries on x86_32 (and possibly other
* architectures) and to 8-byte boundaries on 64-bit architectures. The new
* aligned_64 type enforces 8-byte alignment so that structs containing
* aligned_64 values have the same alignment on 32-bit and 64-bit architectures.
* No conversions are necessary between 32-bit user-space and a 64-bit kernel.
*/
#pragma line 26 "/usr/include/linux/if_ether.h" 2 3 4
#pragma empty_line
/*
* IEEE 802.3 Ethernet magic constants. The frame sizes omit the preamble
* and FCS/CRC (frame check sequence).
*/
#pragma line 43 "/usr/include/linux/if_ether.h" 3 4
/*
* These are the defined Ethernet Protocol ID's.
*/
#pragma line 116 "/usr/include/linux/if_ether.h" 3 4
/*
* Non DIX types. Won't clash for 1500 types.
*/
#pragma line 149 "/usr/include/linux/if_ether.h" 3 4
/*
* This is an Ethernet frame header.
*/
#pragma empty_line
/* allow libcs like musl to deactivate this, glibc does not implement this. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
struct ethhdr {
unsigned char h_dest[6 /* Octets in one ethernet addr */]; /* destination eth addr */
unsigned char h_source[6 /* Octets in one ethernet addr */]; /* source ether addr */
__be16 h_proto; /* packet type ID field */
} __attribute__((packed));
#pragma line 7 "example/udp.h" 2
#pragma line 1 "/usr/include/linux/ip.h" 1 3 4
/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */
/*
* INET An implementation of the TCP/IP protocol suite for the LINUX
* operating system. INET is implemented using the BSD Socket
* interface as the means of communication with the user level.
*
* Definitions for the IP protocol.
*
* Version: @(#)ip.h 1.0.2 04/28/93
*
* Authors: Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version
* 2 of the License, or (at your option) any later version.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/asm/byteorder.h" 1 3 4
/* SPDX-License-Identifier: GPL-2.0 */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/linux/byteorder/little_endian.h" 1 3 4
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
#pragma line 13 "/usr/include/linux/byteorder/little_endian.h" 3 4
#pragma line 1 "/usr/include/linux/swab.h" 1 3 4
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
#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/asm/swab.h" 1 3 4
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
static __inline__ __u32 __arch_swab32(__u32 val)
{
__asm__("bswapl %0" : "=r" (val) : "0" (val));
return val;
}
#pragma empty_line
#pragma empty_line
static __inline__ __u64 __arch_swab64(__u64 val)
{
#pragma line 31 "/usr/include/x86_64-linux-gnu/asm/swab.h" 3 4
__asm__("bswapq %0" : "=r" (val) : "0" (val));
return val;
#pragma empty_line
}
#pragma line 8 "/usr/include/linux/swab.h" 2 3 4
#pragma empty_line
/*
* casts are necessary for constants, because we never know how for sure
* how U/UL/ULL map to __u16, __u32, __u64. At least not in a portable way.
*/
#pragma line 41 "/usr/include/linux/swab.h" 3 4
/*
* Implement the following as inlines, but define the interface using
* macros to allow constant folding when possible:
* ___swab16, ___swab32, ___swab64, ___swahw32, ___swahb32
*/
#pragma empty_line
static __inline__ __u16 __fswab16(__u16 val)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
return ((__u16)( (((__u16)(val) & (__u16)0x00ffU) << 8) | (((__u16)(val) & (__u16)0xff00U) >> 8)));
#pragma empty_line
}
#pragma empty_line
static __inline__ __u32 __fswab32(__u32 val)
{
#pragma empty_line
return __arch_swab32(val);
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
static __inline__ __u64 __fswab64(__u64 val)
{
#pragma empty_line
return __arch_swab64(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
static __inline__ __u32 __fswahw32(__u32 val)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
return ((__u32)( (((__u32)(val) & (__u32)0x0000ffffUL) << 16) | (((__u32)(val) & (__u32)0xffff0000UL) >> 16)));
#pragma empty_line
}
#pragma empty_line
static __inline__ __u32 __fswahb32(__u32 val)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
return ((__u32)( (((__u32)(val) & (__u32)0x00ff00ffUL) << 8) | (((__u32)(val) & (__u32)0xff00ff00UL) >> 8)));
#pragma empty_line
}
#pragma empty_line
/**
* __swab16 - return a byteswapped 16-bit value
* @x: value to byteswap
*/
#pragma line 109 "/usr/include/linux/swab.h" 3 4
/**
* __swab32 - return a byteswapped 32-bit value
* @x: value to byteswap
*/
#pragma line 122 "/usr/include/linux/swab.h" 3 4
/**
* __swab64 - return a byteswapped 64-bit value
* @x: value to byteswap
*/
#pragma line 135 "/usr/include/linux/swab.h" 3 4
/**
* __swahw32 - return a word-swapped 32-bit value
* @x: value to wordswap
*
* __swahw32(0x12340000) is 0x00001234
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/**
* __swahb32 - return a high and low byte-swapped 32-bit value
* @x: value to byteswap
*
* __swahb32(0x12345678) is 0x34127856
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/**
* __swab16p - return a byteswapped 16-bit value from a pointer
* @p: pointer to a naturally-aligned 16-bit value
*/
static __inline__ __u16 __swab16p(const __u16 *p)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
return (__builtin_constant_p((__u16)(*p)) ? ((__u16)( (((__u16)(*p) & (__u16)0x00ffU) << 8) | (((__u16)(*p) & (__u16)0xff00U) >> 8))) : __fswab16(*p));
#pragma empty_line
}
#pragma empty_line
/**
* __swab32p - return a byteswapped 32-bit value from a pointer
* @p: pointer to a naturally-aligned 32-bit value
*/
static __inline__ __u32 __swab32p(const __u32 *p)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
return (__builtin_constant_p((__u32)(*p)) ? ((__u32)( (((__u32)(*p) & (__u32)0x000000ffUL) << 24) | (((__u32)(*p) & (__u32)0x0000ff00UL) << 8) | (((__u32)(*p) & (__u32)0x00ff0000UL) >> 8) | (((__u32)(*p) & (__u32)0xff000000UL) >> 24))) : __fswab32(*p));
#pragma empty_line
}
#pragma empty_line
/**
* __swab64p - return a byteswapped 64-bit value from a pointer
* @p: pointer to a naturally-aligned 64-bit value
*/
static __inline__ __u64 __swab64p(const __u64 *p)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
return (__builtin_constant_p((__u64)(*p)) ? ((__u64)( (((__u64)(*p) & (__u64)0x00000000000000ffULL) << 56) | (((__u64)(*p) & (__u64)0x000000000000ff00ULL) << 40) | (((__u64)(*p) & (__u64)0x0000000000ff0000ULL) << 24) | (((__u64)(*p) & (__u64)0x00000000ff000000ULL) << 8) | (((__u64)(*p) & (__u64)0x000000ff00000000ULL) >> 8) | (((__u64)(*p) & (__u64)0x0000ff0000000000ULL) >> 24) | (((__u64)(*p) & (__u64)0x00ff000000000000ULL) >> 40) | (((__u64)(*p) & (__u64)0xff00000000000000ULL) >> 56))) : __fswab64(*p));
#pragma empty_line
}
#pragma empty_line
/**
* __swahw32p - return a wordswapped 32-bit value from a pointer
* @p: pointer to a naturally-aligned 32-bit value
*
* See __swahw32() for details of wordswapping.
*/
static __inline__ __u32 __swahw32p(const __u32 *p)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
return (__builtin_constant_p((__u32)(*p)) ? ((__u32)( (((__u32)(*p) & (__u32)0x0000ffffUL) << 16) | (((__u32)(*p) & (__u32)0xffff0000UL) >> 16))) : __fswahw32(*p));
#pragma empty_line
}
#pragma empty_line
/**
* __swahb32p - return a high and low byteswapped 32-bit value from a pointer
* @p: pointer to a naturally-aligned 32-bit value
*
* See __swahb32() for details of high/low byteswapping.
*/
static __inline__ __u32 __swahb32p(const __u32 *p)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
return (__builtin_constant_p((__u32)(*p)) ? ((__u32)( (((__u32)(*p) & (__u32)0x00ff00ffUL) << 8) | (((__u32)(*p) & (__u32)0xff00ff00UL) >> 8))) : __fswahb32(*p));
#pragma empty_line
}
#pragma empty_line
/**
* __swab16s - byteswap a 16-bit value in-place
* @p: pointer to a naturally-aligned 16-bit value
*/
static __inline__ void __swab16s(__u16 *p)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
*p = __swab16p(p);
#pragma empty_line
}
/**
* __swab32s - byteswap a 32-bit value in-place
* @p: pointer to a naturally-aligned 32-bit value
*/
static __inline__ void __swab32s(__u32 *p)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
*p = __swab32p(p);
#pragma empty_line
}
#pragma empty_line
/**
* __swab64s - byteswap a 64-bit value in-place
* @p: pointer to a naturally-aligned 64-bit value
*/
static __inline__ void __swab64s(__u64 *p)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
*p = __swab64p(p);
#pragma empty_line
}
#pragma empty_line
/**
* __swahw32s - wordswap a 32-bit value in-place
* @p: pointer to a naturally-aligned 32-bit value
*
* See __swahw32() for details of wordswapping
*/
static __inline__ void __swahw32s(__u32 *p)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
*p = __swahw32p(p);
#pragma empty_line
}
#pragma empty_line
/**
* __swahb32s - high and low byteswap a 32-bit value in-place
* @p: pointer to a naturally-aligned 32-bit value
*
* See __swahb32() for details of high and low byte swapping
*/
static __inline__ void __swahb32s(__u32 *p)
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
*p = __swahb32p(p);
#pragma empty_line
}
#pragma line 14 "/usr/include/linux/byteorder/little_endian.h" 2 3 4
#pragma line 44 "/usr/include/linux/byteorder/little_endian.h" 3 4
static __inline__ __le64 __cpu_to_le64p(const __u64 *p)
{
return (__le64)*p;
}
static __inline__ __u64 __le64_to_cpup(const __le64 *p)
{
return (__u64)*p;
}
static __inline__ __le32 __cpu_to_le32p(const __u32 *p)
{
return (__le32)*p;
}
static __inline__ __u32 __le32_to_cpup(const __le32 *p)
{
return (__u32)*p;
}
static __inline__ __le16 __cpu_to_le16p(const __u16 *p)
{
return (__le16)*p;
}
static __inline__ __u16 __le16_to_cpup(const __le16 *p)
{
return (__u16)*p;
}
static __inline__ __be64 __cpu_to_be64p(const __u64 *p)
{
return (__be64)__swab64p(p);
}
static __inline__ __u64 __be64_to_cpup(const __be64 *p)
{
return __swab64p((__u64 *)p);
}
static __inline__ __be32 __cpu_to_be32p(const __u32 *p)
{
return (__be32)__swab32p(p);
}
static __inline__ __u32 __be32_to_cpup(const __be32 *p)
{
return __swab32p((__u32 *)p);
}
static __inline__ __be16 __cpu_to_be16p(const __u16 *p)
{
return (__be16)__swab16p(p);
}
static __inline__ __u16 __be16_to_cpup(const __be16 *p)
{
return __swab16p((__u16 *)p);
}
#pragma line 6 "/usr/include/x86_64-linux-gnu/asm/byteorder.h" 2 3 4
#pragma line 22 "/usr/include/linux/ip.h" 2 3 4
#pragma line 42 "/usr/include/linux/ip.h" 3 4
/* IP options */
#pragma line 86 "/usr/include/linux/ip.h" 3 4
struct iphdr {
#pragma empty_line
__u8 ihl:4,
version:4;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
__u8 tos;
__be16 tot_len;
__be16 id;
__be16 frag_off;
__u8 ttl;
__u8 protocol;
__sum16 check;
__be32 saddr;
__be32 daddr;
/*The options start here. */
};
#pragma empty_line
#pragma empty_line
struct ip_auth_hdr {
__u8 nexthdr;
__u8 hdrlen; /* This one is measured in 32 bit units! */
__be16 reserved;
__be32 spi;
__be32 seq_no; /* Sequence number */
__u8 auth_data[0]; /* Variable len but >=4. Mind the 64 bit alignment! */
};
#pragma empty_line
struct ip_esp_hdr {
__be32 spi;
__be32 seq_no; /* Sequence number */
__u8 enc_data[0]; /* Variable len but >=8. Mind the 64 bit alignment! */
};
#pragma empty_line
struct ip_comp_hdr {
__u8 nexthdr;
__u8 flags;
__be16 cpi;
};
#pragma empty_line
struct ip_beet_phdr {
__u8 nexthdr;
__u8 hdrlen;
__u8 padlen;
__u8 reserved;
};
#pragma empty_line
/* index values for the variables in ipv4_devconf */
enum
{
IPV4_DEVCONF_FORWARDING=1,
IPV4_DEVCONF_MC_FORWARDING,
IPV4_DEVCONF_PROXY_ARP,
IPV4_DEVCONF_ACCEPT_REDIRECTS,
IPV4_DEVCONF_SECURE_REDIRECTS,
IPV4_DEVCONF_SEND_REDIRECTS,
IPV4_DEVCONF_SHARED_MEDIA,
IPV4_DEVCONF_RP_FILTER,
IPV4_DEVCONF_ACCEPT_SOURCE_ROUTE,
IPV4_DEVCONF_BOOTP_RELAY,
IPV4_DEVCONF_LOG_MARTIANS,
IPV4_DEVCONF_TAG,
IPV4_DEVCONF_ARPFILTER,
IPV4_DEVCONF_MEDIUM_ID,
IPV4_DEVCONF_NOXFRM,
IPV4_DEVCONF_NOPOLICY,
IPV4_DEVCONF_FORCE_IGMP_VERSION,
IPV4_DEVCONF_ARP_ANNOUNCE,
IPV4_DEVCONF_ARP_IGNORE,
IPV4_DEVCONF_PROMOTE_SECONDARIES,
IPV4_DEVCONF_ARP_ACCEPT,
IPV4_DEVCONF_ARP_NOTIFY,
IPV4_DEVCONF_ACCEPT_LOCAL,
IPV4_DEVCONF_SRC_VMARK,
IPV4_DEVCONF_PROXY_ARP_PVLAN,
IPV4_DEVCONF_ROUTE_LOCALNET,
IPV4_DEVCONF_IGMPV2_UNSOLICITED_REPORT_INTERVAL,
IPV4_DEVCONF_IGMPV3_UNSOLICITED_REPORT_INTERVAL,
IPV4_DEVCONF_IGNORE_ROUTES_WITH_LINKDOWN,
IPV4_DEVCONF_DROP_UNICAST_IN_L2_MULTICAST,
IPV4_DEVCONF_DROP_GRATUITOUS_ARP,
__IPV4_DEVCONF_MAX
};
#pragma line 8 "example/udp.h" 2
#pragma line 1 "/usr/include/netinet/in.h" 1 3 4
/* Copyright (C) 1991-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/features.h" 1 3 4
/* Copyright (C) 1991-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* These are defined by the user (or the compiler)
to specify the desired environment:
#pragma empty_line
__STRICT_ANSI__ ISO Standard C.
_ISOC99_SOURCE Extensions to ISO C89 from ISO C99.
_ISOC11_SOURCE Extensions to ISO C99 from ISO C11.
__STDC_WANT_LIB_EXT2__
Extensions to ISO C99 from TR 27431-2:2010.
__STDC_WANT_IEC_60559_BFP_EXT__
Extensions to ISO C11 from TS 18661-1:2014.
__STDC_WANT_IEC_60559_FUNCS_EXT__
Extensions to ISO C11 from TS 18661-4:2015.
__STDC_WANT_IEC_60559_TYPES_EXT__
Extensions to ISO C11 from TS 18661-3:2015.
#pragma empty_line
_POSIX_SOURCE IEEE Std 1003.1.
_POSIX_C_SOURCE If ==1, like _POSIX_SOURCE; if >=2 add IEEE Std 1003.2;
if >=199309L, add IEEE Std 1003.1b-1993;
if >=199506L, add IEEE Std 1003.1c-1995;
if >=200112L, all of IEEE 1003.1-2004
if >=200809L, all of IEEE 1003.1-2008
_XOPEN_SOURCE Includes POSIX and XPG things. Set to 500 if
Single Unix conformance is wanted, to 600 for the
sixth revision, to 700 for the seventh revision.
_XOPEN_SOURCE_EXTENDED XPG things and X/Open Unix extensions.
_LARGEFILE_SOURCE Some more functions for correct standard I/O.
_LARGEFILE64_SOURCE Additional functionality from LFS for large files.
_FILE_OFFSET_BITS=N Select default filesystem interface.
_ATFILE_SOURCE Additional *at interfaces.
_GNU_SOURCE All of the above, plus GNU extensions.
_DEFAULT_SOURCE The default set of features (taking precedence over
__STRICT_ANSI__).
#pragma empty_line
_FORTIFY_SOURCE Add security hardening to many library functions.
Set to 1 or 2; 2 performs stricter checks than 1.
#pragma empty_line
_REENTRANT, _THREAD_SAFE
Obsolete; equivalent to _POSIX_C_SOURCE=199506L.
#pragma empty_line
The `-ansi' switch to the GNU C compiler, and standards conformance
options such as `-std=c99', define __STRICT_ANSI__. If none of
these are defined, or if _DEFAULT_SOURCE is defined, the default is
to have _POSIX_SOURCE set to one and _POSIX_C_SOURCE set to
200809L, as well as enabling miscellaneous functions from BSD and
SVID. If more than one of these are defined, they accumulate. For
example __STRICT_ANSI__, _POSIX_SOURCE and _POSIX_C_SOURCE together
give you ISO C, 1003.1, and 1003.2, but nothing else.
#pragma empty_line
These are defined by this file and are used by the
header files to decide what to declare or define:
#pragma empty_line
__GLIBC_USE (F) Define things from feature set F. This is defined
to 1 or 0; the subsequent macros are either defined
or undefined, and those tests should be moved to
__GLIBC_USE.
__USE_ISOC11 Define ISO C11 things.
__USE_ISOC99 Define ISO C99 things.
__USE_ISOC95 Define ISO C90 AMD1 (C95) things.
__USE_ISOCXX11 Define ISO C++11 things.
__USE_POSIX Define IEEE Std 1003.1 things.
__USE_POSIX2 Define IEEE Std 1003.2 things.
__USE_POSIX199309 Define IEEE Std 1003.1, and .1b things.
__USE_POSIX199506 Define IEEE Std 1003.1, .1b, .1c and .1i things.
__USE_XOPEN Define XPG things.
__USE_XOPEN_EXTENDED Define X/Open Unix things.
__USE_UNIX98 Define Single Unix V2 things.
__USE_XOPEN2K Define XPG6 things.
__USE_XOPEN2KXSI Define XPG6 XSI things.
__USE_XOPEN2K8 Define XPG7 things.
__USE_XOPEN2K8XSI Define XPG7 XSI things.
__USE_LARGEFILE Define correct standard I/O things.
__USE_LARGEFILE64 Define LFS things with separate names.
__USE_FILE_OFFSET64 Define 64bit interface as default.
__USE_MISC Define things from 4.3BSD or System V Unix.
__USE_ATFILE Define *at interfaces and AT_* constants for them.
__USE_GNU Define GNU extensions.
__USE_FORTIFY_LEVEL Additional security measures used, according to level.
#pragma empty_line
The macros `__GNU_LIBRARY__', `__GLIBC__', and `__GLIBC_MINOR__' are
defined by this file unconditionally. `__GNU_LIBRARY__' is provided
only for compatibility. All new code should use the other symbols
to test for features.
#pragma empty_line
All macros listed above as possibly being defined by this file are
explicitly undefined if they are not explicitly defined.
Feature-test macros that are not defined by the user or compiler
but are implied by the other feature-test macros defined (or by the
lack of any definitions) are defined by the file.
#pragma empty_line
ISO C feature test macros depend on the definition of the macro
when an affected header is included, not when the first system
header is included, and so they are handled in
<bits/libc-header-start.h>, which does not have a multiple include
guard. Feature test macros that can be handled from the first
system header included are handled here. */
#pragma empty_line
#pragma empty_line
/* Undefine everything, so we get a clean slate. */
#pragma line 144 "/usr/include/features.h" 3 4
/* Suppress kernel-name space pollution unless user expressedly asks
for it. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Convenience macro to test the version of gcc.
Use like this:
#if __GNUC_PREREQ (2,8)
... code requiring gcc 2.8 or later ...
#endif
Note: only works for GCC 2.0 and later, because __GNUC_MINOR__ was
added in 2.0. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Similarly for clang. Features added to GCC after version 4.2 may
or may not also be available in clang, and clang's definitions of
__GNUC(_MINOR)__ are fixed at 4 and 2 respectively. Not all such
features can be queried via __has_extension/__has_feature. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Whether to use feature set F. */
#pragma empty_line
#pragma empty_line
/* _BSD_SOURCE and _SVID_SOURCE are deprecated aliases for
_DEFAULT_SOURCE. If _DEFAULT_SOURCE is present we do not
issue a warning; the expectation is that the source is being
transitioned to use the new macro. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* If _GNU_SOURCE was defined by the user, turn on all the other features. */
#pragma line 213 "/usr/include/features.h" 3 4
/* If nothing (other than _GNU_SOURCE and _DEFAULT_SOURCE) is defined,
define _DEFAULT_SOURCE. */
#pragma line 224 "/usr/include/features.h" 3 4
/* This is to enable the ISO C11 extension. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* This is to enable the ISO C99 extension. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* This is to enable the ISO C90 Amendment 1:1995 extension. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* This is to enable compatibility for ISO C++17. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* This is to enable compatibility for ISO C++11.
Check the temporary macro for now, too. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* If none of the ANSI/POSIX macros are defined, or if _DEFAULT_SOURCE
is defined, use POSIX.1-2008 (or another version depending on
_XOPEN_SOURCE). */
#pragma line 284 "/usr/include/features.h" 3 4
/* Some C libraries once required _REENTRANT and/or _THREAD_SAFE to be
defined in all multithreaded code. GNU libc has not required this
for many years. We now treat them as compatibility synonyms for
_POSIX_C_SOURCE=199506L, which is the earliest level of POSIX with
comprehensive support for multithreaded code. Using them never
lowers the selected level of POSIX conformance, only raises it. */
#pragma line 390 "/usr/include/features.h" 3 4
/* The function 'gets' existed in C89, but is impossible to use
safely. It has been removed from ISO C11 and ISO C++14. Note: for
compatibility with various implementations of <cstdio>, this test
must consider only the value of __cplusplus when compiling C++. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Get definitions of __STDC_* predefined macros, if the compiler has
not preincluded this header automatically. */
#pragma empty_line
#pragma line 1 "/usr/include/stdc-predef.h" 1 3 4
/* Copyright (C) 1991-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* This header is separate from features.h so that the compiler can
include it implicitly at the start of every compilation. It must
not itself include <features.h> or any other header that includes
<features.h> because the implicit include comes before any feature
test macros that may be defined in a source file before it first
explicitly includes a system header. GCC knows the name of this
header in order to preinclude it. */
#pragma empty_line
/* glibc's intent is to support the IEC 559 math functionality, real
and complex. If the GCC (4.9 and later) predefined macros
specifying compiler intent are available, use them to determine
whether the overall intent is to support these features; otherwise,
presume an older compiler has intent to support these features and
define these macros by default. */
#pragma line 52 "/usr/include/stdc-predef.h" 3 4
/* wchar_t uses Unicode 10.0.0. Version 10.0 of the Unicode Standard is
synchronized with ISO/IEC 10646:2017, fifth edition, plus
the following additions from Amendment 1 to the fifth edition:
- 56 emoji characters
- 285 hentaigana
- 3 additional Zanabazar Square characters */
#pragma empty_line
#pragma empty_line
/* We do not support C11 <threads.h>. */
#pragma line 403 "/usr/include/features.h" 2 3 4
#pragma empty_line
/* This macro indicates that the installed library is the GNU C Library.
For historic reasons the value now is 6 and this will stay from now
on. The use of this variable is deprecated. Use __GLIBC__ and
__GLIBC_MINOR__ now (see below) when you want to test for a specific
GNU C library version and use the values in <gnu/lib-names.h> to get
the sonames of the shared libraries. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Major and minor version number of the GNU C library package. Use
these macros to test for features in specific releases. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* This is here only because every header file already includes this one. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 1 3 4
/* Copyright (C) 1992-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* We are almost always included from features.h. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* The GNU libc does not support any K&R compilers or the traditional mode
of ISO C compilers anymore. Check for some of the combinations not
anymore supported. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Some user header file might have defined this before. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* All functions, except those with callbacks or those that
synchronize memory, are leaf functions. */
#pragma line 49 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 3 4
/* GCC can always grok prototypes. For C++ programs we add throw()
to help it optimize the function calls. But this works only with
gcc 2.8.x and egcs. For gcc 3.2 and up we even mark C functions
as non-throwing using a function attribute since programs can use
the -fexceptions options for C code as well. */
#pragma line 83 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 3 4
/* Compilers that are not clang may object to
#if defined __clang__ && __has_extension(...)
even though they do not need to evaluate the right-hand side of the &&. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* These two macros are not used in glibc anymore. They are kept here
only because some other projects expect the macros to be defined. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* For these things, GCC behaves the ANSI way normally,
and the non-ANSI way under -traditional. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* This is not a typedef so `const __ptr_t' does the right thing. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* C++ needs to know that types and declarations are C, not C++. */
#pragma line 117 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 3 4
/* Fortify support. */
#pragma line 133 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 3 4
/* Support for flexible arrays.
Headers that should use flexible arrays only if they're "real"
(e.g. only if they won't affect sizeof()) should test
#if __glibc_c99_flexarr_available. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* GCC 2.97 supports C99 flexible array members as an extension,
even when in C89 mode or compiling C++ (any version). */
#pragma line 157 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 3 4
/* __asm__ ("xyz") is used throughout the headers to rename functions
at the assembly language level. This is wrapped by the __REDIRECT
macro, in order to support compilers that can do this some other
way. When compilers don't support asm-names at all, we have to do
preprocessor tricks instead (which don't have exactly the right
semantics, but it's the best we can do).
#pragma empty_line
Example:
int __REDIRECT(setpgrp, (__pid_t pid, __pid_t pgrp), setpgid); */
#pragma line 184 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 3 4
/*
#elif __SOME_OTHER_COMPILER__
#pragma empty_line
# define __REDIRECT(name, proto, alias) name proto; \
_Pragma("let " #name " = " #alias)
*/
#pragma empty_line
#pragma empty_line
/* GCC has various useful declarations that can be made with the
`__attribute__' syntax. All of the ways we use this do fine if
they are omitted for compilers that don't understand it. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* At some point during the gcc 2.96 development the `malloc' attribute
for functions was introduced. We don't want to use it unconditionally
(although this would be possible) since it generates warnings. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Tell the compiler which arguments to an allocation function
indicate the size of the allocation. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* At some point during the gcc 2.96 development the `pure' attribute
for functions was introduced. We don't want to use it unconditionally
(although this would be possible) since it generates warnings. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* This declaration tells the compiler that the value is constant. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* At some point during the gcc 3.1 development the `used' attribute
for functions was introduced. We don't want to use it unconditionally
(although this would be possible) since it generates warnings. */
#pragma line 244 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 3 4
/* Since version 3.2, gcc allows marking deprecated functions. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Since version 4.5, gcc also allows one to specify the message printed
when a deprecated function is used. clang claims to be gcc 4.2, but
may also support this feature. */
#pragma line 262 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 3 4
/* At some point during the gcc 2.8 development the `format_arg' attribute
for functions was introduced. We don't want to use it unconditionally
(although this would be possible) since it generates warnings.
If several `format_arg' attributes are given for the same function, in
gcc-3.0 and older, all but the last one are ignored. In newer gccs,
all designated arguments are considered. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* At some point during the gcc 2.97 development the `strfmon' format
attribute for functions was introduced. We don't want to use it
unconditionally (although this would be possible) since it
generates warnings. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* The nonull function attribute allows to mark pointer parameters which
must not be NULL. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* If fortification mode, we warn about unused results of certain
function calls which can lead to problems. */
#pragma line 308 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 3 4
/* Forces a function to be always inlined. */
#pragma empty_line
/* The Linux kernel defines __always_inline in stddef.h (283d7573), and
it conflicts with this definition. Therefore undefine it first to
allow either header to be included first. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Associate error messages with the source location of the call site rather
than with the source location inside the function. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* GCC 4.3 and above with -std=c99 or -std=gnu99 implements ISO C99
inline semantics, unless -fgnu89-inline is used. Using __GNUC_STDC_INLINE__
or __GNUC_GNU_INLINE is not a good enough check for gcc because gcc versions
older than 4.3 may define these macros and still not guarantee GNU inlining
semantics.
#pragma empty_line
clang++ identifies itself as gcc-4.2, but has support for GNU inlining
semantics, that can be checked fot by using the __GNUC_STDC_INLINE_ and
__GNUC_GNU_INLINE__ macro definitions. */
#pragma line 354 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 3 4
/* GCC 4.3 and above allow passing all anonymous arguments of an
__extern_always_inline function to some other vararg function. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* It is possible to compile containing GCC extensions even if GCC is
run in pedantic mode if the uses are carefully marked using the
`__extension__' keyword. But this is not generally available before
version 2.8. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* __restrict is known in EGCS 1.2 and above. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* ISO C99 also allows to declare arrays as non-overlapping. The syntax is
array_name[restrict]
GCC 3.1 supports this. */
#pragma line 427 "/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
/* Determine the wordsize from the preprocessor defines. */
#pragma line 13 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 3 4
/* Both x86-64 and x32 use the 64-bit system call interface. */
#pragma line 428 "/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
/* Properties of long double type. ldbl-96 version.
Copyright (C) 2016-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
/* long double is distinct from double, so there is nothing to
define here. */
#pragma line 429 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 2 3 4
#pragma line 462 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 3 4
/* __glibc_macro_warning (MESSAGE) issues warning MESSAGE. This is
intended for use in preprocessor macros.
#pragma empty_line
Note: MESSAGE must be a _single_ string; concatenation of string
literals is not supported. */
#pragma line 475 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 3 4
/* Generic selection (ISO C11) is a C-only feature, available in GCC
since version 4.9. Previous versions do not provide generic
selection, even though they might set __STDC_VERSION__ to 201112L,
when in -std=c11 mode. Thus, we must check for !defined __GNUC__
when testing __STDC_VERSION__ for generic selection support.
On the other hand, Clang also defines __GNUC__, so a clang-specific
check is required to enable the use of generic selection. */
#pragma line 425 "/usr/include/features.h" 2 3 4
#pragma empty_line
#pragma empty_line
/* If we don't have __REDIRECT, prototypes will be missing if
__USE_FILE_OFFSET64 but not __USE_LARGEFILE[64]. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Decide whether we can define 'extern inline' functions in headers. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* This is here only because every header file already includes this one.
Get the definitions of all the appropriate `__stub_FUNCTION' symbols.
<gnu/stubs.h> contains `#define __stub_FUNCTION' when FUNCTION is a stub
that will always return failure (and set errno to ENOSYS). */
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 1 3 4
/* This file is automatically generated.
This file selects the right generated file of `__stub_FUNCTION' macros
based on the architecture being compiled for. */
#pragma empty_line
#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/gnu/stubs-64.h" 1 3 4
/* This file is automatically generated.
It defines a symbol `__stub_FUNCTION' for each function
in the C library which is a stub, meaning it will fail
every time called, usually setting errno to ENOSYS. */
#pragma line 11 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 2 3 4
#pragma line 449 "/usr/include/features.h" 2 3 4
#pragma line 22 "/usr/include/netinet/in.h" 2 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h" 1 3 4
/* Define uintN_t types.
Copyright (C) 2017-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#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.h" 1 3 4
/* bits/types.h -- definitions of __*_t types underlying *_t types.
Copyright (C) 2002-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
/*
* Never include this file directly; use <sys/types.h> instead.
*/
#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/wordsize.h" 1 3 4
/* Determine the wordsize from the preprocessor defines. */
#pragma line 13 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 3 4
/* Both x86-64 and x32 use the 64-bit system call interface. */
#pragma line 28 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4
#pragma empty_line
/* Convenience types. */
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
/* Fixed-size types, underlying types depend on word size and compiler. */
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
/* quad_t is also 64 bits. */
#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
/* Largest integral types. */
#pragma empty_line
typedef long int __intmax_t;
typedef unsigned long int __uintmax_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* The machine-dependent file <bits/typesizes.h> defines __*_T_TYPE
macros for each of the OS types we define below. The definitions
of those macros must use the following macros for underlying types.
We define __S<SIZE>_TYPE and __U<SIZE>_TYPE for the signed and unsigned
variants of each of the following integer types on this machine.
#pragma empty_line
16 -- "natural" 16-bit type (always short)
32 -- "natural" 32-bit type (always int)
64 -- "natural" 64-bit type (long or long long)
LONG32 -- 32-bit type, traditionally long
QUAD -- 64-bit type, always long long
WORD -- natural type of __WORDSIZE bits (int or long)
LONGWORD -- type of __WORDSIZE bits, traditionally long
#pragma empty_line
We distinguish WORD/LONGWORD, 32/LONG32, and 64/QUAD so that the
conventional uses of `long' or `long long' type modifiers match the
types we define, even when a less-adorned type would be the same size.
This matters for (somewhat) portably writing printf/scanf formats for
these types, where using the appropriate l or ll format modifiers can
make the typedefs and the formats match up across all GNU platforms. If
we used `long' when it's 64 bits where `long long' is expected, then the
compiler would warn about the formats not matching the argument types,
and the programmer changing them to shut up the compiler would break the
program's portability.
#pragma empty_line
Here we assume what is presently the case in all the GCC configurations
we support: long long is always 64 bits, long is always word/address size,
and int is always 32 bits. */
#pragma line 125 "/usr/include/x86_64-linux-gnu/bits/types.h" 3 4
/* No need to mark the typedef with __extension__. */
#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/typesizes.h" 1 3 4
/* bits/typesizes.h -- underlying types for *_t. Linux/x86-64 version.
Copyright (C) 2012-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma line 26 "/usr/include/x86_64-linux-gnu/bits/typesizes.h" 3 4
/* See <bits/types.h> for the meaning of these macros. This file exists so
that <bits/types.h> need not vary across different GNU platforms. */
#pragma empty_line
/* X32 kernel interface is 64-bit. */
#pragma line 77 "/usr/include/x86_64-linux-gnu/bits/typesizes.h" 3 4
/* Tell the libc code that off_t and off64_t are actually the same type
for all ABI purposes, even if possibly expressed as different base types
for C type-checking purposes. */
#pragma empty_line
#pragma empty_line
/* Same for ino_t and ino64_t. */
#pragma empty_line
#pragma empty_line
/* And for __rlim_t and __rlim64_t. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Number of descriptors that can fit in an `fd_set'. */
#pragma line 131 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4
#pragma empty_line
#pragma empty_line
typedef unsigned long int __dev_t; /* Type of device numbers. */
typedef unsigned int __uid_t; /* Type of user identifications. */
typedef unsigned int __gid_t; /* Type of group identifications. */
typedef unsigned long int __ino_t; /* Type of file serial numbers. */
typedef unsigned long int __ino64_t; /* Type of file serial numbers (LFS).*/
typedef unsigned int __mode_t; /* Type of file attribute bitmasks. */
typedef unsigned long int __nlink_t; /* Type of file link counts. */
typedef long int __off_t; /* Type of file sizes and offsets. */
typedef long int __off64_t; /* Type of file sizes and offsets (LFS). */
typedef int __pid_t; /* Type of process identifications. */
typedef struct { int __val[2]; } __fsid_t; /* Type of file system IDs. */
typedef long int __clock_t; /* Type of CPU usage counts. */
typedef unsigned long int __rlim_t; /* Type for resource measurement. */
typedef unsigned long int __rlim64_t; /* Type for resource measurement (LFS). */
typedef unsigned int __id_t; /* General type for IDs. */
typedef long int __time_t; /* Seconds since the Epoch. */
typedef unsigned int __useconds_t; /* Count of microseconds. */
typedef long int __suseconds_t; /* Signed count of microseconds. */
#pragma empty_line
typedef int __daddr_t; /* The type of a disk address. */
typedef int __key_t; /* Type of an IPC key. */
#pragma empty_line
/* Clock ID used in clock and timer functions. */
typedef int __clockid_t;
#pragma empty_line
/* Timer ID returned by `timer_create'. */
typedef void * __timer_t;
#pragma empty_line
/* Type to represent block size. */
typedef long int __blksize_t;
#pragma empty_line
/* Types from the Large File Support interface. */
#pragma empty_line
/* Type to count number of disk blocks. */
typedef long int __blkcnt_t;
typedef long int __blkcnt64_t;
#pragma empty_line
/* Type to count file system blocks. */
typedef unsigned long int __fsblkcnt_t;
typedef unsigned long int __fsblkcnt64_t;
#pragma empty_line
/* Type to count file system nodes. */
typedef unsigned long int __fsfilcnt_t;
typedef unsigned long int __fsfilcnt64_t;
#pragma empty_line
/* Type of miscellaneous file system fields. */
typedef long int __fsword_t;
#pragma empty_line
typedef long int __ssize_t; /* Type of a byte count, or error. */
#pragma empty_line
/* Signed long type used in system calls. */
typedef long int __syscall_slong_t;
/* Unsigned long type used in system calls. */
typedef unsigned long int __syscall_ulong_t;
#pragma empty_line
/* These few don't really vary by system, they always correspond
to one of the other defined types. */
typedef __off64_t __loff_t; /* Type of file sizes and offsets (LFS). */
typedef char *__caddr_t;
#pragma empty_line
/* Duplicates info from stdint.h but this is used in unistd.h. */
typedef long int __intptr_t;
#pragma empty_line
/* Duplicate info from sys/socket.h. */
typedef unsigned int __socklen_t;
#pragma empty_line
/* C99: An integer type that can be accessed as an atomic entity,
even in the presence of asynchronous interrupts.
It is not currently necessary for this to be machine-specific. */
typedef int __sig_atomic_t;
#pragma line 23 "/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h" 2 3 4
#pragma empty_line
typedef __uint8_t uint8_t;
typedef __uint16_t uint16_t;
typedef __uint32_t uint32_t;
typedef __uint64_t uint64_t;
#pragma line 23 "/usr/include/netinet/in.h" 2 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/sys/socket.h" 1 3 4
/* Declarations of socket constants, types, and functions.
Copyright (C) 1991-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#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 line 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_iovec.h" 1 3 4
/* Define struct iovec.
Copyright (C) 1996-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/clang/bin/../lib/clang/3.1/include/stddef.h" 1 3 4
/*===---- stddef.h - Basic type definitions --------------------------------===
*
* Copyright (c) 2008 Eli Friedman
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*===-----------------------------------------------------------------------===
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __typeof__(((int*)0)-((int*)0)) ptrdiff_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __typeof__(sizeof(int)) size_t;
#pragma line 56 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/clang/bin/../lib/clang/3.1/include/stddef.h" 3 4
/* Some C libraries expect to see a wint_t here. Others (notably MinGW) will use
__WINT_TYPE__ directly; accommodate both by requiring __need_wint_t */
#pragma line 24 "/usr/include/x86_64-linux-gnu/bits/types/struct_iovec.h" 2 3 4
#pragma empty_line
/* Structure for scatter/gather I/O. */
struct iovec
{
void *iov_base; /* Pointer to data. */
size_t iov_len; /* Length of data. */
};
#pragma line 27 "/usr/include/x86_64-linux-gnu/sys/socket.h" 2 3 4
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/clang/bin/../lib/clang/3.1/include/stddef.h" 1 3 4
/*===---- stddef.h - Basic type definitions --------------------------------===
*
* Copyright (c) 2008 Eli Friedman
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*===-----------------------------------------------------------------------===
*/
#pragma line 56 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/clang/bin/../lib/clang/3.1/include/stddef.h" 3 4
/* Some C libraries expect to see a wint_t here. Others (notably MinGW) will use
__WINT_TYPE__ directly; accommodate both by requiring __need_wint_t */
#pragma line 29 "/usr/include/x86_64-linux-gnu/sys/socket.h" 2 3 4
#pragma empty_line
/* This operating system-specific header file defines the SOCK_*, PF_*,
AF_*, MSG_*, SOL_*, and SO_* constants, and the `struct sockaddr',
`struct msghdr', and `struct linger' types. */
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/socket.h" 1 3 4
/* System-specific socket constants and types. Linux version.
Copyright (C) 1991-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma line 27 "/usr/include/x86_64-linux-gnu/bits/socket.h" 3 4
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/clang/bin/../lib/clang/3.1/include/stddef.h" 1 3 4
/*===---- stddef.h - Basic type definitions --------------------------------===
*
* Copyright (c) 2008 Eli Friedman
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*===-----------------------------------------------------------------------===
*/
#pragma line 56 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/clang/bin/../lib/clang/3.1/include/stddef.h" 3 4
/* Some C libraries expect to see a wint_t here. Others (notably MinGW) will use
__WINT_TYPE__ directly; accommodate both by requiring __need_wint_t */
#pragma line 28 "/usr/include/x86_64-linux-gnu/bits/socket.h" 2 3 4
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/sys/types.h" 1 3 4
/* Copyright (C) 1991-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
/*
* POSIX Standard: 2.6 Primitive System Data Types <sys/types.h>
*/
#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
#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
#pragma empty_line
#pragma empty_line
typedef __loff_t loff_t;
#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 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 empty_line
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 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/clock_t.h" 1 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Returned by `clock'. */
typedef __clock_t clock_t;
#pragma line 128 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
#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
/* Clock ID used in clock and timer functions. */
typedef __clockid_t clockid_t;
#pragma line 130 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
#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
/* Returned by `time'. */
typedef __time_t time_t;
#pragma line 131 "/usr/include/x86_64-linux-gnu/sys/types.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
/* Timer ID returned by `timer_create'. */
typedef __timer_t timer_t;
#pragma line 132 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
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 empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/clang/bin/../lib/clang/3.1/include/stddef.h" 1 3 4
/*===---- stddef.h - Basic type definitions --------------------------------===
*
* Copyright (c) 2008 Eli Friedman
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*===-----------------------------------------------------------------------===
*/
#pragma line 56 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/clang/bin/../lib/clang/3.1/include/stddef.h" 3 4
/* Some C libraries expect to see a wint_t here. Others (notably MinGW) will use
__WINT_TYPE__ directly; accommodate both by requiring __need_wint_t */
#pragma line 146 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
#pragma empty_line
#pragma empty_line
/* Old compatibility names for C types. */
typedef unsigned long int ulong;
typedef unsigned short int ushort;
typedef unsigned int uint;
#pragma empty_line
#pragma empty_line
/* These size-specific names are used by some of the inet code. */
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/stdint-intn.h" 1 3 4
/* Define intN_t types.
Copyright (C) 2017-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __int8_t int8_t;
typedef __int16_t int16_t;
typedef __int32_t int32_t;
typedef __int64_t int64_t;
#pragma line 157 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
#pragma line 174 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
/* For GCC 2.7 and later, we can use specific type-size attributes. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__)));
typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__)));
typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__)));
typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__)));
#pragma empty_line
typedef int register_t __attribute__ ((__mode__ (__word__)));
#pragma empty_line
#pragma empty_line
/* Some code from BIND tests this macro to see if the types above are
defined. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* In BSD <sys/types.h> is expected to define BYTE_ORDER. */
#pragma empty_line
#pragma line 1 "/usr/include/endian.h" 1 3 4
/* Copyright (C) 1992-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Definitions for byte order, according to significance of bytes,
from low addresses to high addresses. The value is what you get by
putting '4' in the most significant byte, '3' in the second most
significant byte, '2' in the second least significant byte, and '1'
in the least significant byte, and then writing down one digit for
each byte, starting with the byte at the lowest address at the left,
and proceeding to the byte with the highest address at the right. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* This file defines `__BYTE_ORDER' for the particular machine. */
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/endian.h" 1 3 4
/* i386/x86_64 are little-endian. */
#pragma line 37 "/usr/include/endian.h" 2 3 4
#pragma empty_line
/* Some machines may need to use a different endianness for floating point
values. */
#pragma line 59 "/usr/include/endian.h" 3 4
/* Conversion interfaces. */
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 1 3 4
/* Macros to swap the order of bytes in integer values.
Copyright (C) 1997-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma line 28 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
/* Determine the wordsize from the preprocessor defines. */
#pragma line 13 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 3 4
/* Both x86-64 and x32 use the 64-bit system call interface. */
#pragma line 29 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 2 3 4
#pragma empty_line
/* Swap bytes in 16 bit value. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Get __bswap_16. */
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/byteswap-16.h" 1 3 4
/* Macros to swap the order of bytes in 16-bit integer values.
Copyright (C) 2012-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma line 36 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 2 3 4
#pragma empty_line
/* Swap bytes in 32 bit value. */
#pragma line 56 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 3 4
/* To swap the bytes in a word the i486 processors and up provide the
`bswap' opcode. On i386 we have to use three instructions. */
#pragma line 96 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 3 4
/* Swap bytes in 64 bit value. */
#pragma line 61 "/usr/include/endian.h" 2 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/uintn-identity.h" 1 3 4
/* Inline functions to return unsigned integer values unchanged.
Copyright (C) 2017-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma line 28 "/usr/include/x86_64-linux-gnu/bits/uintn-identity.h" 3 4
/* These inline functions are to ensure the appropriate type
conversions and associated diagnostics from macros that convert to
a given endianness. */
#pragma empty_line
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 62 "/usr/include/endian.h" 2 3 4
#pragma line 195 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
#pragma empty_line
/* It also defines `fd_set' and the FD_* macros for `select'. */
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/sys/select.h" 1 3 4
/* `fd_set' type and related macros, and `select'/`pselect' declarations.
Copyright (C) 1996-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
/* POSIX 1003.1g: 6.2 Select from File Descriptor Sets <sys/select.h> */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Get definition of needed basic types. */
#pragma empty_line
#pragma empty_line
/* Get __FD_* definitions. */
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/select.h" 1 3 4
/* Copyright (C) 1997-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#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/wordsize.h" 1 3 4
/* Determine the wordsize from the preprocessor defines. */
#pragma line 13 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 3 4
/* Both x86-64 and x32 use the 64-bit system call interface. */
#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
/* Get sigset_t. */
#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
/* A set of signals to be blocked, unblocked, or waited for. */
typedef __sigset_t sigset_t;
#pragma line 34 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4
#pragma empty_line
/* Get definition of timer specification structures. */
#pragma empty_line
#pragma empty_line
#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
/* A time value that is accurate to the nearest
microsecond but also has a range of years. */
struct timeval
{
__time_t tv_sec; /* Seconds. */
__suseconds_t tv_usec; /* Microseconds. */
};
#pragma line 38 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h" 1 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* POSIX.1b structure for a time value. This is like a `struct timeval' but
has nanoseconds instead of microseconds. */
struct timespec
{
__time_t tv_sec; /* Seconds. */
__syscall_slong_t tv_nsec; /* Nanoseconds. */
};
#pragma line 40 "/usr/include/x86_64-linux-gnu/sys/select.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 empty_line
/* The fd_set member is required to be an array of longs. */
typedef long int __fd_mask;
#pragma empty_line
/* Some versions of <linux/posix_types.h> define this macros. */
#pragma empty_line
/* It's easier to assume 8-bit bytes than to get CHAR_BIT. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* fd_set for select and pselect. */
typedef struct
{
/* XPG4.2 requires this member name. Otherwise avoid the name
from the global namespace. */
#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
/* Maximum number of file descriptors in `fd_set'. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Sometimes the fd_set member is assumed to have this type. */
typedef __fd_mask fd_mask;
#pragma empty_line
/* Number of bits per word of `fd_set' (some code assumes this is 32). */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Access macros for `fd_set'. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern "C" {
#pragma empty_line
/* Check the first NFDS descriptors each in READFDS (if not NULL) for read
readiness, in WRITEFDS (if not NULL) for write readiness, and in EXCEPTFDS
(if not NULL) for exceptional conditions. If TIMEOUT is not NULL, time out
after waiting the interval specified therein. Returns the number of ready
descriptors, or -1 for errors.
#pragma empty_line
This function is a cancellation point and therefore not marked with
__THROW. */
extern int select (int __nfds, fd_set *__restrict __readfds,
fd_set *__restrict __writefds,
fd_set *__restrict __exceptfds,
struct timeval *__restrict __timeout);
#pragma empty_line
#pragma empty_line
/* Same as above only that the TIMEOUT value is given with higher
resolution and a sigmask which is been set temporarily. This version
should be used.
#pragma empty_line
This function is a cancellation point and therefore not marked with
__THROW. */
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 empty_line
#pragma empty_line
#pragma empty_line
/* Define some inlines helping to catch common problems. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 198 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
#pragma empty_line
/* BSD defines `major', `minor', and `makedev' in this header.
However, these symbols are likely to collide with user code, so we are
going to stop defining them here in an upcoming release. Code that needs
these macros should include <sys/sysmacros.h> directly. Code that does
not need these macros should #undef them after including this header. */
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/sys/sysmacros.h" 1 3 4
/* Definitions of macros to access `dev_t' values.
Copyright (C) 1996-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* If <sys/sysmacros.h> is included after <sys/types.h>, these macros
will already be defined, and we need to redefine them without the
deprecation warnings. (If they are included in the opposite order,
the outer #ifndef will suppress this entire file and the macros
will be usable without warnings.) */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* This is the macro that must be defined to satisfy the misuse check
in bits/sysmacros.h. */
#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/sysmacros.h" 1 3 4
/* Definitions of macros to access `dev_t' values.
Copyright (C) 1996-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma line 26 "/usr/include/x86_64-linux-gnu/bits/sysmacros.h" 3 4
/* dev_t in glibc is a 64-bit quantity, with 32-bit major and minor numbers.
Our default encoding is MMMM Mmmm mmmM MMmm, where M is a hex digit of
the major number and m is a hex digit of the minor number. This is
downward compatible with legacy systems where dev_t is 16 bits wide,
encoded as MMmm. It is also downward compatible with the Linux kernel,
which (as of 2016) uses 32-bit dev_t, encoded as mmmM MMmm.
#pragma empty_line
Systems that use an incompatible encoding for dev_t should override this
file in the appropriate sysdeps subdirectory. */
#pragma line 42 "/usr/include/x86_64-linux-gnu/sys/sysmacros.h" 2 3 4
#pragma empty_line
/* Caution: The text of this deprecation message is unquoted, so that
#symbol can be substituted. (It is converted to a string by
__SYSMACROS_DM1.) This means the message must be a sequence of
complete pp-tokens; in particular, English contractions (it's,
can't) cannot be used.
#pragma empty_line
The message has been manually word-wrapped to fit in 80 columns
when output by GCC 5 and 6. The first line is shorter to leave
some room for the "foo.c:23: warning:" annotation. */
#pragma line 60 "/usr/include/x86_64-linux-gnu/sys/sysmacros.h" 3 4
/* This macro is variadic because the deprecation message above
contains commas. */
#pragma line 71 "/usr/include/x86_64-linux-gnu/sys/sysmacros.h" 3 4
extern "C" {
#pragma empty_line
extern unsigned int gnu_dev_major (__dev_t __dev) throw () __attribute__ ((__const__));
extern unsigned int gnu_dev_minor (__dev_t __dev) throw () __attribute__ ((__const__));
extern __dev_t gnu_dev_makedev (unsigned int __major, unsigned int __minor) throw () __attribute__ ((__const__));
#pragma line 85 "/usr/include/x86_64-linux-gnu/sys/sysmacros.h" 3 4
}
#pragma line 206 "/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
#pragma empty_line
typedef __blksize_t blksize_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Types from the Large File Support interface. */
#pragma empty_line
#pragma empty_line
typedef __blkcnt_t blkcnt_t; /* Type to count number of disk blocks. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __fsblkcnt_t fsblkcnt_t; /* Type to count file system blocks. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __fsfilcnt_t fsfilcnt_t; /* Type to count file system inodes. */
#pragma line 246 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
typedef __blkcnt64_t blkcnt64_t; /* Type to count number of disk blocks. */
typedef __fsblkcnt64_t fsblkcnt64_t; /* Type to count file system blocks. */
typedef __fsfilcnt64_t fsfilcnt64_t; /* Type to count file system inodes. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Now add the thread types. */
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 1 3 4
/* Declaration of common pthread types for all architectures.
Copyright (C) 2017-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* For internal mutex and condition variable definitions. */
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 1 3 4
/* Common threading primitives definitions for both POSIX and C11.
Copyright (C) 2017-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Arch-specific definitions. Each architecture must define the following
macros to define the expected sizes of pthread data types:
#pragma empty_line
__SIZEOF_PTHREAD_ATTR_T - size of pthread_attr_t.
__SIZEOF_PTHREAD_MUTEX_T - size of pthread_mutex_t.
__SIZEOF_PTHREAD_MUTEXATTR_T - size of pthread_mutexattr_t.
__SIZEOF_PTHREAD_COND_T - size of pthread_cond_t.
__SIZEOF_PTHREAD_CONDATTR_T - size of pthread_condattr_t.
__SIZEOF_PTHREAD_RWLOCK_T - size of pthread_rwlock_t.
__SIZEOF_PTHREAD_RWLOCKATTR_T - size of pthread_rwlockattr_t.
__SIZEOF_PTHREAD_BARRIER_T - size of pthread_barrier_t.
__SIZEOF_PTHREAD_BARRIERATTR_T - size of pthread_barrierattr_t.
#pragma empty_line
Also, the following macros must be define for internal pthread_mutex_t
struct definitions (struct __pthread_mutex_s):
#pragma empty_line
__PTHREAD_COMPAT_PADDING_MID - any additional members after 'kind'
and before '__spin' (for 64 bits) or
'__nusers' (for 32 bits).
__PTHREAD_COMPAT_PADDING_END - any additional members at the end of
the internal structure.
__PTHREAD_MUTEX_LOCK_ELISION - 1 if the architecture supports lock
elision or 0 otherwise.
__PTHREAD_MUTEX_NUSERS_AFTER_KIND - control where to put __nusers. The
preferred value for new architectures
is 0.
__PTHREAD_MUTEX_USE_UNION - control whether internal __spins and
__list will be place inside a union for
linuxthreads compatibility.
The preferred value for new architectures
is 0.
#pragma empty_line
For a new port the preferred values for the required defines are:
#pragma empty_line
#define __PTHREAD_COMPAT_PADDING_MID
#define __PTHREAD_COMPAT_PADDING_END
#define __PTHREAD_MUTEX_LOCK_ELISION 0
#define __PTHREAD_MUTEX_NUSERS_AFTER_KIND 0
#define __PTHREAD_MUTEX_USE_UNION 0
#pragma empty_line
__PTHREAD_MUTEX_LOCK_ELISION can be set to 1 if the hardware plans to
eventually support lock elision using transactional memory.
#pragma empty_line
The additional macro defines any constraint for the lock alignment
inside the thread structures:
#pragma empty_line
__LOCK_ALIGNMENT - for internal lock/futex usage.
#pragma empty_line
Same idea but for the once locking primitive:
#pragma empty_line
__ONCE_ALIGNMENT - for pthread_once_t/once_flag definition.
#pragma empty_line
And finally the internal pthread_rwlock_t (struct __pthread_rwlock_arch_t)
must be defined.
*/
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h" 1 3 4
/* Copyright (C) 2002-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#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/wordsize.h" 1 3 4
/* Determine the wordsize from the preprocessor defines. */
#pragma line 13 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 3 4
/* Both x86-64 and x32 use the 64-bit system call interface. */
#pragma line 22 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h" 2 3 4
#pragma line 50 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h" 3 4
/* Definitions for internal mutex struct. */
#pragma line 65 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.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;
/* FLAGS must stay at this position in the structure to maintain
binary compatibility. */
unsigned int __flags;
#pragma line 99 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h" 3 4
};
#pragma line 78 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 2 3 4
#pragma empty_line
/* Common definition of pthread_mutex_t. */
#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
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Lock elision support. */
#pragma line 118 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 3 4
struct __pthread_mutex_s
{
int __lock ;
unsigned int __count;
int __owner;
#pragma empty_line
unsigned int __nusers;
#pragma empty_line
/* KIND must stay at this position in the structure to maintain
binary compatibility with static initializers. */
int __kind;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
short __spins; short __elision;
__pthread_list_t __list;
#pragma line 146 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 3 4
};
#pragma empty_line
#pragma empty_line
/* Common definition of pthread_cond_t. */
#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
/* Thread identifiers. The structure of the attribute type is not
exposed on purpose. */
typedef unsigned long int pthread_t;
#pragma empty_line
#pragma empty_line
/* Data structures for mutex handling. The structure of the attribute
type is not exposed on purpose. */
typedef union
{
char __size[4];
int __align;
} pthread_mutexattr_t;
#pragma empty_line
#pragma empty_line
/* Data structure for condition variable handling. The structure of
the attribute type is not exposed on purpose. */
typedef union
{
char __size[4];
int __align;
} pthread_condattr_t;
#pragma empty_line
#pragma empty_line
/* Keys for thread-specific data */
typedef unsigned int pthread_key_t;
#pragma empty_line
#pragma empty_line
/* Once-only execution */
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
/* Data structure for reader-writer lock variable handling. The
structure of the attribute type is deliberately not exposed. */
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
/* POSIX spinlock data type. */
typedef volatile int pthread_spinlock_t;
#pragma empty_line
#pragma empty_line
/* POSIX barriers data type. The structure of the type is
deliberately not exposed. */
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 255 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
#pragma empty_line
#pragma empty_line
}
#pragma line 30 "/usr/include/x86_64-linux-gnu/bits/socket.h" 2 3 4
#pragma empty_line
/* Type for length arguments in socket calls. */
#pragma empty_line
typedef __socklen_t socklen_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Get the architecture-dependent definition of enum __socket_type. */
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/socket_type.h" 1 3 4
/* Define enum __socket_type for generic Linux.
Copyright (C) 1991-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Types of sockets. */
enum __socket_type
{
SOCK_STREAM = 1, /* Sequenced, reliable, connection-based
byte streams. */
#pragma empty_line
SOCK_DGRAM = 2, /* Connectionless, unreliable datagrams
of fixed maximum length. */
#pragma empty_line
SOCK_RAW = 3, /* Raw protocol interface. */
#pragma empty_line
SOCK_RDM = 4, /* Reliably-delivered messages. */
#pragma empty_line
SOCK_SEQPACKET = 5, /* Sequenced, reliable, connection-based,
datagrams of fixed maximum length. */
#pragma empty_line
SOCK_DCCP = 6, /* Datagram Congestion Control Protocol. */
#pragma empty_line
SOCK_PACKET = 10, /* Linux specific way of getting packets
at the dev level. For writing rarp and
other similar things on the user level. */
#pragma empty_line
#pragma empty_line
/* Flags to be ORed into the type parameter of socket and socketpair and
used for the flags parameter of paccept. */
#pragma empty_line
SOCK_CLOEXEC = 02000000, /* Atomically set close-on-exec flag for the
new descriptor(s). */
#pragma empty_line
SOCK_NONBLOCK = 00004000 /* Atomically mark descriptor(s) as
non-blocking. */
#pragma empty_line
};
#pragma line 39 "/usr/include/x86_64-linux-gnu/bits/socket.h" 2 3 4
#pragma empty_line
/* Protocol families. */
#pragma line 90 "/usr/include/x86_64-linux-gnu/bits/socket.h" 3 4
/* Address families. */
#pragma line 140 "/usr/include/x86_64-linux-gnu/bits/socket.h" 3 4
/* Socket level values. Others are defined in the appropriate headers.
#pragma empty_line
XXX These definitions also should go into the appropriate headers as
far as they are available. */
#pragma line 168 "/usr/include/x86_64-linux-gnu/bits/socket.h" 3 4
/* Maximum queue length specifiable by listen. */
#pragma empty_line
#pragma empty_line
/* Get the definition of the macro to define the common sockaddr members. */
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/sockaddr.h" 1 3 4
/* Definition of struct sockaddr_* common members and sizes, generic version.
Copyright (C) 1995-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
/*
* Never include this file directly; use <sys/socket.h> instead.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* POSIX.1g specifies this type name for the `sa_family' member. */
typedef unsigned short int sa_family_t;
#pragma empty_line
/* This macro is used to declare the initial common members
of the data types used for socket addresses, `struct sockaddr',
`struct sockaddr_in', `struct sockaddr_un', etc. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Size of struct sockaddr_storage. */
#pragma line 173 "/usr/include/x86_64-linux-gnu/bits/socket.h" 2 3 4
#pragma empty_line
/* Structure describing a generic socket address. */
struct sockaddr
{
sa_family_t sa_family; /* Common data: address family and length. */
char sa_data[14]; /* Address data. */
};
#pragma empty_line
#pragma empty_line
/* Structure large enough to hold any socket address (with the historical
exception of AF_UNIX). */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
struct sockaddr_storage
{
sa_family_t ss_family; /* Address family, etc. */
char __ss_padding[(128 - (sizeof (unsigned short int)) - sizeof (unsigned long int))];
unsigned long int __ss_align; /* Force desired alignment. */
};
#pragma empty_line
#pragma empty_line
/* Bits in the FLAGS argument to `send', `recv', et al. */
enum
{
MSG_OOB = 0x01, /* Process out-of-band data. */
#pragma empty_line
MSG_PEEK = 0x02, /* Peek at incoming messages. */
#pragma empty_line
MSG_DONTROUTE = 0x04, /* Don't use local routing. */
#pragma empty_line
#pragma empty_line
/* DECnet uses a different name. */
MSG_TRYHARD = MSG_DONTROUTE,
#pragma empty_line
#pragma empty_line
MSG_CTRUNC = 0x08, /* Control data lost before delivery. */
#pragma empty_line
MSG_PROXY = 0x10, /* Supply or ask second address. */
#pragma empty_line
MSG_TRUNC = 0x20,
#pragma empty_line
MSG_DONTWAIT = 0x40, /* Nonblocking IO. */
#pragma empty_line
MSG_EOR = 0x80, /* End of record. */
#pragma empty_line
MSG_WAITALL = 0x100, /* Wait for a full request. */
#pragma empty_line
MSG_FIN = 0x200,
#pragma empty_line
MSG_SYN = 0x400,
#pragma empty_line
MSG_CONFIRM = 0x800, /* Confirm path validity. */
#pragma empty_line
MSG_RST = 0x1000,
#pragma empty_line
MSG_ERRQUEUE = 0x2000, /* Fetch message from error queue. */
#pragma empty_line
MSG_NOSIGNAL = 0x4000, /* Do not generate SIGPIPE. */
#pragma empty_line
MSG_MORE = 0x8000, /* Sender will send more. */
#pragma empty_line
MSG_WAITFORONE = 0x10000, /* Wait for at least one packet to return.*/
#pragma empty_line
MSG_BATCH = 0x40000, /* sendmmsg: more messages coming. */
#pragma empty_line
MSG_ZEROCOPY = 0x4000000, /* Use user data in kernel path. */
#pragma empty_line
MSG_FASTOPEN = 0x20000000, /* Send data in TCP SYN. */
#pragma empty_line
#pragma empty_line
MSG_CMSG_CLOEXEC = 0x40000000 /* Set close_on_exit for file
descriptor received through
SCM_RIGHTS. */
#pragma empty_line
};
#pragma empty_line
#pragma empty_line
/* Structure describing messages sent by
`sendmsg' and received by `recvmsg'. */
struct msghdr
{
void *msg_name; /* Address to send to/receive from. */
socklen_t msg_namelen; /* Length of address data. */
#pragma empty_line
struct iovec *msg_iov; /* Vector of data to send/receive into. */
size_t msg_iovlen; /* Number of elements in the vector. */
#pragma empty_line
void *msg_control; /* Ancillary data (eg BSD filedesc passing). */
size_t msg_controllen; /* Ancillary data buffer length.
!! The type should be socklen_t but the
definition of the kernel is incompatible
with this. */
#pragma empty_line
int msg_flags; /* Flags on received message. */
};
#pragma empty_line
/* Structure used for storage of ancillary data object information. */
struct cmsghdr
{
size_t cmsg_len; /* Length of data in cmsg_data plus length
of cmsghdr structure.
!! The type should be socklen_t but the
definition of the kernel is incompatible
with this. */
int cmsg_level; /* Originating protocol. */
int cmsg_type; /* Protocol specific type. */
#pragma empty_line
__extension__ unsigned char __cmsg_data []; /* Ancillary data. */
#pragma empty_line
};
#pragma empty_line
/* Ancillary data object manipulation macros. */
#pragma line 302 "/usr/include/x86_64-linux-gnu/bits/socket.h" 3 4
extern struct cmsghdr *__cmsg_nxthdr (struct msghdr *__mhdr,
struct cmsghdr *__cmsg) throw ();
#pragma line 327 "/usr/include/x86_64-linux-gnu/bits/socket.h" 3 4
/* Socket level message types. This must match the definitions in
<linux/socket.h>. */
enum
{
SCM_RIGHTS = 0x01 /* Transfer file descriptors. */
#pragma empty_line
#pragma empty_line
, SCM_CREDENTIALS = 0x02 /* Credentials passing. */
#pragma empty_line
#pragma empty_line
};
#pragma empty_line
#pragma empty_line
/* User visible structure for SCM_CREDENTIALS message */
struct ucred
{
pid_t pid; /* PID of sending process. */
uid_t uid; /* UID of sending process. */
gid_t gid; /* GID of sending process. */
};
#pragma empty_line
#pragma empty_line
/* Ugly workaround for unclean kernel headers. */
#pragma line 389 "/usr/include/x86_64-linux-gnu/bits/socket.h" 3 4
/* Get socket manipulation related informations from kernel headers. */
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/asm/socket.h" 1 3 4
#pragma line 1 "/usr/include/asm-generic/socket.h" 1 3 4
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/asm/sockios.h" 1 3 4
#pragma line 1 "/usr/include/asm-generic/sockios.h" 1 3 4
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Socket-level I/O control calls. */
#pragma line 2 "/usr/include/x86_64-linux-gnu/asm/sockios.h" 2 3 4
#pragma line 6 "/usr/include/asm-generic/socket.h" 2 3 4
#pragma empty_line
/* For setsockopt(2) */
#pragma line 36 "/usr/include/asm-generic/socket.h" 3 4
/* Security levels - as per NRL IPv6 - don't actually do anything */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Socket filtering */
#pragma line 73 "/usr/include/asm-generic/socket.h" 3 4
/* Instruct lower device to use last 4-bytes of skb data as FCS */
#pragma line 2 "/usr/include/x86_64-linux-gnu/asm/socket.h" 2 3 4
#pragma line 391 "/usr/include/x86_64-linux-gnu/bits/socket.h" 2 3 4
#pragma line 443 "/usr/include/x86_64-linux-gnu/bits/socket.h" 3 4
/* Structure used to manipulate the SO_LINGER option. */
struct linger
{
int l_onoff; /* Nonzero to linger on close. */
int l_linger; /* Time to linger. */
};
#pragma line 34 "/usr/include/x86_64-linux-gnu/sys/socket.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_osockaddr.h" 1 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* This is the 4.3 BSD `struct sockaddr' format, which is used as wire
format in the grotty old 4.3 `talk' protocol. */
struct osockaddr
{
unsigned short int sa_family;
unsigned char sa_data[14];
};
#pragma line 37 "/usr/include/x86_64-linux-gnu/sys/socket.h" 2 3 4
#pragma empty_line
#pragma empty_line
/* The following constants should be used for the second parameter of
`shutdown'. */
enum
{
SHUT_RD = 0, /* No more receptions. */
#pragma empty_line
SHUT_WR, /* No more transmissions. */
#pragma empty_line
SHUT_RDWR /* No more receptions or transmissions. */
#pragma empty_line
};
#pragma empty_line
/* This is the type we use for generic socket address arguments.
#pragma empty_line
With GCC 2.7 and later, the funky union causes redeclarations or
uses with any of the listed types to be allowed without complaint.
G++ 2.7 does not support transparent unions so there we want the
old-style declaration, too. */
#pragma line 89 "/usr/include/x86_64-linux-gnu/sys/socket.h" 3 4
/* For `recvmmsg' and `sendmmsg'. */
struct mmsghdr
{
struct msghdr msg_hdr; /* Actual message header. */
unsigned int msg_len; /* Number of received or sent bytes for the
entry. */
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Create a new socket of type TYPE in domain DOMAIN, using
protocol PROTOCOL. If PROTOCOL is zero, one is chosen automatically.
Returns a file descriptor for the new socket, or -1 for errors. */
extern int socket (int __domain, int __type, int __protocol) throw ();
#pragma empty_line
/* Create two new sockets, of type TYPE in domain DOMAIN and using
protocol PROTOCOL, which are connected to each other, and put file
descriptors for them in FDS[0] and FDS[1]. If PROTOCOL is zero,
one will be chosen automatically. Returns 0 on success, -1 for errors. */
extern int socketpair (int __domain, int __type, int __protocol,
int __fds[2]) throw ();
#pragma empty_line
/* Give the socket FD the local address ADDR (which is LEN bytes long). */
extern int bind (int __fd, const struct sockaddr * __addr, socklen_t __len)
throw ();
#pragma empty_line
/* Put the local address of FD into *ADDR and its length in *LEN. */
extern int getsockname (int __fd, struct sockaddr *__restrict __addr,
socklen_t *__restrict __len) throw ();
#pragma empty_line
/* Open a connection on socket FD to peer at ADDR (which LEN bytes long).
For connectionless socket types, just set the default address to send to
and the only address from which to accept transmissions.
Return 0 on success, -1 for errors.
#pragma empty_line
This function is a cancellation point and therefore not marked with
__THROW. */
extern int connect (int __fd, const struct sockaddr * __addr, socklen_t __len);
#pragma empty_line
/* Put the address of the peer connected to socket FD into *ADDR
(which is *LEN bytes long), and its actual length into *LEN. */
extern int getpeername (int __fd, struct sockaddr *__restrict __addr,
socklen_t *__restrict __len) throw ();
#pragma empty_line
#pragma empty_line
/* Send N bytes of BUF to socket FD. Returns the number sent or -1.
#pragma empty_line
This function is a cancellation point and therefore not marked with
__THROW. */
extern ssize_t send (int __fd, const void *__buf, size_t __n, int __flags);
#pragma empty_line
/* Read N bytes into BUF from socket FD.
Returns the number read or -1 for errors.
#pragma empty_line
This function is a cancellation point and therefore not marked with
__THROW. */
extern ssize_t recv (int __fd, void *__buf, size_t __n, int __flags);
#pragma empty_line
/* Send N bytes of BUF on socket FD to peer at address ADDR (which is
ADDR_LEN bytes long). Returns the number sent, or -1 for errors.
#pragma empty_line
This function is a cancellation point and therefore not marked with
__THROW. */
extern ssize_t sendto (int __fd, const void *__buf, size_t __n,
int __flags, const struct sockaddr * __addr,
socklen_t __addr_len);
#pragma empty_line
/* Read N bytes into BUF through socket FD.
If ADDR is not NULL, fill in *ADDR_LEN bytes of it with tha address of
the sender, and store the actual size of the address in *ADDR_LEN.
Returns the number of bytes read or -1 for errors.
#pragma empty_line
This function is a cancellation point and therefore not marked with
__THROW. */
extern ssize_t recvfrom (int __fd, void *__restrict __buf, size_t __n,
int __flags, struct sockaddr *__restrict __addr,
socklen_t *__restrict __addr_len);
#pragma empty_line
#pragma empty_line
/* Send a message described MESSAGE on socket FD.
Returns the number of bytes sent, or -1 for errors.
#pragma empty_line
This function is a cancellation point and therefore not marked with
__THROW. */
extern ssize_t sendmsg (int __fd, const struct msghdr *__message,
int __flags);
#pragma empty_line
#pragma empty_line
/* Send a VLEN messages as described by VMESSAGES to socket FD.
Returns the number of datagrams successfully written or -1 for errors.
#pragma empty_line
This function is a cancellation point and therefore not marked with
__THROW. */
extern int sendmmsg (int __fd, struct mmsghdr *__vmessages,
unsigned int __vlen, int __flags);
#pragma empty_line
#pragma empty_line
/* Receive a message as described by MESSAGE from socket FD.
Returns the number of bytes read or -1 for errors.
#pragma empty_line
This function is a cancellation point and therefore not marked with
__THROW. */
extern ssize_t recvmsg (int __fd, struct msghdr *__message, int __flags);
#pragma empty_line
#pragma empty_line
/* Receive up to VLEN messages as described by VMESSAGES from socket FD.
Returns the number of messages received or -1 for errors.
#pragma empty_line
This function is a cancellation point and therefore not marked with
__THROW. */
extern int recvmmsg (int __fd, struct mmsghdr *__vmessages,
unsigned int __vlen, int __flags,
struct timespec *__tmo);
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Put the current value for socket FD's option OPTNAME at protocol level LEVEL
into OPTVAL (which is *OPTLEN bytes long), and set *OPTLEN to the value's
actual length. Returns 0 on success, -1 for errors. */
extern int getsockopt (int __fd, int __level, int __optname,
void *__restrict __optval,
socklen_t *__restrict __optlen) throw ();
#pragma empty_line
/* Set socket FD's option OPTNAME at protocol level LEVEL
to *OPTVAL (which is OPTLEN bytes long).
Returns 0 on success, -1 for errors. */
extern int setsockopt (int __fd, int __level, int __optname,
const void *__optval, socklen_t __optlen) throw ();
#pragma empty_line
#pragma empty_line
/* Prepare to accept connections on socket FD.
N connection requests will be queued before further requests are refused.
Returns 0 on success, -1 for errors. */
extern int listen (int __fd, int __n) throw ();
#pragma empty_line
/* Await a connection on socket FD.
When a connection arrives, open a new socket to communicate with it,
set *ADDR (which is *ADDR_LEN bytes long) to the address of the connecting
peer and *ADDR_LEN to the address's actual length, and return the
new socket's descriptor, or -1 for errors.
#pragma empty_line
This function is a cancellation point and therefore not marked with
__THROW. */
extern int accept (int __fd, struct sockaddr *__restrict __addr,
socklen_t *__restrict __addr_len);
#pragma empty_line
#pragma empty_line
/* Similar to 'accept' but takes an additional parameter to specify flags.
#pragma empty_line
This function is a cancellation point and therefore not marked with
__THROW. */
extern int accept4 (int __fd, struct sockaddr *__restrict __addr,
socklen_t *__restrict __addr_len, int __flags);
#pragma empty_line
#pragma empty_line
/* Shut down all or part of the connection open on socket FD.
HOW determines what to shut down:
SHUT_RD = No more receptions;
SHUT_WR = No more transmissions;
SHUT_RDWR = No more receptions or transmissions.
Returns 0 on success, -1 for errors. */
extern int shutdown (int __fd, int __how) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Determine wheter socket is at a out-of-band mark. */
extern int sockatmark (int __fd) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* FDTYPE is S_IFSOCK or another S_IF* macro defined in <sys/stat.h>;
returns 1 if FD is open on an object of the indicated type, 0 if not,
or -1 for errors (setting errno). */
extern int isfdtype (int __fd, int __fdtype) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Define some macros helping to catch buffer overflows. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 24 "/usr/include/netinet/in.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern "C" {
#pragma empty_line
/* Internet address. */
typedef uint32_t in_addr_t;
struct in_addr
{
in_addr_t s_addr;
};
#pragma empty_line
/* Get system-specific definitions. */
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/in.h" 1 3 4
/* Copyright (C) 1991-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
/* Linux version. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* If the application has already included linux/in6.h from a linux-based
kernel then we will not define the IPv6 IPPROTO_* defines, in6_addr (nor the
defines), sockaddr_in6, or ipv6_mreq. Same for in6_ptkinfo or ip6_mtuinfo
in linux/ipv6.h. The ABI used by the linux-kernel and glibc match exactly.
Neither the linux kernel nor glibc should break this ABI without coordination.
In upstream kernel 56c176c9 the _UAPI prefix was stripped so we need to check
for _LINUX_IN6_H and _IPV6_H now, and keep checking the old versions for
maximum backwards compatibility. */
#pragma line 44 "/usr/include/x86_64-linux-gnu/bits/in.h" 3 4
/* Options for use with `getsockopt' and `setsockopt' at the IP level.
The first word in the comment at the right is the data type used;
"bool" means a boolean value stored in an `int'. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* For BSD compatibility. */
#pragma line 96 "/usr/include/x86_64-linux-gnu/bits/in.h" 3 4
/* TProxy original addresses */
#pragma line 106 "/usr/include/x86_64-linux-gnu/bits/in.h" 3 4
/* IP_MTU_DISCOVER arguments. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Always use interface mtu (ignores dst pmtu) but don't set DF flag.
Also incoming ICMP frag_needed notifications will be ignored on
this socket to prevent accepting spoofed ones. */
#pragma empty_line
/* Like IP_PMTUDISC_INTERFACE but allow packets to be fragmented. */
#pragma line 131 "/usr/include/x86_64-linux-gnu/bits/in.h" 3 4
/* To select the IP level. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Structure used to describe IP options for IP_OPTIONS and IP_RETOPTS.
The `ip_dst' field is used for the first-hop gateway when using a
source route (this gets put into the header proper). */
struct ip_opts
{
struct in_addr ip_dst; /* First hop; zero without source route. */
char ip_opts[40]; /* Actually variable in size. */
};
#pragma empty_line
/* Like `struct ip_mreq' but including interface specification by index. */
struct ip_mreqn
{
struct in_addr imr_multiaddr; /* IP multicast address of group */
struct in_addr imr_address; /* local IP address of interface */
int imr_ifindex; /* Interface index */
};
#pragma empty_line
/* Structure used for IP_PKTINFO. */
struct in_pktinfo
{
int ipi_ifindex; /* Interface index */
struct in_addr ipi_spec_dst; /* Routing destination address */
struct in_addr ipi_addr; /* Header destination address */
};
#pragma empty_line
#pragma empty_line
/* Options for use with `getsockopt' and `setsockopt' at the IPv6 level.
The first word in the comment at the right is the data type used;
"bool" means a boolean value stored in an `int'. */
#pragma line 198 "/usr/include/x86_64-linux-gnu/bits/in.h" 3 4
/* Advanced API (RFC3542) (1). */
#pragma line 214 "/usr/include/x86_64-linux-gnu/bits/in.h" 3 4
/* Advanced API (RFC3542) (2). */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* RFC5014. */
#pragma empty_line
#pragma empty_line
/* RFC5082. */
#pragma line 232 "/usr/include/x86_64-linux-gnu/bits/in.h" 3 4
/* Obsolete synonyms for the above. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* IPV6_MTU_DISCOVER values. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Socket level values for IPv6. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Routing header options for IPv6. */
#pragma line 38 "/usr/include/netinet/in.h" 2 3 4
#pragma empty_line
/* Standard well-defined IP protocols. */
enum
{
IPPROTO_IP = 0, /* Dummy protocol for TCP. */
#pragma empty_line
IPPROTO_ICMP = 1, /* Internet Control Message Protocol. */
#pragma empty_line
IPPROTO_IGMP = 2, /* Internet Group Management Protocol. */
#pragma empty_line
IPPROTO_IPIP = 4, /* IPIP tunnels (older KA9Q tunnels use 94). */
#pragma empty_line
IPPROTO_TCP = 6, /* Transmission Control Protocol. */
#pragma empty_line
IPPROTO_EGP = 8, /* Exterior Gateway Protocol. */
#pragma empty_line
IPPROTO_PUP = 12, /* PUP protocol. */
#pragma empty_line
IPPROTO_UDP = 17, /* User Datagram Protocol. */
#pragma empty_line
IPPROTO_IDP = 22, /* XNS IDP protocol. */
#pragma empty_line
IPPROTO_TP = 29, /* SO Transport Protocol Class 4. */
#pragma empty_line
IPPROTO_DCCP = 33, /* Datagram Congestion Control Protocol. */
#pragma empty_line
IPPROTO_IPV6 = 41, /* IPv6 header. */
#pragma empty_line
IPPROTO_RSVP = 46, /* Reservation Protocol. */
#pragma empty_line
IPPROTO_GRE = 47, /* General Routing Encapsulation. */
#pragma empty_line
IPPROTO_ESP = 50, /* encapsulating security payload. */
#pragma empty_line
IPPROTO_AH = 51, /* authentication header. */
#pragma empty_line
IPPROTO_MTP = 92, /* Multicast Transport Protocol. */
#pragma empty_line
IPPROTO_BEETPH = 94, /* IP option pseudo header for BEET. */
#pragma empty_line
IPPROTO_ENCAP = 98, /* Encapsulation Header. */
#pragma empty_line
IPPROTO_PIM = 103, /* Protocol Independent Multicast. */
#pragma empty_line
IPPROTO_COMP = 108, /* Compression Header Protocol. */
#pragma empty_line
IPPROTO_SCTP = 132, /* Stream Control Transmission Protocol. */
#pragma empty_line
IPPROTO_UDPLITE = 136, /* UDP-Lite protocol. */
#pragma empty_line
IPPROTO_MPLS = 137, /* MPLS in IP. */
#pragma empty_line
IPPROTO_RAW = 255, /* Raw IP packets. */
#pragma empty_line
IPPROTO_MAX
};
#pragma empty_line
/* If __USE_KERNEL_IPV6_DEFS is 1 then the user has included the kernel
network headers first and we should use those ABI-identical definitions
instead of our own, otherwise 0. */
#pragma empty_line
enum
{
IPPROTO_HOPOPTS = 0, /* IPv6 Hop-by-Hop options. */
#pragma empty_line
IPPROTO_ROUTING = 43, /* IPv6 routing header. */
#pragma empty_line
IPPROTO_FRAGMENT = 44, /* IPv6 fragmentation header. */
#pragma empty_line
IPPROTO_ICMPV6 = 58, /* ICMPv6. */
#pragma empty_line
IPPROTO_NONE = 59, /* IPv6 no next header. */
#pragma empty_line
IPPROTO_DSTOPTS = 60, /* IPv6 destination options. */
#pragma empty_line
IPPROTO_MH = 135 /* IPv6 mobility header. */
#pragma empty_line
};
#pragma empty_line
#pragma empty_line
/* Type to represent a port. */
typedef uint16_t in_port_t;
#pragma empty_line
/* Standard well-known ports. */
enum
{
IPPORT_ECHO = 7, /* Echo service. */
IPPORT_DISCARD = 9, /* Discard transmissions service. */
IPPORT_SYSTAT = 11, /* System status service. */
IPPORT_DAYTIME = 13, /* Time of day service. */
IPPORT_NETSTAT = 15, /* Network status service. */
IPPORT_FTP = 21, /* File Transfer Protocol. */
IPPORT_TELNET = 23, /* Telnet protocol. */
IPPORT_SMTP = 25, /* Simple Mail Transfer Protocol. */
IPPORT_TIMESERVER = 37, /* Timeserver service. */
IPPORT_NAMESERVER = 42, /* Domain Name Service. */
IPPORT_WHOIS = 43, /* Internet Whois service. */
IPPORT_MTP = 57,
#pragma empty_line
IPPORT_TFTP = 69, /* Trivial File Transfer Protocol. */
IPPORT_RJE = 77,
IPPORT_FINGER = 79, /* Finger service. */
IPPORT_TTYLINK = 87,
IPPORT_SUPDUP = 95, /* SUPDUP protocol. */
#pragma empty_line
#pragma empty_line
IPPORT_EXECSERVER = 512, /* execd service. */
IPPORT_LOGINSERVER = 513, /* rlogind service. */
IPPORT_CMDSERVER = 514,
IPPORT_EFSSERVER = 520,
#pragma empty_line
/* UDP ports. */
IPPORT_BIFFUDP = 512,
IPPORT_WHOSERVER = 513,
IPPORT_ROUTESERVER = 520,
#pragma empty_line
/* Ports less than this value are reserved for privileged processes. */
IPPORT_RESERVED = 1024,
#pragma empty_line
/* Ports greater this value are reserved for (non-privileged) servers. */
IPPORT_USERRESERVED = 5000
};
#pragma empty_line
/* Definitions of the bits in an Internet address integer.
#pragma empty_line
On subnets, host and network parts are found according to
the subnet mask, not these masks. */
#pragma line 189 "/usr/include/netinet/in.h" 3 4
/* Address to accept any incoming messages. */
#pragma empty_line
/* Address to send to all hosts. */
#pragma empty_line
/* Address indicating an error return. */
#pragma empty_line
#pragma empty_line
/* Network number for local host loopback. */
#pragma empty_line
/* Address to loopback in software to local host. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Defines for Multicast INADDR. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* IPv6 address */
struct in6_addr
{
union
{
uint8_t __u6_addr8[16];
uint16_t __u6_addr16[8];
uint32_t __u6_addr32[4];
} __in6_u;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
};
#pragma empty_line
#pragma empty_line
extern const struct in6_addr in6addr_any; /* :: */
extern const struct in6_addr in6addr_loopback; /* ::1 */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Structure describing an Internet socket address. */
struct sockaddr_in
{
sa_family_t sin_family;
in_port_t sin_port; /* Port number. */
struct in_addr sin_addr; /* Internet address. */
#pragma empty_line
/* Pad to size of `struct sockaddr'. */
unsigned char sin_zero[sizeof (struct sockaddr) -
(sizeof (unsigned short int)) -
sizeof (in_port_t) -
sizeof (struct in_addr)];
};
#pragma empty_line
#pragma empty_line
/* Ditto, for IPv6. */
struct sockaddr_in6
{
sa_family_t sin6_family;
in_port_t sin6_port; /* Transport layer port # */
uint32_t sin6_flowinfo; /* IPv6 flow information */
struct in6_addr sin6_addr; /* IPv6 address */
uint32_t sin6_scope_id; /* IPv6 scope-id */
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* IPv4 multicast request. */
struct ip_mreq
{
/* IP multicast address of group. */
struct in_addr imr_multiaddr;
#pragma empty_line
/* Local IP address of interface. */
struct in_addr imr_interface;
};
#pragma empty_line
struct ip_mreq_source
{
/* IP multicast address of group. */
struct in_addr imr_multiaddr;
#pragma empty_line
/* IP address of interface. */
struct in_addr imr_interface;
#pragma empty_line
/* IP address of source. */
struct in_addr imr_sourceaddr;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Likewise, for IPv6. */
struct ipv6_mreq
{
/* IPv6 multicast address of group */
struct in6_addr ipv6mr_multiaddr;
#pragma empty_line
/* local interface */
unsigned int ipv6mr_interface;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Multicast group request. */
struct group_req
{
/* Interface index. */
uint32_t gr_interface;
#pragma empty_line
/* Group address. */
struct sockaddr_storage gr_group;
};
#pragma empty_line
struct group_source_req
{
/* Interface index. */
uint32_t gsr_interface;
#pragma empty_line
/* Group address. */
struct sockaddr_storage gsr_group;
#pragma empty_line
/* Source address. */
struct sockaddr_storage gsr_source;
};
#pragma empty_line
#pragma empty_line
/* Full-state filter operations. */
struct ip_msfilter
{
/* IP multicast address of group. */
struct in_addr imsf_multiaddr;
#pragma empty_line
/* Local IP address of interface. */
struct in_addr imsf_interface;
#pragma empty_line
/* Filter mode. */
uint32_t imsf_fmode;
#pragma empty_line
/* Number of source addresses. */
uint32_t imsf_numsrc;
/* Source addresses. */
struct in_addr imsf_slist[1];
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
struct group_filter
{
/* Interface index. */
uint32_t gf_interface;
#pragma empty_line
/* Group address. */
struct sockaddr_storage gf_group;
#pragma empty_line
/* Filter mode. */
uint32_t gf_fmode;
#pragma empty_line
/* Number of source addresses. */
uint32_t gf_numsrc;
/* Source addresses. */
struct sockaddr_storage gf_slist[1];
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Functions to convert between host and network byte order.
#pragma empty_line
Please note that these functions normally take `unsigned long int' or
`unsigned short int' values as arguments and also return them. But
this was a short-sighted decision since on different systems the types
may have different representations but the values are always the same. */
#pragma empty_line
extern uint32_t ntohl (uint32_t __netlong) throw () __attribute__ ((__const__));
extern uint16_t ntohs (uint16_t __netshort)
throw () __attribute__ ((__const__));
extern uint32_t htonl (uint32_t __hostlong)
throw () __attribute__ ((__const__));
extern uint16_t htons (uint16_t __hostshort)
throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Get machine dependent optimized versions of byte swapping functions. */
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 1 3 4
/* Macros to swap the order of bytes in integer values.
Copyright (C) 1997-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma line 386 "/usr/include/netinet/in.h" 2 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/uintn-identity.h" 1 3 4
/* Inline functions to return unsigned integer values unchanged.
Copyright (C) 2017-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma line 387 "/usr/include/netinet/in.h" 2 3 4
#pragma line 501 "/usr/include/netinet/in.h" 3 4
/* Bind socket to a privileged IP port. */
extern int bindresvport (int __sockfd, struct sockaddr_in *__sock_in) throw ();
#pragma empty_line
/* The IPv6 version of this function. */
extern int bindresvport6 (int __sockfd, struct sockaddr_in6 *__sock_in)
throw ();
#pragma line 532 "/usr/include/netinet/in.h" 3 4
struct cmsghdr; /* Forward declaration. */
#pragma empty_line
#pragma empty_line
/* IPv6 packet information. */
struct in6_pktinfo
{
struct in6_addr ipi6_addr; /* src/dst IPv6 address */
unsigned int ipi6_ifindex; /* send/recv interface index */
};
#pragma empty_line
/* IPv6 MTU information. */
struct ip6_mtuinfo
{
struct sockaddr_in6 ip6m_addr; /* dst address including zone ID */
uint32_t ip6m_mtu; /* path MTU in host byte order */
};
#pragma empty_line
#pragma empty_line
/* Obsolete hop-by-hop and Destination Options Processing (RFC 2292). */
extern int inet6_option_space (int __nbytes)
throw () __attribute__ ((__deprecated__));
extern int inet6_option_init (void *__bp, struct cmsghdr **__cmsgp,
int __type) throw () __attribute__ ((__deprecated__));
extern int inet6_option_append (struct cmsghdr *__cmsg,
const uint8_t *__typep, int __multx,
int __plusy) throw () __attribute__ ((__deprecated__));
extern uint8_t *inet6_option_alloc (struct cmsghdr *__cmsg, int __datalen,
int __multx, int __plusy)
throw () __attribute__ ((__deprecated__));
extern int inet6_option_next (const struct cmsghdr *__cmsg,
uint8_t **__tptrp)
throw () __attribute__ ((__deprecated__));
extern int inet6_option_find (const struct cmsghdr *__cmsg,
uint8_t **__tptrp, int __type)
throw () __attribute__ ((__deprecated__));
#pragma empty_line
#pragma empty_line
/* Hop-by-Hop and Destination Options Processing (RFC 3542). */
extern int inet6_opt_init (void *__extbuf, socklen_t __extlen) throw ();
extern int inet6_opt_append (void *__extbuf, socklen_t __extlen, int __offset,
uint8_t __type, socklen_t __len, uint8_t __align,
void **__databufp) throw ();
extern int inet6_opt_finish (void *__extbuf, socklen_t __extlen, int __offset)
throw ();
extern int inet6_opt_set_val (void *__databuf, int __offset, void *__val,
socklen_t __vallen) throw ();
extern int inet6_opt_next (void *__extbuf, socklen_t __extlen, int __offset,
uint8_t *__typep, socklen_t *__lenp,
void **__databufp) throw ();
extern int inet6_opt_find (void *__extbuf, socklen_t __extlen, int __offset,
uint8_t __type, socklen_t *__lenp,
void **__databufp) throw ();
extern int inet6_opt_get_val (void *__databuf, int __offset, void *__val,
socklen_t __vallen) throw ();
#pragma empty_line
#pragma empty_line
/* Routing Header Option (RFC 3542). */
extern socklen_t inet6_rth_space (int __type, int __segments) throw ();
extern void *inet6_rth_init (void *__bp, socklen_t __bp_len, int __type,
int __segments) throw ();
extern int inet6_rth_add (void *__bp, const struct in6_addr *__addr) throw ();
extern int inet6_rth_reverse (const void *__in, void *__out) throw ();
extern int inet6_rth_segments (const void *__bp) throw ();
extern struct in6_addr *inet6_rth_getaddr (const void *__bp, int __index)
throw ();
#pragma empty_line
#pragma empty_line
/* Multicast source filter support. */
#pragma empty_line
/* Get IPv4 source filter. */
extern int getipv4sourcefilter (int __s, struct in_addr __interface_addr,
struct in_addr __group, uint32_t *__fmode,
uint32_t *__numsrc, struct in_addr *__slist)
throw ();
#pragma empty_line
/* Set IPv4 source filter. */
extern int setipv4sourcefilter (int __s, struct in_addr __interface_addr,
struct in_addr __group, uint32_t __fmode,
uint32_t __numsrc,
const struct in_addr *__slist)
throw ();
#pragma empty_line
#pragma empty_line
/* Get source filter. */
extern int getsourcefilter (int __s, uint32_t __interface_addr,
const struct sockaddr *__group,
socklen_t __grouplen, uint32_t *__fmode,
uint32_t *__numsrc,
struct sockaddr_storage *__slist) throw ();
#pragma empty_line
/* Set source filter. */
extern int setsourcefilter (int __s, uint32_t __interface_addr,
const struct sockaddr *__group,
socklen_t __grouplen, uint32_t __fmode,
uint32_t __numsrc,
const struct sockaddr_storage *__slist) throw ();
#pragma empty_line
#pragma empty_line
}
#pragma line 9 "example/udp.h" 2
#pragma line 1 "/usr/include/linux/udp.h" 1 3 4
/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */
/*
* INET An implementation of the TCP/IP protocol suite for the LINUX
* operating system. INET is implemented using the BSD Socket
* interface as the means of communication with the user level.
*
* Definitions for the UDP protocol.
*
* Version: @(#)udp.h 1.0.2 04/28/93
*
* Author: Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version
* 2 of the License, or (at your option) any later version.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
struct udphdr {
__be16 source;
__be16 dest;
__be16 len;
__sum16 check;
};
#pragma empty_line
/* UDP socket options */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* UDP encapsulation types */
#pragma line 10 "example/udp.h" 2
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/clang/bin/../lib/clang/3.1/include/stdint.h" 1 3
/*===---- stdint.h - Standard header for sized integer types --------------===*\
*
* Copyright (c) 2009 Chris Lattner
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
\*===----------------------------------------------------------------------===*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* If we're hosted, fall back to the system's stdint.h, which might have
* additional definitions.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/stdint.h" 1 3 4
/* Copyright (C) 1997-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
/*
* ISO C99: 7.18 Integer types <stdint.h>
*/
#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/libc-header-start.h" 1 3 4
/* Handle feature test macros at the start of a header.
Copyright (C) 2016-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
/* This header is internal to glibc and should not be included outside
of glibc headers. Headers including it must define
__GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION first. This header
cannot have multiple include guards because ISO C feature test
macros depend on the definition of the macro when an affected
header is included, not when the first system header is
included. */
#pragma line 35 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 3 4
/* ISO/IEC TR 24731-2:2010 defines the __STDC_WANT_LIB_EXT2__
macro. */
#pragma line 45 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 3 4
/* ISO/IEC TS 18661-1:2014 defines the __STDC_WANT_IEC_60559_BFP_EXT__
macro. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* ISO/IEC TS 18661-4:2015 defines the
__STDC_WANT_IEC_60559_FUNCS_EXT__ macro. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* ISO/IEC TS 18661-3:2015 defines the
__STDC_WANT_IEC_60559_TYPES_EXT__ macro. */
#pragma line 27 "/usr/include/stdint.h" 2 3 4
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/wchar.h" 1 3 4
/* wchar_t type related definitions.
Copyright (C) 2000-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* The fallback definitions, for when __WCHAR_MAX__ or __WCHAR_MIN__
are not defined, give the right value and type as long as both int
and wchar_t are 32-bit types. Adding L'\0' to a constant value
ensures that the type is correct; it is necessary to use (L'\0' +
0) rather than just L'\0' so that the type in C++ is the promoted
version of wchar_t rather than the distinct wchar_t type itself.
Because wchar_t in preprocessor #if expressions is treated as
intmax_t or uintmax_t, the expression (L'\0' - 1) would have the
wrong value for WCHAR_MAX in such expressions and so cannot be used
to define __WCHAR_MAX in the unsigned case. */
#pragma line 29 "/usr/include/stdint.h" 2 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
/* Determine the wordsize from the preprocessor defines. */
#pragma line 13 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 3 4
/* Both x86-64 and x32 use the 64-bit system call interface. */
#pragma line 30 "/usr/include/stdint.h" 2 3 4
#pragma empty_line
/* Exact integral types. */
#pragma empty_line
/* Signed. */
#pragma empty_line
#pragma empty_line
/* Unsigned. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Small types. */
#pragma empty_line
/* Signed. */
typedef signed char int_least8_t;
typedef short int int_least16_t;
typedef int int_least32_t;
#pragma empty_line
typedef long int int_least64_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Unsigned. */
typedef unsigned char uint_least8_t;
typedef unsigned short int uint_least16_t;
typedef unsigned int uint_least32_t;
#pragma empty_line
typedef unsigned long int uint_least64_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Fast types. */
#pragma empty_line
/* Signed. */
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 empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Unsigned. */
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 94 "/usr/include/stdint.h" 3 4
/* Types for `void *' pointers. */
#pragma empty_line
#pragma empty_line
typedef long int intptr_t;
#pragma empty_line
#pragma empty_line
typedef unsigned long int uintptr_t;
#pragma line 110 "/usr/include/stdint.h" 3 4
/* Largest integral types. */
typedef __intmax_t intmax_t;
typedef __uintmax_t uintmax_t;
#pragma line 123 "/usr/include/stdint.h" 3 4
/* Limits of integral types. */
#pragma empty_line
/* Minimum of signed integral types. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Maximum of signed integral types. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Maximum of unsigned integral types. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Minimum of signed integral types having a minimum size. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Maximum of signed integral types having a minimum size. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Maximum of unsigned integral types having a minimum size. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Minimum of fast signed integral types having a minimum size. */
#pragma line 171 "/usr/include/stdint.h" 3 4
/* Maximum of fast signed integral types having a minimum size. */
#pragma line 182 "/usr/include/stdint.h" 3 4
/* Maximum of fast unsigned integral types having a minimum size. */
#pragma line 194 "/usr/include/stdint.h" 3 4
/* Values to test for integral types holding `void *' pointer. */
#pragma line 206 "/usr/include/stdint.h" 3 4
/* Minimum for largest signed integral type. */
#pragma empty_line
/* Maximum for largest signed integral type. */
#pragma empty_line
#pragma empty_line
/* Maximum for largest unsigned integral type. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Limits of other integer types. */
#pragma empty_line
/* Limits of `ptrdiff_t' type. */
#pragma line 231 "/usr/include/stdint.h" 3 4
/* Limits of `sig_atomic_t'. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Limit of `size_t' type. */
#pragma line 246 "/usr/include/stdint.h" 3 4
/* Limits of `wchar_t'. */
#pragma empty_line
/* These constants might also be defined in <wchar.h>. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Limits of `wint_t'. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Signed. */
#pragma line 267 "/usr/include/stdint.h" 3 4
/* Unsigned. */
#pragma line 277 "/usr/include/stdint.h" 3 4
/* Maximal type. */
#pragma line 34 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/clang/bin/../lib/clang/3.1/include/stdint.h" 2 3
#pragma line 12 "example/udp.h" 2
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/hls_stream.h" 1
/* -*- c++ -*-*/
/*
#- (c) Copyright 2011-2016 Xilinx, Inc. All rights reserved.
#-
#- This file contains confidential and proprietary information
#- of Xilinx, Inc. and is protected under U.S. and
#- international copyright and other intellectual property
#- laws.
#-
#- DISCLAIMER
#- This disclaimer is not a license and does not grant any
#- rights to the materials distributed herewith. Except as
#- otherwise provided in a valid license issued to you by
#- Xilinx, and to the maximum extent permitted by applicable
#- law: (1) THESE MATERIALS ARE MADE AVAILABLE "AS IS" AND
#- WITH ALL FAULTS, AND XILINX HEREBY DISCLAIMS ALL WARRANTIES
#- AND CONDITIONS, EXPRESS, IMPLIED, OR STATUTORY, INCLUDING
#- BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, NON-
#- INFRINGEMENT, OR FITNESS FOR ANY PARTICULAR PURPOSE; and
#- (2) Xilinx shall not be liable (whether in contract or tort,
#- including negligence, or under any other theory of
#- liability) for any loss or damage of any kind or nature
#- related to, arising under or in connection with these
#- materials, including for any direct, or any indirect,
#- special, incidental, or consequential loss or damage
#- (including loss of data, profits, goodwill, or any type of
#- loss or damage suffered as a result of any action brought
#- by a third party) even if such damage or loss was
#- reasonably foreseeable or Xilinx had been advised of the
#- possibility of the same.
#-
#- CRITICAL APPLICATIONS
#- Xilinx products are not designed or intended to be fail-
#- safe, or for use in any application requiring fail-safe
#- performance, such as life-support or safety devices or
#- systems, Class III medical devices, nuclear facilities,
#- applications related to the deployment of airbags, or any
#- other applications that could lead to death, personal
#- injury, or severe property or environmental damage
#- (individually and collectively, "Critical
#- Applications"). Customer assumes the sole risk and
#- liability of any use of Xilinx products in Critical
#- Applications, subject only to applicable laws and
#- regulations governing limitations on product liability.
#-
#- THIS COPYRIGHT NOTICE AND DISCLAIMER MUST BE RETAINED AS
#- PART OF THIS FILE AT ALL TIMES.
#- ************************************************************************
#pragma empty_line
*
*
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/*
* This file contains a C++ model of hls::stream.
* It defines AutoESL synthesis model.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/etc/autopilot_enum.h" 1
/*
#- (c) Copyright 2011-2016 Xilinx, Inc. All rights reserved.
#-
#- This file contains confidential and proprietary information
#- of Xilinx, Inc. and is protected under U.S. and
#- international copyright and other intellectual property
#- laws.
#-
#- DISCLAIMER
#- This disclaimer is not a license and does not grant any
#- rights to the materials distributed herewith. Except as
#- otherwise provided in a valid license issued to you by
#- Xilinx, and to the maximum extent permitted by applicable
#- law: (1) THESE MATERIALS ARE MADE AVAILABLE "AS IS" AND
#- WITH ALL FAULTS, AND XILINX HEREBY DISCLAIMS ALL WARRANTIES
#- AND CONDITIONS, EXPRESS, IMPLIED, OR STATUTORY, INCLUDING
#- BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, NON-
#- INFRINGEMENT, OR FITNESS FOR ANY PARTICULAR PURPOSE; and
#- (2) Xilinx shall not be liable (whether in contract or tort,
#- including negligence, or under any other theory of
#- liability) for any loss or damage of any kind or nature
#- related to, arising under or in connection with these
#- materials, including for any direct, or any indirect,
#- special, incidental, or consequential loss or damage
#- (including loss of data, profits, goodwill, or any type of
#- loss or damage suffered as a result of any action brought
#- by a third party) even if such damage or loss was
#- reasonably foreseeable or Xilinx had been advised of the
#- possibility of the same.
#-
#- CRITICAL APPLICATIONS
#- Xilinx products are not designed or intended to be fail-
#- safe, or for use in any application requiring fail-safe
#- performance, such as life-support or safety devices or
#- systems, Class III medical devices, nuclear facilities,
#- applications related to the deployment of airbags, or any
#- other applications that could lead to death, personal
#- injury, or severe property or environmental damage
#- (individually and collectively, "Critical
#- Applications"). Customer assumes the sole risk and
#- liability of any use of Xilinx products in Critical
#- Applications, subject only to applicable laws and
#- regulations governing limitations on product liability.
#-
#- THIS COPYRIGHT NOTICE AND DISCLAIMER MUST BE RETAINED AS
#- PART OF THIS FILE AT ALL TIMES.
#- ************************************************************************
#pragma empty_line
*
* $Id$
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Data Types */
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
/* Ports */
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
/* Threads (Processes) */
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
/* Threads (Processes) */
enum SsdmSensitiveTypes {
_ssdm_sensitive = 0,
_ssdm_sensitive_pos,
_ssdm_sensitive_neg,
_ssdm_sensitive_reset0, /* Level = High*/
_ssdm_sensitive_reset1, /* Level = Low*/
_ssdm_sensitive_end,
};
#pragma empty_line
#pragma empty_line
/* Channels */
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
/* Regions */
enum SsdmRegionTypes {
_ssdm_region_reset,
_ssdm_region_protocol,
_ssdm_region_pipeline,
_ssdm_region_parallel,
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
// XSIP watermark, do not delete 67d7842dbbe25473c3c32b93c0da8047785f30d78e8a024de1b57352245f9689
#pragma line 67 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/hls_stream.h" 2
#pragma empty_line
#pragma empty_line
namespace hls {
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
//////////////////////////////////////////////
// Synthesis models for stream
//////////////////////////////////////////////
template<typename __STREAM_T__>
class stream
{
public:
/// Constructors
inline __attribute__((always_inline)) stream() {
}
#pragma empty_line
inline __attribute__((always_inline)) stream(const char* name) {
}
#pragma empty_line
/// Make copy constructor and assignment operator private
private:
inline __attribute__((always_inline)) stream(const stream< __STREAM_T__ >& chn):V(chn.V) {
}
#pragma empty_line
inline __attribute__((always_inline)) stream& operator= (const stream< __STREAM_T__ >& chn) {
V = chn.V;
return *this;
}
#pragma empty_line
public:
/// Overload >> and << operators to implement read() and write()
inline __attribute__((always_inline)) void operator >> (__STREAM_T__& rdata) {
read(rdata);
}
#pragma empty_line
inline __attribute__((always_inline)) void operator << (const __STREAM_T__& wdata) {
write(wdata);
}
#pragma empty_line
/// Public API
public:
/// Empty & Full
inline __attribute__((always_inline)) bool empty() const {
bool tmp = _ssdm_StreamCanRead(&V);
return !tmp;
}
#pragma empty_line
inline __attribute__((always_inline)) bool full() const {
bool tmp = _ssdm_StreamCanWrite(&V);
return !tmp;
}
#pragma empty_line
/// Blocking read
inline __attribute__((always_inline)) void read(__STREAM_T__& dout) {
__STREAM_T__ tmp;
_ssdm_StreamRead(&V, &tmp);
dout = tmp;
}
#pragma empty_line
inline __attribute__((always_inline)) __STREAM_T__ read() {
__STREAM_T__ tmp;
_ssdm_StreamRead(&V, &tmp);
return tmp;
}
#pragma empty_line
/// Nonblocking read
inline __attribute__((always_inline)) bool read_nb(__STREAM_T__& dout) {
__STREAM_T__ tmp;
bool empty_n = _ssdm_StreamNbRead(&V, &tmp);
dout = tmp;
return empty_n;
}
#pragma empty_line
/// Blocking write
inline __attribute__((always_inline)) void write(const __STREAM_T__& din) {
__STREAM_T__ tmp = din;
_ssdm_StreamWrite(&V, &tmp);
}
#pragma empty_line
/// Nonblocking write
inline __attribute__((always_inline)) bool write_nb(const __STREAM_T__& din) {
__STREAM_T__ tmp = din;
bool full_n = _ssdm_StreamNbWrite(&V, &tmp);
return full_n;
}
#pragma empty_line
/// Fifo size
inline __attribute__((always_inline)) unsigned size() {
unsigned size = _ssdm_StreamSize(&V);
return size;
}
#pragma empty_line
public:
__STREAM_T__ V;
};
#pragma empty_line
} // namespace hls
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
// XSIP watermark, do not delete 67d7842dbbe25473c3c32b93c0da8047785f30d78e8a024de1b57352245f9689
#pragma line 13 "example/udp.h" 2
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_int.h" 1
// -*- c++ -*-
/*
#- (c) Copyright 2011-2016 Xilinx, Inc. All rights reserved.
#-
#- This file contains confidential and proprietary information
#- of Xilinx, Inc. and is protected under U.S. and
#- international copyright and other intellectual property
#- laws.
#-
#- DISCLAIMER
#- This disclaimer is not a license and does not grant any
#- rights to the materials distributed herewith. Except as
#- otherwise provided in a valid license issued to you by
#- Xilinx, and to the maximum extent permitted by applicable
#- law: (1) THESE MATERIALS ARE MADE AVAILABLE "AS IS" AND
#- WITH ALL FAULTS, AND XILINX HEREBY DISCLAIMS ALL WARRANTIES
#- AND CONDITIONS, EXPRESS, IMPLIED, OR STATUTORY, INCLUDING
#- BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, NON-
#- INFRINGEMENT, OR FITNESS FOR ANY PARTICULAR PURPOSE; and
#- (2) Xilinx shall not be liable (whether in contract or tort,
#- including negligence, or under any other theory of
#- liability) for any loss or damage of any kind or nature
#- related to, arising under or in connection with these
#- materials, including for any direct, or any indirect,
#- special, incidental, or consequential loss or damage
#- (including loss of data, profits, goodwill, or any type of
#- loss or damage suffered as a result of any action brought
#- by a third party) even if such damage or loss was
#- reasonably foreseeable or Xilinx had been advised of the
#- possibility of the same.
#-
#- CRITICAL APPLICATIONS
#- Xilinx products are not designed or intended to be fail-
#- safe, or for use in any application requiring fail-safe
#- performance, such as life-support or safety devices or
#- systems, Class III medical devices, nuclear facilities,
#- applications related to the deployment of airbags, or any
#- other applications that could lead to death, personal
#- injury, or severe property or environmental damage
#- (individually and collectively, "Critical
#- Applications"). Customer assumes the sole risk and
#- liability of any use of Xilinx products in Critical
#- Applications, subject only to applicable laws and
#- regulations governing limitations on product liability.
#-
#- THIS COPYRIGHT NOTICE AND DISCLAIMER MUST BE RETAINED AS
#- PART OF THIS FILE AT ALL TIMES.
#- ************************************************************************
#pragma empty_line
*
*/
#pragma line 60 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_int.h"
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_int_syn.h" 1
/* -*- c++ -*-*/
/*
#- (c) Copyright 2011-2016 Xilinx, Inc. All rights reserved.
#-
#- This file contains confidential and proprietary information
#- of Xilinx, Inc. and is protected under U.S. and
#- international copyright and other intellectual property
#- laws.
#-
#- DISCLAIMER
#- This disclaimer is not a license and does not grant any
#- rights to the materials distributed herewith. Except as
#- otherwise provided in a valid license issued to you by
#- Xilinx, and to the maximum extent permitted by applicable
#- law: (1) THESE MATERIALS ARE MADE AVAILABLE "AS IS" AND
#- WITH ALL FAULTS, AND XILINX HEREBY DISCLAIMS ALL WARRANTIES
#- AND CONDITIONS, EXPRESS, IMPLIED, OR STATUTORY, INCLUDING
#- BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, NON-
#- INFRINGEMENT, OR FITNESS FOR ANY PARTICULAR PURPOSE; and
#- (2) Xilinx shall not be liable (whether in contract or tort,
#- including negligence, or under any other theory of
#- liability) for any loss or damage of any kind or nature
#- related to, arising under or in connection with these
#- materials, including for any direct, or any indirect,
#- special, incidental, or consequential loss or damage
#- (including loss of data, profits, goodwill, or any type of
#- loss or damage suffered as a result of any action brought
#- by a third party) even if such damage or loss was
#- reasonably foreseeable or Xilinx had been advised of the
#- possibility of the same.
#-
#- CRITICAL APPLICATIONS
#- Xilinx products are not designed or intended to be fail-
#- safe, or for use in any application requiring fail-safe
#- performance, such as life-support or safety devices or
#- systems, Class III medical devices, nuclear facilities,
#- applications related to the deployment of airbags, or any
#- other applications that could lead to death, personal
#- injury, or severe property or environmental damage
#- (individually and collectively, "Critical
#- Applications"). Customer assumes the sole risk and
#- liability of any use of Xilinx products in Critical
#- Applications, subject only to applicable laws and
#- regulations governing limitations on product liability.
#-
#- THIS COPYRIGHT NOTICE AND DISCLAIMER MUST BE RETAINED AS
#- PART OF THIS FILE AT ALL TIMES.
#- ************************************************************************
#pragma empty_line
*
*/
#pragma line 68 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_int_syn.h"
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/iostream" 1 3
// Standard iostream objects -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2001, 2002, 2005, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file include/iostream
* This is a Standard C++ Library header.
*/
#pragma empty_line
//
// ISO C++ 14882: 27.3 Standard iostream objects
//
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 37 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/iostream" 3
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/c++config.h" 1 3
// Predefined symbols and macros -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file bits/c++config.h
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{iosfwd}
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
// The current version of the C++ library in compressed ISO date format.
#pragma empty_line
#pragma empty_line
// Macros for various attributes.
// _GLIBCXX_PURE
// _GLIBCXX_CONST
// _GLIBCXX_NORETURN
// _GLIBCXX_NOTHROW
// _GLIBCXX_VISIBILITY
#pragma line 63 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/c++config.h" 3
// Macros for visibility attributes.
// _GLIBCXX_HAVE_ATTRIBUTE_VISIBILITY
// _GLIBCXX_VISIBILITY
#pragma line 76 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/c++config.h" 3
// Macros for deprecated attributes.
// _GLIBCXX_USE_DEPRECATED
// _GLIBCXX_DEPRECATED
#pragma line 91 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/c++config.h" 3
// Macro for constexpr, to support in mixed 03/0x mode.
#pragma line 102 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/c++config.h" 3
// Macro for extern template, ie controling template linkage via use
// of extern keyword on template declaration. As documented in the g++
// manual, it inhibits all implicit instantiations and is used
// throughout the library to avoid multiple weak definitions for
// required types that are already explicitly instantiated in the
// library binary. This substantially reduces the binary size of
// resulting executables.
// Special case: _GLIBCXX_EXTERN_TEMPLATE == -1 disallows extern
// templates only in basic_string, thus activating its debug-mode
// checks even at -O0.
#pragma empty_line
#pragma empty_line
/*
Outline of libstdc++ namespaces.
#pragma empty_line
namespace std
{
namespace __debug { }
namespace __parallel { }
namespace __profile { }
namespace __cxx1998 { }
#pragma empty_line
namespace __detail { }
#pragma empty_line
namespace rel_ops { }
#pragma empty_line
namespace tr1
{
namespace placeholders { }
namespace regex_constants { }
namespace __detail { }
}
#pragma empty_line
namespace decimal { }
#pragma empty_line
namespace chrono { }
namespace placeholders { }
namespace regex_constants { }
namespace this_thread { }
}
#pragma empty_line
namespace abi { }
#pragma empty_line
namespace __gnu_cxx
{
namespace __detail { }
}
#pragma empty_line
For full details see:
http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/namespaces.html
*/
namespace std
{
typedef long unsigned int size_t;
typedef long int ptrdiff_t;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma empty_line
#pragma empty_line
// Defined if inline namespaces are used for versioning.
#pragma empty_line
#pragma empty_line
// Inline namespace for symbol versioning.
#pragma line 208 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/c++config.h" 3
// Inline namespaces for special modes: debug, parallel, profile.
#pragma line 255 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/c++config.h" 3
// Macros for namespace scope. Either namespace std:: or the name
// of some nested namespace within it corresponding to the active mode.
// _GLIBCXX_STD_A
// _GLIBCXX_STD_C
//
// Macros for opening/closing conditional namespaces.
// _GLIBCXX_BEGIN_NAMESPACE_ALGO
// _GLIBCXX_END_NAMESPACE_ALGO
// _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
// _GLIBCXX_END_NAMESPACE_CONTAINER
#pragma line 307 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/c++config.h" 3
// GLIBCXX_ABI Deprecated
// Define if compatibility should be provided for -mlong-double-64.
#pragma empty_line
#pragma empty_line
// Inline namespace for long double 128 mode.
#pragma line 326 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/c++config.h" 3
// Assert.
#pragma line 352 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/c++config.h" 3
// Macros for race detectors.
// _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(A) and
// _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(A) should be used to explain
// atomic (lock-free) synchronization to race detectors:
// the race detector will infer a happens-before arc from the former to the
// latter when they share the same argument pointer.
//
// The most frequent use case for these macros (and the only case in the
// current implementation of the library) is atomic reference counting:
// void _M_remove_reference()
// {
// _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&this->_M_refcount);
// if (__gnu_cxx::__exchange_and_add_dispatch(&this->_M_refcount, -1) <= 0)
// {
// _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&this->_M_refcount);
// _M_destroy(__a);
// }
// }
// The annotations in this example tell the race detector that all memory
// accesses occurred when the refcount was positive do not race with
// memory accesses which occurred after the refcount became zero.
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
// Macros for C linkage: define extern "C" linkage only when using C++.
#pragma line 390 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/c++config.h" 3
// First includes.
#pragma empty_line
// Pick up any OS-specific definitions.
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/os_defines.h" 1 3
// Specific definitions for GNU/Linux -*- C++ -*-
#pragma empty_line
// Copyright (C) 2000, 2001, 2002, 2003, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file bits/os_defines.h
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{iosfwd}
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
// System-specific #define, typedefs, corrections, etc, go here. This
// file will come before all others.
#pragma empty_line
// This keeps isanum, et al from being propagated as macros.
#pragma line 394 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/c++config.h" 2 3
#pragma empty_line
// Pick up any CPU-specific definitions.
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/cpu_defines.h" 1 3
// Specific definitions for generic platforms -*- C++ -*-
#pragma empty_line
// Copyright (C) 2005, 2009, 2010 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file bits/cpu_defines.h
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{iosfwd}
*/
#pragma line 397 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/c++config.h" 2 3
#pragma empty_line
// If platform uses neither visibility nor psuedo-visibility,
// specify empty default for namespace annotation macros.
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
// Certain function definitions that are meant to be overridable from
// user code are decorated with this macro. For some targets, this
// macro causes these definitions to be weak.
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
// The remainder of the prewritten config is automatic; all the
// user hooks are listed above.
#pragma empty_line
// Create a boolean flag to be used to determine if --fast-math is set.
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
// This marks string literals in header files to be extracted for eventual
// translation. It is primarily used for messages in thrown exceptions; see
// src/functexcept.cc. We use __N because the more traditional _N is used
// for something else under certain OSes (see BADNAMES).
#pragma empty_line
#pragma empty_line
// For example, <windows.h> is known to #define min and max as macros...
#pragma empty_line
#pragma empty_line
#pragma empty_line
// End of prewritten config; the settings discovered at configure time follow.
/* config.h. Generated from config.h.in by configure. */
/* config.h.in. Generated from configure.ac by autoheader. */
#pragma empty_line
/* Define to 1 if you have the `acosf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `acosl' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `asinf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `asinl' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if the target assembler supports .symver directive. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `atan2f' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `atan2l' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `atanf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `atanl' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if the target assembler supports thread-local storage. */
/* #undef _GLIBCXX_HAVE_CC_TLS */
#pragma empty_line
/* Define to 1 if you have the `ceilf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `ceill' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <complex.h> header file. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `cosf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `coshf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `coshl' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `cosl' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <dlfcn.h> header file. */
#pragma empty_line
#pragma empty_line
/* Define if EBADMSG exists. */
#pragma empty_line
#pragma empty_line
/* Define if ECANCELED exists. */
#pragma empty_line
#pragma empty_line
/* Define if EIDRM exists. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <endian.h> header file. */
#pragma empty_line
#pragma empty_line
/* Define if ENODATA exists. */
#pragma empty_line
#pragma empty_line
/* Define if ENOLINK exists. */
#pragma empty_line
#pragma empty_line
/* Define if ENOSR exists. */
#pragma empty_line
#pragma empty_line
/* Define if ENOSTR exists. */
#pragma empty_line
#pragma empty_line
/* Define if ENOTRECOVERABLE exists. */
#pragma empty_line
#pragma empty_line
/* Define if ENOTSUP exists. */
#pragma empty_line
#pragma empty_line
/* Define if EOVERFLOW exists. */
#pragma empty_line
#pragma empty_line
/* Define if EOWNERDEAD exists. */
#pragma empty_line
#pragma empty_line
/* Define if EPROTO exists. */
#pragma empty_line
#pragma empty_line
/* Define if ETIME exists. */
#pragma empty_line
#pragma empty_line
/* Define if ETXTBSY exists. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <execinfo.h> header file. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `expf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `expl' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `fabsf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `fabsl' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <fenv.h> header file. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `finite' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `finitef' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `finitel' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <float.h> header file. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `floorf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `floorl' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `fmodf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `fmodl' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `fpclass' function. */
/* #undef _GLIBCXX_HAVE_FPCLASS */
#pragma empty_line
/* Define to 1 if you have the <fp.h> header file. */
/* #undef _GLIBCXX_HAVE_FP_H */
#pragma empty_line
/* Define to 1 if you have the `frexpf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `frexpl' function. */
#pragma empty_line
#pragma empty_line
/* Define if _Unwind_GetIPInfo is available. */
#pragma empty_line
#pragma empty_line
/* Define if gthr-default.h exists (meaning that threading support is
enabled). */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `hypot' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `hypotf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `hypotl' function. */
#pragma empty_line
#pragma empty_line
/* Define if you have the iconv() function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <ieeefp.h> header file. */
/* #undef _GLIBCXX_HAVE_IEEEFP_H */
#pragma empty_line
/* Define if int64_t is available in <stdint.h>. */
#pragma empty_line
#pragma empty_line
/* Define if int64_t is a long. */
#pragma empty_line
#pragma empty_line
/* Define if int64_t is a long long. */
/* #undef _GLIBCXX_HAVE_INT64_T_LONG_LONG */
#pragma empty_line
/* Define to 1 if you have the <inttypes.h> header file. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `isinf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `isinff' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `isinfl' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `isnan' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `isnanf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `isnanl' function. */
#pragma empty_line
#pragma empty_line
/* Defined if iswblank exists. */
#pragma empty_line
#pragma empty_line
/* Define if LC_MESSAGES is available in <locale.h>. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `ldexpf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `ldexpl' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <libintl.h> header file. */
#pragma empty_line
#pragma empty_line
/* Only used in build directory testsuite_hooks.h. */
#pragma empty_line
#pragma empty_line
/* Only used in build directory testsuite_hooks.h. */
#pragma empty_line
#pragma empty_line
/* Only used in build directory testsuite_hooks.h. */
#pragma empty_line
#pragma empty_line
/* Only used in build directory testsuite_hooks.h. */
#pragma empty_line
#pragma empty_line
/* Only used in build directory testsuite_hooks.h. */
#pragma empty_line
#pragma empty_line
/* Define if futex syscall is available. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <locale.h> header file. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `log10f' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `log10l' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `logf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `logl' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <machine/endian.h> header file. */
/* #undef _GLIBCXX_HAVE_MACHINE_ENDIAN_H */
#pragma empty_line
/* Define to 1 if you have the <machine/param.h> header file. */
/* #undef _GLIBCXX_HAVE_MACHINE_PARAM_H */
#pragma empty_line
/* Define if mbstate_t exists in wchar.h. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <memory.h> header file. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `modf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `modff' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `modfl' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <nan.h> header file. */
/* #undef _GLIBCXX_HAVE_NAN_H */
#pragma empty_line
/* Define if poll is available in <poll.h>. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `powf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `powl' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `qfpclass' function. */
/* #undef _GLIBCXX_HAVE_QFPCLASS */
#pragma empty_line
/* Define to 1 if you have the `setenv' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `sincos' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `sincosf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `sincosl' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `sinf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `sinhf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `sinhl' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `sinl' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `sqrtf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `sqrtl' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <stdbool.h> header file. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <stdint.h> header file. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <stdlib.h> header file. */
#pragma empty_line
#pragma empty_line
/* Define if strerror_l is available in <string.h>. */
/* #undef _GLIBCXX_HAVE_STRERROR_L */
#pragma empty_line
/* Define if strerror_r is available in <string.h>. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <strings.h> header file. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <string.h> header file. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `strtof' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `strtold' function. */
#pragma empty_line
#pragma empty_line
/* Define if strxfrm_l is available in <string.h>. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if the target runtime linker supports binding the same symbol
to different versions. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <sys/filio.h> header file. */
/* #undef _GLIBCXX_HAVE_SYS_FILIO_H */
#pragma empty_line
/* Define to 1 if you have the <sys/ioctl.h> header file. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <sys/ipc.h> header file. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <sys/isa_defs.h> header file. */
/* #undef _GLIBCXX_HAVE_SYS_ISA_DEFS_H */
#pragma empty_line
/* Define to 1 if you have the <sys/machine.h> header file. */
/* #undef _GLIBCXX_HAVE_SYS_MACHINE_H */
#pragma empty_line
/* Define to 1 if you have the <sys/param.h> header file. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <sys/resource.h> header file. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <sys/sem.h> header file. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <sys/stat.h> header file. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <sys/time.h> header file. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <sys/types.h> header file. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <sys/uio.h> header file. */
#pragma empty_line
#pragma empty_line
/* Define if S_IFREG is available in <sys/stat.h>. */
/* #undef _GLIBCXX_HAVE_S_IFREG */
#pragma empty_line
/* Define if S_IFREG is available in <sys/stat.h>. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `tanf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `tanhf' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `tanhl' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `tanl' function. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <tgmath.h> header file. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if the target supports thread-local storage. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <unistd.h> header file. */
#pragma empty_line
#pragma empty_line
/* Defined if vfwscanf exists. */
#pragma empty_line
#pragma empty_line
/* Defined if vswscanf exists. */
#pragma empty_line
#pragma empty_line
/* Defined if vwscanf exists. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <wchar.h> header file. */
#pragma empty_line
#pragma empty_line
/* Defined if wcstof exists. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the <wctype.h> header file. */
#pragma empty_line
#pragma empty_line
/* Define if writev is available in <sys/uio.h>. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if you have the `_acosf' function. */
/* #undef _GLIBCXX_HAVE__ACOSF */
#pragma empty_line
/* Define to 1 if you have the `_acosl' function. */
/* #undef _GLIBCXX_HAVE__ACOSL */
#pragma empty_line
/* Define to 1 if you have the `_asinf' function. */
/* #undef _GLIBCXX_HAVE__ASINF */
#pragma empty_line
/* Define to 1 if you have the `_asinl' function. */
/* #undef _GLIBCXX_HAVE__ASINL */
#pragma empty_line
/* Define to 1 if you have the `_atan2f' function. */
/* #undef _GLIBCXX_HAVE__ATAN2F */
#pragma empty_line
/* Define to 1 if you have the `_atan2l' function. */
/* #undef _GLIBCXX_HAVE__ATAN2L */
#pragma empty_line
/* Define to 1 if you have the `_atanf' function. */
/* #undef _GLIBCXX_HAVE__ATANF */
#pragma empty_line
/* Define to 1 if you have the `_atanl' function. */
/* #undef _GLIBCXX_HAVE__ATANL */
#pragma empty_line
/* Define to 1 if you have the `_ceilf' function. */
/* #undef _GLIBCXX_HAVE__CEILF */
#pragma empty_line
/* Define to 1 if you have the `_ceill' function. */
/* #undef _GLIBCXX_HAVE__CEILL */
#pragma empty_line
/* Define to 1 if you have the `_cosf' function. */
/* #undef _GLIBCXX_HAVE__COSF */
#pragma empty_line
/* Define to 1 if you have the `_coshf' function. */
/* #undef _GLIBCXX_HAVE__COSHF */
#pragma empty_line
/* Define to 1 if you have the `_coshl' function. */
/* #undef _GLIBCXX_HAVE__COSHL */
#pragma empty_line
/* Define to 1 if you have the `_cosl' function. */
/* #undef _GLIBCXX_HAVE__COSL */
#pragma empty_line
/* Define to 1 if you have the `_expf' function. */
/* #undef _GLIBCXX_HAVE__EXPF */
#pragma empty_line
/* Define to 1 if you have the `_expl' function. */
/* #undef _GLIBCXX_HAVE__EXPL */
#pragma empty_line
/* Define to 1 if you have the `_fabsf' function. */
/* #undef _GLIBCXX_HAVE__FABSF */
#pragma empty_line
/* Define to 1 if you have the `_fabsl' function. */
/* #undef _GLIBCXX_HAVE__FABSL */
#pragma empty_line
/* Define to 1 if you have the `_finite' function. */
/* #undef _GLIBCXX_HAVE__FINITE */
#pragma empty_line
/* Define to 1 if you have the `_finitef' function. */
/* #undef _GLIBCXX_HAVE__FINITEF */
#pragma empty_line
/* Define to 1 if you have the `_finitel' function. */
/* #undef _GLIBCXX_HAVE__FINITEL */
#pragma empty_line
/* Define to 1 if you have the `_floorf' function. */
/* #undef _GLIBCXX_HAVE__FLOORF */
#pragma empty_line
/* Define to 1 if you have the `_floorl' function. */
/* #undef _GLIBCXX_HAVE__FLOORL */
#pragma empty_line
/* Define to 1 if you have the `_fmodf' function. */
/* #undef _GLIBCXX_HAVE__FMODF */
#pragma empty_line
/* Define to 1 if you have the `_fmodl' function. */
/* #undef _GLIBCXX_HAVE__FMODL */
#pragma empty_line
/* Define to 1 if you have the `_fpclass' function. */
/* #undef _GLIBCXX_HAVE__FPCLASS */
#pragma empty_line
/* Define to 1 if you have the `_frexpf' function. */
/* #undef _GLIBCXX_HAVE__FREXPF */
#pragma empty_line
/* Define to 1 if you have the `_frexpl' function. */
/* #undef _GLIBCXX_HAVE__FREXPL */
#pragma empty_line
/* Define to 1 if you have the `_hypot' function. */
/* #undef _GLIBCXX_HAVE__HYPOT */
#pragma empty_line
/* Define to 1 if you have the `_hypotf' function. */
/* #undef _GLIBCXX_HAVE__HYPOTF */
#pragma empty_line
/* Define to 1 if you have the `_hypotl' function. */
/* #undef _GLIBCXX_HAVE__HYPOTL */
#pragma empty_line
/* Define to 1 if you have the `_isinf' function. */
/* #undef _GLIBCXX_HAVE__ISINF */
#pragma empty_line
/* Define to 1 if you have the `_isinff' function. */
/* #undef _GLIBCXX_HAVE__ISINFF */
#pragma empty_line
/* Define to 1 if you have the `_isinfl' function. */
/* #undef _GLIBCXX_HAVE__ISINFL */
#pragma empty_line
/* Define to 1 if you have the `_isnan' function. */
/* #undef _GLIBCXX_HAVE__ISNAN */
#pragma empty_line
/* Define to 1 if you have the `_isnanf' function. */
/* #undef _GLIBCXX_HAVE__ISNANF */
#pragma empty_line
/* Define to 1 if you have the `_isnanl' function. */
/* #undef _GLIBCXX_HAVE__ISNANL */
#pragma empty_line
/* Define to 1 if you have the `_ldexpf' function. */
/* #undef _GLIBCXX_HAVE__LDEXPF */
#pragma empty_line
/* Define to 1 if you have the `_ldexpl' function. */
/* #undef _GLIBCXX_HAVE__LDEXPL */
#pragma empty_line
/* Define to 1 if you have the `_log10f' function. */
/* #undef _GLIBCXX_HAVE__LOG10F */
#pragma empty_line
/* Define to 1 if you have the `_log10l' function. */
/* #undef _GLIBCXX_HAVE__LOG10L */
#pragma empty_line
/* Define to 1 if you have the `_logf' function. */
/* #undef _GLIBCXX_HAVE__LOGF */
#pragma empty_line
/* Define to 1 if you have the `_logl' function. */
/* #undef _GLIBCXX_HAVE__LOGL */
#pragma empty_line
/* Define to 1 if you have the `_modf' function. */
/* #undef _GLIBCXX_HAVE__MODF */
#pragma empty_line
/* Define to 1 if you have the `_modff' function. */
/* #undef _GLIBCXX_HAVE__MODFF */
#pragma empty_line
/* Define to 1 if you have the `_modfl' function. */
/* #undef _GLIBCXX_HAVE__MODFL */
#pragma empty_line
/* Define to 1 if you have the `_powf' function. */
/* #undef _GLIBCXX_HAVE__POWF */
#pragma empty_line
/* Define to 1 if you have the `_powl' function. */
/* #undef _GLIBCXX_HAVE__POWL */
#pragma empty_line
/* Define to 1 if you have the `_qfpclass' function. */
/* #undef _GLIBCXX_HAVE__QFPCLASS */
#pragma empty_line
/* Define to 1 if you have the `_sincos' function. */
/* #undef _GLIBCXX_HAVE__SINCOS */
#pragma empty_line
/* Define to 1 if you have the `_sincosf' function. */
/* #undef _GLIBCXX_HAVE__SINCOSF */
#pragma empty_line
/* Define to 1 if you have the `_sincosl' function. */
/* #undef _GLIBCXX_HAVE__SINCOSL */
#pragma empty_line
/* Define to 1 if you have the `_sinf' function. */
/* #undef _GLIBCXX_HAVE__SINF */
#pragma empty_line
/* Define to 1 if you have the `_sinhf' function. */
/* #undef _GLIBCXX_HAVE__SINHF */
#pragma empty_line
/* Define to 1 if you have the `_sinhl' function. */
/* #undef _GLIBCXX_HAVE__SINHL */
#pragma empty_line
/* Define to 1 if you have the `_sinl' function. */
/* #undef _GLIBCXX_HAVE__SINL */
#pragma empty_line
/* Define to 1 if you have the `_sqrtf' function. */
/* #undef _GLIBCXX_HAVE__SQRTF */
#pragma empty_line
/* Define to 1 if you have the `_sqrtl' function. */
/* #undef _GLIBCXX_HAVE__SQRTL */
#pragma empty_line
/* Define to 1 if you have the `_tanf' function. */
/* #undef _GLIBCXX_HAVE__TANF */
#pragma empty_line
/* Define to 1 if you have the `_tanhf' function. */
/* #undef _GLIBCXX_HAVE__TANHF */
#pragma empty_line
/* Define to 1 if you have the `_tanhl' function. */
/* #undef _GLIBCXX_HAVE__TANHL */
#pragma empty_line
/* Define to 1 if you have the `_tanl' function. */
/* #undef _GLIBCXX_HAVE__TANL */
#pragma empty_line
/* Define as const if the declaration of iconv() needs const. */
#pragma empty_line
#pragma empty_line
/* Define to the sub-directory in which libtool stores uninstalled libraries.
*/
#pragma empty_line
#pragma empty_line
/* Name of package */
/* #undef _GLIBCXX_PACKAGE */
#pragma empty_line
/* Define to the address where bug reports for this package should be sent. */
#pragma empty_line
#pragma empty_line
/* Define to the full name of this package. */
#pragma empty_line
#pragma empty_line
/* Define to the full name and version of this package. */
#pragma empty_line
#pragma empty_line
/* Define to the one symbol short name of this package. */
#pragma empty_line
#pragma empty_line
/* Define to the home page for this package. */
#pragma empty_line
#pragma empty_line
/* Define to the version of this package. */
#pragma empty_line
#pragma empty_line
/* The size of `char', as computed by sizeof. */
/* #undef SIZEOF_CHAR */
#pragma empty_line
/* The size of `int', as computed by sizeof. */
/* #undef SIZEOF_INT */
#pragma empty_line
/* The size of `long', as computed by sizeof. */
/* #undef SIZEOF_LONG */
#pragma empty_line
/* The size of `short', as computed by sizeof. */
/* #undef SIZEOF_SHORT */
#pragma empty_line
/* The size of `void *', as computed by sizeof. */
/* #undef SIZEOF_VOID_P */
#pragma empty_line
/* Define to 1 if you have the ANSI C header files. */
#pragma empty_line
#pragma empty_line
/* Version number of package */
/* #undef _GLIBCXX_VERSION */
#pragma empty_line
/* Define if builtin atomic operations for bool are supported on this host. */
#pragma empty_line
#pragma empty_line
/* Define if builtin atomic operations for short are supported on this host.
*/
#pragma empty_line
#pragma empty_line
/* Define if builtin atomic operations for int are supported on this host. */
#pragma empty_line
#pragma empty_line
/* Define if builtin atomic operations for long long are supported on this
host. */
#pragma empty_line
#pragma empty_line
/* Define to use concept checking code from the boost libraries. */
/* #undef _GLIBCXX_CONCEPT_CHECKS */
#pragma empty_line
/* Define if a fully dynamic basic_string is wanted. */
/* #undef _GLIBCXX_FULLY_DYNAMIC_STRING */
#pragma empty_line
/* Define if gthreads library is available. */
#pragma empty_line
#pragma empty_line
/* Define to 1 if a full hosted library is built, or 0 if freestanding. */
#pragma empty_line
#pragma empty_line
/* Define if compatibility should be provided for -mlong-double-64. */
#pragma empty_line
/* Define if ptrdiff_t is int. */
/* #undef _GLIBCXX_PTRDIFF_T_IS_INT */
#pragma empty_line
/* Define if using setrlimit to set resource limits during "make check" */
#pragma empty_line
#pragma empty_line
/* Define if size_t is unsigned int. */
/* #undef _GLIBCXX_SIZE_T_IS_UINT */
#pragma empty_line
/* Define if the compiler is configured for setjmp/longjmp exceptions. */
/* #undef _GLIBCXX_SJLJ_EXCEPTIONS */
#pragma empty_line
/* Define to the value of the EOF integer constant. */
#pragma empty_line
#pragma empty_line
/* Define to the value of the SEEK_CUR integer constant. */
#pragma empty_line
#pragma empty_line
/* Define to the value of the SEEK_END integer constant. */
#pragma empty_line
#pragma empty_line
/* Define to use symbol versioning in the shared library. */
#pragma empty_line
#pragma empty_line
/* Define to use darwin versioning in the shared library. */
/* #undef _GLIBCXX_SYMVER_DARWIN */
#pragma empty_line
/* Define to use GNU versioning in the shared library. */
#pragma empty_line
#pragma empty_line
/* Define to use GNU namespace versioning in the shared library. */
/* #undef _GLIBCXX_SYMVER_GNU_NAMESPACE */
#pragma empty_line
/* Define to use Sun versioning in the shared library. */
/* #undef _GLIBCXX_SYMVER_SUN */
#pragma empty_line
/* Define if C99 functions or macros from <wchar.h>, <math.h>, <complex.h>,
<stdio.h>, and <stdlib.h> can be used or exposed. */
#pragma empty_line
#pragma empty_line
/* Define if C99 functions in <complex.h> should be used in <complex>. Using
compiler builtins for these functions requires corresponding C99 library
functions to be present. */
#pragma empty_line
#pragma empty_line
/* Define if C99 functions in <complex.h> should be used in <tr1/complex>.
Using compiler builtins for these functions requires corresponding C99
library functions to be present. */
#pragma empty_line
#pragma empty_line
/* Define if C99 functions in <ctype.h> should be imported in <tr1/cctype> in
namespace std::tr1. */
#pragma empty_line
#pragma empty_line
/* Define if C99 functions in <fenv.h> should be imported in <tr1/cfenv> in
namespace std::tr1. */
#pragma empty_line
#pragma empty_line
/* Define if C99 functions in <inttypes.h> should be imported in
<tr1/cinttypes> in namespace std::tr1. */
#pragma empty_line
#pragma empty_line
/* Define if wchar_t C99 functions in <inttypes.h> should be imported in
<tr1/cinttypes> in namespace std::tr1. */
#pragma empty_line
#pragma empty_line
/* Define if C99 functions or macros in <math.h> should be imported in <cmath>
in namespace std. */
#pragma empty_line
#pragma empty_line
/* Define if C99 functions or macros in <math.h> should be imported in
<tr1/cmath> in namespace std::tr1. */
#pragma empty_line
#pragma empty_line
/* Define if C99 types in <stdint.h> should be imported in <tr1/cstdint> in
namespace std::tr1. */
#pragma empty_line
#pragma empty_line
/* Defined if clock_gettime has monotonic clock support. */
/* #undef _GLIBCXX_USE_CLOCK_MONOTONIC */
#pragma empty_line
/* Defined if clock_gettime has realtime clock support. */
/* #undef _GLIBCXX_USE_CLOCK_REALTIME */
#pragma empty_line
/* Define if ISO/IEC TR 24733 decimal floating point types are supported on
this host. */
#pragma empty_line
#pragma empty_line
/* Defined if gettimeofday is available. */
#pragma empty_line
#pragma empty_line
/* Define if LFS support is available. */
#pragma empty_line
#pragma empty_line
/* Define if code specialized for long long should be used. */
#pragma empty_line
#pragma empty_line
/* Defined if nanosleep is available. */
/* #undef _GLIBCXX_USE_NANOSLEEP */
#pragma empty_line
/* Define if NLS translations are to be used. */
#pragma empty_line
#pragma empty_line
/* Define if /dev/random and /dev/urandom are available for the random_device
of TR1 (Chapter 5.1). */
#pragma empty_line
#pragma empty_line
/* Defined if sched_yield is available. */
/* #undef _GLIBCXX_USE_SCHED_YIELD */
#pragma empty_line
/* Define if code specialized for wchar_t should be used. */
#pragma line 39 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/iostream" 2 3
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ostream" 1 3
// Output streams -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010, 2011
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file include/ostream
* This is a Standard C++ Library header.
*/
#pragma empty_line
//
// ISO C++ 14882: 27.6.2 Output streams
//
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 38 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ostream" 3
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ios" 1 3
// Iostreams base classes -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
// 2005, 2006, 2007, 2009, 2010 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file include/ios
* This is a Standard C++ Library header.
*/
#pragma empty_line
//
// ISO C++ 14882: 27.4 Iostreams base classes
//
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 37 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ios" 3
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/iosfwd" 1 3
// Forwarding declarations -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file include/iosfwd
* This is a Standard C++ Library header.
*/
#pragma empty_line
//
// ISO C++ 14882: 27.2 Forward declarations
//
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 38 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/iosfwd" 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stringfwd.h" 1 3
// String support -*- C++ -*-
#pragma empty_line
// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
// 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file bits/stringfwd.h
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{string}
*/
#pragma empty_line
//
// ISO C++ 14882: 21 Strings library
//
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 39 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stringfwd.h" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
template<typename _Alloc>
class allocator;
#pragma empty_line
/**
* @defgroup strings Strings
*
* @{
*/
#pragma empty_line
template<class _CharT>
struct char_traits;
#pragma empty_line
template<typename _CharT, typename _Traits = char_traits<_CharT>,
typename _Alloc = allocator<_CharT> >
class basic_string;
#pragma empty_line
template<> struct char_traits<char>;
#pragma empty_line
typedef basic_string<char> string; /// A string of @c char
#pragma empty_line
#pragma empty_line
template<> struct char_traits<wchar_t>;
#pragma empty_line
typedef basic_string<wchar_t> wstring; /// A string of @c wchar_t
#pragma line 82 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stringfwd.h" 3
/** @} */
#pragma empty_line
#pragma empty_line
} // namespace
#pragma line 41 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/iosfwd" 2 3
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/postypes.h" 1 3
// Position types -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file bits/postypes.h
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{iosfwd}
*/
#pragma empty_line
//
// ISO C++ 14882: 27.4.1 - Types
// ISO C++ 14882: 27.4.3 - Template class fpos
//
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 40 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/postypes.h" 3
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cwchar" 1 3
// -*- C++ -*- forwarding header.
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file include/cwchar
* This is a Standard C++ Library file. You should @c \#include this file
* in your programs, rather than any of the @a *.h implementation files.
*
* This is the C++ version of the Standard C Library header @c wchar.h,
* and its contents are (mostly) the same as that header, but are all
* contained in the namespace @c std (except for names which are defined
* as macros in C).
*/
#pragma empty_line
//
// ISO C++ 14882: 21.4
//
#pragma empty_line
#pragma empty_line
#pragma line 41 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cwchar" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/wchar.h" 1 3 4
/* Copyright (C) 1995-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
/*
* ISO C99 Standard: 7.24
* Extended multibyte and wide character utilities <wchar.h>
*/
#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/libc-header-start.h" 1 3 4
/* Handle feature test macros at the start of a header.
Copyright (C) 2016-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
/* This header is internal to glibc and should not be included outside
of glibc headers. Headers including it must define
__GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION first. This header
cannot have multiple include guards because ISO C feature test
macros depend on the definition of the macro when an affected
header is included, not when the first system header is
included. */
#pragma line 35 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 3 4
/* ISO/IEC TR 24731-2:2010 defines the __STDC_WANT_LIB_EXT2__
macro. */
#pragma line 45 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 3 4
/* ISO/IEC TS 18661-1:2014 defines the __STDC_WANT_IEC_60559_BFP_EXT__
macro. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* ISO/IEC TS 18661-4:2015 defines the
__STDC_WANT_IEC_60559_FUNCS_EXT__ macro. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* ISO/IEC TS 18661-3:2015 defines the
__STDC_WANT_IEC_60559_TYPES_EXT__ macro. */
#pragma line 28 "/usr/include/wchar.h" 2 3 4
#pragma empty_line
/* Gather machine dependent type support. */
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 1 3 4
/* Macros to control TS 18661-3 glibc features on x86.
Copyright (C) 2017-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Defined to 1 if the current compiler invocation provides a
floating-point type with the IEEE 754 binary128 format, and this
glibc includes corresponding *f128 interfaces for it. The required
libgcc support was added some time after the basic compiler
support, for x86_64 and x86. */
#pragma line 38 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 3 4
/* Defined to 1 if __HAVE_FLOAT128 is 1 and the type is ABI-distinct
from the default float, double and long double types in this glibc. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Defined to 1 if the current compiler invocation provides a
floating-point type with the right format for _Float64x, and this
glibc includes corresponding *f64x interfaces for it. */
#pragma empty_line
#pragma empty_line
/* Defined to 1 if __HAVE_FLOAT64X is 1 and _Float64x has the format
of long double. Otherwise, if __HAVE_FLOAT64X is 1, _Float64x has
the format of _Float128, which must be different from that of long
double. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Defined to concatenate the literal suffix to be used with _Float128
types, if __HAVE_FLOAT128 is 1. */
#pragma line 70 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 3 4
/* Defined to a complex binary128 type if __HAVE_FLOAT128 is 1. */
#pragma line 82 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 3 4
/* The remaining of this file provides support for older compilers. */
#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
/* Macros to control TS 18661-3 glibc features where the same
definitions are appropriate for all platforms.
Copyright (C) 2017-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#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/long-double.h" 1 3 4
/* Properties of long double type. ldbl-96 version.
Copyright (C) 2016-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
/* long double is distinct from double, so there is nothing to
define here. */
#pragma line 25 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 2 3 4
#pragma empty_line
/* This header should be included at the bottom of each bits/floatn.h.
It defines the following macros for each _FloatN and _FloatNx type,
where the same definitions, or definitions based only on the macros
in bits/floatn.h, are appropriate for all glibc configurations. */
#pragma empty_line
/* Defined to 1 if the current compiler invocation provides a
floating-point type with the right format for this type, and this
glibc includes corresponding *fN or *fNx interfaces for it. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Defined to 1 if the corresponding __HAVE_<type> macro is 1 and the
type is the first with its format in the sequence of (the default
choices for) float, double, long double, _Float16, _Float32,
_Float64, _Float128, _Float32x, _Float64x, _Float128x for this
glibc; that is, if functions present once per floating-point format
rather than once per type are present for this type.
#pragma empty_line
All configurations supported by glibc have _Float32 the same format
as float, _Float64 and _Float32x the same format as double, the
_Float64x the same format as either long double or _Float128. No
configurations support _Float128x or, as of GCC 7, have compiler
support for a type meeting the requirements for _Float128x. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Defined to 1 if any _FloatN or _FloatNx types that are not
ABI-distinct are however distinct types at the C language level (so
for the purposes of __builtin_types_compatible_p and _Generic). */
#pragma line 70 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4
/* Defined to concatenate the literal suffix to be used with _FloatN
or _FloatNx types, if __HAVE_<type> is 1. The corresponding
literal suffixes exist since GCC 7, for C only. */
#pragma line 130 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4
/* Defined to a complex type if __HAVE_<type> is 1. */
#pragma line 188 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4
/* The remaining of this file provides support for older compilers. */
#pragma line 207 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4
typedef float _Float32;
#pragma line 221 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4
/* If double, long double and _Float64 all have the same set of
values, TS 18661-3 requires the usual arithmetic conversions on
long double and _Float64 to produce _Float64. For this to be the
case when building with a compiler without a distinct _Float64
type, _Float64 must be a typedef for long double, not for
double. */
#pragma line 244 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4
typedef double _Float64;
#pragma line 261 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4
typedef double _Float32x;
#pragma line 278 "/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 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/clang/bin/../lib/clang/3.1/include/stddef.h" 1 3 4
/*===---- stddef.h - Basic type definitions --------------------------------===
*
* Copyright (c) 2008 Eli Friedman
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*===-----------------------------------------------------------------------===
*/
#pragma line 56 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/clang/bin/../lib/clang/3.1/include/stddef.h" 3 4
/* Some C libraries expect to see a wint_t here. Others (notably MinGW) will use
__WINT_TYPE__ directly; accommodate both by requiring __need_wint_t */
#pragma line 36 "/usr/include/wchar.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/clang/bin/../lib/clang/3.1/include/stdarg.h" 1 3 4
/*===---- stdarg.h - Variable argument handling ----------------------------===
*
* Copyright (c) 2008 Eli Friedman
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*===-----------------------------------------------------------------------===
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __builtin_va_list va_list;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* GCC always defines __va_copy, but does not define va_copy unless in c99 mode
* or -ansi is not specified, since it was not part of C90.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Hack required to make standard headers work, at least on Ubuntu */
#pragma empty_line
typedef __builtin_va_list __gnuc_va_list;
#pragma line 39 "/usr/include/wchar.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/types/wint_t.h" 1 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Some versions of stddef.h provide wint_t, even though neither the
C nor C++ standards, nor POSIX, specifies this. We assume that
stddef.h will define the macro _WINT_T if and only if it provides
wint_t, and conversely, that it will avoid providing wint_t if
_WINT_T is already defined. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Integral type unchanged by default argument promotions that can
hold any value corresponding to members of the extended character
set, as well as at least one value that does not correspond to any
member of the extended character set. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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 empty_line
#pragma empty_line
#pragma empty_line
/* Integral type unchanged by default argument promotions that can
hold any value corresponding to members of the extended character
set, as well as at least one value that does not correspond to any
member of the extended character set. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Conversion state information. */
typedef struct
{
int __count;
union
{
unsigned int __wch;
char __wchb[4];
} __value; /* Value so far. */
} __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
/* The opaque type of streams. This is the definition used elsewhere. */
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
/* Definition of locale_t.
Copyright (C) 2017-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#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/__locale_t.h" 1 3 4
/* Definition of struct __locale_struct and __locale_t.
Copyright (C) 1997-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* POSIX.1-2008: the locale_t type, representing a locale context
(implementation-namespace version). This type should be treated
as opaque by applications; some details are exposed for the sake of
efficiency in e.g. ctype functions. */
#pragma empty_line
struct __locale_struct
{
/* Note: LC_ALL is not a valid index into this array. */
struct __locale_data *__locales[13]; /* 13 = __LC_LAST. */
#pragma empty_line
/* To increase the speed of this solution we add some special members. */
const unsigned short int *__ctype_b;
const int *__ctype_tolower;
const int *__ctype_toupper;
#pragma empty_line
/* Note: LC_ALL is not a valid index into this array. */
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 empty_line
#pragma empty_line
/* Tell the caller that we provide correct C++ prototypes. */
#pragma line 67 "/usr/include/wchar.h" 3 4
/* All versions of XPG prior to the publication of ISO C99 required
the bulk of <wctype.h>'s declarations to appear in this header
(because <wctype.h> did not exist prior to C99). In POSIX.1-2001
those declarations were marked as XSI extensions; in -2008 they
were additionally marked as obsolescent. _GNU_SOURCE mode
anticipates the removal of these declarations in the next revision
of POSIX. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern "C" {
#pragma empty_line
/* This incomplete type is defined in <time.h> but needed here because
of `wcsftime'. */
struct tm;
#pragma empty_line
#pragma empty_line
/* Copy SRC to DEST. */
extern wchar_t *wcscpy (wchar_t *__restrict __dest,
const wchar_t *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
/* Copy no more than N wide-characters of SRC to DEST. */
extern wchar_t *wcsncpy (wchar_t *__restrict __dest,
const wchar_t *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
/* Append SRC onto DEST. */
extern wchar_t *wcscat (wchar_t *__restrict __dest,
const wchar_t *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
/* Append no more than N wide-characters of SRC onto DEST. */
extern wchar_t *wcsncat (wchar_t *__restrict __dest,
const wchar_t *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
/* Compare S1 and S2. */
extern int wcscmp (const wchar_t *__s1, const wchar_t *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
/* Compare N wide-characters of S1 and S2. */
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
/* Compare S1 and S2, ignoring case. */
extern int wcscasecmp (const wchar_t *__s1, const wchar_t *__s2) throw ();
#pragma empty_line
/* Compare no more than N chars of S1 and S2, ignoring case. */
extern int wcsncasecmp (const wchar_t *__s1, const wchar_t *__s2,
size_t __n) throw ();
#pragma empty_line
/* Similar to the two functions above but take the information from
the provided locale and not the global locale. */
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
/* Compare S1 and S2, both interpreted as appropriate to the
LC_COLLATE category of the current locale. */
extern int wcscoll (const wchar_t *__s1, const wchar_t *__s2) throw ();
/* Transform S2 into array pointed to by S1 such that if wcscmp is
applied to two transformed strings the result is the as applying
`wcscoll' to the original strings. */
extern size_t wcsxfrm (wchar_t *__restrict __s1,
const wchar_t *__restrict __s2, size_t __n) throw ();
#pragma empty_line
#pragma empty_line
/* Similar to the two functions above but take the information from
the provided locale and not the global locale. */
#pragma empty_line
/* Compare S1 and S2, both interpreted as appropriate to the
LC_COLLATE category of the given locale. */
extern int wcscoll_l (const wchar_t *__s1, const wchar_t *__s2,
locale_t __loc) throw ();
#pragma empty_line
/* Transform S2 into array pointed to by S1 such that if wcscmp is
applied to two transformed strings the result is the as applying
`wcscoll' to the original strings. */
extern size_t wcsxfrm_l (wchar_t *__s1, const wchar_t *__s2,
size_t __n, locale_t __loc) throw ();
#pragma empty_line
/* Duplicate S, returning an identical malloc'd string. */
extern wchar_t *wcsdup (const wchar_t *__s) throw () __attribute__ ((__malloc__));
#pragma empty_line
#pragma empty_line
/* Find the first occurrence of WC in WCS. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern wchar_t *wcschr (const wchar_t *__wcs, wchar_t __wc)
throw () __attribute__ ((__pure__));
#pragma empty_line
/* Find the last occurrence of WC in WCS. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern wchar_t *wcsrchr (const wchar_t *__wcs, wchar_t __wc)
throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* This function is similar to `wcschr'. But it returns a pointer to
the closing NUL wide character in case C is not found in S. */
extern wchar_t *wcschrnul (const wchar_t *__s, wchar_t __wc)
throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
/* Return the length of the initial segmet of WCS which
consists entirely of wide characters not in REJECT. */
extern size_t wcscspn (const wchar_t *__wcs, const wchar_t *__reject)
throw () __attribute__ ((__pure__));
/* Return the length of the initial segmet of WCS which
consists entirely of wide characters in ACCEPT. */
extern size_t wcsspn (const wchar_t *__wcs, const wchar_t *__accept)
throw () __attribute__ ((__pure__));
/* Find the first occurrence in WCS of any character in ACCEPT. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern wchar_t *wcspbrk (const wchar_t *__wcs, const wchar_t *__accept)
throw () __attribute__ ((__pure__));
#pragma empty_line
/* Find the first occurrence of NEEDLE in HAYSTACK. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern wchar_t *wcsstr (const wchar_t *__haystack, const wchar_t *__needle)
throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
/* Divide WCS into tokens separated by characters in DELIM. */
extern wchar_t *wcstok (wchar_t *__restrict __s,
const wchar_t *__restrict __delim,
wchar_t **__restrict __ptr) throw ();
#pragma empty_line
/* Return the number of wide characters in S. */
extern size_t wcslen (const wchar_t *__s) throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
/* Another name for `wcsstr' from XPG4. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern wchar_t *wcswcs (const wchar_t *__haystack, const wchar_t *__needle)
throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Return the number of wide characters in S, but at most MAXLEN. */
extern size_t wcsnlen (const wchar_t *__s, size_t __maxlen)
throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Search N wide characters of S for C. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern wchar_t *wmemchr (const wchar_t *__s, wchar_t __c, size_t __n)
throw () __attribute__ ((__pure__));
#pragma empty_line
#pragma empty_line
/* Compare N wide characters of S1 and S2. */
extern int wmemcmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
throw () __attribute__ ((__pure__));
#pragma empty_line
/* Copy N wide characters of SRC to DEST. */
extern wchar_t *wmemcpy (wchar_t *__restrict __s1,
const wchar_t *__restrict __s2, size_t __n) throw ();
#pragma empty_line
/* Copy N wide characters of SRC to DEST, guaranteeing
correct behavior for overlapping strings. */
extern wchar_t *wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n)
throw ();
#pragma empty_line
/* Set N wide characters of S to C. */
extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) throw ();
#pragma empty_line
#pragma empty_line
/* Copy N wide characters of SRC to DEST and return pointer to following
wide character. */
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
/* Determine whether C constitutes a valid (one-byte) multibyte
character. */
extern wint_t btowc (int __c) throw ();
#pragma empty_line
/* Determine whether C corresponds to a member of the extended
character set whose multibyte representation is a single byte. */
extern int wctob (wint_t __c) throw ();
#pragma empty_line
/* Determine whether PS points to an object representing the initial
state. */
extern int mbsinit (const mbstate_t *__ps) throw () __attribute__ ((__pure__));
#pragma empty_line
/* Write wide character representation of multibyte character pointed
to by S to PWC. */
extern size_t mbrtowc (wchar_t *__restrict __pwc,
const char *__restrict __s, size_t __n,
mbstate_t *__restrict __p) throw ();
#pragma empty_line
/* Write multibyte representation of wide character WC to S. */
extern size_t wcrtomb (char *__restrict __s, wchar_t __wc,
mbstate_t *__restrict __ps) throw ();
#pragma empty_line
/* Return number of bytes in multibyte character pointed to by S. */
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 335 "/usr/include/wchar.h" 3 4
/* Write wide character representation of multibyte character string
SRC to DST. */
extern size_t mbsrtowcs (wchar_t *__restrict __dst,
const char **__restrict __src, size_t __len,
mbstate_t *__restrict __ps) throw ();
#pragma empty_line
/* Write multibyte character representation of wide character string
SRC to DST. */
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
/* Write wide character representation of at most NMC bytes of the
multibyte character string SRC to DST. */
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
/* Write multibyte character representation of at most NWC characters
from the wide character string SRC to DST. */
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
/* The following functions are extensions found in X/Open CAE. */
#pragma empty_line
/* Determine number of column positions required for C. */
extern int wcwidth (wchar_t __c) throw ();
#pragma empty_line
/* Determine number of column positions required for first N wide
characters (or fewer if S ends before this) in S. */
extern int wcswidth (const wchar_t *__s, size_t __n) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Convert initial portion of the wide string NPTR to `double'
representation. */
extern double wcstod (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr) throw ();
#pragma empty_line
#pragma empty_line
/* Likewise for `float' and `long double' sizes of floating-point numbers. */
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 empty_line
#pragma empty_line
/* Likewise for `_FloatN' and `_FloatNx' when support is enabled. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
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 line 411 "/usr/include/wchar.h" 3 4
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 426 "/usr/include/wchar.h" 3 4
/* Convert initial portion of wide string NPTR to `long int'
representation. */
extern long int wcstol (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base) throw ();
#pragma empty_line
/* Convert initial portion of wide string NPTR to `unsigned long int'
representation. */
extern unsigned long int wcstoul (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base)
throw ();
#pragma empty_line
#pragma empty_line
/* Convert initial portion of wide string NPTR to `long long int'
representation. */
__extension__
extern long long int wcstoll (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base)
throw ();
#pragma empty_line
/* Convert initial portion of wide string NPTR to `unsigned long long int'
representation. */
__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
/* Convert initial portion of wide string NPTR to `long long int'
representation. */
__extension__
extern long long int wcstoq (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base)
throw ();
#pragma empty_line
/* Convert initial portion of wide string NPTR to `unsigned long long int'
representation. */
__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
/* Parallel versions of the functions above which take the locale to
use as an additional parameter. These are GNU extensions inspired
by the POSIX.1-2008 extended locale API. */
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 line 529 "/usr/include/wchar.h" 3 4
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 549 "/usr/include/wchar.h" 3 4
/* Copy SRC to DEST, returning the address of the terminating L'\0' in
DEST. */
extern wchar_t *wcpcpy (wchar_t *__restrict __dest,
const wchar_t *__restrict __src) throw ();
#pragma empty_line
/* Copy no more than N characters of SRC to DEST, returning the address of
the last character written into DEST. */
extern wchar_t *wcpncpy (wchar_t *__restrict __dest,
const wchar_t *__restrict __src, size_t __n)
throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Wide character I/O functions. */
#pragma empty_line
#pragma empty_line
/* Like OPEN_MEMSTREAM, but the stream is wide oriented and produces
a wide character string. */
extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Select orientation for stream. */
extern int fwide (__FILE *__fp, int __mode) throw ();
#pragma empty_line
#pragma empty_line
/* Write formatted output to STREAM.
#pragma empty_line
This function is a possible cancellation point and therefore not
marked with __THROW. */
extern int fwprintf (__FILE *__restrict __stream,
const wchar_t *__restrict __format, ...)
/* __attribute__ ((__format__ (__wprintf__, 2, 3))) */;
/* Write formatted output to stdout.
#pragma empty_line
This function is a possible cancellation point and therefore not
marked with __THROW. */
extern int wprintf (const wchar_t *__restrict __format, ...)
/* __attribute__ ((__format__ (__wprintf__, 1, 2))) */;
/* Write formatted output of at most N characters to S. */
extern int swprintf (wchar_t *__restrict __s, size_t __n,
const wchar_t *__restrict __format, ...)
throw () /* __attribute__ ((__format__ (__wprintf__, 3, 4))) */;
#pragma empty_line
/* Write formatted output to S from argument list ARG.
#pragma empty_line
This function is a possible cancellation point and therefore not
marked with __THROW. */
extern int vfwprintf (__FILE *__restrict __s,
const wchar_t *__restrict __format,
__gnuc_va_list __arg)
/* __attribute__ ((__format__ (__wprintf__, 2, 0))) */;
/* Write formatted output to stdout from argument list ARG.
#pragma empty_line
This function is a possible cancellation point and therefore not
marked with __THROW. */
extern int vwprintf (const wchar_t *__restrict __format,
__gnuc_va_list __arg)
/* __attribute__ ((__format__ (__wprintf__, 1, 0))) */;
/* Write formatted output of at most N character to S from argument
list ARG. */
extern int vswprintf (wchar_t *__restrict __s, size_t __n,
const wchar_t *__restrict __format,
__gnuc_va_list __arg)
throw () /* __attribute__ ((__format__ (__wprintf__, 3, 0))) */;
#pragma empty_line
#pragma empty_line
/* Read formatted input from STREAM.
#pragma empty_line
This function is a possible cancellation point and therefore not
marked with __THROW. */
extern int fwscanf (__FILE *__restrict __stream,
const wchar_t *__restrict __format, ...)
/* __attribute__ ((__format__ (__wscanf__, 2, 3))) */;
/* Read formatted input from stdin.
#pragma empty_line
This function is a possible cancellation point and therefore not
marked with __THROW. */
extern int wscanf (const wchar_t *__restrict __format, ...)
/* __attribute__ ((__format__ (__wscanf__, 1, 2))) */;
/* Read formatted input from S. */
extern int swscanf (const wchar_t *__restrict __s,
const wchar_t *__restrict __format, ...)
throw () /* __attribute__ ((__format__ (__wscanf__, 2, 3))) */;
#pragma line 669 "/usr/include/wchar.h" 3 4
/* Read formatted input from S into argument list ARG.
#pragma empty_line
This function is a possible cancellation point and therefore not
marked with __THROW. */
extern int vfwscanf (__FILE *__restrict __s,
const wchar_t *__restrict __format,
__gnuc_va_list __arg)
/* __attribute__ ((__format__ (__wscanf__, 2, 0))) */;
/* Read formatted input from stdin into argument list ARG.
#pragma empty_line
This function is a possible cancellation point and therefore not
marked with __THROW. */
extern int vwscanf (const wchar_t *__restrict __format,
__gnuc_va_list __arg)
/* __attribute__ ((__format__ (__wscanf__, 1, 0))) */;
/* Read formatted input from S into argument list ARG. */
extern int vswscanf (const wchar_t *__restrict __s,
const wchar_t *__restrict __format,
__gnuc_va_list __arg)
throw () /* __attribute__ ((__format__ (__wscanf__, 2, 0))) */;
#pragma line 723 "/usr/include/wchar.h" 3 4
/* Read a character from STREAM.
#pragma empty_line
These functions are possible cancellation points and therefore not
marked with __THROW. */
extern wint_t fgetwc (__FILE *__stream);
extern wint_t getwc (__FILE *__stream);
#pragma empty_line
/* Read a character from stdin.
#pragma empty_line
This function is a possible cancellation point and therefore not
marked with __THROW. */
extern wint_t getwchar (void);
#pragma empty_line
#pragma empty_line
/* Write a character to STREAM.
#pragma empty_line
These functions are possible cancellation points and therefore not
marked with __THROW. */
extern wint_t fputwc (wchar_t __wc, __FILE *__stream);
extern wint_t putwc (wchar_t __wc, __FILE *__stream);
#pragma empty_line
/* Write a character to stdout.
#pragma empty_line
This function is a possible cancellation point and therefore not
marked with __THROW. */
extern wint_t putwchar (wchar_t __wc);
#pragma empty_line
#pragma empty_line
/* Get a newline-terminated wide character string of finite length
from STREAM.
#pragma empty_line
This function is a possible cancellation point and therefore not
marked with __THROW. */
extern wchar_t *fgetws (wchar_t *__restrict __ws, int __n,
__FILE *__restrict __stream);
#pragma empty_line
/* Write a string to STREAM.
#pragma empty_line
This function is a possible cancellation point and therefore not
marked with __THROW. */
extern int fputws (const wchar_t *__restrict __ws,
__FILE *__restrict __stream);
#pragma empty_line
#pragma empty_line
/* Push a character back onto the input buffer of STREAM.
#pragma empty_line
This function is a possible cancellation point and therefore not
marked with __THROW. */
extern wint_t ungetwc (wint_t __wc, __FILE *__stream);
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* These are defined to be equivalent to the `char' functions defined
in POSIX.1:1996.
#pragma empty_line
These functions are not part of POSIX and therefore no official
cancellation point. But due to similarity with an POSIX interface
or due to the implementation they are cancellation points and
therefore not marked with __THROW. */
extern wint_t getwc_unlocked (__FILE *__stream);
extern wint_t getwchar_unlocked (void);
#pragma empty_line
/* This is the wide character version of a GNU extension.
#pragma empty_line
This function is not part of POSIX and therefore no official
cancellation point. But due to similarity with an POSIX interface
or due to the implementation it is a cancellation point and
therefore not marked with __THROW. */
extern wint_t fgetwc_unlocked (__FILE *__stream);
#pragma empty_line
/* Faster version when locking is not necessary.
#pragma empty_line
This function is not part of POSIX and therefore no official
cancellation point. But due to similarity with an POSIX interface
or due to the implementation it is a cancellation point and
therefore not marked with __THROW. */
extern wint_t fputwc_unlocked (wchar_t __wc, __FILE *__stream);
#pragma empty_line
/* These are defined to be equivalent to the `char' functions defined
in POSIX.1:1996.
#pragma empty_line
These functions are not part of POSIX and therefore no official
cancellation point. But due to similarity with an POSIX interface
or due to the implementation they are cancellation points and
therefore not marked with __THROW. */
extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream);
extern wint_t putwchar_unlocked (wchar_t __wc);
#pragma empty_line
#pragma empty_line
/* This function does the same as `fgetws' but does not lock the stream.
#pragma empty_line
This function is not part of POSIX and therefore no official
cancellation point. But due to similarity with an POSIX interface
or due to the implementation it is a cancellation point and
therefore not marked with __THROW. */
extern wchar_t *fgetws_unlocked (wchar_t *__restrict __ws, int __n,
__FILE *__restrict __stream);
#pragma empty_line
/* This function does the same as `fputws' but does not lock the stream.
#pragma empty_line
This function is not part of POSIX and therefore no official
cancellation point. But due to similarity with an POSIX interface
or due to the implementation it is a cancellation point and
therefore not marked with __THROW. */
extern int fputws_unlocked (const wchar_t *__restrict __ws,
__FILE *__restrict __stream);
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Format TP into S according to FORMAT.
Write no more than MAXSIZE wide characters and return the number
of wide characters written, or 0 if it would exceed MAXSIZE. */
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
/* Similar to `wcsftime' but takes the information from
the provided locale and not the global locale. */
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 empty_line
#pragma empty_line
/* Define some macros helping to catch buffer overflows. */
#pragma line 857 "/usr/include/wchar.h" 3 4
}
#pragma line 46 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cwchar" 2 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
// Need to do a bit of trickery here with mbstate_t as char_traits
// assumes it is in wchar.h, regardless of wchar_t specializations.
#pragma line 63 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cwchar" 3
namespace std
{
using ::mbstate_t;
} // namespace std
#pragma empty_line
// Get rid of those macros defined in <wchar.h> in lieu of real functions.
#pragma line 136 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cwchar" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
#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 empty_line
#pragma empty_line
inline wchar_t*
wcschr(wchar_t* __p, wchar_t __c)
{ return wcschr(const_cast<const wchar_t*>(__p), __c); }
#pragma empty_line
inline wchar_t*
wcspbrk(wchar_t* __s1, const wchar_t* __s2)
{ return wcspbrk(const_cast<const wchar_t*>(__s1), __s2); }
#pragma empty_line
inline wchar_t*
wcsrchr(wchar_t* __p, wchar_t __c)
{ return wcsrchr(const_cast<const wchar_t*>(__p), __c); }
#pragma empty_line
inline wchar_t*
wcsstr(wchar_t* __s1, const wchar_t* __s2)
{ return wcsstr(const_cast<const wchar_t*>(__s1), __s2); }
#pragma empty_line
inline wchar_t*
wmemchr(wchar_t* __p, wchar_t __c, size_t __n)
{ return wmemchr(const_cast<const wchar_t*>(__p), __c, __n); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
} // namespace
#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 258 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cwchar" 3
using ::wcstoll;
using ::wcstoull;
#pragma empty_line
} // namespace __gnu_cxx
#pragma empty_line
namespace std
{
using ::__gnu_cxx::wcstold;
using ::__gnu_cxx::wcstoll;
using ::__gnu_cxx::wcstoull;
} // namespace
#pragma line 42 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/postypes.h" 2 3
#pragma empty_line
// XXX If <stdint.h> is really needed, make sure to define the macros
// before including it, in order not to break <tr1/cstdint> (and <cstdint>
// in C++0x). Reconsider all this as soon as possible...
#pragma line 69 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/postypes.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
// The types streamoff, streampos and wstreampos and the class
// template fpos<> are described in clauses 21.1.2, 21.1.3, 27.1.2,
// 27.2, 27.4.1, 27.4.3 and D.6. Despite all this verbiage, the
// behaviour of these types is mostly implementation defined or
// unspecified. The behaviour in this implementation is as noted
// below.
#pragma empty_line
/**
* @brief Type used by fpos, char_traits<char>, and char_traits<wchar_t>.
*
* In clauses 21.1.3.1 and 27.4.1 streamoff is described as an
* implementation defined type.
* Note: In versions of GCC up to and including GCC 3.3, streamoff
* was typedef long.
*/
#pragma empty_line
typedef long streamoff;
#pragma line 98 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/postypes.h" 3
/// Integral type for I/O operation counts and buffer sizes.
typedef ptrdiff_t streamsize; // Signed integral type
#pragma empty_line
/**
* @brief Class representing stream positions.
*
* The standard places no requirements upon the template parameter StateT.
* In this implementation StateT must be DefaultConstructible,
* CopyConstructible and Assignable. The standard only requires that fpos
* should contain a member of type StateT. In this implementation it also
* contains an offset stored as a signed integer.
*
* @param StateT Type passed to and returned from state().
*/
template<typename _StateT>
class fpos
{
private:
streamoff _M_off;
_StateT _M_state;
#pragma empty_line
public:
// The standard doesn't require that fpos objects can be default
// constructed. This implementation provides a default
// constructor that initializes the offset to 0 and default
// constructs the state.
fpos()
: _M_off(0), _M_state() { }
#pragma empty_line
// The standard requires that fpos objects can be constructed
// from streamoff objects using the constructor syntax, and
// fails to give any meaningful semantics. In this
// implementation implicit conversion is also allowed, and this
// constructor stores the streamoff as the offset and default
// constructs the state.
/// Construct position from offset.
fpos(streamoff __off)
: _M_off(__off), _M_state() { }
#pragma empty_line
/// Convert to streamoff.
operator streamoff() const { return _M_off; }
#pragma empty_line
/// Remember the value of @a st.
void
state(_StateT __st)
{ _M_state = __st; }
#pragma empty_line
/// Return the last set value of @a st.
_StateT
state() const
{ return _M_state; }
#pragma empty_line
// The standard requires that this operator must be defined, but
// gives no semantics. In this implementation it just adds its
// argument to the stored offset and returns *this.
/// Add offset to this position.
fpos&
operator+=(streamoff __off)
{
_M_off += __off;
return *this;
}
#pragma empty_line
// The standard requires that this operator must be defined, but
// gives no semantics. In this implementation it just subtracts
// its argument from the stored offset and returns *this.
/// Subtract offset from this position.
fpos&
operator-=(streamoff __off)
{
_M_off -= __off;
return *this;
}
#pragma empty_line
// The standard requires that this operator must be defined, but
// defines its semantics only in terms of operator-. In this
// implementation it constructs a copy of *this, adds the
// argument to that copy using operator+= and then returns the
// copy.
/// Add position and offset.
fpos
operator+(streamoff __off) const
{
fpos __pos(*this);
__pos += __off;
return __pos;
}
#pragma empty_line
// The standard requires that this operator must be defined, but
// defines its semantics only in terms of operator+. In this
// implementation it constructs a copy of *this, subtracts the
// argument from that copy using operator-= and then returns the
// copy.
/// Subtract offset from position.
fpos
operator-(streamoff __off) const
{
fpos __pos(*this);
__pos -= __off;
return __pos;
}
#pragma empty_line
// The standard requires that this operator must be defined, but
// defines its semantics only in terms of operator+. In this
// implementation it returns the difference between the offset
// stored in *this and in the argument.
/// Subtract position to return offset.
streamoff
operator-(const fpos& __other) const
{ return _M_off - __other._M_off; }
};
#pragma empty_line
// The standard only requires that operator== must be an
// equivalence relation. In this implementation two fpos<StateT>
// objects belong to the same equivalence class if the contained
// offsets compare equal.
/// Test if equivalent to another position.
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
// Clauses 21.1.3.1 and 21.1.3.2 describe streampos and wstreampos
// as implementation defined types, but clause 27.2 requires that
// they must both be typedefs for fpos<mbstate_t>
/// File position for char streams.
typedef fpos<mbstate_t> streampos;
/// File position for wchar_t streams.
typedef fpos<mbstate_t> wstreampos;
#pragma line 241 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/postypes.h" 3
} // namespace
#pragma line 42 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/iosfwd" 2 3
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
/**
* @defgroup io I/O
*
* Nearly all of the I/O classes are parameterized on the type of
* characters they read and write. (The major exception is ios_base at
* the top of the hierarchy.) This is a change from pre-Standard
* streams, which were not templates.
*
* For ease of use and compatibility, all of the basic_* I/O-related
* classes are given typedef names for both of the builtin character
* widths (wide and narrow). The typedefs are the same as the
* pre-Standard names, for example:
*
* @code
* typedef basic_ifstream<char> ifstream;
* @endcode
*
* Because properly forward-declaring these classes can be difficult, you
* should not do it yourself. Instead, include the <iosfwd>
* header, which contains only declarations of all the I/O classes as
* well as the typedefs. Trying to forward-declare the typedefs
* themselves (e.g., <code>class ostream;</code>) is not valid ISO C++.
*
* For more specific declarations, see
* http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch24.html
*
* @{
*/
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
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
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
/// Base class for @c char streams.
typedef basic_ios<char> ios;
#pragma empty_line
/// Base class for @c char buffers.
typedef basic_streambuf<char> streambuf;
#pragma empty_line
/// Base class for @c char input streams.
typedef basic_istream<char> istream;
#pragma empty_line
/// Base class for @c char output streams.
typedef basic_ostream<char> ostream;
#pragma empty_line
/// Base class for @c char mixed input and output streams.
typedef basic_iostream<char> iostream;
#pragma empty_line
/// Class for @c char memory buffers.
typedef basic_stringbuf<char> stringbuf;
#pragma empty_line
/// Class for @c char input memory streams.
typedef basic_istringstream<char> istringstream;
#pragma empty_line
/// Class for @c char output memory streams.
typedef basic_ostringstream<char> ostringstream;
#pragma empty_line
/// Class for @c char mixed input and output memory streams.
typedef basic_stringstream<char> stringstream;
#pragma empty_line
/// Class for @c char file buffers.
typedef basic_filebuf<char> filebuf;
#pragma empty_line
/// Class for @c char input file streams.
typedef basic_ifstream<char> ifstream;
#pragma empty_line
/// Class for @c char output file streams.
typedef basic_ofstream<char> ofstream;
#pragma empty_line
/// Class for @c char mixed input and output file streams.
typedef basic_fstream<char> fstream;
#pragma empty_line
#pragma empty_line
/// Base class for @c wchar_t streams.
typedef basic_ios<wchar_t> wios;
#pragma empty_line
/// Base class for @c wchar_t buffers.
typedef basic_streambuf<wchar_t> wstreambuf;
#pragma empty_line
/// Base class for @c wchar_t input streams.
typedef basic_istream<wchar_t> wistream;
#pragma empty_line
/// Base class for @c wchar_t output streams.
typedef basic_ostream<wchar_t> wostream;
#pragma empty_line
/// Base class for @c wchar_t mixed input and output streams.
typedef basic_iostream<wchar_t> wiostream;
#pragma empty_line
/// Class for @c wchar_t memory buffers.
typedef basic_stringbuf<wchar_t> wstringbuf;
#pragma empty_line
/// Class for @c wchar_t input memory streams.
typedef basic_istringstream<wchar_t> wistringstream;
#pragma empty_line
/// Class for @c wchar_t output memory streams.
typedef basic_ostringstream<wchar_t> wostringstream;
#pragma empty_line
/// Class for @c wchar_t mixed input and output memory streams.
typedef basic_stringstream<wchar_t> wstringstream;
#pragma empty_line
/// Class for @c wchar_t file buffers.
typedef basic_filebuf<wchar_t> wfilebuf;
#pragma empty_line
/// Class for @c wchar_t input file streams.
typedef basic_ifstream<wchar_t> wifstream;
#pragma empty_line
/// Class for @c wchar_t output file streams.
typedef basic_ofstream<wchar_t> wofstream;
#pragma empty_line
/// Class for @c wchar_t mixed input and output file streams.
typedef basic_fstream<wchar_t> wfstream;
#pragma empty_line
/** @} */
#pragma empty_line
#pragma empty_line
} // namespace
#pragma line 39 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ios" 2 3
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/exception" 1 3
// Exception Handling support header for -*- C++ -*-
#pragma empty_line
// Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
// 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
// Free Software Foundation
//
// This file is part of GCC.
//
// GCC is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// GCC is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file exception
* This is a Standard C++ Library header.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 35 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/exception" 3
#pragma empty_line
#pragma GCC visibility push(default)
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern "C++" {
#pragma empty_line
namespace std
{
/**
* @defgroup exceptions Exceptions
* @ingroup diagnostics
*
* Classes and functions for reporting errors via exception classes.
* @{
*/
#pragma empty_line
/**
* @brief Base class for all library exceptions.
*
* This is the base class for all exceptions thrown by the standard
* library, and by certain language expressions. You are free to derive
* your own %exception classes, or use a different hierarchy, or to
* throw non-class data (e.g., fundamental types).
*/
class exception
{
public:
exception() throw() { }
virtual ~exception() throw();
#pragma empty_line
/** Returns a C-style character string describing the general cause
* of the current error. */
virtual const char* what() const throw();
};
#pragma empty_line
/** If an %exception is thrown which is not listed in a function's
* %exception specification, one of these may be thrown. */
class bad_exception : public exception
{
public:
bad_exception() throw() { }
#pragma empty_line
// This declaration is not useless:
// http://gcc.gnu.org/onlinedocs/gcc-3.0.2/gcc_6.html#SEC118
virtual ~bad_exception() throw();
#pragma empty_line
// See comment in eh_exception.cc.
virtual const char* what() const throw();
};
#pragma empty_line
/// If you write a replacement %terminate handler, it must be of this type.
typedef void (*terminate_handler) ();
#pragma empty_line
/// If you write a replacement %unexpected handler, it must be of this type.
typedef void (*unexpected_handler) ();
#pragma empty_line
/// Takes a new handler function as an argument, returns the old function.
terminate_handler set_terminate(terminate_handler) throw();
#pragma empty_line
/** The runtime will call this function if %exception handling must be
* abandoned for any reason. It can also be called by the user. */
void terminate() throw() __attribute__ ((__noreturn__));
#pragma empty_line
/// Takes a new handler function as an argument, returns the old function.
unexpected_handler set_unexpected(unexpected_handler) throw();
#pragma empty_line
/** The runtime will call this function if an %exception is thrown which
* violates the function's %exception specification. */
void unexpected() __attribute__ ((__noreturn__));
#pragma empty_line
/** [18.6.4]/1: 'Returns true after completing evaluation of a
* throw-expression until either completing initialization of the
* exception-declaration in the matching handler or entering @c unexpected()
* due to the throw; or after entering @c terminate() for any reason
* other than an explicit call to @c terminate(). [Note: This includes
* stack unwinding [15.2]. end note]'
*
* 2: 'When @c uncaught_exception() is true, throwing an
* %exception can result in a call of @c terminate()
* (15.5.1).'
*/
bool uncaught_exception() throw() __attribute__ ((__pure__));
#pragma empty_line
// @} group exceptions
} // namespace std
#pragma empty_line
namespace __gnu_cxx
{
#pragma empty_line
#pragma empty_line
/**
* @brief A replacement for the standard terminate_handler which
* prints more information about the terminating exception (if any)
* on stderr.
*
* @ingroup exceptions
*
* Call
* @code
* std::set_terminate(__gnu_cxx::__verbose_terminate_handler)
* @endcode
* to use. For more info, see
* http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt02ch06s02.html
*
* In 3.4 and later, this is on by default.
*/
void __verbose_terminate_handler();
#pragma empty_line
#pragma empty_line
} // namespace
#pragma empty_line
} // extern "C++"
#pragma empty_line
#pragma GCC visibility pop
#pragma line 40 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ios" 2 3
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/char_traits.h" 1 3
// Character Traits for use by standard string and iostream -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file bits/char_traits.h
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{string}
*/
#pragma empty_line
//
// ISO C++ 14882: 21 Strings library
//
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 39 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/char_traits.h" 3
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_algobase.h" 1 3
// Core algorithmic facilities -*- C++ -*-
#pragma empty_line
// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
// 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1996-1998
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*/
#pragma empty_line
/** @file bits/stl_algobase.h
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{algorithm}
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/functexcept.h" 1 3
// Function-Based Exception Support -*- C++ -*-
#pragma empty_line
// Copyright (C) 2001, 2004, 2005, 2008, 2009, 2010, 2011
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file bits/functexcept.h
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{exception}
*
* This header provides support for -fno-exceptions.
*/
#pragma empty_line
//
// ISO C++ 14882: 19.1 Exception classes
//
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/exception_defines.h" 1 3
// -fno-exceptions Support -*- C++ -*-
#pragma empty_line
// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2006, 2007, 2008, 2009,
// 2011
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file bits/exception_defines.h
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{exception}
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
// Iff -fno-exceptions, transform error handling code to work without it.
#pragma line 42 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/functexcept.h" 2 3
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
// Helper for exception objects in <except>
void
__throw_bad_exception(void) __attribute__((__noreturn__));
#pragma empty_line
// Helper for exception objects in <new>
void
__throw_bad_alloc(void) __attribute__((__noreturn__));
#pragma empty_line
// Helper for exception objects in <typeinfo>
void
__throw_bad_cast(void) __attribute__((__noreturn__));
#pragma empty_line
void
__throw_bad_typeid(void) __attribute__((__noreturn__));
#pragma empty_line
// Helpers for exception objects in <stdexcept>
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_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
// Helpers for exception objects in <ios>
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
// Helpers for exception objects in <functional>
void
__throw_bad_function_call() __attribute__((__noreturn__));
#pragma empty_line
#pragma empty_line
} // namespace
#pragma line 62 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_algobase.h" 2 3
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/cpp_type_traits.h" 1 3
// The -*- C++ -*- type traits classes for internal use in libstdc++
#pragma empty_line
// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file bits/cpp_type_traits.h
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{ext/type_traits}
*/
#pragma empty_line
// Written by Gabriel Dos Reis <dosreis@cmla.ens-cachan.fr>
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 36 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/cpp_type_traits.h" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
//
// This file provides some compile-time information about various types.
// These representations were designed, on purpose, to be constant-expressions
// and not types as found in <bits/type_traits.h>. In particular, they
// can be used in control structures and the optimizer hopefully will do
// the obvious thing.
//
// Why integral expressions, and not functions nor types?
// Firstly, these compile-time entities are used as template-arguments
// so function return values won't work: We need compile-time entities.
// We're left with types and constant integral expressions.
// Secondly, from the point of view of ease of use, type-based compile-time
// information is -not- *that* convenient. On has to write lots of
// overloaded functions and to hope that the compiler will select the right
// one. As a net effect, the overall structure isn't very clear at first
// glance.
// Thirdly, partial ordering and overload resolution (of function templates)
// is highly costly in terms of compiler-resource. It is a Good Thing to
// keep these resource consumption as least as possible.
//
// See valarray_array.h for a case use.
//
// -- Gaby (dosreis@cmla.ens-cachan.fr) 2000-03-06.
//
// Update 2005: types are also provided and <bits/type_traits.h> has been
// removed.
//
#pragma empty_line
// Forward declaration hack, should really include this from somewhere.
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
template<typename _Iterator, typename _Container>
class __normal_iterator;
#pragma empty_line
#pragma empty_line
} // namespace
#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
// N.B. The conversions to bool are needed due to the issue
// explained in c++/19404.
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
// Compare for equality of types.
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
// Holds if the template-argument is a void type.
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
//
// Integer types
//
template<typename _Tp>
struct __is_integer
{
enum { __value = 0 };
typedef __false_type __type;
};
#pragma empty_line
// Thirteen specializations (yes there are eleven standard integer
// types; <em>long long</em> and <em>unsigned long long</em> are
// supported as extensions)
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 line 198 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/cpp_type_traits.h" 3
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 empty_line
//
// Floating point types
//
template<typename _Tp>
struct __is_floating
{
enum { __value = 0 };
typedef __false_type __type;
};
#pragma empty_line
// three specializations (float, double and 'long double')
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
//
// Pointer types
//
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
//
// Normal iterator type
//
template<typename _Tp>
struct __is_normal_iterator
{
enum { __value = 0 };
typedef __false_type __type;
};
#pragma empty_line
template<typename _Iterator, typename _Container>
struct __is_normal_iterator< __gnu_cxx::__normal_iterator<_Iterator,
_Container> >
{
enum { __value = 1 };
typedef __true_type __type;
};
#pragma empty_line
//
// An arithmetic type is an integer type or a floating point type
//
template<typename _Tp>
struct __is_arithmetic
: public __traitor<__is_integer<_Tp>, __is_floating<_Tp> >
{ };
#pragma empty_line
//
// A fundamental type is `void' or and arithmetic type
//
template<typename _Tp>
struct __is_fundamental
: public __traitor<__is_void<_Tp>, __is_arithmetic<_Tp> >
{ };
#pragma empty_line
//
// A scalar type is an arithmetic type or a pointer type
//
template<typename _Tp>
struct __is_scalar
: public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> >
{ };
#pragma empty_line
//
// For use in std::copy and std::find overloads for streambuf iterators.
//
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
//
// Move iterator type
//
template<typename _Tp>
struct __is_move_iterator
{
enum { __value = 0 };
typedef __false_type __type;
};
#pragma line 422 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/cpp_type_traits.h" 3
} // namespace
#pragma line 63 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_algobase.h" 2 3
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ext/type_traits.h" 1 3
// -*- C++ -*-
#pragma empty_line
// Copyright (C) 2005, 2006, 2007, 2009, 2010, 2011
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the terms
// of the GNU General Public License as published by the Free Software
// Foundation; either version 3, or (at your option) any later
// version.
#pragma empty_line
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file ext/type_traits.h
* This file is a GNU extension to the Standard C++ Library.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 33 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ext/type_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 empty_line
// Define a nested type if some predicate holds.
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
// Conditional expression for types. If true, first, if false, second.
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
// Given an integral builtin type, return the corresponding unsigned type.
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
// Declare but don't define.
template<>
struct __add_unsigned<bool>;
#pragma empty_line
template<>
struct __add_unsigned<wchar_t>;
#pragma empty_line
#pragma empty_line
// Given an integral builtin type, return the corresponding signed type.
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
// Declare but don't define.
template<>
struct __remove_unsigned<bool>;
#pragma empty_line
template<>
struct __remove_unsigned<wchar_t>;
#pragma empty_line
#pragma empty_line
// For use in string and vstring.
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
// For complex and cmath
template<typename _Tp, bool = std::__is_integer<_Tp>::__value>
struct __promote
{ typedef double __type; };
#pragma empty_line
// No nested __type member for non-integer non-floating point types,
// allows this type to be used for SFINAE to constrain overloads in
// <cmath> and <complex> to only the intended types.
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
} // namespace
#pragma line 64 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_algobase.h" 2 3
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ext/numeric_traits.h" 1 3
// -*- C++ -*-
#pragma empty_line
// Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the terms
// of the GNU General Public License as published by the Free Software
// Foundation; either version 3, or (at your option) any later
// version.
#pragma empty_line
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file ext/numeric_traits.h
* This file is a GNU extension to the Standard C++ Library.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 32 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/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 empty_line
// Compile time constants for builtin types.
// Sadly std::numeric_limits member functions cannot be used for this.
#pragma line 53 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ext/numeric_traits.h" 3
template<typename _Value>
struct __numeric_traits_integer
{
// Only integers for initialization of member constant.
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
// NB: these two also available in std::numeric_limits as compile
// time constants, but <limits> is big and we avoid including it.
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 98 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ext/numeric_traits.h" 3
template<typename _Value>
struct __numeric_traits_floating
{
// Only floating point types. See N1822.
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
// See above comment...
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
} // namespace
#pragma line 65 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_algobase.h" 2 3
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_pair.h" 1 3
// Pair implementation -*- C++ -*-
#pragma empty_line
// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1996,1997
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*/
#pragma empty_line
/** @file bits/stl_pair.h
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{utility}
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/move.h" 1 3
// Move, forward and identity for C++0x + swap -*- C++ -*-
#pragma empty_line
// Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file bits/move.h
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{utility}
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/concept_check.h" 1 3
// Concept-checking control -*- C++ -*-
#pragma empty_line
// Copyright (C) 2001, 2009, 2010 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file bits/concept_check.h
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{iterator}
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 33 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/concept_check.h" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
// All places in libstdc++-v3 where these are used, or /might/ be used, or
// don't need to be used, or perhaps /should/ be used, are commented with
// "concept requirements" (and maybe some more text). So grep like crazy
// if you're looking for additional places to use these.
#pragma empty_line
// Concept-checking code is off by default unless users turn it on via
// configure options or editing c++config.h.
#pragma line 35 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/move.h" 2 3
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
// Used, in C++03 mode too, by allocators, etc.
template<typename _Tp>
inline _Tp*
__addressof(_Tp& __r)
{
return reinterpret_cast<_Tp*>
(&const_cast<char&>(reinterpret_cast<const volatile char&>(__r)));
}
#pragma empty_line
#pragma empty_line
} // namespace
#pragma line 109 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/move.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
/**
* @brief Swaps two values.
* @ingroup mutating_algorithms
* @param __a A thing of arbitrary type.
* @param __b Another thing of arbitrary type.
* @return Nothing.
*/
template<typename _Tp>
inline void
swap(_Tp& __a, _Tp& __b)
{
// concept requirements
#pragma empty_line
#pragma empty_line
_Tp __tmp = (__a);
__a = (__b);
__b = (__tmp);
}
#pragma empty_line
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 809. std::swap should be overloaded for array types.
template<typename _Tp, size_t _Nm>
inline void
swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
{
for (size_t __n = 0; __n < _Nm; ++__n)
swap(__a[__n], __b[__n]);
}
#pragma empty_line
#pragma empty_line
} // namespace
#pragma line 61 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/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 line 85 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_pair.h" 3
/// Struct holding two objects of arbitrary type.
template<class _T1, class _T2>
struct pair
{
typedef _T1 first_type; /// @c first_type is the first bound type
typedef _T2 second_type; /// @c second_type is the second bound type
#pragma empty_line
_T1 first; /// @c first is a copy of the first object
_T2 second; /// @c second is a copy of the second object
#pragma empty_line
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 265. std::pair::pair() effects overly restrictive
/** The default constructor creates @c first and @c second using their
* respective default constructors. */
pair()
: first(), second() { }
#pragma empty_line
/** Two objects may be passed to a @c pair constructor to be copied. */
pair(const _T1& __a, const _T2& __b)
: first(__a), second(__b) { }
#pragma empty_line
/** There is also a templated copy ctor for the @c pair class itself. */
template<class _U1, class _U2>
pair(const pair<_U1, _U2>& __p)
: first(__p.first), second(__p.second) { }
#pragma line 196 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_pair.h" 3
};
#pragma empty_line
/// Two pairs of the same type are equal iff their members are equal.
template<class _T1, class _T2>
inline bool
operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return __x.first == __y.first && __x.second == __y.second; }
#pragma empty_line
/// <http://gcc.gnu.org/onlinedocs/libstdc++/manual/utilities.html>
template<class _T1, class _T2>
inline 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
/// Uses @c operator== to find the result.
template<class _T1, class _T2>
inline bool
operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return !(__x == __y); }
#pragma empty_line
/// Uses @c operator< to find the result.
template<class _T1, class _T2>
inline bool
operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return __y < __x; }
#pragma empty_line
/// Uses @c operator< to find the result.
template<class _T1, class _T2>
inline bool
operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return !(__y < __x); }
#pragma empty_line
/// Uses @c operator< to find the result.
template<class _T1, class _T2>
inline bool
operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return !(__x < __y); }
#pragma line 245 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_pair.h" 3
/**
* @brief A convenience wrapper for creating a pair from two objects.
* @param x The first object.
* @param y The second object.
* @return A newly-constructed pair<> object of the appropriate type.
*
* The standard requires that the objects be passed by reference-to-const,
* but LWG issue #181 says they should be passed by const value. We follow
* the LWG by default.
*/
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 181. make_pair() unintended behavior
#pragma line 270 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_pair.h" 3
template<class _T1, class _T2>
inline pair<_T1, _T2>
make_pair(_T1 __x, _T2 __y)
{ return pair<_T1, _T2>(__x, __y); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
} // namespace
#pragma line 66 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_algobase.h" 2 3
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_iterator_base_types.h" 1 3
// Types used in iterator implementation -*- C++ -*-
#pragma empty_line
// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1996-1998
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*/
#pragma empty_line
/** @file bits/stl_iterator_base_types.h
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{iterator}
*
* This file contains all of the general iterator-related utility types,
* such as iterator_traits and struct iterator.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 63 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/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 empty_line
/**
* @defgroup iterators Iterators
* Abstractions for uniform iterating through various underlying types.
*/
//@{
#pragma empty_line
/**
* @defgroup iterator_tags Iterator Tags
* These are empty types, used to distinguish different iterators. The
* distinction is not made by what they contain, but simply by what they
* are. Different underlying algorithms can then be used based on the
* different operations supported by different iterator types.
*/
//@{
/// Marking input iterators.
struct input_iterator_tag { };
#pragma empty_line
/// Marking output iterators.
struct output_iterator_tag { };
#pragma empty_line
/// Forward iterators support a superset of input iterator operations.
struct forward_iterator_tag : public input_iterator_tag { };
#pragma empty_line
/// Bidirectional iterators support a superset of forward iterator
/// operations.
struct bidirectional_iterator_tag : public forward_iterator_tag { };
#pragma empty_line
/// Random-access iterators support a superset of bidirectional
/// iterator operations.
struct random_access_iterator_tag : public bidirectional_iterator_tag { };
//@}
#pragma empty_line
/**
* @brief Common %iterator class.
*
* This class does nothing but define nested typedefs. %Iterator classes
* can inherit from this class to save some work. The typedefs are then
* used in specializations and overloading.
*
* In particular, there are no default implementations of requirements
* such as @c operator++ and the like. (How could there be?)
*/
template<typename _Category, typename _Tp, typename _Distance = ptrdiff_t,
typename _Pointer = _Tp*, typename _Reference = _Tp&>
struct iterator
{
/// One of the @link iterator_tags tag types@endlink.
typedef _Category iterator_category;
/// The type "pointed to" by the iterator.
typedef _Tp value_type;
/// Distance between iterators is represented as this type.
typedef _Distance difference_type;
/// This type represents a pointer-to-value_type.
typedef _Pointer pointer;
/// This type represents a reference-to-value_type.
typedef _Reference reference;
};
#pragma empty_line
/**
* @brief Traits class for iterators.
*
* This class does nothing but define nested typedefs. The general
* version simply @a forwards the nested typedefs from the Iterator
* argument. Specialized versions for pointers and pointers-to-const
* provide tighter, more correct semantics.
*/
#pragma line 162 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_iterator_base_types.h" 3
template<typename _Iterator>
struct iterator_traits
{
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
#pragma empty_line
/// Partial specialization for pointer types.
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
/// Partial specialization for const pointer types.
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
/**
* This function is not a part of the C++ standard but is syntactic
* sugar for internal library use only.
*/
template<typename _Iter>
inline typename iterator_traits<_Iter>::iterator_category
__iterator_category(const _Iter&)
{ return typename iterator_traits<_Iter>::iterator_category(); }
#pragma empty_line
//@}
#pragma empty_line
// If _Iterator has a base returns it otherwise _Iterator is returned
// untouched
template<typename _Iterator, bool _HasBase>
struct _Iter_base
{
typedef _Iterator iterator_type;
static iterator_type _S_base(_Iterator __it)
{ return __it; }
};
#pragma empty_line
template<typename _Iterator>
struct _Iter_base<_Iterator, true>
{
typedef typename _Iterator::iterator_type iterator_type;
static iterator_type _S_base(_Iterator __it)
{ return __it.base(); }
};
#pragma empty_line
#pragma empty_line
} // namespace
#pragma line 67 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_algobase.h" 2 3
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_iterator_base_funcs.h" 1 3
// Functions used by iterators -*- C++ -*-
#pragma empty_line
// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1996-1998
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*/
#pragma empty_line
/** @file bits/stl_iterator_base_funcs.h
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{iterator}
*
* This file contains all of the general iterator-related utility
* functions, such as distance() and advance().
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 63 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_iterator_base_funcs.h" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
template<typename _InputIterator>
inline typename iterator_traits<_InputIterator>::difference_type
__distance(_InputIterator __first, _InputIterator __last,
input_iterator_tag)
{
// concept requirements
#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)
{
// concept requirements
#pragma empty_line
#pragma empty_line
return __last - __first;
}
#pragma empty_line
/**
* @brief A generalization of pointer arithmetic.
* @param first An input iterator.
* @param last An input iterator.
* @return The distance between them.
*
* Returns @c n such that first + n == last. This requires that @p last
* must be reachable from @p first. Note that @c n may be negative.
*
* For random access iterators, this uses their @c + and @c - operations
* and are constant time. For other %iterator classes they are linear time.
*/
template<typename _InputIterator>
inline typename iterator_traits<_InputIterator>::difference_type
distance(_InputIterator __first, _InputIterator __last)
{
// concept requirements -- taken care of in __distance
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)
{
// concept requirements
#pragma empty_line
while (__n--)
++__i;
}
#pragma empty_line
template<typename _BidirectionalIterator, typename _Distance>
inline void
__advance(_BidirectionalIterator& __i, _Distance __n,
bidirectional_iterator_tag)
{
// concept requirements
#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)
{
// concept requirements
#pragma empty_line
#pragma empty_line
__i += __n;
}
#pragma empty_line
/**
* @brief A generalization of pointer arithmetic.
* @param i An input iterator.
* @param n The @a delta by which to change @p i.
* @return Nothing.
*
* This increments @p i by @p n. For bidirectional and random access
* iterators, @p n may be negative, in which case @p i is decremented.
*
* For random access iterators, this uses their @c + and @c - operations
* and are constant time. For other %iterator classes they are linear time.
*/
template<typename _InputIterator, typename _Distance>
inline void
advance(_InputIterator& __i, _Distance __n)
{
// concept requirements -- taken care of in __advance
typename iterator_traits<_InputIterator>::difference_type __d = __n;
std::__advance(__i, __d, std::__iterator_category(__i));
}
#pragma line 200 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_iterator_base_funcs.h" 3
} // namespace
#pragma line 68 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_algobase.h" 2 3
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_iterator.h" 1 3
// Iterators -*- C++ -*-
#pragma empty_line
// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1996-1998
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*/
#pragma empty_line
/** @file bits/stl_iterator.h
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{iterator}
*
* This file implements reverse_iterator, back_insert_iterator,
* front_insert_iterator, insert_iterator, __normal_iterator, and their
* supporting functions and overloaded operators.
*/
#pragma line 68 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_iterator.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
/**
* @addtogroup iterators
* @{
*/
#pragma empty_line
// 24.4.1 Reverse iterators
/**
* Bidirectional and random access iterators have corresponding reverse
* %iterator adaptors that iterate through the data structure in the
* opposite direction. They have the same signatures as the corresponding
* iterators. The fundamental relation between a reverse %iterator and its
* corresponding %iterator @c i is established by the identity:
* @code
* &*(reverse_iterator(i)) == &*(i - 1)
* @endcode
*
* <em>This mapping is dictated by the fact that while there is always a
* pointer past the end of an array, there might not be a valid pointer
* before the beginning of an array.</em> [24.4.1]/1,2
*
* Reverse iterators can be tricky and surprising at first. Their
* semantics make sense, however, and the trickiness is a side effect of
* the requirement that the iterators must be safe.
*/
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
/**
* The default constructor default-initializes member @p current.
* If it is a pointer, that means it is zero-initialized.
*/
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 235 No specification of default ctor for reverse_iterator
reverse_iterator() : current() { }
#pragma empty_line
/**
* This %iterator will move in the opposite direction that @p x does.
*/
explicit
reverse_iterator(iterator_type __x) : current(__x) { }
#pragma empty_line
/**
* The copy constructor is normal.
*/
reverse_iterator(const reverse_iterator& __x)
: current(__x.current) { }
#pragma empty_line
/**
* A reverse_iterator across other types can be copied in the normal
* fashion.
*/
template<typename _Iter>
reverse_iterator(const reverse_iterator<_Iter>& __x)
: current(__x.base()) { }
#pragma empty_line
/**
* @return @c current, the %iterator used for underlying work.
*/
iterator_type
base() const
{ return current; }
#pragma empty_line
/**
* @return TODO
*
* @doctodo
*/
reference
operator*() const
{
_Iterator __tmp = current;
return *--__tmp;
}
#pragma empty_line
/**
* @return TODO
*
* @doctodo
*/
pointer
operator->() const
{ return &(operator*()); }
#pragma empty_line
/**
* @return TODO
*
* @doctodo
*/
reverse_iterator&
operator++()
{
--current;
return *this;
}
#pragma empty_line
/**
* @return TODO
*
* @doctodo
*/
reverse_iterator
operator++(int)
{
reverse_iterator __tmp = *this;
--current;
return __tmp;
}
#pragma empty_line
/**
* @return TODO
*
* @doctodo
*/
reverse_iterator&
operator--()
{
++current;
return *this;
}
#pragma empty_line
/**
* @return TODO
*
* @doctodo
*/
reverse_iterator
operator--(int)
{
reverse_iterator __tmp = *this;
++current;
return __tmp;
}
#pragma empty_line
/**
* @return TODO
*
* @doctodo
*/
reverse_iterator
operator+(difference_type __n) const
{ return reverse_iterator(current - __n); }
#pragma empty_line
/**
* @return TODO
*
* @doctodo
*/
reverse_iterator&
operator+=(difference_type __n)
{
current -= __n;
return *this;
}
#pragma empty_line
/**
* @return TODO
*
* @doctodo
*/
reverse_iterator
operator-(difference_type __n) const
{ return reverse_iterator(current + __n); }
#pragma empty_line
/**
* @return TODO
*
* @doctodo
*/
reverse_iterator&
operator-=(difference_type __n)
{
current += __n;
return *this;
}
#pragma empty_line
/**
* @return TODO
*
* @doctodo
*/
reference
operator[](difference_type __n) const
{ return *(*this + __n); }
};
#pragma empty_line
//@{
/**
* @param x A %reverse_iterator.
* @param y A %reverse_iterator.
* @return A simple bool.
*
* Reverse iterators forward many operations to their underlying base()
* iterators. Others are implemented in terms of one another.
*
*/
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
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 280. Comparison of reverse_iterator to const reverse_iterator.
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
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline typename reverse_iterator<_IteratorL>::difference_type
operator-(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
#pragma empty_line
{ return __y.base() - __x.base(); }
//@}
#pragma empty_line
// 24.4.2.2.1 back_insert_iterator
/**
* @brief Turns assignment into insertion.
*
* These are output iterators, constructed from a container-of-T.
* Assigning a T to the iterator appends it to the container using
* push_back.
*
* Tip: Using the back_inserter function to create these iterators can
* save typing.
*/
template<typename _Container>
class back_insert_iterator
: public iterator<output_iterator_tag, void, void, void, void>
{
protected:
_Container* container;
#pragma empty_line
public:
/// A nested typedef for the type of whatever container you used.
typedef _Container container_type;
#pragma empty_line
/// The only way to create this %iterator is with a container.
explicit
back_insert_iterator(_Container& __x) : container(&__x) { }
#pragma empty_line
/**
* @param value An instance of whatever type
* container_type::const_reference is; presumably a
* reference-to-const T for container<T>.
* @return This %iterator, for chained operations.
*
* This kind of %iterator doesn't really have a @a position in the
* container (you can think of the position as being permanently at
* the end, if you like). Assigning a value to the %iterator will
* always append the value to the end of the container.
*/
#pragma empty_line
back_insert_iterator&
operator=(typename _Container::const_reference __value)
{
container->push_back(__value);
return *this;
}
#pragma line 444 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_iterator.h" 3
/// Simply returns *this.
back_insert_iterator&
operator*()
{ return *this; }
#pragma empty_line
/// Simply returns *this. (This %iterator does not @a move.)
back_insert_iterator&
operator++()
{ return *this; }
#pragma empty_line
/// Simply returns *this. (This %iterator does not @a move.)
back_insert_iterator
operator++(int)
{ return *this; }
};
#pragma empty_line
/**
* @param x A container of arbitrary type.
* @return An instance of back_insert_iterator working on @p x.
*
* This wrapper function helps in creating back_insert_iterator instances.
* Typing the name of the %iterator requires knowing the precise full
* type of the container, which can be tedious and impedes generic
* programming. Using this function lets you take advantage of automatic
* template parameter deduction, making the compiler match the correct
* types for you.
*/
template<typename _Container>
inline back_insert_iterator<_Container>
back_inserter(_Container& __x)
{ return back_insert_iterator<_Container>(__x); }
#pragma empty_line
/**
* @brief Turns assignment into insertion.
*
* These are output iterators, constructed from a container-of-T.
* Assigning a T to the iterator prepends it to the container using
* push_front.
*
* Tip: Using the front_inserter function to create these iterators can
* save typing.
*/
template<typename _Container>
class front_insert_iterator
: public iterator<output_iterator_tag, void, void, void, void>
{
protected:
_Container* container;
#pragma empty_line
public:
/// A nested typedef for the type of whatever container you used.
typedef _Container container_type;
#pragma empty_line
/// The only way to create this %iterator is with a container.
explicit front_insert_iterator(_Container& __x) : container(&__x) { }
#pragma empty_line
/**
* @param value An instance of whatever type
* container_type::const_reference is; presumably a
* reference-to-const T for container<T>.
* @return This %iterator, for chained operations.
*
* This kind of %iterator doesn't really have a @a position in the
* container (you can think of the position as being permanently at
* the front, if you like). Assigning a value to the %iterator will
* always prepend the value to the front of the container.
*/
#pragma empty_line
front_insert_iterator&
operator=(typename _Container::const_reference __value)
{
container->push_front(__value);
return *this;
}
#pragma line 534 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_iterator.h" 3
/// Simply returns *this.
front_insert_iterator&
operator*()
{ return *this; }
#pragma empty_line
/// Simply returns *this. (This %iterator does not @a move.)
front_insert_iterator&
operator++()
{ return *this; }
#pragma empty_line
/// Simply returns *this. (This %iterator does not @a move.)
front_insert_iterator
operator++(int)
{ return *this; }
};
#pragma empty_line
/**
* @param x A container of arbitrary type.
* @return An instance of front_insert_iterator working on @p x.
*
* This wrapper function helps in creating front_insert_iterator instances.
* Typing the name of the %iterator requires knowing the precise full
* type of the container, which can be tedious and impedes generic
* programming. Using this function lets you take advantage of automatic
* template parameter deduction, making the compiler match the correct
* types for you.
*/
template<typename _Container>
inline front_insert_iterator<_Container>
front_inserter(_Container& __x)
{ return front_insert_iterator<_Container>(__x); }
#pragma empty_line
/**
* @brief Turns assignment into insertion.
*
* These are output iterators, constructed from a container-of-T.
* Assigning a T to the iterator inserts it in the container at the
* %iterator's position, rather than overwriting the value at that
* position.
*
* (Sequences will actually insert a @e copy of the value before the
* %iterator's position.)
*
* Tip: Using the inserter function to create these iterators can
* save typing.
*/
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:
/// A nested typedef for the type of whatever container you used.
typedef _Container container_type;
#pragma empty_line
/**
* The only way to create this %iterator is with a container and an
* initial position (a normal %iterator into the container).
*/
insert_iterator(_Container& __x, typename _Container::iterator __i)
: container(&__x), iter(__i) {}
#pragma empty_line
/**
* @param value An instance of whatever type
* container_type::const_reference is; presumably a
* reference-to-const T for container<T>.
* @return This %iterator, for chained operations.
*
* This kind of %iterator maintains its own position in the
* container. Assigning a value to the %iterator will insert the
* value into the container at the place before the %iterator.
*
* The position is maintained such that subsequent assignments will
* insert values immediately after one another. For example,
* @code
* // vector v contains A and Z
*
* insert_iterator i (v, ++v.begin());
* i = 1;
* i = 2;
* i = 3;
*
* // vector v contains A, 1, 2, 3, and Z
* @endcode
*/
#pragma empty_line
insert_iterator&
operator=(typename _Container::const_reference __value)
{
iter = container->insert(iter, __value);
++iter;
return *this;
}
#pragma line 648 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_iterator.h" 3
/// Simply returns *this.
insert_iterator&
operator*()
{ return *this; }
#pragma empty_line
/// Simply returns *this. (This %iterator does not @a move.)
insert_iterator&
operator++()
{ return *this; }
#pragma empty_line
/// Simply returns *this. (This %iterator does not @a move.)
insert_iterator&
operator++(int)
{ return *this; }
};
#pragma empty_line
/**
* @param x A container of arbitrary type.
* @return An instance of insert_iterator working on @p x.
*
* This wrapper function helps in creating insert_iterator instances.
* Typing the name of the %iterator requires knowing the precise full
* type of the container, which can be tedious and impedes generic
* programming. Using this function lets you take advantage of automatic
* template parameter deduction, making the compiler match the correct
* types for you.
*/
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
// @} group iterators
#pragma empty_line
#pragma empty_line
} // namespace
#pragma empty_line
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
// This iterator adapter is @a normal in the sense that it does not
// change the semantics of any of the operators of its iterator
// parameter. Its primary purpose is to convert an iterator that is
// not a class, e.g. a pointer, into an iterator that is a class.
// The _Container parameter exists solely so that different containers
// using this template can instantiate different types, even if the
// _Iterator parameter is the same.
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
__normal_iterator() : _M_current(_Iterator()) { }
#pragma empty_line
explicit
__normal_iterator(const _Iterator& __i) : _M_current(__i) { }
#pragma empty_line
// Allow iterator to const_iterator conversion
template<typename _Iter>
__normal_iterator(const __normal_iterator<_Iter,
typename __enable_if<
(std::__are_same<_Iter, typename _Container::pointer>::__value),
_Container>::__type>& __i)
: _M_current(__i.base()) { }
#pragma empty_line
// Forward iterator requirements
reference
operator*() const
{ return *_M_current; }
#pragma empty_line
pointer
operator->() const
{ return _M_current; }
#pragma empty_line
__normal_iterator&
operator++()
{
++_M_current;
return *this;
}
#pragma empty_line
__normal_iterator
operator++(int)
{ return __normal_iterator(_M_current++); }
#pragma empty_line
// Bidirectional iterator requirements
__normal_iterator&
operator--()
{
--_M_current;
return *this;
}
#pragma empty_line
__normal_iterator
operator--(int)
{ return __normal_iterator(_M_current--); }
#pragma empty_line
// Random access iterator requirements
reference
operator[](const difference_type& __n) const
{ return _M_current[__n]; }
#pragma empty_line
__normal_iterator&
operator+=(const difference_type& __n)
{ _M_current += __n; return *this; }
#pragma empty_line
__normal_iterator
operator+(const difference_type& __n) const
{ return __normal_iterator(_M_current + __n); }
#pragma empty_line
__normal_iterator&
operator-=(const difference_type& __n)
{ _M_current -= __n; return *this; }
#pragma empty_line
__normal_iterator
operator-(const difference_type& __n) const
{ return __normal_iterator(_M_current - __n); }
#pragma empty_line
const _Iterator&
base() const
{ return _M_current; }
};
#pragma empty_line
// Note: In what follows, the left- and right-hand-side iterators are
// allowed to vary in types (conceptually in cv-qualification) so that
// comparison between cv-qualified and non-cv-qualified iterators be
// valid. However, the greedy and unfriendly operators in std::rel_ops
// will make overload resolution ambiguous (when in scope) if we don't
// provide overloads whose operands are of the same type. Can someone
// remind me what generic programming is about? -- Gaby
#pragma empty_line
// Forward iterator requirements
template<typename _IteratorL, typename _IteratorR, typename _Container>
inline bool
operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs)
{ 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)
{ 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)
{ 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)
{ return __lhs.base() != __rhs.base(); }
#pragma empty_line
// Random access iterator requirements
template<typename _IteratorL, typename _IteratorR, typename _Container>
inline bool
operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs)
{ 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)
{ 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)
{ 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)
{ 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)
{ 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)
{ 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)
{ 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)
{ return __lhs.base() >= __rhs.base(); }
#pragma empty_line
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// According to the resolution of DR179 not only the various comparison
// operators but also operator- must accept mixed iterator/const_iterator
// parameters.
template<typename _IteratorL, typename _IteratorR, typename _Container>
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline typename __normal_iterator<_IteratorL, _Container>::difference_type
operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs)
#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)
{ 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)
{ return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
#pragma empty_line
#pragma empty_line
} // namespace
#pragma line 69 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_algobase.h" 2 3
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/debug/debug.h" 1 3
// Debugging support implementation -*- C++ -*-
#pragma empty_line
// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file debug/debug.h
* This file is a GNU debug extension to the Standard C++ Library.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/** Macros and namespaces used by the implementation outside of debug
* wrappers to verify certain properties. The __glibcxx_requires_xxx
* macros are merely wrappers around the __glibcxx_check_xxx wrappers
* when we are compiling with debug mode, but disappear when we are
* in release mode so that there is no checking performed in, e.g.,
* the standard library algorithms.
*/
#pragma empty_line
// Debug mode namespaces.
#pragma empty_line
/**
* @namespace std::__debug
* @brief GNU debug code, replaces standard behavior with debug behavior.
*/
namespace std
{
namespace __debug { }
}
#pragma empty_line
/** @namespace __gnu_debug
* @brief GNU debug classes for public use.
*/
namespace __gnu_debug
{
using namespace std::__debug;
}
#pragma line 71 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_algobase.h" 2 3
#pragma empty_line
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
// See http://gcc.gnu.org/ml/libstdc++/2004-08/msg00167.html: in a
// nutshell, we are partially implementing the resolution of DR 187,
// when it's safe, i.e., the value_types are equal.
template<bool _BoolType>
struct __iter_swap
{
template<typename _ForwardIterator1, typename _ForwardIterator2>
static void
iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
{
typedef typename iterator_traits<_ForwardIterator1>::value_type
_ValueType1;
_ValueType1 __tmp = (*__a);
*__a = (*__b);
*__b = (__tmp);
}
};
#pragma empty_line
template<>
struct __iter_swap<true>
{
template<typename _ForwardIterator1, typename _ForwardIterator2>
static void
iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
{
swap(*__a, *__b);
}
};
#pragma empty_line
/**
* @brief Swaps the contents of two iterators.
* @ingroup mutating_algorithms
* @param a An iterator.
* @param b Another iterator.
* @return Nothing.
*
* This function swaps the values pointed to by two iterators, not the
* iterators themselves.
*/
template<typename _ForwardIterator1, typename _ForwardIterator2>
inline void
iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
{
typedef typename iterator_traits<_ForwardIterator1>::value_type
_ValueType1;
typedef typename iterator_traits<_ForwardIterator2>::value_type
_ValueType2;
#pragma empty_line
// concept requirements
#pragma line 135 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_algobase.h" 3
typedef typename iterator_traits<_ForwardIterator1>::reference
_ReferenceType1;
typedef typename iterator_traits<_ForwardIterator2>::reference
_ReferenceType2;
std::__iter_swap<__are_same<_ValueType1, _ValueType2>::__value
&& __are_same<_ValueType1&, _ReferenceType1>::__value
&& __are_same<_ValueType2&, _ReferenceType2>::__value>::
iter_swap(__a, __b);
}
#pragma empty_line
/**
* @brief Swap the elements of two sequences.
* @ingroup mutating_algorithms
* @param first1 A forward iterator.
* @param last1 A forward iterator.
* @param first2 A forward iterator.
* @return An iterator equal to @p first2+(last1-first1).
*
* Swaps each element in the range @p [first1,last1) with the
* corresponding element in the range @p [first2,(last1-first1)).
* The ranges must not overlap.
*/
template<typename _ForwardIterator1, typename _ForwardIterator2>
_ForwardIterator2
swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2)
{
// concept requirements
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
for (; __first1 != __last1; ++__first1, ++__first2)
std::iter_swap(__first1, __first2);
return __first2;
}
#pragma empty_line
/**
* @brief This does what you think it does.
* @ingroup sorting_algorithms
* @param a A thing of arbitrary type.
* @param b Another thing of arbitrary type.
* @return The lesser of the parameters.
*
* This is the simple classic generic implementation. It will work on
* temporary expressions, since they are only evaluated once, unlike a
* preprocessor macro.
*/
template<typename _Tp>
inline const _Tp&
min(const _Tp& __a, const _Tp& __b)
{
// concept requirements
#pragma empty_line
//return __b < __a ? __b : __a;
if (__b < __a)
return __b;
return __a;
}
#pragma empty_line
/**
* @brief This does what you think it does.
* @ingroup sorting_algorithms
* @param a A thing of arbitrary type.
* @param b Another thing of arbitrary type.
* @return The greater of the parameters.
*
* This is the simple classic generic implementation. It will work on
* temporary expressions, since they are only evaluated once, unlike a
* preprocessor macro.
*/
template<typename _Tp>
inline const _Tp&
max(const _Tp& __a, const _Tp& __b)
{
// concept requirements
#pragma empty_line
//return __a < __b ? __b : __a;
if (__a < __b)
return __b;
return __a;
}
#pragma empty_line
/**
* @brief This does what you think it does.
* @ingroup sorting_algorithms
* @param a A thing of arbitrary type.
* @param b Another thing of arbitrary type.
* @param comp A @link comparison_functors comparison functor@endlink.
* @return The lesser of the parameters.
*
* This will work on temporary expressions, since they are only evaluated
* once, unlike a preprocessor macro.
*/
template<typename _Tp, typename _Compare>
inline const _Tp&
min(const _Tp& __a, const _Tp& __b, _Compare __comp)
{
//return __comp(__b, __a) ? __b : __a;
if (__comp(__b, __a))
return __b;
return __a;
}
#pragma empty_line
/**
* @brief This does what you think it does.
* @ingroup sorting_algorithms
* @param a A thing of arbitrary type.
* @param b Another thing of arbitrary type.
* @param comp A @link comparison_functors comparison functor@endlink.
* @return The greater of the parameters.
*
* This will work on temporary expressions, since they are only evaluated
* once, unlike a preprocessor macro.
*/
template<typename _Tp, typename _Compare>
inline const _Tp&
max(const _Tp& __a, const _Tp& __b, _Compare __comp)
{
//return __comp(__a, __b) ? __b : __a;
if (__comp(__a, __b))
return __b;
return __a;
}
#pragma empty_line
// If _Iterator is a __normal_iterator return its base (a plain pointer,
// normally) otherwise return it untouched. See copy, fill, ...
template<typename _Iterator>
struct _Niter_base
: _Iter_base<_Iterator, __is_normal_iterator<_Iterator>::__value>
{ };
#pragma empty_line
template<typename _Iterator>
inline typename _Niter_base<_Iterator>::iterator_type
__niter_base(_Iterator __it)
{ return std::_Niter_base<_Iterator>::_S_base(__it); }
#pragma empty_line
// Likewise, for move_iterator.
template<typename _Iterator>
struct _Miter_base
: _Iter_base<_Iterator, __is_move_iterator<_Iterator>::__value>
{ };
#pragma empty_line
template<typename _Iterator>
inline typename _Miter_base<_Iterator>::iterator_type
__miter_base(_Iterator __it)
{ return std::_Miter_base<_Iterator>::_S_base(__it); }
#pragma empty_line
// All of these auxiliary structs serve two purposes. (1) Replace
// calls to copy with memmove whenever possible. (Memmove, not memcpy,
// because the input and output ranges are permitted to overlap.)
// (2) If we're using random access iterators, then write the loop as
// a for loop with an explicit count.
#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, ++__first)
*__result = *__first;
return __result;
}
};
#pragma line 319 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_algobase.h" 3
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 line 357 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_algobase.h" 3
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)
{
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
// Helpers for streambuf iterators (either istream or ostream).
// NB: avoid including <iosfwd>, relatively large.
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 empty_line
/**
* @brief Copies the range [first,last) into result.
* @ingroup mutating_algorithms
* @param first An input iterator.
* @param last An input iterator.
* @param result An output iterator.
* @return result + (first - last)
*
* This inline function will boil down to a call to @c memmove whenever
* possible. Failing that, if random access iterators are passed, then the
* loop count will be known (and therefore a candidate for compiler
* optimizations such as unrolling). Result may not be contained within
* [first,last); the copy_backward function should be used instead.
*
* Note that the end of the output range is permitted to be contained
* within [first,last).
*/
template<typename _II, typename _OI>
inline _OI
copy(_II __first, _II __last, _OI __result)
{
// concept requirements
#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 494 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_algobase.h" 3
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 line 522 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_algobase.h" 3
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 line 552 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_algobase.h" 3
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)
{
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 empty_line
/**
* @brief Copies the range [first,last) into result.
* @ingroup mutating_algorithms
* @param first A bidirectional iterator.
* @param last A bidirectional iterator.
* @param result A bidirectional iterator.
* @return result - (first - last)
*
* The function has the same effect as copy, but starts at the end of the
* range and works its way to the start, returning the start of the result.
* This inline function will boil down to a call to @c memmove whenever
* possible. Failing that, if random access iterators are passed, then the
* loop count will be known (and therefore a candidate for compiler
* optimizations such as unrolling).
*
* Result may not be in the range [first,last). Use copy instead. Note
* that the start of the output range may overlap [first,last).
*/
template<typename _BI1, typename _BI2>
inline _BI2
copy_backward(_BI1 __first, _BI1 __last, _BI2 __result)
{
// concept requirements
#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 669 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_algobase.h" 3
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
// Specialization: for char types we can use memset.
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;
__builtin_memset(__first, static_cast<unsigned char>(__tmp),
__last - __first);
}
#pragma empty_line
/**
* @brief Fills the range [first,last) with copies of value.
* @ingroup mutating_algorithms
* @param first A forward iterator.
* @param last A forward iterator.
* @param value A reference-to-const of arbitrary type.
* @return Nothing.
*
* This function fills a range with copies of the same value. For char
* types filling contiguous areas of memory, this becomes an inline call
* to @c memset or @c wmemset.
*/
template<typename _ForwardIterator, typename _Tp>
inline void
fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
{
// concept requirements
#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 empty_line
/**
* @brief Fills the range [first,first+n) with copies of value.
* @ingroup mutating_algorithms
* @param first An output iterator.
* @param n The count of copies to perform.
* @param value A reference-to-const of arbitrary type.
* @return The iterator at first+n.
*
* This function fills a range with copies of the same value. For char
* types filling contiguous areas of memory, this becomes an inline call
* to @c memset or @ wmemset.
*
* _GLIBCXX_RESOLVE_LIB_DEFECTS
* DR 865. More algorithms that throw away information
*/
template<typename _OI, typename _Size, typename _Tp>
inline _OI
fill_n(_OI __first, _Size __n, const _Tp& __value)
{
// concept requirements
#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, ++__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)
{
return !__builtin_memcmp(__first1, __first2, sizeof(_Tp)
* (__last1 - __first1));
}
};
#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<_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
#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<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)
{
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, ++__first2)
{
if (*__first1 < *__first2)
return true;
if (*__first2 < *__first1)
return false;
}
return __first1 == __last1 && __first2 != __last2;
}
#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;
const int __result = __builtin_memcmp(__first1, __first2,
std::min(__len1, __len2));
return __result != 0 ? __result < 0 : __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
/**
* @brief Finds the first position in which @a val could be inserted
* without changing the ordering.
* @param first An iterator.
* @param last Another iterator.
* @param val The search term.
* @return An iterator pointing to the first element <em>not less
* than</em> @a val, or end() if every element is less than
* @a val.
* @ingroup binary_search_algorithms
*/
template<typename _ForwardIterator, typename _Tp>
_ForwardIterator
lower_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val)
{
typedef typename iterator_traits<_ForwardIterator>::value_type
_ValueType;
typedef typename iterator_traits<_ForwardIterator>::difference_type
_DistanceType;
#pragma empty_line
// concept requirements
#pragma empty_line
#pragma empty_line
;
#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 (*__middle < __val)
{
__first = __middle;
++__first;
__len = __len - __half - 1;
}
else
__len = __half;
}
return __first;
}
#pragma empty_line
/// This is a helper function for the sort routines and for random.tcc.
// Precondition: __n > 0.
template<typename _Size>
inline _Size
__lg(_Size __n)
{
_Size __k;
for (__k = 0; __n != 0; __n >>= 1)
++__k;
return __k - 1;
}
#pragma empty_line
inline int
__lg(int __n)
{ return sizeof(int) * 8 - 1 - __builtin_clz(__n); }
#pragma empty_line
inline long
__lg(long __n)
{ return sizeof(long) * 8 - 1 - __builtin_clzl(__n); }
#pragma empty_line
inline long long
__lg(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 empty_line
/**
* @brief Tests a range for element-wise equality.
* @ingroup non_mutating_algorithms
* @param first1 An input iterator.
* @param last1 An input iterator.
* @param first2 An input iterator.
* @return A boolean true or false.
*
* This compares the elements of two ranges using @c == and returns true or
* false depending on whether all of the corresponding elements of the
* ranges are equal.
*/
template<typename _II1, typename _II2>
inline bool
equal(_II1 __first1, _II1 __last1, _II2 __first2)
{
// concept requirements
#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 empty_line
/**
* @brief Tests a range for element-wise equality.
* @ingroup non_mutating_algorithms
* @param first1 An input iterator.
* @param last1 An input iterator.
* @param first2 An input iterator.
* @param binary_pred A binary predicate @link functors
* functor@endlink.
* @return A boolean true or false.
*
* This compares the elements of two ranges using the binary_pred
* parameter, and returns true or
* false depending on whether all of the corresponding elements of the
* ranges are equal.
*/
template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
inline bool
equal(_IIter1 __first1, _IIter1 __last1,
_IIter2 __first2, _BinaryPredicate __binary_pred)
{
// concept requirements
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
for (; __first1 != __last1; ++__first1, ++__first2)
if (!bool(__binary_pred(*__first1, *__first2)))
return false;
return true;
}
#pragma empty_line
/**
* @brief Performs @b dictionary comparison on ranges.
* @ingroup sorting_algorithms
* @param first1 An input iterator.
* @param last1 An input iterator.
* @param first2 An input iterator.
* @param last2 An input iterator.
* @return A boolean true or false.
*
* <em>Returns true if the sequence of elements defined by the range
* [first1,last1) is lexicographically less than the sequence of elements
* defined by the range [first2,last2). Returns false otherwise.</em>
* (Quoted from [25.3.8]/1.) If the iterators are all character pointers,
* then this is an inline call to @c memcmp.
*/
template<typename _II1, typename _II2>
inline bool
lexicographical_compare(_II1 __first1, _II1 __last1,
_II2 __first2, _II2 __last2)
{
// concept requirements
typedef typename iterator_traits<_II1>::value_type _ValueType1;
typedef typename iterator_traits<_II2>::value_type _ValueType2;
#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 empty_line
/**
* @brief Performs @b dictionary comparison on ranges.
* @ingroup sorting_algorithms
* @param first1 An input iterator.
* @param last1 An input iterator.
* @param first2 An input iterator.
* @param last2 An input iterator.
* @param comp A @link comparison_functors comparison functor@endlink.
* @return A boolean true or false.
*
* The same as the four-parameter @c lexicographical_compare, but uses the
* comp parameter instead of @c <.
*/
template<typename _II1, typename _II2, typename _Compare>
bool
lexicographical_compare(_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
// concept requirements
#pragma empty_line
#pragma empty_line
;
;
#pragma empty_line
__last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2);
for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2);
++__first1, ++__first2)
{
if (__comp(*__first1, *__first2))
return true;
if (__comp(*__first2, *__first1))
return false;
}
return __first1 == __last1 && __first2 != __last2;
}
#pragma empty_line
/**
* @brief Finds the places in ranges which don't match.
* @ingroup non_mutating_algorithms
* @param first1 An input iterator.
* @param last1 An input iterator.
* @param first2 An input iterator.
* @return A pair of iterators pointing to the first mismatch.
*
* This compares the elements of two ranges using @c == and returns a pair
* of iterators. The first iterator points into the first range, the
* second iterator points into the second range, and the elements pointed
* to by the iterators are not equal.
*/
template<typename _InputIterator1, typename _InputIterator2>
pair<_InputIterator1, _InputIterator2>
mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2)
{
// concept requirements
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
while (__first1 != __last1 && *__first1 == *__first2)
{
++__first1;
++__first2;
}
return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
}
#pragma empty_line
/**
* @brief Finds the places in ranges which don't match.
* @ingroup non_mutating_algorithms
* @param first1 An input iterator.
* @param last1 An input iterator.
* @param first2 An input iterator.
* @param binary_pred A binary predicate @link functors
* functor@endlink.
* @return A pair of iterators pointing to the first mismatch.
*
* This compares the elements of two ranges using the binary_pred
* parameter, and returns a pair
* of iterators. The first iterator points into the first range, the
* second iterator points into the second range, and the elements pointed
* to by the iterators are not equal.
*/
template<typename _InputIterator1, typename _InputIterator2,
typename _BinaryPredicate>
pair<_InputIterator1, _InputIterator2>
mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _BinaryPredicate __binary_pred)
{
// concept requirements
#pragma empty_line
#pragma empty_line
;
#pragma empty_line
while (__first1 != __last1 && bool(__binary_pred(*__first1, *__first2)))
{
++__first1;
++__first2;
}
return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
}
#pragma empty_line
#pragma empty_line
} // namespace std
#pragma empty_line
// NB: This file is included within many other C++ includes, as a way
// of getting the base algorithms. So, make sure that parallel bits
// come in too if requested.
#pragma line 41 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/char_traits.h" 2 3
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cwchar" 1 3
// -*- C++ -*- forwarding header.
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file include/cwchar
* This is a Standard C++ Library file. You should @c \#include this file
* in your programs, rather than any of the @a *.h implementation files.
*
* This is the C++ version of the Standard C Library header @c wchar.h,
* and its contents are (mostly) the same as that header, but are all
* contained in the namespace @c std (except for names which are defined
* as macros in C).
*/
#pragma empty_line
//
// ISO C++ 14882: 21.4
//
#pragma empty_line
#pragma empty_line
#pragma line 41 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cwchar" 3
#pragma line 43 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/char_traits.h" 2 3
#pragma empty_line
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
/**
* @brief Mapping from character type to associated types.
*
* @note This is an implementation class for the generic version
* of char_traits. It defines int_type, off_type, pos_type, and
* state_type. By default these are unsigned long, streamoff,
* streampos, and mbstate_t. Users who need a different set of
* types, but who don't need to change the definitions of any function
* defined in char_traits, can specialize __gnu_cxx::_Char_types
* while leaving __gnu_cxx::char_traits alone. */
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 empty_line
#pragma empty_line
/**
* @brief Base class used to implement std::char_traits.
*
* @note For any given actual character type, this definition is
* probably wrong. (Most of the member functions are likely to be
* right, but the int_type and state_type typedefs, and the eof()
* member function, are likely to be wrong.) The reason this class
* exists is so users can specialize it. Classes in namespace std
* may not be specialized for fundamental types, but classes in
* namespace __gnu_cxx may be.
*
* See http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt05ch13s03.html
* for advice on how to make use of this class for @a unusual character
* types. Also, check out include/ext/pod_char_traits.h.
*/
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 bool
eq(const char_type& __c1, const char_type& __c2)
{ return __c1 == __c2; }
#pragma empty_line
static 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 char_type
to_char_type(const int_type& __c)
{ return static_cast<char_type>(__c); }
#pragma empty_line
static int_type
to_int_type(const char_type& __c)
{ return static_cast<int_type>(__c); }
#pragma empty_line
static bool
eq_int_type(const int_type& __c1, const int_type& __c2)
{ return __c1 == __c2; }
#pragma empty_line
static int_type
eof()
{ return static_cast<int_type>(-1); }
#pragma empty_line
static 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)
{
// NB: Inline std::copy so no recursive dependencies.
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)
{
// NB: Inline std::fill_n so no recursive dependencies.
std::fill_n(__s, __n, __a);
return __s;
}
#pragma empty_line
#pragma empty_line
} // namespace
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
// 21.1
/**
* @brief Basis for explicit traits specializations.
*
* @note For any given actual character type, this definition is
* probably wrong. Since this is just a thin wrapper around
* __gnu_cxx::char_traits, it is possible to achieve a more
* appropriate definition by specializing __gnu_cxx::char_traits.
*
* See http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt05ch13s03.html
* for advice on how to make use of this class for @a unusual character
* types. Also, check out include/ext/pod_char_traits.h.
*/
template<class _CharT>
struct char_traits : public __gnu_cxx::char_traits<_CharT>
{ };
#pragma empty_line
#pragma empty_line
/// 21.1.3.1 char_traits specializations
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)
{ __c1 = __c2; }
#pragma empty_line
static bool
eq(const char_type& __c1, const char_type& __c2)
{ return __c1 == __c2; }
#pragma empty_line
static 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, size_t __n)
{ 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)
{ 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)
{ 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)
{ 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)
{ return static_cast<char_type*>(__builtin_memset(__s, __a, __n)); }
#pragma empty_line
static char_type
to_char_type(const int_type& __c)
{ return static_cast<char_type>(__c); }
#pragma empty_line
// To keep both the byte 0xff and the eof symbol 0xffffffff
// from ending up as 0xffffffff.
static int_type
to_int_type(const char_type& __c)
{ return static_cast<int_type>(static_cast<unsigned char>(__c)); }
#pragma empty_line
static bool
eq_int_type(const int_type& __c1, const int_type& __c2)
{ return __c1 == __c2; }
#pragma empty_line
static int_type
eof()
{ return static_cast<int_type>(-1); }
#pragma empty_line
static int_type
not_eof(const int_type& __c)
{ return (__c == eof()) ? 0 : __c; }
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
/// 21.1.3.2 char_traits specializations
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)
{ __c1 = __c2; }
#pragma empty_line
static bool
eq(const char_type& __c1, const char_type& __c2)
{ return __c1 == __c2; }
#pragma empty_line
static 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, size_t __n)
{ 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)
{ return wmemchr(__s, __a, __n); }
#pragma empty_line
static char_type*
move(char_type* __s1, const char_type* __s2, size_t __n)
{ return wmemmove(__s1, __s2, __n); }
#pragma empty_line
static char_type*
copy(char_type* __s1, const char_type* __s2, size_t __n)
{ return wmemcpy(__s1, __s2, __n); }
#pragma empty_line
static char_type*
assign(char_type* __s, size_t __n, char_type __a)
{ return wmemset(__s, __a, __n); }
#pragma empty_line
static char_type
to_char_type(const int_type& __c)
{ return char_type(__c); }
#pragma empty_line
static int_type
to_int_type(const char_type& __c)
{ return int_type(__c); }
#pragma empty_line
static bool
eq_int_type(const int_type& __c1, const int_type& __c2)
{ return __c1 == __c2; }
#pragma empty_line
static int_type
eof()
{ return static_cast<int_type>((0xffffffffu)); }
#pragma empty_line
static int_type
not_eof(const int_type& __c)
{ return eq_int_type(__c, eof()) ? 0 : __c; }
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
} // namespace
#pragma line 41 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ios" 2 3
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/localefwd.h" 1 3
// Locale support -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file bits/localefwd.h
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{locale}
*/
#pragma empty_line
//
// ISO C++ 14882: 22.1 Locales
//
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 39 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/localefwd.h" 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/c++locale.h" 1 3
// Wrapper for underlying C-language localization -*- C++ -*-
#pragma empty_line
// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file bits/c++locale.h
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{locale}
*/
#pragma empty_line
//
// ISO C++ 14882: 22.8 Standard locale categories.
//
#pragma empty_line
// Written by Benjamin Kosnik <bkoz@redhat.com>
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 40 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/c++locale.h" 3
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/clocale" 1 3
// -*- C++ -*- forwarding header.
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file clocale
* This is a Standard C++ Library file. You should @c \#include this file
* in your programs, rather than any of the @a *.h implementation files.
*
* This is the C++ version of the Standard C Library header @c locale.h,
* and its contents are (mostly) the same as that header, but are all
* contained in the namespace @c std (except for names which are defined
* as macros in C).
*/
#pragma empty_line
//
// ISO C++ 14882: 18.2.2 Implementation properties: C library
//
#pragma empty_line
#pragma empty_line
#pragma line 41 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/clocale" 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/locale.h" 1 3 4
/* Copyright (C) 1991-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
/*
* ISO C99 Standard: 7.11 Localization <locale.h>
*/
#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 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/clang/bin/../lib/clang/3.1/include/stddef.h" 1 3 4
/*===---- stddef.h - Basic type definitions --------------------------------===
*
* Copyright (c) 2008 Eli Friedman
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*===-----------------------------------------------------------------------===
*/
#pragma line 56 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/clang/bin/../lib/clang/3.1/include/stddef.h" 3 4
/* Some C libraries expect to see a wint_t here. Others (notably MinGW) will use
__WINT_TYPE__ directly; accommodate both by requiring __need_wint_t */
#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
/* Definition of locale category symbol values.
Copyright (C) 2001-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma line 30 "/usr/include/locale.h" 2 3 4
#pragma empty_line
extern "C" {
#pragma empty_line
/* These are the possibilities for the first argument to setlocale.
The code assumes that the lowest LC_* symbol has the value zero. */
#pragma line 50 "/usr/include/locale.h" 3 4
/* Structure giving information about numeric and monetary notation. */
struct lconv
{
/* Numeric (non-monetary) information. */
#pragma empty_line
char *decimal_point; /* Decimal point character. */
char *thousands_sep; /* Thousands separator. */
/* Each element is the number of digits in each group;
elements with higher indices are farther left.
An element with value CHAR_MAX means that no further grouping is done.
An element with value 0 means that the previous element is used
for all groups farther left. */
char *grouping;
#pragma empty_line
/* Monetary information. */
#pragma empty_line
/* First three chars are a currency symbol from ISO 4217.
Fourth char is the separator. Fifth char is '\0'. */
char *int_curr_symbol;
char *currency_symbol; /* Local currency symbol. */
char *mon_decimal_point; /* Decimal point character. */
char *mon_thousands_sep; /* Thousands separator. */
char *mon_grouping; /* Like `grouping' element (above). */
char *positive_sign; /* Sign for positive values. */
char *negative_sign; /* Sign for negative values. */
char int_frac_digits; /* Int'l fractional digits. */
char frac_digits; /* Local fractional digits. */
/* 1 if currency_symbol precedes a positive value, 0 if succeeds. */
char p_cs_precedes;
/* 1 iff a space separates currency_symbol from a positive value. */
char p_sep_by_space;
/* 1 if currency_symbol precedes a negative value, 0 if succeeds. */
char n_cs_precedes;
/* 1 iff a space separates currency_symbol from a negative value. */
char n_sep_by_space;
/* Positive and negative sign positions:
0 Parentheses surround the quantity and currency_symbol.
1 The sign string precedes the quantity and currency_symbol.
2 The sign string follows the quantity and currency_symbol.
3 The sign string immediately precedes the currency_symbol.
4 The sign string immediately follows the currency_symbol. */
char p_sign_posn;
char n_sign_posn;
#pragma empty_line
/* 1 if int_curr_symbol precedes a positive value, 0 if succeeds. */
char int_p_cs_precedes;
/* 1 iff a space separates int_curr_symbol from a positive value. */
char int_p_sep_by_space;
/* 1 if int_curr_symbol precedes a negative value, 0 if succeeds. */
char int_n_cs_precedes;
/* 1 iff a space separates int_curr_symbol from a negative value. */
char int_n_sep_by_space;
/* Positive and negative sign positions:
0 Parentheses surround the quantity and int_curr_symbol.
1 The sign string precedes the quantity and int_curr_symbol.
2 The sign string follows the quantity and int_curr_symbol.
3 The sign string immediately precedes the int_curr_symbol.
4 The sign string immediately follows the int_curr_symbol. */
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
/* Set and/or return the current locale. */
extern char *setlocale (int __category, const char *__locale) throw ();
#pragma empty_line
/* Return the numeric/monetary information for the current locale. */
extern struct lconv *localeconv (void) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* POSIX.1-2008 extends the locale interface with functions for
explicit creation and manipulation of 'locale_t' objects
representing locale contexts, and a set of parallel
locale-sensitive text processing functions that take a locale_t
argument. This enables applications to work with data from
multiple locales simultaneously and thread-safely. */
#pragma empty_line
#pragma empty_line
/* Return a reference to a data structure representing a set of locale
datasets. Unlike for the CATEGORY parameter for `setlocale' the
CATEGORY_MASK parameter here uses a single bit for each category,
made by OR'ing together LC_*_MASK bits above. */
extern locale_t newlocale (int __category_mask, const char *__locale,
locale_t __base) throw ();
#pragma empty_line
/* These are the bits that can be set in the CATEGORY_MASK argument to
`newlocale'. In the GNU implementation, LC_FOO_MASK has the value
of (1 << LC_FOO), but this is not a part of the interface that
callers can assume will be true. */
#pragma line 174 "/usr/include/locale.h" 3 4
/* Return a duplicate of the set of locale in DATASET. All usage
counters are increased if necessary. */
extern locale_t duplocale (locale_t __dataset) throw ();
#pragma empty_line
/* Free the data associated with a locale dataset previously returned
by a call to `setlocale_r'. */
extern void freelocale (locale_t __dataset) throw ();
#pragma empty_line
/* Switch the current thread's locale to DATASET.
If DATASET is null, instead just return the current setting.
The special value LC_GLOBAL_LOCALE is the initial setting
for all threads and can also be installed any time, meaning
the thread uses the global settings controlled by `setlocale'. */
extern locale_t uselocale (locale_t __dataset) throw ();
#pragma empty_line
/* This value can be passed to `uselocale' and may be returned by it.
Passing this value to any other function has undefined behavior. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 44 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/clocale" 2 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
// Get rid of those macros defined in <locale.h> in lieu of real functions.
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std
{
using ::lconv;
using ::setlocale;
using ::localeconv;
} // namespace std
#pragma line 42 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/c++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
} // namespace
#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
// Convert numeric value of type double and long double to string and
// return length of string. If vsnprintf is available use it, otherwise
// fall back to the unsafe vsprintf which, in general, can be dangerous
// and should be avoided.
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 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/c++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
} // namespace
#pragma line 42 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/localefwd.h" 2 3
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cctype" 1 3
// -*- C++ -*- forwarding header.
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file include/cctype
* This is a Standard C++ Library file. You should @c \#include this file
* in your programs, rather than any of the @a *.h implementation files.
*
* This is the C++ version of the Standard C Library header @c ctype.h,
* and its contents are (mostly) the same as that header, but are all
* contained in the namespace @c std (except for names which are defined
* as macros in C).
*/
#pragma empty_line
//
// ISO C++ 14882: <ccytpe>
//
#pragma empty_line
#pragma empty_line
#pragma line 41 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cctype" 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/ctype.h" 1 3 4
/* Copyright (C) 1991-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
/*
* ISO C99 Standard 7.4: Character handling <ctype.h>
*/
#pragma empty_line
#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
/* These are all the characteristics of characters.
If there get to be more than 16 distinct characteristics,
many things must be changed that use `unsigned short int's.
#pragma empty_line
The characteristics are stored always in network byte order (big
endian). We define the bit value interpretations here dependent on the
machine's byte order. */
#pragma line 46 "/usr/include/ctype.h" 3 4
enum
{
_ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)), /* UPPERCASE. */
_ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)), /* lowercase. */
_ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)), /* Alphabetic. */
_ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)), /* Numeric. */
_ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)), /* Hexadecimal numeric. */
_ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)), /* Whitespace. */
_ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)), /* Printing. */
_ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)), /* Graphical. */
_ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)), /* Blank (usually SPC and TAB). */
_IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)), /* Control character. */
_ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)), /* Punctuation. */
_ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8)) /* Alphanumeric. */
};
#pragma empty_line
#pragma empty_line
/* These are defined in ctype-info.c.
The declarations here must match those in localeinfo.h.
#pragma empty_line
In the thread-specific locale model (see `uselocale' in <locale.h>)
we cannot use global variables for these as was done in the past.
Instead, the following accessor functions return the address of
each variable, which is local to the current thread if multithreaded.
#pragma empty_line
These point into arrays of 384, so they can be indexed by any `unsigned
char' value [0,255]; by EOF (-1); or by any `signed char' value
[-128,-1). ISO C requires that the ctype functions work for `unsigned
char' values and for EOF; we also support negative `signed char' values
for broken old programs. The case conversion arrays are of `int's
rather than `unsigned char's because tolower (EOF) must be EOF, which
doesn't fit into an `unsigned char'. But today more important is that
the arrays are also used for multi-byte character sets. */
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 104 "/usr/include/ctype.h" 3 4
/* The following names are all functions:
int isCHARACTERISTIC(int c);
which return nonzero iff C has CHARACTERISTIC.
For the meaning of the characteristic names, see the `enum' above. */
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
/* Return the lowercase version of C. */
extern int tolower (int __c) throw ();
#pragma empty_line
/* Return the uppercase version of C. */
extern int toupper (int __c) throw ();
#pragma empty_line
#pragma empty_line
/* ISO C99 introduced one new function. */
#pragma empty_line
extern int isblank (int) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Test C for a set of character classes according to MASK. */
extern int isctype (int __c, int __mask) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Return nonzero iff C is in the ASCII set
(i.e., is no more than 7 bits wide). */
extern int isascii (int __c) throw ();
#pragma empty_line
/* Return the part of C that is in the ASCII set
(i.e., the low-order 7 bits of C). */
extern int toascii (int __c) throw ();
#pragma empty_line
/* These are the same as `toupper' and `tolower' except that they do not
check the argument for being in the range of a `char'. */
extern int _toupper (int) throw ();
extern int _tolower (int) throw ();
#pragma empty_line
#pragma empty_line
/* This code is needed for the optimized mapping functions. */
#pragma line 236 "/usr/include/ctype.h" 3 4
/* POSIX.1-2008 extended locale interface (see locale.h). */
#pragma empty_line
#pragma empty_line
/* These definitions are similar to the ones above but all functions
take as an argument a handle for the locale which shall be used. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* The following names are all functions:
int isCHARACTERISTIC(int c, locale_t *locale);
which return nonzero iff C has CHARACTERISTIC.
For the meaning of the characteristic names, see the `enum' above. */
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
/* Return the lowercase version of C in locale L. */
extern int __tolower_l (int __c, locale_t __l) throw ();
extern int tolower_l (int __c, locale_t __l) throw ();
#pragma empty_line
/* Return the uppercase version of C. */
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 44 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cctype" 2 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
// Get rid of those macros defined in <ctype.h> in lieu of real functions.
#pragma line 63 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cctype" 3
namespace std
{
using ::isalnum;
using ::isalpha;
using ::iscntrl;
using ::isdigit;
using ::isgraph;
using ::islower;
using ::isprint;
using ::ispunct;
using ::isspace;
using ::isupper;
using ::isxdigit;
using ::tolower;
using ::toupper;
} // namespace std
#pragma line 44 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/localefwd.h" 2 3
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
/**
* @defgroup locales Locales
*
* Classes and functions for internationalization and localization.
*/
#pragma empty_line
// 22.1.1 Locale
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
// 22.1.3 Convenience interfaces
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
template<typename _CharT>
_CharT
toupper(_CharT, const locale&);
#pragma empty_line
template<typename _CharT>
_CharT
tolower(_CharT, const locale&);
#pragma empty_line
// 22.2.1 and 22.2.1.3 ctype
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;
// NB: Specialized for char and wchar_t in locale_facets.h.
#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
// 22.2.2 and 22.2.3 numeric
#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
template<typename _CharT> class numpunct;
template<typename _CharT> class numpunct_byname;
#pragma empty_line
// 22.2.4 collation
template<typename _CharT>
class collate;
template<typename _CharT> class
collate_byname;
#pragma empty_line
// 22.2.5 date and time
class time_base;
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
// 22.2.6 money
class money_base;
#pragma empty_line
template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
class money_get;
template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
class money_put;
#pragma empty_line
template<typename _CharT, bool _Intl = false>
class moneypunct;
template<typename _CharT, bool _Intl = false>
class moneypunct_byname;
#pragma empty_line
// 22.2.7 message retrieval
class messages_base;
template<typename _CharT>
class messages;
template<typename _CharT>
class messages_byname;
#pragma empty_line
#pragma empty_line
} // namespace
#pragma line 42 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ios" 2 3
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/ios_base.h" 1 3
// Iostreams base classes -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file bits/ios_base.h
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{ios}
*/
#pragma empty_line
//
// ISO C++ 14882: 27.4 Iostreams base classes
//
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 39 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/ios_base.h" 3
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ext/atomicity.h" 1 3
// Support for atomic operations -*- C++ -*-
#pragma empty_line
// Copyright (C) 2004, 2005, 2006, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file ext/atomicity.h
* This file is a GNU extension to the Standard C++ Library.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/gthr.h" 1 3
/* Threads compatibility routines for libgcc2. */
/* Compile this one with gcc. */
/* Copyright (C) 1997, 1998, 2004, 2008, 2009 Free Software Foundation, Inc.
#pragma empty_line
This file is part of GCC.
#pragma empty_line
GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.
#pragma empty_line
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
#pragma empty_line
Under Section 7 of GPL version 3, you are granted additional
permissions described in the GCC Runtime Library Exception, version
3.1, as published by the Free Software Foundation.
#pragma empty_line
You should have received a copy of the GNU General Public License and
a copy of the GCC Runtime Library Exception along with this program;
see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<http://www.gnu.org/licenses/>. */
#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
/* If this file is compiled with threads support, it must
#define __GTHREADS 1
to indicate that threads support is present. Also it has define
function
int __gthread_active_p ()
that returns 1 if thread system is active, 0 if not.
#pragma empty_line
The threads interface must define the following types:
__gthread_key_t
__gthread_once_t
__gthread_mutex_t
__gthread_recursive_mutex_t
#pragma empty_line
The threads interface must define the following macros:
#pragma empty_line
__GTHREAD_ONCE_INIT
to initialize __gthread_once_t
__GTHREAD_MUTEX_INIT
to initialize __gthread_mutex_t to get a fast
non-recursive mutex.
__GTHREAD_MUTEX_INIT_FUNCTION
some systems can't initialize a mutex without a
function call. On such systems, define this to a
function which looks like this:
void __GTHREAD_MUTEX_INIT_FUNCTION (__gthread_mutex_t *)
Don't define __GTHREAD_MUTEX_INIT in this case
__GTHREAD_RECURSIVE_MUTEX_INIT
__GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION
as above, but for a recursive mutex.
#pragma empty_line
The threads interface must define the following static functions:
#pragma empty_line
int __gthread_once (__gthread_once_t *once, void (*func) ())
#pragma empty_line
int __gthread_key_create (__gthread_key_t *keyp, void (*dtor) (void *))
int __gthread_key_delete (__gthread_key_t key)
#pragma empty_line
void *__gthread_getspecific (__gthread_key_t key)
int __gthread_setspecific (__gthread_key_t key, const void *ptr)
#pragma empty_line
int __gthread_mutex_destroy (__gthread_mutex_t *mutex);
#pragma empty_line
int __gthread_mutex_lock (__gthread_mutex_t *mutex);
int __gthread_mutex_trylock (__gthread_mutex_t *mutex);
int __gthread_mutex_unlock (__gthread_mutex_t *mutex);
#pragma empty_line
int __gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *mutex);
int __gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *mutex);
int __gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *mutex);
#pragma empty_line
The following are supported in POSIX threads only. They are required to
fix a deadlock in static initialization inside libsupc++. The header file
gthr-posix.h defines a symbol __GTHREAD_HAS_COND to signify that these extra
features are supported.
#pragma empty_line
Types:
__gthread_cond_t
#pragma empty_line
Macros:
__GTHREAD_COND_INIT
__GTHREAD_COND_INIT_FUNCTION
#pragma empty_line
Interface:
int __gthread_cond_broadcast (__gthread_cond_t *cond);
int __gthread_cond_wait (__gthread_cond_t *cond, __gthread_mutex_t *mutex);
int __gthread_cond_wait_recursive (__gthread_cond_t *cond,
__gthread_recursive_mutex_t *mutex);
#pragma empty_line
All functions returning int should return zero on success or the error
number. If the operation is not supported, -1 is returned.
#pragma empty_line
If the following are also defined, you should
#define __GTHREADS_CXX0X 1
to enable the c++0x thread library.
#pragma empty_line
Types:
__gthread_t
__gthread_time_t
#pragma empty_line
Interface:
int __gthread_create (__gthread_t *thread, void *(*func) (void*),
void *args);
int __gthread_join (__gthread_t thread, void **value_ptr);
int __gthread_detach (__gthread_t thread);
int __gthread_equal (__gthread_t t1, __gthread_t t2);
__gthread_t __gthread_self (void);
int __gthread_yield (void);
#pragma empty_line
int __gthread_mutex_timedlock (__gthread_mutex_t *m,
const __gthread_time_t *abs_timeout);
int __gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *m,
const __gthread_time_t *abs_time);
#pragma empty_line
int __gthread_cond_signal (__gthread_cond_t *cond);
int __gthread_cond_timedwait (__gthread_cond_t *cond,
__gthread_mutex_t *mutex,
const __gthread_time_t *abs_timeout);
int __gthread_cond_timedwait_recursive (__gthread_cond_t *cond,
__gthread_recursive_mutex_t *mutex,
const __gthread_time_t *abs_time)
#pragma empty_line
Currently supported threads packages are
TPF threads with -D__tpf__
POSIX/Unix98 threads with -D_PTHREADS
POSIX/Unix95 threads with -D_PTHREADS95
DCE threads with -D_DCE_THREADS
Solaris/UI threads with -D_SOLARIS_THREADS
#pragma empty_line
*/
#pragma empty_line
/* Check first for thread specific defines. */
#pragma line 158 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/gthr.h" 3
/* The pe-coff weak support isn't fully compatible to ELF's weak.
For static libraries it might would work, but as we need to deal
with shared versions too, we disable it for mingw-targets. */
#pragma line 170 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/gthr.h" 3
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/gthr-default.h" 1 3
/* Threads compatibility routines for libgcc2 and libobjc. */
/* Compile this one with gcc. */
/* Copyright (C) 1997, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
2008, 2009, 2010 Free Software Foundation, Inc.
#pragma empty_line
This file is part of GCC.
#pragma empty_line
GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.
#pragma empty_line
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
#pragma empty_line
Under Section 7 of GPL version 3, you are granted additional
permissions described in the GCC Runtime Library Exception, version
3.1, as published by the Free Software Foundation.
#pragma empty_line
You should have received a copy of the GNU General Public License and
a copy of the GCC Runtime Library Exception along with this program;
see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* POSIX threads specific definitions.
Easy, since the interface is just one-to-one mapping. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Some implementations of <pthread.h> require this to be defined. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/pthread.h" 1 3 4
/* Copyright (C) 2002-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/sched.h" 1 3 4
/* Definitions for POSIX 1003.1b-1993 (aka POSIX.4) scheduling interface.
Copyright (C) 1996-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Get type definitions. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/clang/bin/../lib/clang/3.1/include/stddef.h" 1 3 4
/*===---- stddef.h - Basic type definitions --------------------------------===
*
* Copyright (c) 2008 Eli Friedman
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*===-----------------------------------------------------------------------===
*/
#pragma line 56 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/clang/bin/../lib/clang/3.1/include/stddef.h" 3 4
/* Some C libraries expect to see a wint_t here. Others (notably MinGW) will use
__WINT_TYPE__ directly; accommodate both by requiring __need_wint_t */
#pragma line 30 "/usr/include/sched.h" 2 3 4
#pragma line 42 "/usr/include/sched.h" 3 4
/* Get system specific constant and data structure definitions. */
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/sched.h" 1 3 4
/* Definitions of constants and data structure for POSIX 1003.1b-1993
scheduling interface.
Copyright (C) 1996-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma line 27 "/usr/include/x86_64-linux-gnu/bits/sched.h" 3 4
/* Scheduling algorithms. */
#pragma line 41 "/usr/include/x86_64-linux-gnu/bits/sched.h" 3 4
/* Cloning flags. */
#pragma line 74 "/usr/include/x86_64-linux-gnu/bits/sched.h" 3 4
/* Data structure to describe a process' schedulability. */
struct sched_param
{
int sched_priority;
};
#pragma empty_line
extern "C" {
#pragma empty_line
#pragma empty_line
/* Clone current process. */
extern int clone (int (*__fn) (void *__arg), void *__child_stack,
int __flags, void *__arg, ...) throw ();
#pragma empty_line
/* Unshare the specified resources. */
extern int unshare (int __flags) throw ();
#pragma empty_line
/* Get index of currently used CPU. */
extern int sched_getcpu (void) throw ();
#pragma empty_line
/* Switch process to namespace of type NSTYPE indicated by FD. */
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
/* Definition of the cpu_set_t structure used by the POSIX 1003.1b-1993
scheduling interface.
Copyright (C) 1996-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma line 27 "/usr/include/x86_64-linux-gnu/bits/cpu-set.h" 3 4
/* Size definition for CPU sets. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Type for array elements in 'cpu_set_t'. */
typedef unsigned long int __cpu_mask;
#pragma empty_line
/* Basic access functions. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Data structure to describe CPU mask. */
typedef struct
{
__cpu_mask __bits[1024 / (8 * sizeof (__cpu_mask))];
} cpu_set_t;
#pragma empty_line
/* Access functions for CPU masks. */
#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 () /* Ignore */;
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
/* Backward compatibility. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern "C" {
#pragma empty_line
/* Set scheduling parameters for a process. */
extern int sched_setparam (__pid_t __pid, const struct sched_param *__param)
throw ();
#pragma empty_line
/* Retrieve scheduling parameters for a particular process. */
extern int sched_getparam (__pid_t __pid, struct sched_param *__param) throw ();
#pragma empty_line
/* Set scheduling algorithm and/or parameters for a process. */
extern int sched_setscheduler (__pid_t __pid, int __policy,
const struct sched_param *__param) throw ();
#pragma empty_line
/* Retrieve scheduling algorithm for a particular purpose. */
extern int sched_getscheduler (__pid_t __pid) throw ();
#pragma empty_line
/* Yield the processor. */
extern int sched_yield (void) throw ();
#pragma empty_line
/* Get maximum priority value for a scheduler. */
extern int sched_get_priority_max (int __algorithm) throw ();
#pragma empty_line
/* Get minimum priority value for a scheduler. */
extern int sched_get_priority_min (int __algorithm) throw ();
#pragma empty_line
/* Get the SCHED_RR interval for the named process. */
extern int sched_rr_get_interval (__pid_t __pid, struct timespec *__t) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Access macros for `cpu_set'. */
#pragma line 120 "/usr/include/sched.h" 3 4
/* Set the CPU affinity for a task */
extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize,
const cpu_set_t *__cpuset) throw ();
#pragma empty_line
/* Get the CPU affinity for a task */
extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize,
cpu_set_t *__cpuset) throw ();
#pragma empty_line
#pragma empty_line
}
#pragma line 24 "/usr/include/pthread.h" 2 3 4
#pragma line 1 "/usr/include/time.h" 1 3 4
/* Copyright (C) 1991-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
/*
* ISO C99 Standard: 7.23 Date and time <time.h>
*/
#pragma line 29 "/usr/include/time.h" 3 4
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/clang/bin/../lib/clang/3.1/include/stddef.h" 1 3 4
/*===---- stddef.h - Basic type definitions --------------------------------===
*
* Copyright (c) 2008 Eli Friedman
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*===-----------------------------------------------------------------------===
*/
#pragma line 56 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/clang/bin/../lib/clang/3.1/include/stddef.h" 3 4
/* Some C libraries expect to see a wint_t here. Others (notably MinGW) will use
__WINT_TYPE__ directly; accommodate both by requiring __need_wint_t */
#pragma line 30 "/usr/include/time.h" 2 3 4
#pragma empty_line
/* This defines CLOCKS_PER_SEC, which is the number of processor clock
ticks per second, and possibly a number of other constants. */
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/time.h" 1 3 4
/* System-dependent timing definitions. Linux version.
Copyright (C) 1996-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
/*
* Never include this file directly; use <time.h> instead.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* ISO/IEC 9899:1999 7.23.1: Components of time
The macro `CLOCKS_PER_SEC' is an expression with type `clock_t' that is
the number per second of the value returned by the `clock' function. */
/* CAE XSH, Issue 4, Version 2: <time.h>
The value of CLOCKS_PER_SEC is required to be 1 million on all
XSI-conformant systems. */
#pragma line 45 "/usr/include/x86_64-linux-gnu/bits/time.h" 3 4
/* Identifier for system-wide realtime clock. */
#pragma empty_line
/* Monotonic system-wide clock. */
#pragma empty_line
/* High-resolution timer from the CPU. */
#pragma empty_line
/* Thread-specific CPU-time clock. */
#pragma empty_line
/* Monotonic system-wide clock, not adjusted for frequency scaling. */
#pragma empty_line
/* Identifier for system-wide realtime clock, updated only on ticks. */
#pragma empty_line
/* Monotonic system-wide clock, updated only on ticks. */
#pragma empty_line
/* Monotonic system-wide clock that includes time spent in suspension. */
#pragma empty_line
/* Like CLOCK_REALTIME but also wakes suspended system. */
#pragma empty_line
/* Like CLOCK_BOOTTIME but also wakes suspended system. */
#pragma empty_line
/* Like CLOCK_REALTIME but in International Atomic Time. */
#pragma empty_line
#pragma empty_line
/* Flag to indicate time is absolute. */
#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/timex.h" 1 3 4
/* Copyright (C) 1995-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* These definitions from linux/timex.h as of 3.18. */
#pragma empty_line
struct timex
{
unsigned int modes; /* mode selector */
__syscall_slong_t offset; /* time offset (usec) */
__syscall_slong_t freq; /* frequency offset (scaled ppm) */
__syscall_slong_t maxerror; /* maximum error (usec) */
__syscall_slong_t esterror; /* estimated error (usec) */
int status; /* clock command/status */
__syscall_slong_t constant; /* pll time constant */
__syscall_slong_t precision; /* clock precision (usec) (ro) */
__syscall_slong_t tolerance; /* clock frequency tolerance (ppm) (ro) */
struct timeval time; /* (read only, except for ADJ_SETOFFSET) */
__syscall_slong_t tick; /* (modified) usecs between clock ticks */
__syscall_slong_t ppsfreq; /* pps frequency (scaled ppm) (ro) */
__syscall_slong_t jitter; /* pps jitter (us) (ro) */
int shift; /* interval duration (s) (shift) (ro) */
__syscall_slong_t stabil; /* pps stability (scaled ppm) (ro) */
__syscall_slong_t jitcnt; /* jitter limit exceeded (ro) */
__syscall_slong_t calcnt; /* calibration intervals (ro) */
__syscall_slong_t errcnt; /* calibration errors (ro) */
__syscall_slong_t stbcnt; /* stability limit exceeded (ro) */
#pragma empty_line
int tai; /* TAI offset (ro) */
#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 empty_line
/* Mode codes (timex.mode) */
#pragma line 71 "/usr/include/x86_64-linux-gnu/bits/timex.h" 3 4
/* xntp 3.4 compatibility names */
#pragma line 85 "/usr/include/x86_64-linux-gnu/bits/timex.h" 3 4
/* Status codes (timex.status) */
#pragma line 106 "/usr/include/x86_64-linux-gnu/bits/timex.h" 3 4
/* Read-only bits */
#pragma line 74 "/usr/include/x86_64-linux-gnu/bits/time.h" 2 3 4
#pragma empty_line
extern "C" {
#pragma empty_line
/* Tune a POSIX clock. */
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
/* Many of the typedefs and structs whose official home is this header
may also need to be defined by other headers. */
#pragma empty_line
#pragma empty_line
#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
/* ISO C `broken-down time' structure. */
struct tm
{
int tm_sec; /* Seconds. [0-60] (1 leap second) */
int tm_min; /* Minutes. [0-59] */
int tm_hour; /* Hours. [0-23] */
int tm_mday; /* Day. [1-31] */
int tm_mon; /* Month. [0-11] */
int tm_year; /* Year - 1900. */
int tm_wday; /* Day of week. [0-6] */
int tm_yday; /* Days in year.[0-365] */
int tm_isdst; /* DST. [-1/0/1]*/
#pragma empty_line
#pragma empty_line
long int tm_gmtoff; /* Seconds east of UTC. */
const char *tm_zone; /* Timezone abbreviation. */
#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 empty_line
#pragma empty_line
#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
/* POSIX.1b structure for timer start values and intervals. */
struct itimerspec
{
struct timespec it_interval;
struct timespec it_value;
};
#pragma line 49 "/usr/include/time.h" 2 3 4
struct sigevent;
#pragma line 64 "/usr/include/time.h" 3 4
/* Time base values for timespec_get. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern "C" {
#pragma empty_line
/* Time used by the program so far (user time + system time).
The result / CLOCKS_PER_SEC is program time in seconds. */
extern clock_t clock (void) throw ();
#pragma empty_line
/* Return the current time and put it in *TIMER if TIMER is not NULL. */
extern time_t time (time_t *__timer) throw ();
#pragma empty_line
/* Return the difference between TIME1 and TIME0. */
extern double difftime (time_t __time1, time_t __time0)
throw () __attribute__ ((__const__));
#pragma empty_line
/* Return the `time_t' representation of TP and normalize TP. */
extern time_t mktime (struct tm *__tp) throw ();
#pragma empty_line
#pragma empty_line
/* Format TP into S according to FORMAT.
Write no more than MAXSIZE characters and return the number
of characters written, or 0 if it would exceed MAXSIZE. */
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
/* Parse S according to FORMAT and store binary time information in TP.
The return value is a pointer to the first unparsed character in S. */
extern char *strptime (const char *__restrict __s,
const char *__restrict __fmt, struct tm *__tp)
throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Similar to the two functions above but take the information from
the provided locale and not the global locale. */
#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
/* Return the `struct tm' representation of *TIMER
in Universal Coordinated Time (aka Greenwich Mean Time). */
extern struct tm *gmtime (const time_t *__timer) throw ();
#pragma empty_line
/* Return the `struct tm' representation
of *TIMER in the local timezone. */
extern struct tm *localtime (const time_t *__timer) throw ();
#pragma empty_line
#pragma empty_line
/* Return the `struct tm' representation of *TIMER in UTC,
using *TP to store the result. */
extern struct tm *gmtime_r (const time_t *__restrict __timer,
struct tm *__restrict __tp) throw ();
#pragma empty_line
/* Return the `struct tm' representation of *TIMER in local time,
using *TP to store the result. */
extern struct tm *localtime_r (const time_t *__restrict __timer,
struct tm *__restrict __tp) throw ();
#pragma empty_line
#pragma empty_line
/* Return a string of the form "Day Mon dd hh:mm:ss yyyy\n"
that is the representation of TP in this format. */
extern char *asctime (const struct tm *__tp) throw ();
#pragma empty_line
/* Equivalent to `asctime (localtime (timer))'. */
extern char *ctime (const time_t *__timer) throw ();
#pragma empty_line
#pragma empty_line
/* Reentrant versions of the above functions. */
#pragma empty_line
/* Return in BUF a string of the form "Day Mon dd hh:mm:ss yyyy\n"
that is the representation of TP in this format. */
extern char *asctime_r (const struct tm *__restrict __tp,
char *__restrict __buf) throw ();
#pragma empty_line
/* Equivalent to `asctime_r (localtime_r (timer, *TMP*), buf)'. */
extern char *ctime_r (const time_t *__restrict __timer,
char *__restrict __buf) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Defined in localtime.c. */
extern char *__tzname[2]; /* Current timezone names. */
extern int __daylight; /* If daylight-saving time is ever in use. */
extern long int __timezone; /* Seconds west of UTC. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Same as above. */
extern char *tzname[2];
#pragma empty_line
/* Set time conversion information from the TZ environment variable.
If TZ is not defined, a locale-dependent default is used. */
extern void tzset (void) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int daylight;
extern long int timezone;
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Set the system time to *WHEN.
This call is restricted to the superuser. */
extern int stime (const time_t *__when) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Nonzero if YEAR is a leap year (every 4 years,
except every 100th isn't, and every 400th is). */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Miscellaneous functions many Unices inherited from the public domain
localtime package. These are included only for compatibility. */
#pragma empty_line
/* Like `mktime', but for TP represents Universal Time, not local time. */
extern time_t timegm (struct tm *__tp) throw ();
#pragma empty_line
/* Another name for `mktime'. */
extern time_t timelocal (struct tm *__tp) throw ();
#pragma empty_line
/* Return the number of days in YEAR. */
extern int dysize (int __year) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Pause execution for a number of nanoseconds.
#pragma empty_line
This function is a cancellation point and therefore not marked with
__THROW. */
extern int nanosleep (const struct timespec *__requested_time,
struct timespec *__remaining);
#pragma empty_line
#pragma empty_line
/* Get resolution of clock CLOCK_ID. */
extern int clock_getres (clockid_t __clock_id, struct timespec *__res) throw ();
#pragma empty_line
/* Get current value of clock CLOCK_ID and store it in TP. */
extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) throw ();
#pragma empty_line
/* Set clock CLOCK_ID to value TP. */
extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp)
throw ();
#pragma empty_line
#pragma empty_line
/* High-resolution sleep with the specified clock.
#pragma empty_line
This function is a cancellation point and therefore not marked with
__THROW. */
extern int clock_nanosleep (clockid_t __clock_id, int __flags,
const struct timespec *__req,
struct timespec *__rem);
#pragma empty_line
/* Return clock ID for CPU-time clock. */
extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Create new per-process timer using CLOCK_ID. */
extern int timer_create (clockid_t __clock_id,
struct sigevent *__restrict __evp,
timer_t *__restrict __timerid) throw ();
#pragma empty_line
/* Delete timer TIMERID. */
extern int timer_delete (timer_t __timerid) throw ();
#pragma empty_line
/* Set timer TIMERID to VALUE, returning old value in OVALUE. */
extern int timer_settime (timer_t __timerid, int __flags,
const struct itimerspec *__restrict __value,
struct itimerspec *__restrict __ovalue) throw ();
#pragma empty_line
/* Get current value of timer TIMERID and store it in VALUE. */
extern int timer_gettime (timer_t __timerid, struct itimerspec *__value)
throw ();
#pragma empty_line
/* Get expiration overrun for timer TIMERID. */
extern int timer_getoverrun (timer_t __timerid) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Set TS to calendar time based in time base BASE. */
extern int timespec_get (struct timespec *__ts, int __base)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Set to one of the following values to indicate an error.
1 the DATEMSK environment variable is null or undefined,
2 the template file cannot be opened for reading,
3 failed to get file status information,
4 the template file is not a regular file,
5 an error is encountered while reading the template file,
6 memory allication failed (not enough memory available),
7 there is no line in the template that matches the input,
8 invalid input specification Example: February 31 or a time is
specified that can not be represented in a time_t (representing
the time in seconds since 00:00:00 UTC, January 1, 1970) */
extern int getdate_err;
#pragma empty_line
/* Parse the given string as a date specification and return a value
representing the value. The templates from the file identified by
the environment variable DATEMSK are used. In case of an error
`getdate_err' is set.
#pragma empty_line
This function is a possible cancellation point and therefore not
marked with __THROW. */
extern struct tm *getdate (const char *__string);
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Since `getdate' is not reentrant because of the use of `getdate_err'
and the static buffer to return the result in, we provide a thread-safe
variant. The functionality is the same. The result is returned in
the buffer pointed to by RESBUFP and in case of an error the return
value is != 0 with the same values as given above for `getdate_err'.
#pragma empty_line
This function is not part of POSIX and therefore no official
cancellation point. But due to similarity with an POSIX interface
or due to the implementation it is a cancellation point and
therefore not marked with __THROW. */
extern int getdate_r (const char *__restrict __string,
struct tm *__restrict __resbufp);
#pragma empty_line
#pragma empty_line
}
#pragma line 25 "/usr/include/pthread.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/setjmp.h" 1 3 4
/* Copyright (C) 2001-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
/* Define the machine-dependent type `jmp_buf'. x86-64 version. */
#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 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
/* Determine the wordsize from the preprocessor defines. */
#pragma line 13 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 3 4
/* Both x86-64 and x32 use the 64-bit system call interface. */
#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
/* Determine the wordsize from the preprocessor defines. */
#pragma line 13 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 3 4
/* Both x86-64 and x32 use the 64-bit system call interface. */
#pragma line 29 "/usr/include/pthread.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Detach state. */
enum
{
PTHREAD_CREATE_JOINABLE,
#pragma empty_line
PTHREAD_CREATE_DETACHED
#pragma empty_line
};
#pragma empty_line
#pragma empty_line
/* Mutex types. */
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
/* For compatibility. */
, PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_TIMED_NP
#pragma empty_line
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Robust mutex or not flags. */
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
/* Mutex protocols. */
enum
{
PTHREAD_PRIO_NONE,
PTHREAD_PRIO_INHERIT,
PTHREAD_PRIO_PROTECT
};
#pragma line 113 "/usr/include/pthread.h" 3 4
/* Read-write lock types. */
#pragma empty_line
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 empty_line
/* Define __PTHREAD_RWLOCK_INT_FLAGS_SHARED to 1 if pthread_rwlock_t
has the shared field. All 64-bit architectures have the shared field
in pthread_rwlock_t. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Read-write lock initializers. */
#pragma line 155 "/usr/include/pthread.h" 3 4
/* Scheduler inheritance. */
enum
{
PTHREAD_INHERIT_SCHED,
#pragma empty_line
PTHREAD_EXPLICIT_SCHED
#pragma empty_line
};
#pragma empty_line
#pragma empty_line
/* Scope handling. */
enum
{
PTHREAD_SCOPE_SYSTEM,
#pragma empty_line
PTHREAD_SCOPE_PROCESS
#pragma empty_line
};
#pragma empty_line
#pragma empty_line
/* Process shared or private flag. */
enum
{
PTHREAD_PROCESS_PRIVATE,
#pragma empty_line
PTHREAD_PROCESS_SHARED
#pragma empty_line
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Conditional variable handling. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Cleanup buffers */
struct _pthread_cleanup_buffer
{
void (*__routine) (void *); /* Function to call. */
void *__arg; /* Its argument. */
int __canceltype; /* Saved cancellation type. */
struct _pthread_cleanup_buffer *__prev; /* Chaining of cleanup functions. */
};
#pragma empty_line
/* Cancellation */
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 empty_line
#pragma empty_line
#pragma empty_line
/* Single execution handling. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Value returned by 'pthread_barrier_wait' for one of the threads after
the required number of threads have called this function.
-1 is distinct from 0 and all errno constants */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern "C" {
#pragma empty_line
/* Create a new thread, starting with execution of START-ROUTINE
getting passed ARG. Creation attributed come from ATTR. The new
handle is stored in *NEWTHREAD. */
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
/* Terminate calling thread.
#pragma empty_line
The registered cleanup handlers are called via exception handling
so we cannot mark this function with __THROW.*/
extern void pthread_exit (void *__retval) __attribute__ ((__noreturn__));
#pragma empty_line
/* Make calling thread wait for termination of the thread TH. The
exit status of the thread is stored in *THREAD_RETURN, if THREAD_RETURN
is not NULL.
#pragma empty_line
This function is a cancellation point and therefore not marked with
__THROW. */
extern int pthread_join (pthread_t __th, void **__thread_return);
#pragma empty_line
#pragma empty_line
/* Check whether thread TH has terminated. If yes return the status of
the thread in *THREAD_RETURN, if THREAD_RETURN is not NULL. */
extern int pthread_tryjoin_np (pthread_t __th, void **__thread_return) throw ();
#pragma empty_line
/* Make calling thread wait for termination of the thread TH, but only
until TIMEOUT. The exit status of the thread is stored in
*THREAD_RETURN, if THREAD_RETURN is not NULL.
#pragma empty_line
This function is a cancellation point and therefore not marked with
__THROW. */
extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return,
const struct timespec *__abstime);
#pragma empty_line
#pragma empty_line
/* Indicate that the thread TH is never to be joined with PTHREAD_JOIN.
The resources of TH will therefore be freed immediately when it
terminates, instead of waiting for another thread to perform PTHREAD_JOIN
on it. */
extern int pthread_detach (pthread_t __th) throw ();
#pragma empty_line
#pragma empty_line
/* Obtain the identifier of the current thread. */
extern pthread_t pthread_self (void) throw () __attribute__ ((__const__));
#pragma empty_line
/* Compare two thread identifiers. */
extern int pthread_equal (pthread_t __thread1, pthread_t __thread2)
throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
/* Thread attribute handling. */
#pragma empty_line
/* Initialize thread attribute *ATTR with default attributes
(detachstate is PTHREAD_JOINABLE, scheduling policy is SCHED_OTHER,
no user-provided stack). */
extern int pthread_attr_init (pthread_attr_t *__attr) throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
/* Destroy thread attribute *ATTR. */
extern int pthread_attr_destroy (pthread_attr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
/* Get detach state attribute. */
extern int pthread_attr_getdetachstate (const pthread_attr_t *__attr,
int *__detachstate)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
/* Set detach state attribute. */
extern int pthread_attr_setdetachstate (pthread_attr_t *__attr,
int __detachstate)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
/* Get the size of the guard area created for stack overflow protection. */
extern int pthread_attr_getguardsize (const pthread_attr_t *__attr,
size_t *__guardsize)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
/* Set the size of the guard area created for stack overflow protection. */
extern int pthread_attr_setguardsize (pthread_attr_t *__attr,
size_t __guardsize)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
/* Return in *PARAM the scheduling parameters of *ATTR. */
extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict __attr,
struct sched_param *__restrict __param)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
/* Set scheduling parameters (priority, etc) in *ATTR according to PARAM. */
extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr,
const struct sched_param *__restrict
__param) throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
/* Return in *POLICY the scheduling policy of *ATTR. */
extern int pthread_attr_getschedpolicy (const pthread_attr_t *__restrict
__attr, int *__restrict __policy)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
/* Set scheduling policy in *ATTR according to POLICY. */
extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
/* Return in *INHERIT the scheduling inheritance mode of *ATTR. */
extern int pthread_attr_getinheritsched (const pthread_attr_t *__restrict
__attr, int *__restrict __inherit)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
/* Set scheduling inheritance mode in *ATTR according to INHERIT. */
extern int pthread_attr_setinheritsched (pthread_attr_t *__attr,
int __inherit)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
/* Return in *SCOPE the scheduling contention scope of *ATTR. */
extern int pthread_attr_getscope (const pthread_attr_t *__restrict __attr,
int *__restrict __scope)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
/* Set scheduling contention scope in *ATTR according to SCOPE. */
extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
/* Return the previously set address for the stack. */
extern int pthread_attr_getstackaddr (const pthread_attr_t *__restrict
__attr, void **__restrict __stackaddr)
throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__deprecated__));
#pragma empty_line
/* Set the starting address of the stack of the thread to be created.
Depending on whether the stack grows up or down the value must either
be higher or lower than all the address in the memory block. The
minimal size of the block must be PTHREAD_STACK_MIN. */
extern int pthread_attr_setstackaddr (pthread_attr_t *__attr,
void *__stackaddr)
throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__));
#pragma empty_line
/* Return the currently used minimal stack size. */
extern int pthread_attr_getstacksize (const pthread_attr_t *__restrict
__attr, size_t *__restrict __stacksize)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
/* Add information about the minimum stack size needed for the thread
to be started. This size must never be less than PTHREAD_STACK_MIN
and must also not exceed the system limits. */
extern int pthread_attr_setstacksize (pthread_attr_t *__attr,
size_t __stacksize)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
/* Return the previously set address for the stack. */
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
/* The following two interfaces are intended to replace the last two. They
require setting the address as well as the size since only setting the
address will make the implementation on some architectures impossible. */
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
/* Thread created with attribute ATTR will be limited to run only on
the processors represented in CPUSET. */
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
/* Get bit set in CPUSET representing the processors threads created with
ATTR can run on. */
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
/* Get the default attributes used by pthread_create in this process. */
extern int pthread_getattr_default_np (pthread_attr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
/* Set the default attributes to be used by pthread_create in this
process. */
extern int pthread_setattr_default_np (const pthread_attr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
/* Initialize thread attribute *ATTR with attributes corresponding to the
already running thread TH. It shall be called on uninitialized ATTR
and destroyed with pthread_attr_destroy when no longer needed. */
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
/* Functions for scheduling control. */
#pragma empty_line
/* Set the scheduling parameters for TARGET_THREAD according to POLICY
and *PARAM. */
extern int pthread_setschedparam (pthread_t __target_thread, int __policy,
const struct sched_param *__param)
throw () __attribute__ ((__nonnull__ (3)));
#pragma empty_line
/* Return in *POLICY and *PARAM the scheduling parameters for TARGET_THREAD. */
extern int pthread_getschedparam (pthread_t __target_thread,
int *__restrict __policy,
struct sched_param *__restrict __param)
throw () __attribute__ ((__nonnull__ (2, 3)));
#pragma empty_line
/* Set the scheduling priority for TARGET_THREAD. */
extern int pthread_setschedprio (pthread_t __target_thread, int __prio)
throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Get thread name visible in the kernel and its interfaces. */
extern int pthread_getname_np (pthread_t __target_thread, char *__buf,
size_t __buflen)
throw () __attribute__ ((__nonnull__ (2)));
#pragma empty_line
/* Set thread name visible in the kernel and its interfaces. */
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
/* Determine level of concurrency. */
extern int pthread_getconcurrency (void) throw ();
#pragma empty_line
/* Set new concurrency level to LEVEL. */
extern int pthread_setconcurrency (int __level) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Yield the processor to another thread or process.
This function is similar to the POSIX `sched_yield' function but
might be differently implemented in the case of a m-on-n thread
implementation. */
extern int pthread_yield (void) throw ();
#pragma empty_line
#pragma empty_line
/* Limit specified thread TH to run only on the processors represented
in CPUSET. */
extern int pthread_setaffinity_np (pthread_t __th, size_t __cpusetsize,
const cpu_set_t *__cpuset)
throw () __attribute__ ((__nonnull__ (3)));
#pragma empty_line
/* Get bit set in CPUSET representing the processors TH can run on. */
extern int pthread_getaffinity_np (pthread_t __th, size_t __cpusetsize,
cpu_set_t *__cpuset)
throw () __attribute__ ((__nonnull__ (3)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Functions for handling initialization. */
#pragma empty_line
/* Guarantee that the initialization function INIT_ROUTINE will be called
only once, even if pthread_once is executed several times with the
same ONCE_CONTROL argument. ONCE_CONTROL must point to a static or
extern variable initialized to PTHREAD_ONCE_INIT.
#pragma empty_line
The initialization functions might throw exception which is why
this function is not marked with __THROW. */
extern int pthread_once (pthread_once_t *__once_control,
void (*__init_routine) (void)) __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
/* Functions for handling cancellation.
#pragma empty_line
Note that these functions are explicitly not marked to not throw an
exception in C++ code. If cancellation is implemented by unwinding
this is necessary to have the compiler generate the unwind information. */
#pragma empty_line
/* Set cancelability state of current thread to STATE, returning old
state in *OLDSTATE if OLDSTATE is not NULL. */
extern int pthread_setcancelstate (int __state, int *__oldstate);
#pragma empty_line
/* Set cancellation state of current thread to TYPE, returning the old
type in *OLDTYPE if OLDTYPE is not NULL. */
extern int pthread_setcanceltype (int __type, int *__oldtype);
#pragma empty_line
/* Cancel THREAD immediately or at the next possibility. */
extern int pthread_cancel (pthread_t __th);
#pragma empty_line
/* Test for pending cancellation for the current thread and terminate
the thread as per pthread_exit(PTHREAD_CANCELED) if it has been
cancelled. */
extern void pthread_testcancel (void);
#pragma empty_line
#pragma empty_line
/* Cancellation handling with integration into exception handling. */
#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 empty_line
/* No special attributes by default. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Structure to hold the cleanup handler information. */
struct __pthread_cleanup_frame
{
void (*__cancel_routine) (void *);
void *__cancel_arg;
int __do_it;
int __cancel_type;
};
#pragma line 658 "/usr/include/pthread.h" 3 4
/* Install a cleanup handler: ROUTINE will be called with arguments ARG
when the thread is canceled or calls pthread_exit. ROUTINE will also
be called with arguments ARG when the matching pthread_cleanup_pop
is executed with non-zero EXECUTE argument.
#pragma empty_line
pthread_cleanup_push and pthread_cleanup_pop are macros and must always
be used in matching pairs at the same nesting level of braces. */
#pragma line 681 "/usr/include/pthread.h" 3 4
extern void __pthread_register_cancel (__pthread_unwind_buf_t *__buf)
;
#pragma empty_line
/* Remove a cleanup handler installed by the matching pthread_cleanup_push.
If EXECUTE is non-zero, the handler function is called. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern void __pthread_unregister_cancel (__pthread_unwind_buf_t *__buf)
;
#pragma empty_line
#pragma empty_line
/* Install a cleanup handler as pthread_cleanup_push does, but also
saves the current cancellation type and sets it to deferred
cancellation. */
#pragma line 716 "/usr/include/pthread.h" 3 4
extern void __pthread_register_cancel_defer (__pthread_unwind_buf_t *__buf)
;
#pragma empty_line
/* Remove a cleanup handler as pthread_cleanup_pop does, but also
restores the cancellation type that was in effect when the matching
pthread_cleanup_push_defer was called. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern void __pthread_unregister_cancel_restore (__pthread_unwind_buf_t *__buf)
;
#pragma empty_line
#pragma empty_line
/* Internal interface to initiate cleanup. */
extern void __pthread_unwind_next (__pthread_unwind_buf_t *__buf)
__attribute__ ((__noreturn__))
#pragma empty_line
__attribute__ ((__weak__))
#pragma empty_line
;
#pragma empty_line
#pragma empty_line
/* Function used in the macros. */
struct __jmp_buf_tag;
extern int __sigsetjmp (struct __jmp_buf_tag *__env, int __savemask) throw ();
#pragma empty_line
#pragma empty_line
/* Mutex handling. */
#pragma empty_line
/* Initialize a mutex. */
extern int pthread_mutex_init (pthread_mutex_t *__mutex,
const pthread_mutexattr_t *__mutexattr)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
/* Destroy a mutex. */
extern int pthread_mutex_destroy (pthread_mutex_t *__mutex)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
/* Try locking a mutex. */
extern int pthread_mutex_trylock (pthread_mutex_t *__mutex)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
/* Lock a mutex. */
extern int pthread_mutex_lock (pthread_mutex_t *__mutex)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
/* Wait until lock becomes available, or specified time passes. */
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
/* Unlock a mutex. */
extern int pthread_mutex_unlock (pthread_mutex_t *__mutex)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
/* Get the priority ceiling of MUTEX. */
extern int pthread_mutex_getprioceiling (const pthread_mutex_t *
__restrict __mutex,
int *__restrict __prioceiling)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
/* Set the priority ceiling of MUTEX to PRIOCEILING, return old
priority ceiling value in *OLD_CEILING. */
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
/* Declare the state protected by MUTEX as consistent. */
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 empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Functions for handling mutex attributes. */
#pragma empty_line
/* Initialize mutex attribute object ATTR with default attributes
(kind is PTHREAD_MUTEX_TIMED_NP). */
extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
/* Destroy mutex attribute object ATTR. */
extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
/* Get the process-shared flag of the mutex attribute ATTR. */
extern int pthread_mutexattr_getpshared (const pthread_mutexattr_t *
__restrict __attr,
int *__restrict __pshared)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
/* Set the process-shared flag of the mutex attribute ATTR. */
extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr,
int __pshared)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
/* Return in *KIND the mutex kind attribute in *ATTR. */
extern int pthread_mutexattr_gettype (const pthread_mutexattr_t *__restrict
__attr, int *__restrict __kind)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
/* Set the mutex kind attribute in *ATTR to KIND (either PTHREAD_MUTEX_NORMAL,
PTHREAD_MUTEX_RECURSIVE, PTHREAD_MUTEX_ERRORCHECK, or
PTHREAD_MUTEX_DEFAULT). */
extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
/* Return in *PROTOCOL the mutex protocol attribute in *ATTR. */
extern int pthread_mutexattr_getprotocol (const pthread_mutexattr_t *
__restrict __attr,
int *__restrict __protocol)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
/* Set the mutex protocol attribute in *ATTR to PROTOCOL (either
PTHREAD_PRIO_NONE, PTHREAD_PRIO_INHERIT, or PTHREAD_PRIO_PROTECT). */
extern int pthread_mutexattr_setprotocol (pthread_mutexattr_t *__attr,
int __protocol)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
/* Return in *PRIOCEILING the mutex prioceiling attribute in *ATTR. */
extern int pthread_mutexattr_getprioceiling (const pthread_mutexattr_t *
__restrict __attr,
int *__restrict __prioceiling)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
/* Set the mutex prioceiling attribute in *ATTR to PRIOCEILING. */
extern int pthread_mutexattr_setprioceiling (pthread_mutexattr_t *__attr,
int __prioceiling)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
/* Get the robustness flag of the mutex attribute ATTR. */
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
/* Set the robustness flag of the mutex attribute ATTR. */
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 empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Functions for handling read-write locks. */
#pragma empty_line
/* Initialize read-write lock RWLOCK using attributes ATTR, or use
the default values if later is NULL. */
extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock,
const pthread_rwlockattr_t *__restrict
__attr) throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
/* Destroy read-write lock RWLOCK. */
extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
/* Acquire read lock for RWLOCK. */
extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
/* Try to acquire read lock for RWLOCK. */
extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
/* Try to acquire read lock for RWLOCK or return after specfied time. */
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
/* Acquire write lock for RWLOCK. */
extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
/* Try to acquire write lock for RWLOCK. */
extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
/* Try to acquire write lock for RWLOCK or return after specfied time. */
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
/* Unlock RWLOCK. */
extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
/* Functions for handling read-write lock attributes. */
#pragma empty_line
/* Initialize attribute object ATTR with default values. */
extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
/* Destroy attribute object ATTR. */
extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
/* Return current setting of process-shared attribute of ATTR in PSHARED. */
extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *
__restrict __attr,
int *__restrict __pshared)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
/* Set process-shared attribute of ATTR to PSHARED. */
extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr,
int __pshared)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
/* Return current setting of reader/writer preference. */
extern int pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t *
__restrict __attr,
int *__restrict __pref)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
/* Set reader/write preference. */
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
/* Functions for handling conditional variables. */
#pragma empty_line
/* Initialize condition variable COND using attributes ATTR, or use
the default values if later is NULL. */
extern int pthread_cond_init (pthread_cond_t *__restrict __cond,
const pthread_condattr_t *__restrict __cond_attr)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
/* Destroy condition variable COND. */
extern int pthread_cond_destroy (pthread_cond_t *__cond)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
/* Wake up one thread waiting for condition variable COND. */
extern int pthread_cond_signal (pthread_cond_t *__cond)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
/* Wake up all threads waiting for condition variables COND. */
extern int pthread_cond_broadcast (pthread_cond_t *__cond)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
/* Wait for condition variable COND to be signaled or broadcast.
MUTEX is assumed to be locked before.
#pragma empty_line
This function is a cancellation point and therefore not marked with
__THROW. */
extern int pthread_cond_wait (pthread_cond_t *__restrict __cond,
pthread_mutex_t *__restrict __mutex)
__attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
/* Wait for condition variable COND to be signaled or broadcast until
ABSTIME. MUTEX is assumed to be locked before. ABSTIME is an
absolute time specification; zero is the beginning of the epoch
(00:00:00 GMT, January 1, 1970).
#pragma empty_line
This function is a cancellation point and therefore not marked with
__THROW. */
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 empty_line
/* Functions for handling condition variable attributes. */
#pragma empty_line
/* Initialize condition variable attribute ATTR. */
extern int pthread_condattr_init (pthread_condattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
/* Destroy condition variable attribute ATTR. */
extern int pthread_condattr_destroy (pthread_condattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
/* Get the process-shared flag of the condition variable attribute ATTR. */
extern int pthread_condattr_getpshared (const pthread_condattr_t *
__restrict __attr,
int *__restrict __pshared)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
/* Set the process-shared flag of the condition variable attribute ATTR. */
extern int pthread_condattr_setpshared (pthread_condattr_t *__attr,
int __pshared) throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
/* Get the clock selected for the condition variable attribute ATTR. */
extern int pthread_condattr_getclock (const pthread_condattr_t *
__restrict __attr,
__clockid_t *__restrict __clock_id)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
/* Set the clock selected for the condition variable attribute ATTR. */
extern int pthread_condattr_setclock (pthread_condattr_t *__attr,
__clockid_t __clock_id)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Functions to handle spinlocks. */
#pragma empty_line
/* Initialize the spinlock LOCK. If PSHARED is nonzero the spinlock can
be shared between different processes. */
extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
/* Destroy the spinlock LOCK. */
extern int pthread_spin_destroy (pthread_spinlock_t *__lock)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
/* Wait until spinlock LOCK is retrieved. */
extern int pthread_spin_lock (pthread_spinlock_t *__lock)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
/* Try to lock spinlock LOCK. */
extern int pthread_spin_trylock (pthread_spinlock_t *__lock)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
/* Release spinlock LOCK. */
extern int pthread_spin_unlock (pthread_spinlock_t *__lock)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
/* Functions to handle barriers. */
#pragma empty_line
/* Initialize BARRIER with the attributes in ATTR. The barrier is
opened when COUNT waiters arrived. */
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
/* Destroy a previously dynamically initialized barrier BARRIER. */
extern int pthread_barrier_destroy (pthread_barrier_t *__barrier)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
/* Wait on barrier BARRIER. */
extern int pthread_barrier_wait (pthread_barrier_t *__barrier)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
/* Initialize barrier attribute ATTR. */
extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
/* Destroy previously dynamically initialized barrier attribute ATTR. */
extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
/* Get the process-shared flag of the barrier attribute ATTR. */
extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t *
__restrict __attr,
int *__restrict __pshared)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
/* Set the process-shared flag of the barrier attribute ATTR. */
extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr,
int __pshared)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Functions for handling thread-specific data. */
#pragma empty_line
/* Create a key value identifying a location in the thread-specific
data area. Each thread maintains a distinct thread-specific data
area. DESTR_FUNCTION, if non-NULL, is called with the value
associated to that key when the key is destroyed.
DESTR_FUNCTION is not called if the value associated is NULL when
the key is destroyed. */
extern int pthread_key_create (pthread_key_t *__key,
void (*__destr_function) (void *))
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
/* Destroy KEY. */
extern int pthread_key_delete (pthread_key_t __key) throw ();
#pragma empty_line
/* Return current value of the thread-specific data slot identified by KEY. */
extern void *pthread_getspecific (pthread_key_t __key) throw ();
#pragma empty_line
/* Store POINTER in the thread-specific data slot identified by KEY. */
extern int pthread_setspecific (pthread_key_t __key,
const void *__pointer) throw () ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Get ID of CPU-time clock for thread THREAD_ID. */
extern int pthread_getcpuclockid (pthread_t __thread_id,
__clockid_t *__clock_id)
throw () __attribute__ ((__nonnull__ (2)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Install handlers to be called when a new process is created with FORK.
The PREPARE handler is called in the parent process just before performing
FORK. The PARENT handler is called in the parent process just after FORK.
The CHILD handler is called in the child process. Each of the three
handlers can be NULL, meaning that no handler needs to be called at that
point.
PTHREAD_ATFORK can be called several times, in which case the PREPARE
handlers are called in LIFO order (last added with PTHREAD_ATFORK,
first called before FORK), and the PARENT and CHILD handlers are called
in FIFO (first added, first called). */
#pragma empty_line
extern int pthread_atfork (void (*__prepare) (void),
void (*__parent) (void),
void (*__child) (void)) throw ();
#pragma line 1160 "/usr/include/pthread.h" 3 4
}
#pragma line 42 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/gthr-default.h" 2 3
#pragma line 1 "/usr/include/unistd.h" 1 3 4
/* Copyright (C) 1991-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
/*
* POSIX Standard: 2.10 Symbolic Constants <unistd.h>
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern "C" {
#pragma empty_line
/* These may be used to determine what facilities are present at compile time.
Their values can be obtained at run time from `sysconf'. */
#pragma empty_line
#pragma empty_line
/* POSIX Standard approved as ISO/IEC 9945-1 as of September 2008. */
#pragma line 49 "/usr/include/unistd.h" 3 4
/* These are not #ifdef __USE_POSIX2 because they are
in the theoretically application-owned namespace. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* The utilities on GNU systems also correspond to this version. */
#pragma line 66 "/usr/include/unistd.h" 3 4
/* The utilities on GNU systems also correspond to this version. */
#pragma empty_line
#pragma empty_line
/* This symbol was required until the 2001 edition of POSIX. */
#pragma empty_line
#pragma empty_line
/* If defined, the implementation supports the
C Language Bindings Option. */
#pragma empty_line
#pragma empty_line
/* If defined, the implementation supports the
C Language Development Utilities Option. */
#pragma empty_line
#pragma empty_line
/* If defined, the implementation supports the
Software Development Utilities Option. */
#pragma empty_line
#pragma empty_line
/* If defined, the implementation supports the
creation of locales with the localedef utility. */
#pragma empty_line
#pragma empty_line
/* X/Open version number to which the library conforms. It is selectable. */
#pragma line 99 "/usr/include/unistd.h" 3 4
/* Commands and utilities from XPG4 are available. */
#pragma empty_line
#pragma empty_line
/* We are compatible with the old published standards as well. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* The X/Open Unix extensions are available. */
#pragma empty_line
#pragma empty_line
/* Encryption is present. */
#pragma empty_line
#pragma empty_line
/* The enhanced internationalization capabilities according to XPG4.2
are present. */
#pragma empty_line
#pragma empty_line
/* The legacy interfaces are also available. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Get values of POSIX options:
#pragma empty_line
If these symbols are defined, the corresponding features are
always available. If not, they may be available sometimes.
The current values can be obtained with `sysconf'.
#pragma empty_line
_POSIX_JOB_CONTROL Job control is supported.
_POSIX_SAVED_IDS Processes have a saved set-user-ID
and a saved set-group-ID.
_POSIX_REALTIME_SIGNALS Real-time, queued signals are supported.
_POSIX_PRIORITY_SCHEDULING Priority scheduling is supported.
_POSIX_TIMERS POSIX.4 clocks and timers are supported.
_POSIX_ASYNCHRONOUS_IO Asynchronous I/O is supported.
_POSIX_PRIORITIZED_IO Prioritized asynchronous I/O is supported.
_POSIX_SYNCHRONIZED_IO Synchronizing file data is supported.
_POSIX_FSYNC The fsync function is present.
_POSIX_MAPPED_FILES Mapping of files to memory is supported.
_POSIX_MEMLOCK Locking of all memory is supported.
_POSIX_MEMLOCK_RANGE Locking of ranges of memory is supported.
_POSIX_MEMORY_PROTECTION Setting of memory protections is supported.
_POSIX_MESSAGE_PASSING POSIX.4 message queues are supported.
_POSIX_SEMAPHORES POSIX.4 counting semaphores are supported.
_POSIX_SHARED_MEMORY_OBJECTS POSIX.4 shared memory objects are supported.
_POSIX_THREADS POSIX.1c pthreads are supported.
_POSIX_THREAD_ATTR_STACKADDR Thread stack address attribute option supported.
_POSIX_THREAD_ATTR_STACKSIZE Thread stack size attribute option supported.
_POSIX_THREAD_SAFE_FUNCTIONS Thread-safe functions are supported.
_POSIX_THREAD_PRIORITY_SCHEDULING
POSIX.1c thread execution scheduling supported.
_POSIX_THREAD_PRIO_INHERIT Thread priority inheritance option supported.
_POSIX_THREAD_PRIO_PROTECT Thread priority protection option supported.
_POSIX_THREAD_PROCESS_SHARED Process-shared synchronization supported.
_POSIX_PII Protocol-independent interfaces are supported.
_POSIX_PII_XTI XTI protocol-indep. interfaces are supported.
_POSIX_PII_SOCKET Socket protocol-indep. interfaces are supported.
_POSIX_PII_INTERNET Internet family of protocols supported.
_POSIX_PII_INTERNET_STREAM Connection-mode Internet protocol supported.
_POSIX_PII_INTERNET_DGRAM Connectionless Internet protocol supported.
_POSIX_PII_OSI ISO/OSI family of protocols supported.
_POSIX_PII_OSI_COTS Connection-mode ISO/OSI service supported.
_POSIX_PII_OSI_CLTS Connectionless ISO/OSI service supported.
_POSIX_POLL Implementation supports `poll' function.
_POSIX_SELECT Implementation supports `select' and `pselect'.
#pragma empty_line
_XOPEN_REALTIME X/Open realtime support is available.
_XOPEN_REALTIME_THREADS X/Open realtime thread support is available.
_XOPEN_SHM Shared memory interface according to XPG4.2.
#pragma empty_line
_XBS5_ILP32_OFF32 Implementation provides environment with 32-bit
int, long, pointer, and off_t types.
_XBS5_ILP32_OFFBIG Implementation provides environment with 32-bit
int, long, and pointer and off_t with at least
64 bits.
_XBS5_LP64_OFF64 Implementation provides environment with 32-bit
int, and 64-bit long, pointer, and off_t types.
_XBS5_LPBIG_OFFBIG Implementation provides environment with at
least 32 bits int and long, pointer, and off_t
with at least 64 bits.
#pragma empty_line
If any of these symbols is defined as -1, the corresponding option is not
true for any file. If any is defined as other than -1, the corresponding
option is true for all files. If a symbol is not defined at all, the value
for a specific file can be obtained from `pathconf' and `fpathconf'.
#pragma empty_line
_POSIX_CHOWN_RESTRICTED Only the super user can use `chown' to change
the owner of a file. `chown' can only be used
to change the group ID of a file to a group of
which the calling process is a member.
_POSIX_NO_TRUNC Pathname components longer than
NAME_MAX generate an error.
_POSIX_VDISABLE If defined, if the value of an element of the
`c_cc' member of `struct termios' is
_POSIX_VDISABLE, no character will have the
effect associated with that element.
_POSIX_SYNC_IO Synchronous I/O may be performed.
_POSIX_ASYNC_IO Asynchronous I/O may be performed.
_POSIX_PRIO_IO Prioritized Asynchronous I/O may be performed.
#pragma empty_line
Support for the Large File Support interface is not generally available.
If it is available the following constants are defined to one.
_LFS64_LARGEFILE Low-level I/O supports large files.
_LFS64_STDIO Standard I/O supports large files.
*/
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/posix_opt.h" 1 3 4
/* Define POSIX options for Linux.
Copyright (C) 1996-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public License as
published by the Free Software Foundation; either version 2.1 of the
License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; see the file COPYING.LIB. If
not, see <http://www.gnu.org/licenses/>. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Job control is supported. */
#pragma empty_line
#pragma empty_line
/* Processes have a saved set-user-ID and a saved set-group-ID. */
#pragma empty_line
#pragma empty_line
/* Priority scheduling is supported. */
#pragma empty_line
#pragma empty_line
/* Synchronizing file data is supported. */
#pragma empty_line
#pragma empty_line
/* The fsync function is present. */
#pragma empty_line
#pragma empty_line
/* Mapping of files to memory is supported. */
#pragma empty_line
#pragma empty_line
/* Locking of all memory is supported. */
#pragma empty_line
#pragma empty_line
/* Locking of ranges of memory is supported. */
#pragma empty_line
#pragma empty_line
/* Setting of memory protections is supported. */
#pragma empty_line
#pragma empty_line
/* Some filesystems allow all users to change file ownership. */
#pragma empty_line
#pragma empty_line
/* `c_cc' member of 'struct termios' structure can be disabled by
using the value _POSIX_VDISABLE. */
#pragma empty_line
#pragma empty_line
/* Filenames are not silently truncated. */
#pragma empty_line
#pragma empty_line
/* X/Open realtime support is available. */
#pragma empty_line
#pragma empty_line
/* X/Open thread realtime support is available. */
#pragma empty_line
#pragma empty_line
/* XPG4.2 shared memory is supported. */
#pragma empty_line
#pragma empty_line
/* Tell we have POSIX threads. */
#pragma empty_line
#pragma empty_line
/* We have the reentrant functions described in POSIX. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* We provide priority scheduling for threads. */
#pragma empty_line
#pragma empty_line
/* We support user-defined stack sizes. */
#pragma empty_line
#pragma empty_line
/* We support user-defined stacks. */
#pragma empty_line
#pragma empty_line
/* We support priority inheritence. */
#pragma empty_line
#pragma empty_line
/* We support priority protection, though only for non-robust
mutexes. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* We support priority inheritence for robust mutexes. */
#pragma empty_line
#pragma empty_line
/* We do not support priority protection for robust mutexes. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* We support POSIX.1b semaphores. */
#pragma empty_line
#pragma empty_line
/* Real-time signals are supported. */
#pragma empty_line
#pragma empty_line
/* We support asynchronous I/O. */
#pragma empty_line
#pragma empty_line
/* Alternative name for Unix98. */
#pragma empty_line
/* Support for prioritization is also available. */
#pragma empty_line
#pragma empty_line
/* The LFS support in asynchronous I/O is also available. */
#pragma empty_line
#pragma empty_line
/* The rest of the LFS is also available. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* POSIX shared memory objects are implemented. */
#pragma empty_line
#pragma empty_line
/* CPU-time clocks support needs to be checked at runtime. */
#pragma empty_line
#pragma empty_line
/* Clock support in threads must be also checked at runtime. */
#pragma empty_line
#pragma empty_line
/* GNU libc provides regular expression handling. */
#pragma empty_line
#pragma empty_line
/* Reader/Writer locks are available. */
#pragma empty_line
#pragma empty_line
/* We have a POSIX shell. */
#pragma empty_line
#pragma empty_line
/* We support the Timeouts option. */
#pragma empty_line
#pragma empty_line
/* We support spinlocks. */
#pragma empty_line
#pragma empty_line
/* The `spawn' function family is supported. */
#pragma empty_line
#pragma empty_line
/* We have POSIX timers. */
#pragma empty_line
#pragma empty_line
/* The barrier functions are available. */
#pragma empty_line
#pragma empty_line
/* POSIX message queues are available. */
#pragma empty_line
#pragma empty_line
/* Thread process-shared synchronization is supported. */
#pragma empty_line
#pragma empty_line
/* The monotonic clock might be available. */
#pragma empty_line
#pragma empty_line
/* The clock selection interfaces are available. */
#pragma empty_line
#pragma empty_line
/* Advisory information interfaces are available. */
#pragma empty_line
#pragma empty_line
/* IPv6 support is available. */
#pragma empty_line
#pragma empty_line
/* Raw socket support is available. */
#pragma empty_line
#pragma empty_line
/* We have at least one terminal. */
#pragma empty_line
#pragma empty_line
/* Neither process nor thread sporadic server interfaces is available. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* trace.h is not available. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Typed memory objects are not available. */
#pragma line 206 "/usr/include/unistd.h" 2 3 4
#pragma empty_line
/* Get the environment definitions from Unix98. */
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/environments.h" 1 3 4
/* Copyright (C) 1999-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#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/wordsize.h" 1 3 4
/* Determine the wordsize from the preprocessor defines. */
#pragma line 13 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 3 4
/* Both x86-64 and x32 use the 64-bit system call interface. */
#pragma line 23 "/usr/include/x86_64-linux-gnu/bits/environments.h" 2 3 4
#pragma empty_line
/* This header should define the following symbols under the described
situations. A value `1' means that the model is always supported,
`-1' means it is never supported. Undefined means it cannot be
statically decided.
#pragma empty_line
_POSIX_V7_ILP32_OFF32 32bit int, long, pointers, and off_t type
_POSIX_V7_ILP32_OFFBIG 32bit int, long, and pointers and larger off_t type
#pragma empty_line
_POSIX_V7_LP64_OFF32 64bit long and pointers and 32bit off_t type
_POSIX_V7_LPBIG_OFFBIG 64bit long and pointers and large off_t type
#pragma empty_line
The macros _POSIX_V6_ILP32_OFF32, _POSIX_V6_ILP32_OFFBIG,
_POSIX_V6_LP64_OFF32, _POSIX_V6_LPBIG_OFFBIG, _XBS5_ILP32_OFF32,
_XBS5_ILP32_OFFBIG, _XBS5_LP64_OFF32, and _XBS5_LPBIG_OFFBIG were
used in previous versions of the Unix standard and are available
only for compatibility.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Environments with 32-bit wide pointers are optionally provided.
Therefore following macros aren't defined:
# undef _POSIX_V7_ILP32_OFF32
# undef _POSIX_V7_ILP32_OFFBIG
# undef _POSIX_V6_ILP32_OFF32
# undef _POSIX_V6_ILP32_OFFBIG
# undef _XBS5_ILP32_OFF32
# undef _XBS5_ILP32_OFFBIG
and users need to check at runtime. */
#pragma empty_line
/* We also have no use (for now) for an environment with bigger pointers
and offsets. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* By default we have 64-bit wide `long int', pointers and `off_t'. */
#pragma line 210 "/usr/include/unistd.h" 2 3 4
#pragma empty_line
#pragma empty_line
/* Standard file descriptors. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* All functions that are not declared anywhere else. */
#pragma line 229 "/usr/include/unistd.h" 3 4
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/clang/bin/../lib/clang/3.1/include/stddef.h" 1 3 4
/*===---- stddef.h - Basic type definitions --------------------------------===
*
* Copyright (c) 2008 Eli Friedman
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*===-----------------------------------------------------------------------===
*/
#pragma line 56 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/clang/bin/../lib/clang/3.1/include/stddef.h" 3 4
/* Some C libraries expect to see a wint_t here. Others (notably MinGW) will use
__WINT_TYPE__ directly; accommodate both by requiring __need_wint_t */
#pragma line 230 "/usr/include/unistd.h" 2 3 4
#pragma empty_line
#pragma empty_line
/* The Single Unix specification says that some more types are
available here. */
#pragma line 282 "/usr/include/unistd.h" 3 4
/* Values for the second argument to access.
These may be OR'd together. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Test for access to NAME using the real UID and real GID. */
extern int access (const char *__name, int __type) throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
/* Test for access to NAME using the effective UID and GID
(as normal file operations use). */
extern int euidaccess (const char *__name, int __type)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
/* An alias for `euidaccess', used by some other systems. */
extern int eaccess (const char *__name, int __type)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Test for access to FILE relative to the directory FD is open on.
If AT_EACCESS is set in FLAG, then use effective IDs like `eaccess',
otherwise use real IDs like `access'. */
extern int faccessat (int __fd, const char *__file, int __type, int __flag)
throw () __attribute__ ((__nonnull__ (2))) /* Ignore */;
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Values for the WHENCE argument to lseek. */
#pragma line 324 "/usr/include/unistd.h" 3 4
/* Old BSD names for the same constants; just for compatibility. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Move FD's file position to OFFSET bytes from the
beginning of the file (if WHENCE is SEEK_SET),
the current position (if WHENCE is SEEK_CUR),
or the end of the file (if WHENCE is SEEK_END).
Return the new file position. */
#pragma empty_line
extern __off_t lseek (int __fd, __off_t __offset, int __whence) throw ();
#pragma line 348 "/usr/include/unistd.h" 3 4
extern __off64_t lseek64 (int __fd, __off64_t __offset, int __whence)
throw ();
#pragma empty_line
#pragma empty_line
/* Close the file descriptor FD.
#pragma empty_line
This function is a cancellation point and therefore not marked with
__THROW. */
extern int close (int __fd);
#pragma empty_line
/* Read NBYTES into BUF from FD. Return the
number read, -1 for errors or 0 for EOF.
#pragma empty_line
This function is a cancellation point and therefore not marked with
__THROW. */
extern ssize_t read (int __fd, void *__buf, size_t __nbytes) /* Ignore */;
#pragma empty_line
/* Write N bytes of BUF to FD. Return the number written, or -1.
#pragma empty_line
This function is a cancellation point and therefore not marked with
__THROW. */
extern ssize_t write (int __fd, const void *__buf, size_t __n) /* Ignore */;
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Read NBYTES into BUF from FD at the given position OFFSET without
changing the file pointer. Return the number read, -1 for errors
or 0 for EOF.
#pragma empty_line
This function is a cancellation point and therefore not marked with
__THROW. */
extern ssize_t pread (int __fd, void *__buf, size_t __nbytes,
__off_t __offset) /* Ignore */;
#pragma empty_line
/* Write N bytes of BUF to FD at the given position OFFSET without
changing the file pointer. Return the number written, or -1.
#pragma empty_line
This function is a cancellation point and therefore not marked with
__THROW. */
extern ssize_t pwrite (int __fd, const void *__buf, size_t __n,
__off_t __offset) /* Ignore */;
#pragma line 404 "/usr/include/unistd.h" 3 4
/* Read NBYTES into BUF from FD at the given position OFFSET without
changing the file pointer. Return the number read, -1 for errors
or 0 for EOF. */
extern ssize_t pread64 (int __fd, void *__buf, size_t __nbytes,
__off64_t __offset) /* Ignore */;
/* Write N bytes of BUF to FD at the given position OFFSET without
changing the file pointer. Return the number written, or -1. */
extern ssize_t pwrite64 (int __fd, const void *__buf, size_t __n,
__off64_t __offset) /* Ignore */;
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Create a one-way communication channel (pipe).
If successful, two file descriptors are stored in PIPEDES;
bytes written on PIPEDES[1] can be read from PIPEDES[0].
Returns 0 if successful, -1 if not. */
extern int pipe (int __pipedes[2]) throw () /* Ignore */;
#pragma empty_line
#pragma empty_line
/* Same as pipe but apply flags passed in FLAGS to the new file
descriptors. */
extern int pipe2 (int __pipedes[2], int __flags) throw () /* Ignore */;
#pragma empty_line
#pragma empty_line
/* Schedule an alarm. In SECONDS seconds, the process will get a SIGALRM.
If SECONDS is zero, any currently scheduled alarm will be cancelled.
The function returns the number of seconds remaining until the last
alarm scheduled would have signaled, or zero if there wasn't one.
There is no return value to indicate an error, but you can set `errno'
to 0 and check its value after calling `alarm', and this might tell you.
The signal may come late due to processor scheduling. */
extern unsigned int alarm (unsigned int __seconds) throw ();
#pragma empty_line
/* Make the process sleep for SECONDS seconds, or until a signal arrives
and is not ignored. The function returns the number of seconds less
than SECONDS which it actually slept (thus zero if it slept the full time).
If a signal handler does a `longjmp' or modifies the handling of the
SIGALRM signal while inside `sleep' call, the handling of the SIGALRM
signal afterwards is undefined. There is no return value to indicate
error, but if `sleep' returns SECONDS, it probably didn't work.
#pragma empty_line
This function is a cancellation point and therefore not marked with
__THROW. */
extern unsigned int sleep (unsigned int __seconds);
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Set an alarm to go off (generating a SIGALRM signal) in VALUE
microseconds. If INTERVAL is nonzero, when the alarm goes off, the
timer is reset to go off every INTERVAL microseconds thereafter.
Returns the number of microseconds remaining before the alarm. */
extern __useconds_t ualarm (__useconds_t __value, __useconds_t __interval)
throw ();
#pragma empty_line
/* Sleep USECONDS microseconds, or until a signal arrives that is not blocked
or ignored.
#pragma empty_line
This function is a cancellation point and therefore not marked with
__THROW. */
extern int usleep (__useconds_t __useconds);
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Suspend the process until a signal arrives.
This always returns -1 and sets `errno' to EINTR.
#pragma empty_line
This function is a cancellation point and therefore not marked with
__THROW. */
extern int pause (void);
#pragma empty_line
#pragma empty_line
/* Change the owner and group of FILE. */
extern int chown (const char *__file, __uid_t __owner, __gid_t __group)
throw () __attribute__ ((__nonnull__ (1))) /* Ignore */;
#pragma empty_line
#pragma empty_line
/* Change the owner and group of the file that FD is open on. */
extern int fchown (int __fd, __uid_t __owner, __gid_t __group) throw () /* Ignore */;
#pragma empty_line
#pragma empty_line
/* Change owner and group of FILE, if it is a symbolic
link the ownership of the symbolic link is changed. */
extern int lchown (const char *__file, __uid_t __owner, __gid_t __group)
throw () __attribute__ ((__nonnull__ (1))) /* Ignore */;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Change the owner and group of FILE relative to the directory FD is open
on. */
extern int fchownat (int __fd, const char *__file, __uid_t __owner,
__gid_t __group, int __flag)
throw () __attribute__ ((__nonnull__ (2))) /* Ignore */;
#pragma empty_line
#pragma empty_line
/* Change the process's working directory to PATH. */
extern int chdir (const char *__path) throw () __attribute__ ((__nonnull__ (1))) /* Ignore */;
#pragma empty_line
#pragma empty_line
/* Change the process's working directory to the one FD is open on. */
extern int fchdir (int __fd) throw () /* Ignore */;
#pragma empty_line
#pragma empty_line
/* Get the pathname of the current working directory,
and put it in SIZE bytes of BUF. Returns NULL if the
directory couldn't be determined or SIZE was too small.
If successful, returns BUF. In GNU, if BUF is NULL,
an array is allocated with `malloc'; the array is SIZE
bytes long, unless SIZE == 0, in which case it is as
big as necessary. */
extern char *getcwd (char *__buf, size_t __size) throw () /* Ignore */;
#pragma empty_line
#pragma empty_line
/* Return a malloc'd string containing the current directory name.
If the environment variable `PWD' is set, and its value is correct,
that value is used. */
extern char *get_current_dir_name (void) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Put the absolute pathname of the current working directory in BUF.
If successful, return BUF. If not, put an error message in
BUF and return NULL. BUF should be at least PATH_MAX bytes long. */
extern char *getwd (char *__buf)
throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__)) /* Ignore */;
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Duplicate FD, returning a new file descriptor on the same file. */
extern int dup (int __fd) throw () /* Ignore */;
#pragma empty_line
/* Duplicate FD to FD2, closing FD2 and making it open on the same file. */
extern int dup2 (int __fd, int __fd2) throw ();
#pragma empty_line
#pragma empty_line
/* Duplicate FD to FD2, closing FD2 and making it open on the same
file while setting flags according to FLAGS. */
extern int dup3 (int __fd, int __fd2, int __flags) throw ();
#pragma empty_line
#pragma empty_line
/* NULL-terminated array of "NAME=VALUE" environment variables. */
extern char **__environ;
#pragma empty_line
extern char **environ;
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Replace the current process, executing PATH with arguments ARGV and
environment ENVP. ARGV and ENVP are terminated by NULL pointers. */
extern int execve (const char *__path, char *const __argv[],
char *const __envp[]) throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
/* Execute the file FD refers to, overlaying the running program image.
ARGV and ENVP are passed to the new program, as for `execve'. */
extern int fexecve (int __fd, char *const __argv[], char *const __envp[])
throw () __attribute__ ((__nonnull__ (2)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Execute PATH with arguments ARGV and environment from `environ'. */
extern int execv (const char *__path, char *const __argv[])
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
/* Execute PATH with all arguments after PATH until a NULL pointer,
and the argument after that for environment. */
extern int execle (const char *__path, const char *__arg, ...)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
/* Execute PATH with all arguments after PATH until
a NULL pointer and environment from `environ'. */
extern int execl (const char *__path, const char *__arg, ...)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
/* Execute FILE, searching in the `PATH' environment variable if it contains
no slashes, with arguments ARGV and environment from `environ'. */
extern int execvp (const char *__file, char *const __argv[])
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
/* Execute FILE, searching in the `PATH' environment variable if
it contains no slashes, with all arguments after FILE until a
NULL pointer and environment from `environ'. */
extern int execlp (const char *__file, const char *__arg, ...)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
/* Execute FILE, searching in the `PATH' environment variable if it contains
no slashes, with arguments ARGV and environment from `environ'. */
extern int execvpe (const char *__file, char *const __argv[],
char *const __envp[])
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Add INC to priority of the current process. */
extern int nice (int __inc) throw () /* Ignore */;
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Terminate program execution with the low-order 8 bits of STATUS. */
extern void _exit (int __status) __attribute__ ((__noreturn__));
#pragma empty_line
#pragma empty_line
/* Get the `_PC_*' symbols for the NAME argument to `pathconf' and `fpathconf';
the `_SC_*' symbols for the NAME argument to `sysconf';
and the `_CS_*' symbols for the NAME argument to `confstr'. */
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/confname.h" 1 3 4
/* `sysconf', `pathconf', and `confstr' NAME values. Generic version.
Copyright (C) 1993-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Values for the NAME argument to `pathconf' and `fpathconf'. */
enum
{
_PC_LINK_MAX,
#pragma empty_line
_PC_MAX_CANON,
#pragma empty_line
_PC_MAX_INPUT,
#pragma empty_line
_PC_NAME_MAX,
#pragma empty_line
_PC_PATH_MAX,
#pragma empty_line
_PC_PIPE_BUF,
#pragma empty_line
_PC_CHOWN_RESTRICTED,
#pragma empty_line
_PC_NO_TRUNC,
#pragma empty_line
_PC_VDISABLE,
#pragma empty_line
_PC_SYNC_IO,
#pragma empty_line
_PC_ASYNC_IO,
#pragma empty_line
_PC_PRIO_IO,
#pragma empty_line
_PC_SOCK_MAXBUF,
#pragma empty_line
_PC_FILESIZEBITS,
#pragma empty_line
_PC_REC_INCR_XFER_SIZE,
#pragma empty_line
_PC_REC_MAX_XFER_SIZE,
#pragma empty_line
_PC_REC_MIN_XFER_SIZE,
#pragma empty_line
_PC_REC_XFER_ALIGN,
#pragma empty_line
_PC_ALLOC_SIZE_MIN,
#pragma empty_line
_PC_SYMLINK_MAX,
#pragma empty_line
_PC_2_SYMLINKS
#pragma empty_line
};
#pragma empty_line
/* Values for the argument to `sysconf'. */
enum
{
_SC_ARG_MAX,
#pragma empty_line
_SC_CHILD_MAX,
#pragma empty_line
_SC_CLK_TCK,
#pragma empty_line
_SC_NGROUPS_MAX,
#pragma empty_line
_SC_OPEN_MAX,
#pragma empty_line
_SC_STREAM_MAX,
#pragma empty_line
_SC_TZNAME_MAX,
#pragma empty_line
_SC_JOB_CONTROL,
#pragma empty_line
_SC_SAVED_IDS,
#pragma empty_line
_SC_REALTIME_SIGNALS,
#pragma empty_line
_SC_PRIORITY_SCHEDULING,
#pragma empty_line
_SC_TIMERS,
#pragma empty_line
_SC_ASYNCHRONOUS_IO,
#pragma empty_line
_SC_PRIORITIZED_IO,
#pragma empty_line
_SC_SYNCHRONIZED_IO,
#pragma empty_line
_SC_FSYNC,
#pragma empty_line
_SC_MAPPED_FILES,
#pragma empty_line
_SC_MEMLOCK,
#pragma empty_line
_SC_MEMLOCK_RANGE,
#pragma empty_line
_SC_MEMORY_PROTECTION,
#pragma empty_line
_SC_MESSAGE_PASSING,
#pragma empty_line
_SC_SEMAPHORES,
#pragma empty_line
_SC_SHARED_MEMORY_OBJECTS,
#pragma empty_line
_SC_AIO_LISTIO_MAX,
#pragma empty_line
_SC_AIO_MAX,
#pragma empty_line
_SC_AIO_PRIO_DELTA_MAX,
#pragma empty_line
_SC_DELAYTIMER_MAX,
#pragma empty_line
_SC_MQ_OPEN_MAX,
#pragma empty_line
_SC_MQ_PRIO_MAX,
#pragma empty_line
_SC_VERSION,
#pragma empty_line
_SC_PAGESIZE,
#pragma empty_line
#pragma empty_line
_SC_RTSIG_MAX,
#pragma empty_line
_SC_SEM_NSEMS_MAX,
#pragma empty_line
_SC_SEM_VALUE_MAX,
#pragma empty_line
_SC_SIGQUEUE_MAX,
#pragma empty_line
_SC_TIMER_MAX,
#pragma empty_line
#pragma empty_line
/* Values for the argument to `sysconf'
corresponding to _POSIX2_* symbols. */
_SC_BC_BASE_MAX,
#pragma empty_line
_SC_BC_DIM_MAX,
#pragma empty_line
_SC_BC_SCALE_MAX,
#pragma empty_line
_SC_BC_STRING_MAX,
#pragma empty_line
_SC_COLL_WEIGHTS_MAX,
#pragma empty_line
_SC_EQUIV_CLASS_MAX,
#pragma empty_line
_SC_EXPR_NEST_MAX,
#pragma empty_line
_SC_LINE_MAX,
#pragma empty_line
_SC_RE_DUP_MAX,
#pragma empty_line
_SC_CHARCLASS_NAME_MAX,
#pragma empty_line
#pragma empty_line
_SC_2_VERSION,
#pragma empty_line
_SC_2_C_BIND,
#pragma empty_line
_SC_2_C_DEV,
#pragma empty_line
_SC_2_FORT_DEV,
#pragma empty_line
_SC_2_FORT_RUN,
#pragma empty_line
_SC_2_SW_DEV,
#pragma empty_line
_SC_2_LOCALEDEF,
#pragma empty_line
#pragma empty_line
_SC_PII,
#pragma empty_line
_SC_PII_XTI,
#pragma empty_line
_SC_PII_SOCKET,
#pragma empty_line
_SC_PII_INTERNET,
#pragma empty_line
_SC_PII_OSI,
#pragma empty_line
_SC_POLL,
#pragma empty_line
_SC_SELECT,
#pragma empty_line
_SC_UIO_MAXIOV,
#pragma empty_line
_SC_IOV_MAX = _SC_UIO_MAXIOV,
#pragma empty_line
_SC_PII_INTERNET_STREAM,
#pragma empty_line
_SC_PII_INTERNET_DGRAM,
#pragma empty_line
_SC_PII_OSI_COTS,
#pragma empty_line
_SC_PII_OSI_CLTS,
#pragma empty_line
_SC_PII_OSI_M,
#pragma empty_line
_SC_T_IOV_MAX,
#pragma empty_line
#pragma empty_line
/* Values according to POSIX 1003.1c (POSIX threads). */
_SC_THREADS,
#pragma empty_line
_SC_THREAD_SAFE_FUNCTIONS,
#pragma empty_line
_SC_GETGR_R_SIZE_MAX,
#pragma empty_line
_SC_GETPW_R_SIZE_MAX,
#pragma empty_line
_SC_LOGIN_NAME_MAX,
#pragma empty_line
_SC_TTY_NAME_MAX,
#pragma empty_line
_SC_THREAD_DESTRUCTOR_ITERATIONS,
#pragma empty_line
_SC_THREAD_KEYS_MAX,
#pragma empty_line
_SC_THREAD_STACK_MIN,
#pragma empty_line
_SC_THREAD_THREADS_MAX,
#pragma empty_line
_SC_THREAD_ATTR_STACKADDR,
#pragma empty_line
_SC_THREAD_ATTR_STACKSIZE,
#pragma empty_line
_SC_THREAD_PRIORITY_SCHEDULING,
#pragma empty_line
_SC_THREAD_PRIO_INHERIT,
#pragma empty_line
_SC_THREAD_PRIO_PROTECT,
#pragma empty_line
_SC_THREAD_PROCESS_SHARED,
#pragma empty_line
#pragma empty_line
_SC_NPROCESSORS_CONF,
#pragma empty_line
_SC_NPROCESSORS_ONLN,
#pragma empty_line
_SC_PHYS_PAGES,
#pragma empty_line
_SC_AVPHYS_PAGES,
#pragma empty_line
_SC_ATEXIT_MAX,
#pragma empty_line
_SC_PASS_MAX,
#pragma empty_line
#pragma empty_line
_SC_XOPEN_VERSION,
#pragma empty_line
_SC_XOPEN_XCU_VERSION,
#pragma empty_line
_SC_XOPEN_UNIX,
#pragma empty_line
_SC_XOPEN_CRYPT,
#pragma empty_line
_SC_XOPEN_ENH_I18N,
#pragma empty_line
_SC_XOPEN_SHM,
#pragma empty_line
#pragma empty_line
_SC_2_CHAR_TERM,
#pragma empty_line
_SC_2_C_VERSION,
#pragma empty_line
_SC_2_UPE,
#pragma empty_line
#pragma empty_line
_SC_XOPEN_XPG2,
#pragma empty_line
_SC_XOPEN_XPG3,
#pragma empty_line
_SC_XOPEN_XPG4,
#pragma empty_line
#pragma empty_line
_SC_CHAR_BIT,
#pragma empty_line
_SC_CHAR_MAX,
#pragma empty_line
_SC_CHAR_MIN,
#pragma empty_line
_SC_INT_MAX,
#pragma empty_line
_SC_INT_MIN,
#pragma empty_line
_SC_LONG_BIT,
#pragma empty_line
_SC_WORD_BIT,
#pragma empty_line
_SC_MB_LEN_MAX,
#pragma empty_line
_SC_NZERO,
#pragma empty_line
_SC_SSIZE_MAX,
#pragma empty_line
_SC_SCHAR_MAX,
#pragma empty_line
_SC_SCHAR_MIN,
#pragma empty_line
_SC_SHRT_MAX,
#pragma empty_line
_SC_SHRT_MIN,
#pragma empty_line
_SC_UCHAR_MAX,
#pragma empty_line
_SC_UINT_MAX,
#pragma empty_line
_SC_ULONG_MAX,
#pragma empty_line
_SC_USHRT_MAX,
#pragma empty_line
#pragma empty_line
_SC_NL_ARGMAX,
#pragma empty_line
_SC_NL_LANGMAX,
#pragma empty_line
_SC_NL_MSGMAX,
#pragma empty_line
_SC_NL_NMAX,
#pragma empty_line
_SC_NL_SETMAX,
#pragma empty_line
_SC_NL_TEXTMAX,
#pragma empty_line
#pragma empty_line
_SC_XBS5_ILP32_OFF32,
#pragma empty_line
_SC_XBS5_ILP32_OFFBIG,
#pragma empty_line
_SC_XBS5_LP64_OFF64,
#pragma empty_line
_SC_XBS5_LPBIG_OFFBIG,
#pragma empty_line
#pragma empty_line
_SC_XOPEN_LEGACY,
#pragma empty_line
_SC_XOPEN_REALTIME,
#pragma empty_line
_SC_XOPEN_REALTIME_THREADS,
#pragma empty_line
#pragma empty_line
_SC_ADVISORY_INFO,
#pragma empty_line
_SC_BARRIERS,
#pragma empty_line
_SC_BASE,
#pragma empty_line
_SC_C_LANG_SUPPORT,
#pragma empty_line
_SC_C_LANG_SUPPORT_R,
#pragma empty_line
_SC_CLOCK_SELECTION,
#pragma empty_line
_SC_CPUTIME,
#pragma empty_line
_SC_THREAD_CPUTIME,
#pragma empty_line
_SC_DEVICE_IO,
#pragma empty_line
_SC_DEVICE_SPECIFIC,
#pragma empty_line
_SC_DEVICE_SPECIFIC_R,
#pragma empty_line
_SC_FD_MGMT,
#pragma empty_line
_SC_FIFO,
#pragma empty_line
_SC_PIPE,
#pragma empty_line
_SC_FILE_ATTRIBUTES,
#pragma empty_line
_SC_FILE_LOCKING,
#pragma empty_line
_SC_FILE_SYSTEM,
#pragma empty_line
_SC_MONOTONIC_CLOCK,
#pragma empty_line
_SC_MULTI_PROCESS,
#pragma empty_line
_SC_SINGLE_PROCESS,
#pragma empty_line
_SC_NETWORKING,
#pragma empty_line
_SC_READER_WRITER_LOCKS,
#pragma empty_line
_SC_SPIN_LOCKS,
#pragma empty_line
_SC_REGEXP,
#pragma empty_line
_SC_REGEX_VERSION,
#pragma empty_line
_SC_SHELL,
#pragma empty_line
_SC_SIGNALS,
#pragma empty_line
_SC_SPAWN,
#pragma empty_line
_SC_SPORADIC_SERVER,
#pragma empty_line
_SC_THREAD_SPORADIC_SERVER,
#pragma empty_line
_SC_SYSTEM_DATABASE,
#pragma empty_line
_SC_SYSTEM_DATABASE_R,
#pragma empty_line
_SC_TIMEOUTS,
#pragma empty_line
_SC_TYPED_MEMORY_OBJECTS,
#pragma empty_line
_SC_USER_GROUPS,
#pragma empty_line
_SC_USER_GROUPS_R,
#pragma empty_line
_SC_2_PBS,
#pragma empty_line
_SC_2_PBS_ACCOUNTING,
#pragma empty_line
_SC_2_PBS_LOCATE,
#pragma empty_line
_SC_2_PBS_MESSAGE,
#pragma empty_line
_SC_2_PBS_TRACK,
#pragma empty_line
_SC_SYMLOOP_MAX,
#pragma empty_line
_SC_STREAMS,
#pragma empty_line
_SC_2_PBS_CHECKPOINT,
#pragma empty_line
#pragma empty_line
_SC_V6_ILP32_OFF32,
#pragma empty_line
_SC_V6_ILP32_OFFBIG,
#pragma empty_line
_SC_V6_LP64_OFF64,
#pragma empty_line
_SC_V6_LPBIG_OFFBIG,
#pragma empty_line
#pragma empty_line
_SC_HOST_NAME_MAX,
#pragma empty_line
_SC_TRACE,
#pragma empty_line
_SC_TRACE_EVENT_FILTER,
#pragma empty_line
_SC_TRACE_INHERIT,
#pragma empty_line
_SC_TRACE_LOG,
#pragma empty_line
#pragma empty_line
_SC_LEVEL1_ICACHE_SIZE,
#pragma empty_line
_SC_LEVEL1_ICACHE_ASSOC,
#pragma empty_line
_SC_LEVEL1_ICACHE_LINESIZE,
#pragma empty_line
_SC_LEVEL1_DCACHE_SIZE,
#pragma empty_line
_SC_LEVEL1_DCACHE_ASSOC,
#pragma empty_line
_SC_LEVEL1_DCACHE_LINESIZE,
#pragma empty_line
_SC_LEVEL2_CACHE_SIZE,
#pragma empty_line
_SC_LEVEL2_CACHE_ASSOC,
#pragma empty_line
_SC_LEVEL2_CACHE_LINESIZE,
#pragma empty_line
_SC_LEVEL3_CACHE_SIZE,
#pragma empty_line
_SC_LEVEL3_CACHE_ASSOC,
#pragma empty_line
_SC_LEVEL3_CACHE_LINESIZE,
#pragma empty_line
_SC_LEVEL4_CACHE_SIZE,
#pragma empty_line
_SC_LEVEL4_CACHE_ASSOC,
#pragma empty_line
_SC_LEVEL4_CACHE_LINESIZE,
#pragma empty_line
/* Leave room here, maybe we need a few more cache levels some day. */
#pragma empty_line
_SC_IPV6 = _SC_LEVEL1_ICACHE_SIZE + 50,
#pragma empty_line
_SC_RAW_SOCKETS,
#pragma empty_line
#pragma empty_line
_SC_V7_ILP32_OFF32,
#pragma empty_line
_SC_V7_ILP32_OFFBIG,
#pragma empty_line
_SC_V7_LP64_OFF64,
#pragma empty_line
_SC_V7_LPBIG_OFFBIG,
#pragma empty_line
#pragma empty_line
_SC_SS_REPL_MAX,
#pragma empty_line
#pragma empty_line
_SC_TRACE_EVENT_NAME_MAX,
#pragma empty_line
_SC_TRACE_NAME_MAX,
#pragma empty_line
_SC_TRACE_SYS_MAX,
#pragma empty_line
_SC_TRACE_USER_EVENT_MAX,
#pragma empty_line
#pragma empty_line
_SC_XOPEN_STREAMS,
#pragma empty_line
#pragma empty_line
_SC_THREAD_ROBUST_PRIO_INHERIT,
#pragma empty_line
_SC_THREAD_ROBUST_PRIO_PROTECT
#pragma empty_line
};
#pragma empty_line
/* Values for the NAME argument to `confstr'. */
enum
{
_CS_PATH, /* The default search path. */
#pragma empty_line
#pragma empty_line
_CS_V6_WIDTH_RESTRICTED_ENVS,
#pragma empty_line
#pragma empty_line
#pragma empty_line
_CS_GNU_LIBC_VERSION,
#pragma empty_line
_CS_GNU_LIBPTHREAD_VERSION,
#pragma empty_line
#pragma empty_line
_CS_V5_WIDTH_RESTRICTED_ENVS,
#pragma empty_line
#pragma empty_line
#pragma empty_line
_CS_V7_WIDTH_RESTRICTED_ENVS,
#pragma empty_line
#pragma empty_line
#pragma empty_line
_CS_LFS_CFLAGS = 1000,
#pragma empty_line
_CS_LFS_LDFLAGS,
#pragma empty_line
_CS_LFS_LIBS,
#pragma empty_line
_CS_LFS_LINTFLAGS,
#pragma empty_line
_CS_LFS64_CFLAGS,
#pragma empty_line
_CS_LFS64_LDFLAGS,
#pragma empty_line
_CS_LFS64_LIBS,
#pragma empty_line
_CS_LFS64_LINTFLAGS,
#pragma empty_line
#pragma empty_line
_CS_XBS5_ILP32_OFF32_CFLAGS = 1100,
#pragma empty_line
_CS_XBS5_ILP32_OFF32_LDFLAGS,
#pragma empty_line
_CS_XBS5_ILP32_OFF32_LIBS,
#pragma empty_line
_CS_XBS5_ILP32_OFF32_LINTFLAGS,
#pragma empty_line
_CS_XBS5_ILP32_OFFBIG_CFLAGS,
#pragma empty_line
_CS_XBS5_ILP32_OFFBIG_LDFLAGS,
#pragma empty_line
_CS_XBS5_ILP32_OFFBIG_LIBS,
#pragma empty_line
_CS_XBS5_ILP32_OFFBIG_LINTFLAGS,
#pragma empty_line
_CS_XBS5_LP64_OFF64_CFLAGS,
#pragma empty_line
_CS_XBS5_LP64_OFF64_LDFLAGS,
#pragma empty_line
_CS_XBS5_LP64_OFF64_LIBS,
#pragma empty_line
_CS_XBS5_LP64_OFF64_LINTFLAGS,
#pragma empty_line
_CS_XBS5_LPBIG_OFFBIG_CFLAGS,
#pragma empty_line
_CS_XBS5_LPBIG_OFFBIG_LDFLAGS,
#pragma empty_line
_CS_XBS5_LPBIG_OFFBIG_LIBS,
#pragma empty_line
_CS_XBS5_LPBIG_OFFBIG_LINTFLAGS,
#pragma empty_line
#pragma empty_line
_CS_POSIX_V6_ILP32_OFF32_CFLAGS,
#pragma empty_line
_CS_POSIX_V6_ILP32_OFF32_LDFLAGS,
#pragma empty_line
_CS_POSIX_V6_ILP32_OFF32_LIBS,
#pragma empty_line
_CS_POSIX_V6_ILP32_OFF32_LINTFLAGS,
#pragma empty_line
_CS_POSIX_V6_ILP32_OFFBIG_CFLAGS,
#pragma empty_line
_CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS,
#pragma empty_line
_CS_POSIX_V6_ILP32_OFFBIG_LIBS,
#pragma empty_line
_CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS,
#pragma empty_line
_CS_POSIX_V6_LP64_OFF64_CFLAGS,
#pragma empty_line
_CS_POSIX_V6_LP64_OFF64_LDFLAGS,
#pragma empty_line
_CS_POSIX_V6_LP64_OFF64_LIBS,
#pragma empty_line
_CS_POSIX_V6_LP64_OFF64_LINTFLAGS,
#pragma empty_line
_CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS,
#pragma empty_line
_CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS,
#pragma empty_line
_CS_POSIX_V6_LPBIG_OFFBIG_LIBS,
#pragma empty_line
_CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS,
#pragma empty_line
#pragma empty_line
_CS_POSIX_V7_ILP32_OFF32_CFLAGS,
#pragma empty_line
_CS_POSIX_V7_ILP32_OFF32_LDFLAGS,
#pragma empty_line
_CS_POSIX_V7_ILP32_OFF32_LIBS,
#pragma empty_line
_CS_POSIX_V7_ILP32_OFF32_LINTFLAGS,
#pragma empty_line
_CS_POSIX_V7_ILP32_OFFBIG_CFLAGS,
#pragma empty_line
_CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS,
#pragma empty_line
_CS_POSIX_V7_ILP32_OFFBIG_LIBS,
#pragma empty_line
_CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS,
#pragma empty_line
_CS_POSIX_V7_LP64_OFF64_CFLAGS,
#pragma empty_line
_CS_POSIX_V7_LP64_OFF64_LDFLAGS,
#pragma empty_line
_CS_POSIX_V7_LP64_OFF64_LIBS,
#pragma empty_line
_CS_POSIX_V7_LP64_OFF64_LINTFLAGS,
#pragma empty_line
_CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS,
#pragma empty_line
_CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS,
#pragma empty_line
_CS_POSIX_V7_LPBIG_OFFBIG_LIBS,
#pragma empty_line
_CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS,
#pragma empty_line
#pragma empty_line
_CS_V6_ENV,
#pragma empty_line
_CS_V7_ENV
#pragma empty_line
};
#pragma line 613 "/usr/include/unistd.h" 2 3 4
#pragma empty_line
/* Get file-specific configuration information about PATH. */
extern long int pathconf (const char *__path, int __name)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
/* Get file-specific configuration about descriptor FD. */
extern long int fpathconf (int __fd, int __name) throw ();
#pragma empty_line
/* Get the value of the system variable NAME. */
extern long int sysconf (int __name) throw ();
#pragma empty_line
#pragma empty_line
/* Get the value of the string-valued system variable NAME. */
extern size_t confstr (int __name, char *__buf, size_t __len) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Get the process ID of the calling process. */
extern __pid_t getpid (void) throw ();
#pragma empty_line
/* Get the process ID of the calling process's parent. */
extern __pid_t getppid (void) throw ();
#pragma empty_line
/* Get the process group ID of the calling process. */
extern __pid_t getpgrp (void) throw ();
#pragma empty_line
/* Get the process group ID of process PID. */
extern __pid_t __getpgid (__pid_t __pid) throw ();
#pragma empty_line
extern __pid_t getpgid (__pid_t __pid) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Set the process group ID of the process matching PID to PGID.
If PID is zero, the current process's process group ID is set.
If PGID is zero, the process ID of the process is used. */
extern int setpgid (__pid_t __pid, __pid_t __pgid) throw ();
#pragma empty_line
#pragma empty_line
/* Both System V and BSD have `setpgrp' functions, but with different
calling conventions. The BSD function is the same as POSIX.1 `setpgid'
(above). The System V function takes no arguments and puts the calling
process in its on group like `setpgid (0, 0)'.
#pragma empty_line
New programs should always use `setpgid' instead.
#pragma empty_line
GNU provides the POSIX.1 function. */
#pragma empty_line
/* Set the process group ID of the calling process to its own PID.
This is exactly the same as `setpgid (0, 0)'. */
extern int setpgrp (void) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Create a new session with the calling process as its leader.
The process group IDs of the session and the calling process
are set to the process ID of the calling process, which is returned. */
extern __pid_t setsid (void) throw ();
#pragma empty_line
#pragma empty_line
/* Return the session ID of the given process. */
extern __pid_t getsid (__pid_t __pid) throw ();
#pragma empty_line
#pragma empty_line
/* Get the real user ID of the calling process. */
extern __uid_t getuid (void) throw ();
#pragma empty_line
/* Get the effective user ID of the calling process. */
extern __uid_t geteuid (void) throw ();
#pragma empty_line
/* Get the real group ID of the calling process. */
extern __gid_t getgid (void) throw ();
#pragma empty_line
/* Get the effective group ID of the calling process. */
extern __gid_t getegid (void) throw ();
#pragma empty_line
/* If SIZE is zero, return the number of supplementary groups
the calling process is in. Otherwise, fill in the group IDs
of its supplementary groups in LIST and return the number written. */
extern int getgroups (int __size, __gid_t __list[]) throw () /* Ignore */;
#pragma empty_line
#pragma empty_line
/* Return nonzero iff the calling process is in group GID. */
extern int group_member (__gid_t __gid) throw ();
#pragma empty_line
#pragma empty_line
/* Set the user ID of the calling process to UID.
If the calling process is the super-user, set the real
and effective user IDs, and the saved set-user-ID to UID;
if not, the effective user ID is set to UID. */
extern int setuid (__uid_t __uid) throw () /* Ignore */;
#pragma empty_line
#pragma empty_line
/* Set the real user ID of the calling process to RUID,
and the effective user ID of the calling process to EUID. */
extern int setreuid (__uid_t __ruid, __uid_t __euid) throw () /* Ignore */;
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Set the effective user ID of the calling process to UID. */
extern int seteuid (__uid_t __uid) throw () /* Ignore */;
#pragma empty_line
#pragma empty_line
/* Set the group ID of the calling process to GID.
If the calling process is the super-user, set the real
and effective group IDs, and the saved set-group-ID to GID;
if not, the effective group ID is set to GID. */
extern int setgid (__gid_t __gid) throw () /* Ignore */;
#pragma empty_line
#pragma empty_line
/* Set the real group ID of the calling process to RGID,
and the effective group ID of the calling process to EGID. */
extern int setregid (__gid_t __rgid, __gid_t __egid) throw () /* Ignore */;
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Set the effective group ID of the calling process to GID. */
extern int setegid (__gid_t __gid) throw () /* Ignore */;
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Fetch the real user ID, effective user ID, and saved-set user ID,
of the calling process. */
extern int getresuid (__uid_t *__ruid, __uid_t *__euid, __uid_t *__suid)
throw ();
#pragma empty_line
/* Fetch the real group ID, effective group ID, and saved-set group ID,
of the calling process. */
extern int getresgid (__gid_t *__rgid, __gid_t *__egid, __gid_t *__sgid)
throw ();
#pragma empty_line
/* Set the real user ID, effective user ID, and saved-set user ID,
of the calling process to RUID, EUID, and SUID, respectively. */
extern int setresuid (__uid_t __ruid, __uid_t __euid, __uid_t __suid)
throw () /* Ignore */;
#pragma empty_line
/* Set the real group ID, effective group ID, and saved-set group ID,
of the calling process to RGID, EGID, and SGID, respectively. */
extern int setresgid (__gid_t __rgid, __gid_t __egid, __gid_t __sgid)
throw () /* Ignore */;
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Clone the calling process, creating an exact copy.
Return -1 for errors, 0 to the new process,
and the process ID of the new process to the old process. */
extern __pid_t fork (void) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Clone the calling process, but without copying the whole address space.
The calling process is suspended until the new process exits or is
replaced by a call to `execve'. Return -1 for errors, 0 to the new process,
and the process ID of the new process to the old process. */
extern __pid_t vfork (void) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Return the pathname of the terminal FD is open on, or NULL on errors.
The returned storage is good only until the next call to this function. */
extern char *ttyname (int __fd) throw ();
#pragma empty_line
/* Store at most BUFLEN characters of the pathname of the terminal FD is
open on in BUF. Return 0 on success, otherwise an error number. */
extern int ttyname_r (int __fd, char *__buf, size_t __buflen)
throw () __attribute__ ((__nonnull__ (2))) /* Ignore */;
#pragma empty_line
/* Return 1 if FD is a valid descriptor associated
with a terminal, zero if not. */
extern int isatty (int __fd) throw ();
#pragma empty_line
#pragma empty_line
/* Return the index into the active-logins file (utmp) for
the controlling terminal. */
extern int ttyslot (void) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Make a link to FROM named TO. */
extern int link (const char *__from, const char *__to)
throw () __attribute__ ((__nonnull__ (1, 2))) /* Ignore */;
#pragma empty_line
#pragma empty_line
/* Like link but relative paths in TO and FROM are interpreted relative
to FROMFD and TOFD respectively. */
extern int linkat (int __fromfd, const char *__from, int __tofd,
const char *__to, int __flags)
throw () __attribute__ ((__nonnull__ (2, 4))) /* Ignore */;
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Make a symbolic link to FROM named TO. */
extern int symlink (const char *__from, const char *__to)
throw () __attribute__ ((__nonnull__ (1, 2))) /* Ignore */;
#pragma empty_line
/* Read the contents of the symbolic link PATH into no more than
LEN bytes of BUF. The contents are not null-terminated.
Returns the number of characters read, or -1 for errors. */
extern ssize_t readlink (const char *__restrict __path,
char *__restrict __buf, size_t __len)
throw () __attribute__ ((__nonnull__ (1, 2))) /* Ignore */;
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Like symlink but a relative path in TO is interpreted relative to TOFD. */
extern int symlinkat (const char *__from, int __tofd,
const char *__to) throw () __attribute__ ((__nonnull__ (1, 3))) /* Ignore */;
#pragma empty_line
/* Like readlink but a relative PATH is interpreted relative to FD. */
extern ssize_t readlinkat (int __fd, const char *__restrict __path,
char *__restrict __buf, size_t __len)
throw () __attribute__ ((__nonnull__ (2, 3))) /* Ignore */;
#pragma empty_line
#pragma empty_line
/* Remove the link NAME. */
extern int unlink (const char *__name) throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
/* Remove the link NAME relative to FD. */
extern int unlinkat (int __fd, const char *__name, int __flag)
throw () __attribute__ ((__nonnull__ (2)));
#pragma empty_line
#pragma empty_line
/* Remove the directory PATH. */
extern int rmdir (const char *__path) throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
/* Return the foreground process group ID of FD. */
extern __pid_t tcgetpgrp (int __fd) throw ();
#pragma empty_line
/* Set the foreground process group ID of FD set PGRP_ID. */
extern int tcsetpgrp (int __fd, __pid_t __pgrp_id) throw ();
#pragma empty_line
#pragma empty_line
/* Return the login name of the user.
#pragma empty_line
This function is a possible cancellation point and therefore not
marked with __THROW. */
extern char *getlogin (void);
#pragma empty_line
/* Return at most NAME_LEN characters of the login name of the user in NAME.
If it cannot be determined or some other error occurred, return the error
code. Otherwise return 0.
#pragma empty_line
This function is a possible cancellation point and therefore not
marked with __THROW. */
extern int getlogin_r (char *__name, size_t __name_len) __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Set the login name returned by `getlogin'. */
extern int setlogin (const char *__name) throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Get definitions and prototypes for functions to process the
arguments in ARGV (ARGC of them, minus the program name) for
options given in OPTS. */
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/getopt_posix.h" 1 3 4
/* Declarations for getopt (POSIX compatibility shim).
Copyright (C) 1989-2018 Free Software Foundation, Inc.
Unlike the bulk of the getopt implementation, this file is NOT part
of gnulib.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma line 27 "/usr/include/x86_64-linux-gnu/bits/getopt_posix.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/getopt_core.h" 1 3 4
/* Declarations for getopt (basic, portable features only).
Copyright (C) 1989-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library and is also part of gnulib.
Patches to this file should be submitted to both projects.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* This header should not be used directly; include getopt.h or
unistd.h instead. Unlike most bits headers, it does not have
a protective #error, because the guard macro for getopt.h in
gnulib is not fixed. */
#pragma empty_line
extern "C" {
#pragma empty_line
/* For communication from 'getopt' to the caller.
When 'getopt' finds an option that takes an argument,
the argument value is returned here.
Also, when 'ordering' is RETURN_IN_ORDER,
each non-option ARGV-element is returned here. */
#pragma empty_line
extern char *optarg;
#pragma empty_line
/* Index in ARGV of the next element to be scanned.
This is used for communication to and from the caller
and for communication between successive calls to 'getopt'.
#pragma empty_line
On entry to 'getopt', zero means this is the first call; initialize.
#pragma empty_line
When 'getopt' returns -1, this is the index of the first of the
non-option elements that the caller should itself scan.
#pragma empty_line
Otherwise, 'optind' communicates from one call to the next
how much of ARGV has been scanned so far. */
#pragma empty_line
extern int optind;
#pragma empty_line
/* Callers store zero here to inhibit the error message 'getopt' prints
for unrecognized options. */
#pragma empty_line
extern int opterr;
#pragma empty_line
/* Set to an option character which was unrecognized. */
#pragma empty_line
extern int optopt;
#pragma empty_line
/* Get definitions and prototypes for functions to process the
arguments in ARGV (ARGC of them, minus the program name) for
options given in OPTS.
#pragma empty_line
Return the option character from OPTS just read. Return -1 when
there are no more options. For unrecognized options, or options
missing arguments, 'optopt' is set to the option letter, and '?' is
returned.
#pragma empty_line
The OPTS string is a list of characters which are recognized option
letters, optionally followed by colons, specifying that that letter
takes an argument, to be placed in 'optarg'.
#pragma empty_line
If a letter in OPTS is followed by two colons, its argument is
optional. This behavior is specific to the GNU 'getopt'.
#pragma empty_line
The argument '--' causes premature termination of argument
scanning, explicitly telling 'getopt' that there are no more
options.
#pragma empty_line
If OPTS begins with '-', then non-option arguments are treated as
arguments to the option '\1'. This behavior is specific to the GNU
'getopt'. If OPTS begins with '+', or POSIXLY_CORRECT is set in
the environment, then do not permute arguments.
#pragma empty_line
For standards compliance, the 'argv' argument has the type
char *const *, but this is inaccurate; if argument permutation is
enabled, the argv array (not the strings it points to) must be
writable. */
#pragma empty_line
extern int getopt (int ___argc, char *const *___argv, const char *__shortopts)
throw () __attribute__ ((__nonnull__ (2, 3)));
#pragma empty_line
}
#pragma line 28 "/usr/include/x86_64-linux-gnu/bits/getopt_posix.h" 2 3 4
#pragma empty_line
extern "C" {
#pragma line 49 "/usr/include/x86_64-linux-gnu/bits/getopt_posix.h" 3 4
}
#pragma line 873 "/usr/include/unistd.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Put the name of the current host in no more than LEN bytes of NAME.
The result is null-terminated if LEN is large enough for the full
name and the terminator. */
extern int gethostname (char *__name, size_t __len) throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Set the name of the current host to NAME, which is LEN bytes long.
This call is restricted to the super-user. */
extern int sethostname (const char *__name, size_t __len)
throw () __attribute__ ((__nonnull__ (1))) /* Ignore */;
#pragma empty_line
/* Set the current machine's Internet number to ID.
This call is restricted to the super-user. */
extern int sethostid (long int __id) throw () /* Ignore */;
#pragma empty_line
#pragma empty_line
/* Get and set the NIS (aka YP) domain name, if any.
Called just like `gethostname' and `sethostname'.
The NIS domain name is usually the empty string when not using NIS. */
extern int getdomainname (char *__name, size_t __len)
throw () __attribute__ ((__nonnull__ (1))) /* Ignore */;
extern int setdomainname (const char *__name, size_t __len)
throw () __attribute__ ((__nonnull__ (1))) /* Ignore */;
#pragma empty_line
#pragma empty_line
/* Revoke access permissions to all processes currently communicating
with the control terminal, and then send a SIGHUP signal to the process
group of the control terminal. */
extern int vhangup (void) throw ();
#pragma empty_line
/* Revoke the access of all descriptors currently open on FILE. */
extern int revoke (const char *__file) throw () __attribute__ ((__nonnull__ (1))) /* Ignore */;
#pragma empty_line
#pragma empty_line
/* Enable statistical profiling, writing samples of the PC into at most
SIZE bytes of SAMPLE_BUFFER; every processor clock tick while profiling
is enabled, the system examines the user PC and increments
SAMPLE_BUFFER[((PC - OFFSET) / 2) * SCALE / 65536]. If SCALE is zero,
disable profiling. Returns zero on success, -1 on error. */
extern int profil (unsigned short int *__sample_buffer, size_t __size,
size_t __offset, unsigned int __scale)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
/* Turn accounting on if NAME is an existing file. The system will then write
a record for each process as it terminates, to this file. If NAME is NULL,
turn accounting off. This call is restricted to the super-user. */
extern int acct (const char *__name) throw ();
#pragma empty_line
#pragma empty_line
/* Successive calls return the shells listed in `/etc/shells'. */
extern char *getusershell (void) throw ();
extern void endusershell (void) throw (); /* Discard cached info. */
extern void setusershell (void) throw (); /* Rewind and re-read the file. */
#pragma empty_line
#pragma empty_line
/* Put the program in the background, and dissociate from the controlling
terminal. If NOCHDIR is zero, do `chdir ("/")'. If NOCLOSE is zero,
redirects stdin, stdout, and stderr to /dev/null. */
extern int daemon (int __nochdir, int __noclose) throw () /* Ignore */;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Make PATH be the root directory (the starting point for absolute paths).
This call is restricted to the super-user. */
extern int chroot (const char *__path) throw () __attribute__ ((__nonnull__ (1))) /* Ignore */;
#pragma empty_line
/* Prompt with PROMPT and read a string from the terminal without echoing.
Uses /dev/tty if possible; otherwise stderr and stdin. */
extern char *getpass (const char *__prompt) __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Make all changes done to FD actually appear on disk.
#pragma empty_line
This function is a cancellation point and therefore not marked with
__THROW. */
extern int fsync (int __fd);
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Make all changes done to all files on the file system associated
with FD actually appear on disk. */
extern int syncfs (int __fd) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Return identifier for the current host. */
extern long int gethostid (void);
#pragma empty_line
/* Make all changes done to all files actually appear on disk. */
extern void sync (void) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Return the number of bytes in a page. This is the system's page size,
which is not necessarily the same as the hardware page size. */
extern int getpagesize (void) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
/* Return the maximum number of file descriptors
the current process could possibly have. */
extern int getdtablesize (void) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Truncate FILE to LENGTH bytes. */
#pragma empty_line
extern int truncate (const char *__file, __off_t __length)
throw () __attribute__ ((__nonnull__ (1))) /* Ignore */;
#pragma line 1006 "/usr/include/unistd.h" 3 4
extern int truncate64 (const char *__file, __off64_t __length)
throw () __attribute__ ((__nonnull__ (1))) /* Ignore */;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Truncate the file FD is open on to LENGTH bytes. */
#pragma empty_line
extern int ftruncate (int __fd, __off_t __length) throw () /* Ignore */;
#pragma line 1027 "/usr/include/unistd.h" 3 4
extern int ftruncate64 (int __fd, __off64_t __length) throw () /* Ignore */;
#pragma line 1036 "/usr/include/unistd.h" 3 4
/* Set the end of accessible data space (aka "the break") to ADDR.
Returns zero on success and -1 for errors (with errno set). */
extern int brk (void *__addr) throw () /* Ignore */;
#pragma empty_line
/* Increase or decrease the end of accessible data space by DELTA bytes.
If successful, returns the address the previous end of data space
(i.e. the beginning of the new space, if DELTA > 0);
returns (void *) -1 for errors (with errno set). */
extern void *sbrk (intptr_t __delta) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Invoke `system call' number SYSNO, passing it the remaining arguments.
This is completely system-dependent, and not often useful.
#pragma empty_line
In Unix, `syscall' sets `errno' for all errors and most calls return -1
for errors; in many systems you cannot pass arguments or get return
values for all system calls (`pipe', `fork', and `getppid' typically
among them).
#pragma empty_line
In Mach, all system calls take normal arguments and always return an
error code (zero for success). */
extern long int syscall (long int __sysno, ...) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* NOTE: These declarations also appear in <fcntl.h>; be sure to keep both
files consistent. Some systems have them there and some here, and some
software depends on the macros being defined without including both. */
#pragma empty_line
/* `lockf' is a simpler interface to the locking facilities of `fcntl'.
LEN is always relative to the current file position.
The CMD argument is one of the following.
#pragma empty_line
This function is a cancellation point and therefore not marked with
__THROW. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int lockf (int __fd, int __cmd, __off_t __len) /* Ignore */;
#pragma line 1092 "/usr/include/unistd.h" 3 4
extern int lockf64 (int __fd, int __cmd, __off64_t __len) /* Ignore */;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Evaluate EXPRESSION, and repeat as long as it returns -1 with `errno'
set to EINTR. */
#pragma line 1109 "/usr/include/unistd.h" 3 4
/* Copy LENGTH bytes from INFD to OUTFD. */
ssize_t copy_file_range (int __infd, __off64_t *__pinoff,
int __outfd, __off64_t *__poutoff,
size_t __length, unsigned int __flags);
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Synchronize at least the data part of a file with the underlying
media. */
extern int fdatasync (int __fildes);
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* XPG4.2 specifies that prototypes for the encryption functions must
be defined here. */
#pragma empty_line
/* Encrypt at most 8 characters from KEY using salt to perturb DES. */
extern char *crypt (const char *__key, const char *__salt)
throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
/* Encrypt data in BLOCK in place if EDFLAG is zero; otherwise decrypt
block in place. */
extern void encrypt (char *__glibc_block, int __edflag)
throw () __attribute__ ((__nonnull__ (1)));
#pragma empty_line
#pragma empty_line
/* Swab pairs bytes in the first N bytes of the area pointed to by
FROM and copy the result to TO. The value of TO must not be in the
range [FROM - N + 1, FROM - 1]. If N is odd the first byte in FROM
is without partner. */
extern void swab (const void *__restrict __from, void *__restrict __to,
ssize_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Prior to Issue 6, the Single Unix Specification required these
prototypes to appear in this header. They are also found in
<stdio.h>. */
#pragma line 1156 "/usr/include/unistd.h" 3 4
/* Unix98 requires this function to be declared here. In other
standards it is in <pthread.h>. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Write LENGTH bytes of randomness starting at BUFFER. Return 0 on
success or -1 on error. */
int getentropy (void *__buffer, size_t __length) /* Ignore */;
#pragma empty_line
#pragma empty_line
/* Define some macros helping to catch buffer overflows. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 43 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/gthr-default.h" 2 3
#pragma empty_line
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 empty_line
/* POSIX like conditional variables are supported. Please look at comments
in gthr.h for details. */
#pragma line 81 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/gthr-default.h" 3
/* Typically, __gthrw_foo is a weak reference to symbol foo. */
#pragma empty_line
#pragma empty_line
/* On Tru64, /usr/include/pthread.h uses #pragma extern_prefix "__" to
map a subset of the POSIX pthread API to mangled versions of their
names. */
#pragma line 118 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-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
#pragma empty_line
static __typeof(pthread_mutex_timedlock) __gthrw_pthread_mutex_timedlock __attribute__ ((__weakref__("pthread_mutex_timedlock")));
#pragma empty_line
#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_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
#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 183 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/gthr-default.h" 3
/* On Solaris 2.6 up to 9, the libc exposes a POSIX threads interface even if
-pthreads is not specified. The functions are dummies and most return an
error value. However pthread_once returns 0 without invoking the routine
it is passed so we cannot pretend that the interface is active if -pthreads
is not specified. On Solaris 2.5.1, the interface is not exposed at all so
we need to play the usual game with weak symbols. On Solaris 10 and up, a
working interface is always exposed. On FreeBSD 6 and later, libc also
exposes a dummy POSIX threads interface, similar to what Solaris 2.6 up
to 9 does. FreeBSD >= 700014 even provides a pthread_cancel stub in libc,
which means the alternate __gthread_active_p below cannot be used there. */
#pragma line 239 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/gthr-default.h" 3
static inline int
__gthread_active_p (void)
{
static void *const __gthread_active_ptr
= __extension__ (void *) &__gthrw_pthread_cancel;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
return __gthread_active_ptr != 0;
}
#pragma line 657 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-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 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
#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
#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 800 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-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
#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
#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_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_timedwait_recursive (__gthread_cond_t *__cond,
__gthread_recursive_mutex_t *__mutex,
const __gthread_time_t *__abs_timeout)
{
return __gthread_cond_timedwait (__cond, __mutex, __abs_timeout);
}
#pragma empty_line
static inline int
__gthread_cond_destroy (__gthread_cond_t* __cond)
{
return __gthrw_pthread_cond_destroy (__cond);
}
#pragma line 171 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/gthr.h" 2 3
#pragma empty_line
/* Fallback to single thread definitions. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma GCC visibility pop
#pragma line 35 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ext/atomicity.h" 2 3
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/atomic_word.h" 1 3
// Low-level type for atomic operations -*- C++ -*-
#pragma empty_line
// Copyright (C) 2004, 2009 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file atomic_word.h
* This file is a GNU extension to the Standard C++ Library.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef int _Atomic_word;
#pragma empty_line
// Define these two macros using the appropriate memory barrier for the target.
// The commented out versions below are the defaults.
// See ia64/atomic_word.h for an alternative approach.
#pragma empty_line
// This one prevents loads from being hoisted across the barrier;
// in other words, this is a Load-Load acquire barrier.
// This is necessary iff TARGET_RELAXED_ORDERING is defined in tm.h.
// #define _GLIBCXX_READ_MEM_BARRIER __asm __volatile ("":::"memory")
#pragma empty_line
// This one prevents stores from being sunk across the barrier; in other
// words, a Store-Store release barrier.
// #define _GLIBCXX_WRITE_MEM_BARRIER __asm __volatile ("":::"memory")
#pragma line 36 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ext/atomicity.h" 2 3
#pragma empty_line
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
// Functions for portable atomic access.
// To abstract locking primitives across all thread policies, use:
// __exchange_and_add_dispatch
// __atomic_add_dispatch
#pragma empty_line
static inline _Atomic_word
__exchange_and_add(volatile _Atomic_word* __mem, int __val)
{ return __sync_fetch_and_add(__mem, __val); }
#pragma empty_line
static inline void
__atomic_add(volatile _Atomic_word* __mem, int __val)
{ __sync_fetch_and_add(__mem, __val); }
#pragma line 63 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/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
} // namespace
#pragma empty_line
// Even if the CPU doesn't need a memory barrier, we need to ensure
// that the compiler doesn't reorder memory accesses across the
// barriers.
#pragma line 41 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/ios_base.h" 2 3
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_classes.h" 1 3
// Locale support -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010, 2011
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file bits/locale_classes.h
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{locale}
*/
#pragma empty_line
//
// ISO C++ 14882: 22.1 Locales
//
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 39 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_classes.h" 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/string" 1 3
// Components for manipulating sequences of characters -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
// 2005, 2006, 2007, 2009, 2010, 2011
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file include/string
* This is a Standard C++ Library header.
*/
#pragma empty_line
//
// ISO C++ 14882: 21 Strings library
//
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 38 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/string" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/allocator.h" 1 3
// Allocators -*- C++ -*-
#pragma empty_line
// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
// 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/*
* Copyright (c) 1996-1997
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*/
#pragma empty_line
/** @file bits/allocator.h
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{memory}
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
// Define the base class to std::allocator.
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/c++allocator.h" 1 3
// Base to std::allocator -*- C++ -*-
#pragma empty_line
// Copyright (C) 2004, 2005, 2009, 2010 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file bits/c++allocator.h
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{memory}
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
// Define new_allocator as the base class to std::allocator.
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ext/new_allocator.h" 1 3
// Allocator that wraps operator new -*- C++ -*-
#pragma empty_line
// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file ext/new_allocator.h
* This file is a GNU extension to the Standard C++ Library.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/new" 1 3
// The -*- C++ -*- dynamic memory management header.
#pragma empty_line
// Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
// 2003, 2004, 2005, 2006, 2007, 2009, 2010
// Free Software Foundation
#pragma empty_line
// This file is part of GCC.
//
// GCC is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// GCC is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file new
* This is a Standard C++ Library header.
*
* The header @c new defines several functions to manage dynamic memory and
* handling memory allocation errors; see
* http://gcc.gnu.org/onlinedocs/libstdc++/18_support/howto.html#4 for more.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 39 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/new" 3
#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 std
{
/**
* @brief Exception possibly thrown by @c new.
* @ingroup exceptions
*
* @c bad_alloc (or classes derived from it) is used to report allocation
* errors from the throwing forms of @c new. */
class bad_alloc : public exception
{
public:
bad_alloc() throw() { }
#pragma empty_line
// This declaration is not useless:
// http://gcc.gnu.org/onlinedocs/gcc-3.0.2/gcc_6.html#SEC118
virtual ~bad_alloc() throw();
#pragma empty_line
// See comment in eh_exception.cc.
virtual const char* what() const throw();
};
#pragma empty_line
struct nothrow_t { };
#pragma empty_line
extern const nothrow_t nothrow;
#pragma empty_line
/** If you write your own error handler to be called by @c new, it must
* be of this type. */
typedef void (*new_handler)();
#pragma empty_line
/// Takes a replacement handler as the argument, returns the
/// previous handler.
new_handler set_new_handler(new_handler) throw();
} // namespace std
#pragma empty_line
//@{
/** These are replaceable signatures:
* - normal single new and delete (no arguments, throw @c bad_alloc on error)
* - normal array new and delete (same)
* - @c nothrow single new and delete (take a @c nothrow argument, return
* @c NULL on error)
* - @c nothrow array new and delete (same)
*
* Placement new and delete signatures (take a memory address argument,
* does nothing) may not be replaced by a user's program.
*/
void* operator new(std::size_t) throw (std::bad_alloc);
void* operator new[](std::size_t) throw (std::bad_alloc);
void operator delete(void*) throw();
void operator delete[](void*) throw();
void* operator new(std::size_t, const std::nothrow_t&) throw();
void* operator new[](std::size_t, const std::nothrow_t&) throw();
void operator delete(void*, const std::nothrow_t&) throw();
void operator delete[](void*, const std::nothrow_t&) throw();
#pragma empty_line
// Default placement versions of operator new.
inline void* operator new(std::size_t, void* __p) throw() { return __p; }
inline void* operator new[](std::size_t, void* __p) throw() { return __p; }
#pragma empty_line
// Default placement versions of operator delete.
inline void operator delete (void*, void*) throw() { }
inline void operator delete[](void*, void*) throw() { }
//@}
} // extern "C++"
#pragma empty_line
#pragma GCC visibility pop
#pragma line 35 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ext/new_allocator.h" 2 3
#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 empty_line
/**
* @brief An allocator that uses global new, as per [20.4].
* @ingroup allocators
*
* This is precisely the allocator defined in the C++ Standard.
* - all allocation calls operator new
* - all deallocation calls operator delete
*/
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
new_allocator() throw() { }
#pragma empty_line
new_allocator(const new_allocator&) throw() { }
#pragma empty_line
template<typename _Tp1>
new_allocator(const new_allocator<_Tp1>&) throw() { }
#pragma empty_line
~new_allocator() throw() { }
#pragma empty_line
pointer
address(reference __x) const { return std::__addressof(__x); }
#pragma empty_line
const_pointer
address(const_reference __x) const { return std::__addressof(__x); }
#pragma empty_line
// NB: __n is permitted to be 0. The C++ standard says nothing
// about what the return value is when __n == 0.
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
// __p is not permitted to be a null pointer.
void
deallocate(pointer __p, size_type)
{ ::operator delete(__p); }
#pragma empty_line
size_type
max_size() const throw()
{ return size_t(-1) / sizeof(_Tp); }
#pragma empty_line
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 402. wrong new expression in [some_] allocator::construct
void
construct(pointer __p, const _Tp& __val)
{ ::new((void *)__p) _Tp(__val); }
#pragma line 117 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ext/new_allocator.h" 3
void
destroy(pointer __p) { __p->~_Tp(); }
};
#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
} // namespace
#pragma line 35 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/c++allocator.h" 2 3
#pragma line 49 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/allocator.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 empty_line
/**
* @defgroup allocators Allocators
* @ingroup memory
*
* Classes encapsulating memory operations.
*/
#pragma empty_line
template<typename _Tp>
class allocator;
#pragma empty_line
/// allocator<void> specialization.
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
/**
* @brief The @a standard allocator, as per [20.4].
* @ingroup allocators
*
* Further details:
* http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt04ch11.html
*/
template<typename _Tp>
class allocator: public __gnu_cxx::new_allocator<_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
allocator() throw() { }
#pragma empty_line
allocator(const allocator& __a) throw()
: __gnu_cxx::new_allocator<_Tp>(__a) { }
#pragma empty_line
template<typename _Tp1>
allocator(const allocator<_Tp1>&) throw() { }
#pragma empty_line
~allocator() throw() { }
#pragma empty_line
// Inherit everything else.
};
#pragma empty_line
template<typename _T1, typename _T2>
inline bool
operator==(const allocator<_T1>&, const allocator<_T2>&)
{ return true; }
#pragma empty_line
template<typename _Tp>
inline bool
operator==(const allocator<_Tp>&, const allocator<_Tp>&)
{ return true; }
#pragma empty_line
template<typename _T1, typename _T2>
inline bool
operator!=(const allocator<_T1>&, const allocator<_T2>&)
{ return false; }
#pragma empty_line
template<typename _Tp>
inline bool
operator!=(const allocator<_Tp>&, const allocator<_Tp>&)
{ return false; }
#pragma empty_line
// Inhibit implicit instantiations for required instantiations,
// which are defined via explicit instantiations elsewhere.
#pragma empty_line
extern template class allocator<char>;
extern template class allocator<wchar_t>;
#pragma empty_line
#pragma empty_line
// Undefine.
#pragma empty_line
#pragma empty_line
// To implement Option 3 of DR 431.
template<typename _Alloc, bool = __is_empty(_Alloc)>
struct __alloc_swap
{ static void _S_do_it(_Alloc&, _Alloc&) { } };
#pragma empty_line
template<typename _Alloc>
struct __alloc_swap<_Alloc, false>
{
static void
_S_do_it(_Alloc& __one, _Alloc& __two)
{
// Precondition: swappable allocators.
if (__one != __two)
swap(__one, __two);
}
};
#pragma empty_line
// Optimize for stateless allocators.
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 line 237 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/allocator.h" 3
} // namespace std
#pragma line 43 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/string" 2 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/ostream_insert.h" 1 3
// Helpers for ostream inserters -*- C++ -*-
#pragma empty_line
// Copyright (C) 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file bits/ostream_insert.h
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{ostream}
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 33 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/ostream_insert.h" 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/cxxabi_forced.h" 1 3
// cxxabi.h subset for cancellation -*- C++ -*-
#pragma empty_line
// Copyright (C) 2007, 2009, 2010, 2011 Free Software Foundation, Inc.
//
// This file is part of GCC.
//
// GCC is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// GCC is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file bits/cxxabi_forced.h
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{cxxabi.h}
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 34 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/cxxabi_forced.h" 3
#pragma empty_line
#pragma GCC visibility push(default)
#pragma empty_line
#pragma empty_line
namespace __cxxabiv1
{
/**
* @brief Thrown as part of forced unwinding.
* @ingroup exceptions
*
* A magic placeholder class that can be caught by reference to
* recognize forced unwinding.
*/
class __forced_unwind
{
virtual ~__forced_unwind() throw();
#pragma empty_line
// Prevent catch by value.
virtual void __pure_dummy() = 0;
};
}
#pragma empty_line
#pragma empty_line
#pragma GCC visibility pop
#pragma line 36 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/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)
{
if (true)
{
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);
}
if (false)
{
__out._M_setstate(__ios_base::badbit);
;
}
if (false)
{ __out._M_setstate(__ios_base::badbit); }
}
return __out;
}
#pragma empty_line
// Inhibit implicit instantiations for required instantiations,
// which are defined via explicit instantiations elsewhere.
#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
} // namespace std
#pragma line 46 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/string" 2 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_function.h" 1 3
// Functor implementations -*- C++ -*-
#pragma empty_line
// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009, 2010, 2011
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1996-1998
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*/
#pragma empty_line
/** @file bits/stl_function.h
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{functional}
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
// 20.3.1 base classes
/** @defgroup functors Function Objects
* @ingroup utilities
*
* Function objects, or @e functors, are objects with an @c operator()
* defined and accessible. They can be passed as arguments to algorithm
* templates and used in place of a function pointer. Not only is the
* resulting expressiveness of the library increased, but the generated
* code can be more efficient than what you might write by hand. When we
* refer to @a functors, then, generally we include function pointers in
* the description as well.
*
* Often, functors are only created as temporaries passed to algorithm
* calls, rather than being created as named variables.
*
* Two examples taken from the standard itself follow. To perform a
* by-element addition of two vectors @c a and @c b containing @c double,
* and put the result in @c a, use
* \code
* transform (a.begin(), a.end(), b.begin(), a.begin(), plus<double>());
* \endcode
* To negate every element in @c a, use
* \code
* transform(a.begin(), a.end(), a.begin(), negate<double>());
* \endcode
* The addition and negation functions will be inlined directly.
*
* The standard functors are derived from structs named @c unary_function
* and @c binary_function. These two classes contain nothing but typedefs,
* to aid in generic (template) programming. If you write your own
* functors, you might consider doing the same.
*
* @{
*/
/**
* This is one of the @link functors functor base classes@endlink.
*/
template<typename _Arg, typename _Result>
struct unary_function
{
/// @c argument_type is the type of the argument
typedef _Arg argument_type;
#pragma empty_line
/// @c result_type is the return type
typedef _Result result_type;
};
#pragma empty_line
/**
* This is one of the @link functors functor base classes@endlink.
*/
template<typename _Arg1, typename _Arg2, typename _Result>
struct binary_function
{
/// @c first_argument_type is the type of the first argument
typedef _Arg1 first_argument_type;
#pragma empty_line
/// @c second_argument_type is the type of the second argument
typedef _Arg2 second_argument_type;
#pragma empty_line
/// @c result_type is the return type
typedef _Result result_type;
};
/** @} */
#pragma empty_line
// 20.3.2 arithmetic
/** @defgroup arithmetic_functors Arithmetic Classes
* @ingroup functors
*
* Because basic math often needs to be done during an algorithm,
* the library provides functors for those operations. See the
* documentation for @link functors the base classes@endlink
* for examples of their use.
*
* @{
*/
/// One of the @link arithmetic_functors math functors@endlink.
template<typename _Tp>
struct plus : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x + __y; }
};
#pragma empty_line
/// One of the @link arithmetic_functors math functors@endlink.
template<typename _Tp>
struct minus : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x - __y; }
};
#pragma empty_line
/// One of the @link arithmetic_functors math functors@endlink.
template<typename _Tp>
struct multiplies : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x * __y; }
};
#pragma empty_line
/// One of the @link arithmetic_functors math functors@endlink.
template<typename _Tp>
struct divides : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x / __y; }
};
#pragma empty_line
/// One of the @link arithmetic_functors math functors@endlink.
template<typename _Tp>
struct modulus : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x % __y; }
};
#pragma empty_line
/// One of the @link arithmetic_functors math functors@endlink.
template<typename _Tp>
struct negate : public unary_function<_Tp, _Tp>
{
_Tp
operator()(const _Tp& __x) const
{ return -__x; }
};
/** @} */
#pragma empty_line
// 20.3.3 comparisons
/** @defgroup comparison_functors Comparison Classes
* @ingroup functors
*
* The library provides six wrapper functors for all the basic comparisons
* in C++, like @c <.
*
* @{
*/
/// One of the @link comparison_functors comparison functors@endlink.
template<typename _Tp>
struct equal_to : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x == __y; }
};
#pragma empty_line
/// One of the @link comparison_functors comparison functors@endlink.
template<typename _Tp>
struct not_equal_to : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x != __y; }
};
#pragma empty_line
/// One of the @link comparison_functors comparison functors@endlink.
template<typename _Tp>
struct greater : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x > __y; }
};
#pragma empty_line
/// One of the @link comparison_functors comparison functors@endlink.
template<typename _Tp>
struct less : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x < __y; }
};
#pragma empty_line
/// One of the @link comparison_functors comparison functors@endlink.
template<typename _Tp>
struct greater_equal : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x >= __y; }
};
#pragma empty_line
/// One of the @link comparison_functors comparison functors@endlink.
template<typename _Tp>
struct less_equal : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x <= __y; }
};
/** @} */
#pragma empty_line
// 20.3.4 logical operations
/** @defgroup logical_functors Boolean Operations Classes
* @ingroup functors
*
* Here are wrapper functors for Boolean operations: @c &&, @c ||,
* and @c !.
*
* @{
*/
/// One of the @link logical_functors Boolean operations functors@endlink.
template<typename _Tp>
struct logical_and : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x && __y; }
};
#pragma empty_line
/// One of the @link logical_functors Boolean operations functors@endlink.
template<typename _Tp>
struct logical_or : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x || __y; }
};
#pragma empty_line
/// One of the @link logical_functors Boolean operations functors@endlink.
template<typename _Tp>
struct logical_not : public unary_function<_Tp, bool>
{
bool
operator()(const _Tp& __x) const
{ return !__x; }
};
/** @} */
#pragma empty_line
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 660. Missing Bitwise Operations.
template<typename _Tp>
struct bit_and : public binary_function<_Tp, _Tp, _Tp>
{
_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>
{
_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>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x ^ __y; }
};
#pragma empty_line
// 20.3.5 negators
/** @defgroup negators Negators
* @ingroup functors
*
* The functions @c not1 and @c not2 each take a predicate functor
* and return an instance of @c unary_negate or
* @c binary_negate, respectively. These classes are functors whose
* @c operator() performs the stored predicate function and then returns
* the negation of the result.
*
* For example, given a vector of integers and a trivial predicate,
* \code
* struct IntGreaterThanThree
* : public std::unary_function<int, bool>
* {
* bool operator() (int x) { return x > 3; }
* };
*
* std::find_if (v.begin(), v.end(), not1(IntGreaterThanThree()));
* \endcode
* The call to @c find_if will locate the first index (i) of @c v for which
* <code>!(v[i] > 3)</code> is true.
*
* The not1/unary_negate combination works on predicates taking a single
* argument. The not2/binary_negate combination works on predicates which
* take two arguments.
*
* @{
*/
/// One of the @link negators negation functors@endlink.
template<typename _Predicate>
class unary_negate
: public unary_function<typename _Predicate::argument_type, bool>
{
protected:
_Predicate _M_pred;
#pragma empty_line
public:
explicit
unary_negate(const _Predicate& __x) : _M_pred(__x) { }
#pragma empty_line
bool
operator()(const typename _Predicate::argument_type& __x) const
{ return !_M_pred(__x); }
};
#pragma empty_line
/// One of the @link negators negation functors@endlink.
template<typename _Predicate>
inline unary_negate<_Predicate>
not1(const _Predicate& __pred)
{ return unary_negate<_Predicate>(__pred); }
#pragma empty_line
/// One of the @link negators negation functors@endlink.
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:
explicit
binary_negate(const _Predicate& __x) : _M_pred(__x) { }
#pragma empty_line
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
/// One of the @link negators negation functors@endlink.
template<typename _Predicate>
inline binary_negate<_Predicate>
not2(const _Predicate& __pred)
{ return binary_negate<_Predicate>(__pred); }
/** @} */
#pragma empty_line
// 20.3.7 adaptors pointers functions
/** @defgroup pointer_adaptors Adaptors for pointers to functions
* @ingroup functors
*
* The advantage of function objects over pointers to functions is that
* the objects in the standard library declare nested typedefs describing
* their argument and result types with uniform names (e.g., @c result_type
* from the base classes @c unary_function and @c binary_function).
* Sometimes those typedefs are required, not just optional.
*
* Adaptors are provided to turn pointers to unary (single-argument) and
* binary (double-argument) functions into function objects. The
* long-winded functor @c pointer_to_unary_function is constructed with a
* function pointer @c f, and its @c operator() called with argument @c x
* returns @c f(x). The functor @c pointer_to_binary_function does the same
* thing, but with a double-argument @c f and @c operator().
*
* The function @c ptr_fun takes a pointer-to-function @c f and constructs
* an instance of the appropriate functor.
*
* @{
*/
/// One of the @link pointer_adaptors adaptors for function pointers@endlink.
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
/// One of the @link pointer_adaptors adaptors for function pointers@endlink.
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
/// One of the @link pointer_adaptors adaptors for function pointers@endlink.
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
/// One of the @link pointer_adaptors adaptors for function pointers@endlink.
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
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 line 508 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_function.h" 3
};
#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 empty_line
// 20.3.8 adaptors pointers members
/** @defgroup memory_adaptors Adaptors for pointers to members
* @ingroup functors
*
* There are a total of 8 = 2^3 function objects in this family.
* (1) Member functions taking no arguments vs member functions taking
* one argument.
* (2) Call through pointer vs call through reference.
* (3) Const vs non-const member function.
*
* All of this complexity is in the function objects themselves. You can
* ignore it by using the helper function mem_fun and mem_fun_ref,
* which create whichever type of adaptor is appropriate.
*
* @{
*/
/// One of the @link memory_adaptors adaptors for member
/// pointers@endlink.
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
/// One of the @link memory_adaptors adaptors for member
/// pointers@endlink.
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
/// One of the @link memory_adaptors adaptors for member
/// pointers@endlink.
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
/// One of the @link memory_adaptors adaptors for member
/// pointers@endlink.
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
/// One of the @link memory_adaptors adaptors for member
/// pointers@endlink.
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
/// One of the @link memory_adaptors adaptors for member
/// pointers@endlink.
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
/// One of the @link memory_adaptors adaptors for member
/// pointers@endlink.
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
/// One of the @link memory_adaptors adaptors for member
/// pointers@endlink.
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
// Mem_fun adaptor helper functions. There are only two:
// mem_fun and mem_fun_ref.
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
} // namespace
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/backward/binders.h" 1 3
// Functor implementations -*- C++ -*-
#pragma empty_line
// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009, 2010, 2011
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1996-1998
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*/
#pragma empty_line
/** @file backward/binders.h
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{functional}
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
// 20.3.6 binders
/** @defgroup binders Binder Classes
* @ingroup functors
*
* Binders turn functions/functors with two arguments into functors
* with a single argument, storing an argument to be applied later.
* For example, a variable @c B of type @c binder1st is constructed
* from a functor @c f and an argument @c x. Later, B's @c
* operator() is called with a single argument @c y. The return
* value is the value of @c f(x,y). @c B can be @a called with
* various arguments (y1, y2, ...) and will in turn call @c
* f(x,y1), @c f(x,y2), ...
*
* The function @c bind1st is provided to save some typing. It takes the
* function and an argument as parameters, and returns an instance of
* @c binder1st.
*
* The type @c binder2nd and its creator function @c bind2nd do the same
* thing, but the stored argument is passed as the second parameter instead
* of the first, e.g., @c bind2nd(std::minus<float>,1.3) will create a
* functor whose @c operator() accepts a floating-point number, subtracts
* 1.3 from it, and returns the result. (If @c bind1st had been used,
* the functor would perform <em>1.3 - x</em> instead.
*
* Creator-wrapper functions like @c bind1st are intended to be used in
* calling algorithms. Their return values will be temporary objects.
* (The goal is to not require you to type names like
* @c std::binder1st<std::plus<int>> for declaring a variable to hold the
* return value from @c bind1st(std::plus<int>,5).
*
* These become more useful when combined with the composition functions.
*
* @{
*/
/// One of the @link binders binder functors@endlink.
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
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 109. Missing binders for non-const sequence elements
typename _Operation::result_type
operator()(typename _Operation::second_argument_type& __x) const
{ return op(value, __x); }
} ;
#pragma empty_line
/// One of the @link binders binder functors@endlink.
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
/// One of the @link binders binder functors@endlink.
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
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 109. Missing binders for non-const sequence elements
typename _Operation::result_type
operator()(typename _Operation::first_argument_type& __x) const
{ return op(__x, value); }
} ;
#pragma empty_line
/// One of the @link binders binder functors@endlink.
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
} // namespace
#pragma line 732 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_function.h" 2 3
#pragma line 50 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/string" 2 3
#pragma empty_line
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/range_access.h" 1 3
// <range_access.h> -*- C++ -*-
#pragma empty_line
// Copyright (C) 2010 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file bits/range_access.h
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{iterator}
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 33 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/range_access.h" 3
#pragma line 53 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/string" 2 3
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 1 3
// Components for manipulating sequences of characters -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010, 2011
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file bits/basic_string.h
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{string}
*/
#pragma empty_line
//
// ISO C++ 14882: 21 Strings library
//
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 39 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/initializer_list" 1 3
// std::initializer_list support -*- C++ -*-
#pragma empty_line
// Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
//
// This file is part of GCC.
//
// GCC is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// GCC is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file initializer_list
* This is a Standard C++ Library header.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 33 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/initializer_list" 3
#pragma line 43 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 2 3
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
/**
* @class basic_string basic_string.h <string>
* @brief Managing sequences of characters and character-like objects.
*
* @ingroup strings
* @ingroup sequences
*
* Meets the requirements of a <a href="tables.html#65">container</a>, a
* <a href="tables.html#66">reversible container</a>, and a
* <a href="tables.html#67">sequence</a>. Of the
* <a href="tables.html#68">optional sequence requirements</a>, only
* @c push_back, @c at, and @c %array access are supported.
*
* @doctodo
*
*
* Documentation? What's that?
* Nathan Myers <ncm@cantrip.org>.
*
* A string looks like this:
*
* @code
* [_Rep]
* _M_length
* [basic_string<char_type>] _M_capacity
* _M_dataplus _M_refcount
* _M_p ----------------> unnamed array of char_type
* @endcode
*
* Where the _M_p points to the first character in the string, and
* you cast it to a pointer-to-_Rep and subtract 1 to get a
* pointer to the header.
*
* This approach has the enormous advantage that a string object
* requires only one allocation. All the ugliness is confined
* within a single %pair of inline functions, which each compile to
* a single @a add instruction: _Rep::_M_data(), and
* string::_M_rep(); and the allocation function which gets a
* block of raw bytes and with room enough and constructs a _Rep
* object at the front.
*
* The reason you want _M_data pointing to the character %array and
* not the _Rep is so that the debugger can see the string
* contents. (Probably we should add a non-inline member to get
* the _Rep for the debugger to use, so users can check the actual
* string length.)
*
* Note that the _Rep object is a POD so that you can have a
* static <em>empty string</em> _Rep object already @a constructed before
* static constructors have run. The reference-count encoding is
* chosen so that a 0 indicates one reference, so you never try to
* destroy the empty-string _Rep object.
*
* All but the last paragraph is considered pretty conventional
* for a C++ string implementation.
*/
// 21.3 Template class basic_string
template<typename _CharT, typename _Traits, typename _Alloc>
class basic_string
{
typedef typename _Alloc::template rebind<_CharT>::other _CharT_alloc_type;
#pragma empty_line
// Types:
public:
typedef _Traits traits_type;
typedef typename _Traits::char_type value_type;
typedef _Alloc allocator_type;
typedef typename _CharT_alloc_type::size_type size_type;
typedef typename _CharT_alloc_type::difference_type difference_type;
typedef typename _CharT_alloc_type::reference reference;
typedef typename _CharT_alloc_type::const_reference const_reference;
typedef typename _CharT_alloc_type::pointer pointer;
typedef typename _CharT_alloc_type::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
private:
// _Rep: string representation
// Invariants:
// 1. String really contains _M_length + 1 characters: due to 21.3.4
// must be kept null-terminated.
// 2. _M_capacity >= _M_length
// Allocated memory is always (_M_capacity + 1) * sizeof(_CharT).
// 3. _M_refcount has three states:
// -1: leaked, one reference, no ref-copies allowed, non-const.
// 0: one reference, non-const.
// n>0: n + 1 references, operations require a lock, const.
// 4. All fields==0 is an empty string, given the extra storage
// beyond-the-end for a null terminator; thus, the shared
// empty string representation needs no constructor.
#pragma empty_line
struct _Rep_base
{
size_type _M_length;
size_type _M_capacity;
_Atomic_word _M_refcount;
};
#pragma empty_line
struct _Rep : _Rep_base
{
// Types:
typedef typename _Alloc::template rebind<char>::other _Raw_bytes_alloc;
#pragma empty_line
// (Public) Data members:
#pragma empty_line
// The maximum number of individual char_type elements of an
// individual string is determined by _S_max_size. This is the
// value that will be returned by max_size(). (Whereas npos
// is the maximum number of bytes the allocator can allocate.)
// If one was to divvy up the theoretical largest size string,
// with a terminating character and m _CharT elements, it'd
// look like this:
// npos = sizeof(_Rep) + (m * sizeof(_CharT)) + sizeof(_CharT)
// Solving for m:
// m = ((npos - sizeof(_Rep))/sizeof(CharT)) - 1
// In addition, this implementation quarters this amount.
static const size_type _S_max_size;
static const _CharT _S_terminal;
#pragma empty_line
// The following storage is init'd to 0 by the linker, resulting
// (carefully) in an empty string with one reference.
static size_type _S_empty_rep_storage[];
#pragma empty_line
static _Rep&
_S_empty_rep()
{
// NB: Mild hack to avoid strict-aliasing warnings. Note that
// _S_empty_rep_storage is never modified and the punning should
// be reasonably safe in this case.
void* __p = reinterpret_cast<void*>(&_S_empty_rep_storage);
return *reinterpret_cast<_Rep*>(__p);
}
#pragma empty_line
bool
_M_is_leaked() const
{ return this->_M_refcount < 0; }
#pragma empty_line
bool
_M_is_shared() const
{ return this->_M_refcount > 0; }
#pragma empty_line
void
_M_set_leaked()
{ this->_M_refcount = -1; }
#pragma empty_line
void
_M_set_sharable()
{ this->_M_refcount = 0; }
#pragma empty_line
void
_M_set_length_and_sharable(size_type __n)
{
#pragma empty_line
if (__builtin_expect(this != &_S_empty_rep(), false))
#pragma empty_line
{
this->_M_set_sharable(); // One reference.
this->_M_length = __n;
traits_type::assign(this->_M_refdata()[__n], _S_terminal);
// grrr. (per 21.3.4)
// You cannot leave those LWG people alone for a second.
}
}
#pragma empty_line
_CharT*
_M_refdata() throw()
{ return reinterpret_cast<_CharT*>(this + 1); }
#pragma empty_line
_CharT*
_M_grab(const _Alloc& __alloc1, const _Alloc& __alloc2)
{
return (!_M_is_leaked() && __alloc1 == __alloc2)
? _M_refcopy() : _M_clone(__alloc1);
}
#pragma empty_line
// Create & Destroy
static _Rep*
_S_create(size_type, size_type, const _Alloc&);
#pragma empty_line
void
_M_dispose(const _Alloc& __a)
{
#pragma empty_line
if (__builtin_expect(this != &_S_empty_rep(), false))
#pragma empty_line
{
// Be race-detector-friendly. For more info see bits/c++config.
;
if (__gnu_cxx::__exchange_and_add_dispatch(&this->_M_refcount,
-1) <= 0)
{
;
_M_destroy(__a);
}
}
} // XXX MT
#pragma empty_line
void
_M_destroy(const _Alloc&) throw();
#pragma empty_line
_CharT*
_M_refcopy() throw()
{
#pragma empty_line
if (__builtin_expect(this != &_S_empty_rep(), false))
#pragma empty_line
__gnu_cxx::__atomic_add_dispatch(&this->_M_refcount, 1);
return _M_refdata();
} // XXX MT
#pragma empty_line
_CharT*
_M_clone(const _Alloc&, size_type __res = 0);
};
#pragma empty_line
// Use empty-base optimization: http://www.cantrip.org/emptyopt.html
struct _Alloc_hider : _Alloc
{
_Alloc_hider(_CharT* __dat, const _Alloc& __a)
: _Alloc(__a), _M_p(__dat) { }
#pragma empty_line
_CharT* _M_p; // The actual data.
};
#pragma empty_line
public:
// Data Members (public):
// NB: This is an unsigned type, and thus represents the maximum
// size that the allocator can hold.
/// Value returned by various member functions when they fail.
static const size_type npos = static_cast<size_type>(-1);
#pragma empty_line
private:
// Data Members (private):
mutable _Alloc_hider _M_dataplus;
#pragma empty_line
_CharT*
_M_data() const
{ return _M_dataplus._M_p; }
#pragma empty_line
_CharT*
_M_data(_CharT* __p)
{ return (_M_dataplus._M_p = __p); }
#pragma empty_line
_Rep*
_M_rep() const
{ return &((reinterpret_cast<_Rep*> (_M_data()))[-1]); }
#pragma empty_line
// For the internal use we have functions similar to `begin'/`end'
// but they do not call _M_leak.
iterator
_M_ibegin() const
{ return iterator(_M_data()); }
#pragma empty_line
iterator
_M_iend() const
{ return iterator(_M_data() + this->size()); }
#pragma empty_line
void
_M_leak() // for use in begin() & non-const op[]
{
if (!_M_rep()->_M_is_leaked())
_M_leak_hard();
}
#pragma empty_line
size_type
_M_check(size_type __pos, const char* __s) const
{
if (__pos > this->size())
__throw_out_of_range((__s));
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
// NB: _M_limit doesn't check for a bad __pos value.
size_type
_M_limit(size_type __pos, size_type __off) const
{
const bool __testoff = __off < this->size() - __pos;
return __testoff ? __off : this->size() - __pos;
}
#pragma empty_line
// True if _Rep and source do not overlap.
bool
_M_disjunct(const _CharT* __s) const
{
return (less<const _CharT*>()(__s, _M_data())
|| less<const _CharT*>()(_M_data() + this->size(), __s));
}
#pragma empty_line
// When __n = 1 way faster than the general multichar
// traits_type::copy/move/assign.
static void
_M_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
_M_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
_M_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
// _S_copy_chars is a separate template to permit specialization
// to optimize for the common case of pointers as iterators.
template<class _Iterator>
static void
_S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2)
{
for (; __k1 != __k2; ++__k1, ++__p)
traits_type::assign(*__p, *__k1); // These types are off.
}
#pragma empty_line
static void
_S_copy_chars(_CharT* __p, iterator __k1, iterator __k2)
{ _S_copy_chars(__p, __k1.base(), __k2.base()); }
#pragma empty_line
static void
_S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2)
{ _S_copy_chars(__p, __k1.base(), __k2.base()); }
#pragma empty_line
static void
_S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2)
{ _M_copy(__p, __k1, __k2 - __k1); }
#pragma empty_line
static void
_S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
{ _M_copy(__p, __k1, __k2 - __k1); }
#pragma empty_line
static int
_S_compare(size_type __n1, size_type __n2)
{
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_mutate(size_type __pos, size_type __len1, size_type __len2);
#pragma empty_line
void
_M_leak_hard();
#pragma empty_line
static _Rep&
_S_empty_rep()
{ return _Rep::_S_empty_rep(); }
#pragma empty_line
public:
// Construct/copy/destroy:
// NB: We overload ctors in some cases instead of using default
// arguments, per 17.4.4.4 para. 2 item 2.
#pragma empty_line
/**
* @brief Default constructor creates an empty string.
*/
basic_string()
#pragma empty_line
: _M_dataplus(_S_empty_rep()._M_refdata(), _Alloc()) { }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/**
* @brief Construct an empty string using allocator @a a.
*/
explicit
basic_string(const _Alloc& __a);
#pragma empty_line
// NB: per LWG issue 42, semantics different from IS:
/**
* @brief Construct string with copy of value of @a str.
* @param str Source string.
*/
basic_string(const basic_string& __str);
/**
* @brief Construct string as copy of a substring.
* @param str Source string.
* @param pos Index of first character to copy from.
* @param n Number of characters to copy (default remainder).
*/
basic_string(const basic_string& __str, size_type __pos,
size_type __n = npos);
/**
* @brief Construct string as copy of a substring.
* @param str Source string.
* @param pos Index of first character to copy from.
* @param n Number of characters to copy.
* @param a Allocator to use.
*/
basic_string(const basic_string& __str, size_type __pos,
size_type __n, const _Alloc& __a);
#pragma empty_line
/**
* @brief Construct string initialized by a character %array.
* @param s Source character %array.
* @param n Number of characters to copy.
* @param a Allocator to use (default is default allocator).
*
* NB: @a s must have at least @a n characters, '\\0'
* has no special meaning.
*/
basic_string(const _CharT* __s, size_type __n,
const _Alloc& __a = _Alloc());
/**
* @brief Construct string as copy of a C string.
* @param s Source C string.
* @param a Allocator to use (default is default allocator).
*/
basic_string(const _CharT* __s, const _Alloc& __a = _Alloc());
/**
* @brief Construct string as multiple characters.
* @param n Number of characters.
* @param c Character to use.
* @param a Allocator to use (default is default allocator).
*/
basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc());
#pragma line 519 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
/**
* @brief Construct string as copy of a range.
* @param beg Start of range.
* @param end End of range.
* @param a Allocator to use (default is default allocator).
*/
template<class _InputIterator>
basic_string(_InputIterator __beg, _InputIterator __end,
const _Alloc& __a = _Alloc());
#pragma empty_line
/**
* @brief Destroy the string instance.
*/
~basic_string()
{ _M_rep()->_M_dispose(this->get_allocator()); }
#pragma empty_line
/**
* @brief Assign the value of @a str to this string.
* @param str Source string.
*/
basic_string&
operator=(const basic_string& __str)
{ return this->assign(__str); }
#pragma empty_line
/**
* @brief Copy contents of @a s into this string.
* @param s Source null-terminated string.
*/
basic_string&
operator=(const _CharT* __s)
{ return this->assign(__s); }
#pragma empty_line
/**
* @brief Set value to string of length 1.
* @param c Source character.
*
* Assigning to a character makes this string length 1 and
* (*this)[0] == @a c.
*/
basic_string&
operator=(_CharT __c)
{
this->assign(1, __c);
return *this;
}
#pragma line 593 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
// Iterators:
/**
* Returns a read/write iterator that points to the first character in
* the %string. Unshares the string.
*/
iterator
begin()
{
_M_leak();
return iterator(_M_data());
}
#pragma empty_line
/**
* Returns a read-only (constant) iterator that points to the first
* character in the %string.
*/
const_iterator
begin() const
{ return const_iterator(_M_data()); }
#pragma empty_line
/**
* Returns a read/write iterator that points one past the last
* character in the %string. Unshares the string.
*/
iterator
end()
{
_M_leak();
return iterator(_M_data() + this->size());
}
#pragma empty_line
/**
* Returns a read-only (constant) iterator that points one past the
* last character in the %string.
*/
const_iterator
end() const
{ return const_iterator(_M_data() + this->size()); }
#pragma empty_line
/**
* Returns a read/write reverse iterator that points to the last
* character in the %string. Iteration is done in reverse element
* order. Unshares the string.
*/
reverse_iterator
rbegin()
{ return reverse_iterator(this->end()); }
#pragma empty_line
/**
* Returns a read-only (constant) reverse iterator that points
* to the last character in the %string. Iteration is done in
* reverse element order.
*/
const_reverse_iterator
rbegin() const
{ return const_reverse_iterator(this->end()); }
#pragma empty_line
/**
* Returns a read/write reverse iterator that points to one before the
* first character in the %string. Iteration is done in reverse
* element order. Unshares the string.
*/
reverse_iterator
rend()
{ return reverse_iterator(this->begin()); }
#pragma empty_line
/**
* Returns a read-only (constant) reverse iterator that points
* to one before the first character in the %string. Iteration
* is done in reverse element order.
*/
const_reverse_iterator
rend() const
{ return const_reverse_iterator(this->begin()); }
#pragma line 704 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
public:
// Capacity:
/// Returns the number of characters in the string, not including any
/// null-termination.
size_type
size() const
{ return _M_rep()->_M_length; }
#pragma empty_line
/// Returns the number of characters in the string, not including any
/// null-termination.
size_type
length() const
{ return _M_rep()->_M_length; }
#pragma empty_line
/// Returns the size() of the largest possible %string.
size_type
max_size() const
{ return _Rep::_S_max_size; }
#pragma empty_line
/**
* @brief Resizes the %string to the specified number of characters.
* @param n Number of characters the %string should contain.
* @param c Character to fill any new elements.
*
* This function will %resize the %string to the specified
* number of characters. If the number is smaller than the
* %string's current size the %string is truncated, otherwise
* the %string is extended and new elements are %set to @a c.
*/
void
resize(size_type __n, _CharT __c);
#pragma empty_line
/**
* @brief Resizes the %string to the specified number of characters.
* @param n Number of characters the %string should contain.
*
* This function will resize the %string to the specified length. If
* the new size is smaller than the %string's current size the %string
* is truncated, otherwise the %string is extended and new characters
* are default-constructed. For basic types such as char, this means
* setting them to 0.
*/
void
resize(size_type __n)
{ this->resize(__n, _CharT()); }
#pragma line 762 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
/**
* Returns the total number of characters that the %string can hold
* before needing to allocate more memory.
*/
size_type
capacity() const
{ return _M_rep()->_M_capacity; }
#pragma empty_line
/**
* @brief Attempt to preallocate enough memory for specified number of
* characters.
* @param res_arg Number of characters required.
* @throw std::length_error If @a res_arg exceeds @c max_size().
*
* This function attempts to reserve enough memory for the
* %string to hold the specified number of characters. If the
* number requested is more than max_size(), length_error is
* thrown.
*
* The advantage of this function is that if optimal code is a
* necessity and the user can determine the string length that will be
* required, the user can reserve the memory in %advance, and thus
* prevent a possible reallocation of memory and copying of %string
* data.
*/
void
reserve(size_type __res_arg = 0);
#pragma empty_line
/**
* Erases the string, making it empty.
*/
void
clear()
{ _M_mutate(0, this->size(), 0); }
#pragma empty_line
/**
* Returns true if the %string is empty. Equivalent to
* <code>*this == ""</code>.
*/
bool
empty() const
{ return this->size() == 0; }
#pragma empty_line
// Element access:
/**
* @brief Subscript access to the data contained in the %string.
* @param pos The index of the character to access.
* @return Read-only (constant) reference to the character.
*
* This operator allows for easy, array-style, data access.
* Note that data access with this operator is unchecked and
* out_of_range lookups are not defined. (For checked lookups
* see at().)
*/
const_reference
operator[] (size_type __pos) const
{
;
return _M_data()[__pos];
}
#pragma empty_line
/**
* @brief Subscript access to the data contained in the %string.
* @param pos The index of the character to access.
* @return Read/write reference to the character.
*
* This operator allows for easy, array-style, data access.
* Note that data access with this operator is unchecked and
* out_of_range lookups are not defined. (For checked lookups
* see at().) Unshares the string.
*/
reference
operator[](size_type __pos)
{
// allow pos == size() as v3 extension:
;
// but be strict in pedantic mode:
;
_M_leak();
return _M_data()[__pos];
}
#pragma empty_line
/**
* @brief Provides access to the data contained in the %string.
* @param n The index of the character to access.
* @return Read-only (const) reference to the character.
* @throw std::out_of_range If @a n is an invalid index.
*
* This function provides for safer data access. The parameter is
* first checked that it is in the range of the string. The function
* throws out_of_range if the check fails.
*/
const_reference
at(size_type __n) const
{
if (__n >= this->size())
__throw_out_of_range(("basic_string::at"));
return _M_data()[__n];
}
#pragma line 896 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
/**
* @brief Provides access to the data contained in the %string.
* @param n The index of the character to access.
* @return Read/write reference to the character.
* @throw std::out_of_range If @a n is an invalid index.
*
* This function provides for safer data access. The parameter is
* first checked that it is in the range of the string. The function
* throws out_of_range if the check fails. Success results in
* unsharing the string.
*/
reference
at(size_type __n)
{
if (__n >= size())
__throw_out_of_range(("basic_string::at"));
_M_leak();
return _M_data()[__n];
}
#pragma empty_line
// Modifiers:
/**
* @brief Append a string to this string.
* @param str The string to append.
* @return Reference to this string.
*/
basic_string&
operator+=(const basic_string& __str)
{ return this->append(__str); }
#pragma empty_line
/**
* @brief Append a C string.
* @param s The C string to append.
* @return Reference to this string.
*/
basic_string&
operator+=(const _CharT* __s)
{ return this->append(__s); }
#pragma empty_line
/**
* @brief Append a character.
* @param c The character to append.
* @return Reference to this string.
*/
basic_string&
operator+=(_CharT __c)
{
this->push_back(__c);
return *this;
}
#pragma line 958 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
/**
* @brief Append a string to this string.
* @param str The string to append.
* @return Reference to this string.
*/
basic_string&
append(const basic_string& __str);
#pragma empty_line
/**
* @brief Append a substring.
* @param str The string to append.
* @param pos Index of the first character of str to append.
* @param n The number of characters to append.
* @return Reference to this string.
* @throw std::out_of_range if @a pos is not a valid index.
*
* This function appends @a n characters from @a str starting at @a pos
* to this string. If @a n is is larger than the number of available
* characters in @a str, the remainder of @a str is appended.
*/
basic_string&
append(const basic_string& __str, size_type __pos, size_type __n);
#pragma empty_line
/**
* @brief Append a C substring.
* @param s The C string to append.
* @param n The number of characters to append.
* @return Reference to this string.
*/
basic_string&
append(const _CharT* __s, size_type __n);
#pragma empty_line
/**
* @brief Append a C string.
* @param s The C string to append.
* @return Reference to this string.
*/
basic_string&
append(const _CharT* __s)
{
;
return this->append(__s, traits_type::length(__s));
}
#pragma empty_line
/**
* @brief Append multiple characters.
* @param n The number of characters to append.
* @param c The character to use.
* @return Reference to this string.
*
* Appends n copies of c to this string.
*/
basic_string&
append(size_type __n, _CharT __c);
#pragma line 1024 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
/**
* @brief Append a range of characters.
* @param first Iterator referencing the first character to append.
* @param last Iterator marking the end of the range.
* @return Reference to this string.
*
* Appends characters in the range [first,last) to this string.
*/
template<class _InputIterator>
basic_string&
append(_InputIterator __first, _InputIterator __last)
{ return this->replace(_M_iend(), _M_iend(), __first, __last); }
#pragma empty_line
/**
* @brief Append a single character.
* @param c Character to append.
*/
void
push_back(_CharT __c)
{
const size_type __len = 1 + this->size();
if (__len > this->capacity() || _M_rep()->_M_is_shared())
this->reserve(__len);
traits_type::assign(_M_data()[this->size()], __c);
_M_rep()->_M_set_length_and_sharable(__len);
}
#pragma empty_line
/**
* @brief Set value to contents of another string.
* @param str Source string to use.
* @return Reference to this string.
*/
basic_string&
assign(const basic_string& __str);
#pragma line 1076 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
/**
* @brief Set value to a substring of a string.
* @param str The string to use.
* @param pos Index of the first character of str.
* @param n Number of characters to use.
* @return Reference to this string.
* @throw std::out_of_range if @a pos is not a valid index.
*
* This function sets this string to the substring of @a str consisting
* of @a n characters at @a pos. If @a n is is larger than the number
* of available characters in @a str, the remainder of @a str is used.
*/
basic_string&
assign(const basic_string& __str, size_type __pos, size_type __n)
{ return this->assign(__str._M_data()
+ __str._M_check(__pos, "basic_string::assign"),
__str._M_limit(__pos, __n)); }
#pragma empty_line
/**
* @brief Set value to a C substring.
* @param s The C string to use.
* @param n Number of characters to use.
* @return Reference to this string.
*
* This function sets the value of this string to the first @a n
* characters of @a s. If @a n is is larger than the number of
* available characters in @a s, the remainder of @a s is used.
*/
basic_string&
assign(const _CharT* __s, size_type __n);
#pragma empty_line
/**
* @brief Set value to contents of a C string.
* @param s The C string to use.
* @return Reference to this string.
*
* This function sets the value of this string to the value of @a s.
* The data is copied, so there is no dependence on @a s once the
* function returns.
*/
basic_string&
assign(const _CharT* __s)
{
;
return this->assign(__s, traits_type::length(__s));
}
#pragma empty_line
/**
* @brief Set value to multiple characters.
* @param n Length of the resulting string.
* @param c The character to use.
* @return Reference to this string.
*
* This function sets the value of this string to @a n copies of
* character @a c.
*/
basic_string&
assign(size_type __n, _CharT __c)
{ return _M_replace_aux(size_type(0), this->size(), __n, __c); }
#pragma empty_line
/**
* @brief Set value to a range of characters.
* @param first Iterator referencing the first character to append.
* @param last Iterator marking the end of the range.
* @return Reference to this string.
*
* Sets value of string to characters in the range [first,last).
*/
template<class _InputIterator>
basic_string&
assign(_InputIterator __first, _InputIterator __last)
{ return this->replace(_M_ibegin(), _M_iend(), __first, __last); }
#pragma line 1160 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
/**
* @brief Insert multiple characters.
* @param p Iterator referencing location in string to insert at.
* @param n Number of characters to insert
* @param c The character to insert.
* @throw std::length_error If new length exceeds @c max_size().
*
* Inserts @a n copies of character @a c starting at the position
* referenced by iterator @a p. If adding characters causes the length
* to exceed max_size(), length_error is thrown. The value of the
* string doesn't change if an error is thrown.
*/
void
insert(iterator __p, size_type __n, _CharT __c)
{ this->replace(__p, __p, __n, __c); }
#pragma empty_line
/**
* @brief Insert a range of characters.
* @param p Iterator referencing location in string to insert at.
* @param beg Start of range.
* @param end End of range.
* @throw std::length_error If new length exceeds @c max_size().
*
* Inserts characters in range [beg,end). If adding characters causes
* the length to exceed max_size(), length_error is thrown. The value
* of the string doesn't change if an error is thrown.
*/
template<class _InputIterator>
void
insert(iterator __p, _InputIterator __beg, _InputIterator __end)
{ this->replace(__p, __p, __beg, __end); }
#pragma line 1207 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
/**
* @brief Insert value of a string.
* @param pos1 Iterator referencing location in string to insert at.
* @param str The string to insert.
* @return Reference to this string.
* @throw std::length_error If new length exceeds @c max_size().
*
* Inserts value of @a str starting at @a pos1. If adding characters
* causes the length to exceed max_size(), length_error is thrown. The
* value of the string doesn't change if an error is thrown.
*/
basic_string&
insert(size_type __pos1, const basic_string& __str)
{ return this->insert(__pos1, __str, size_type(0), __str.size()); }
#pragma empty_line
/**
* @brief Insert a substring.
* @param pos1 Iterator referencing location in string to insert at.
* @param str The string to insert.
* @param pos2 Start of characters in str to insert.
* @param n Number of characters to insert.
* @return Reference to this string.
* @throw std::length_error If new length exceeds @c max_size().
* @throw std::out_of_range If @a pos1 > size() or
* @a pos2 > @a str.size().
*
* Starting at @a pos1, insert @a n character of @a str beginning with
* @a pos2. If adding characters causes the length to exceed
* max_size(), length_error is thrown. If @a pos1 is beyond the end of
* this string or @a pos2 is beyond the end of @a str, out_of_range is
* thrown. The value of the string doesn't change if an error is
* thrown.
*/
basic_string&
insert(size_type __pos1, const basic_string& __str,
size_type __pos2, size_type __n)
{ return this->insert(__pos1, __str._M_data()
+ __str._M_check(__pos2, "basic_string::insert"),
__str._M_limit(__pos2, __n)); }
#pragma empty_line
/**
* @brief Insert a C substring.
* @param pos Iterator referencing location in string to insert at.
* @param s The C string to insert.
* @param n The number of characters to insert.
* @return Reference to this string.
* @throw std::length_error If new length exceeds @c max_size().
* @throw std::out_of_range If @a pos is beyond the end of this
* string.
*
* Inserts the first @a n characters of @a s starting at @a pos. If
* adding characters causes the length to exceed max_size(),
* length_error is thrown. If @a pos is beyond end(), out_of_range is
* thrown. The value of the string doesn't change if an error is
* thrown.
*/
basic_string&
insert(size_type __pos, const _CharT* __s, size_type __n);
#pragma empty_line
/**
* @brief Insert a C string.
* @param pos Iterator referencing location in string to insert at.
* @param s The C string to insert.
* @return Reference to this string.
* @throw std::length_error If new length exceeds @c max_size().
* @throw std::out_of_range If @a pos is beyond the end of this
* string.
*
* Inserts the first @a n characters of @a s starting at @a pos. If
* adding characters causes the length to exceed max_size(),
* length_error is thrown. If @a pos is beyond end(), out_of_range is
* thrown. The value of the string doesn't change if an error is
* thrown.
*/
basic_string&
insert(size_type __pos, const _CharT* __s)
{
;
return this->insert(__pos, __s, traits_type::length(__s));
}
#pragma empty_line
/**
* @brief Insert multiple characters.
* @param pos Index in string to insert at.
* @param n Number of characters to insert
* @param c The character to insert.
* @return Reference to this string.
* @throw std::length_error If new length exceeds @c max_size().
* @throw std::out_of_range If @a pos is beyond the end of this
* string.
*
* Inserts @a n copies of character @a c starting at index @a pos. If
* adding characters causes the length to exceed max_size(),
* length_error is thrown. If @a pos > length(), out_of_range is
* thrown. The value of the string doesn't change if an error is
* thrown.
*/
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 empty_line
/**
* @brief Insert one character.
* @param p Iterator referencing position in string to insert at.
* @param c The character to insert.
* @return Iterator referencing newly inserted char.
* @throw std::length_error If new length exceeds @c max_size().
*
* Inserts character @a c at position referenced by @a p. If adding
* character causes the length to exceed max_size(), length_error is
* thrown. If @a p is beyond end of string, out_of_range is thrown.
* The value of the string doesn't change if an error is thrown.
*/
iterator
insert(iterator __p, _CharT __c)
{
;
const size_type __pos = __p - _M_ibegin();
_M_replace_aux(__pos, size_type(0), size_type(1), __c);
_M_rep()->_M_set_leaked();
return iterator(_M_data() + __pos);
}
#pragma empty_line
/**
* @brief Remove characters.
* @param pos Index of first character to remove (default 0).
* @param n Number of characters to remove (default remainder).
* @return Reference to this string.
* @throw std::out_of_range If @a pos is beyond the end of this
* string.
*
* Removes @a n characters from this string starting at @a pos. The
* length of the string is reduced by @a n. If there are < @a n
* characters to remove, the remainder of the string is truncated. If
* @a p is beyond end of string, out_of_range is thrown. The value of
* the string doesn't change if an error is thrown.
*/
basic_string&
erase(size_type __pos = 0, size_type __n = npos)
{
_M_mutate(_M_check(__pos, "basic_string::erase"),
_M_limit(__pos, __n), size_type(0));
return *this;
}
#pragma empty_line
/**
* @brief Remove one character.
* @param position Iterator referencing the character to remove.
* @return iterator referencing same location after removal.
*
* Removes the character at @a position from this string. The value
* of the string doesn't change if an error is thrown.
*/
iterator
erase(iterator __position)
{
#pragma empty_line
;
const size_type __pos = __position - _M_ibegin();
_M_mutate(__pos, size_type(1), size_type(0));
_M_rep()->_M_set_leaked();
return iterator(_M_data() + __pos);
}
#pragma empty_line
/**
* @brief Remove a range of characters.
* @param first Iterator referencing the first character to remove.
* @param last Iterator referencing the end of the range.
* @return Iterator referencing location of first after removal.
*
* Removes the characters in the range [first,last) from this string.
* The value of the string doesn't change if an error is thrown.
*/
iterator
erase(iterator __first, iterator __last);
#pragma empty_line
/**
* @brief Replace characters with value from another string.
* @param pos Index of first character to replace.
* @param n Number of characters to be replaced.
* @param str String to insert.
* @return Reference to this string.
* @throw std::out_of_range If @a pos is beyond the end of this
* string.
* @throw std::length_error If new length exceeds @c max_size().
*
* Removes the characters in the range [pos,pos+n) from this string.
* In place, the value of @a str is inserted. If @a pos is beyond end
* of string, out_of_range is thrown. If the length of the result
* exceeds max_size(), length_error is thrown. The value of the string
* doesn't change if an error is thrown.
*/
basic_string&
replace(size_type __pos, size_type __n, const basic_string& __str)
{ return this->replace(__pos, __n, __str._M_data(), __str.size()); }
#pragma empty_line
/**
* @brief Replace characters with value from another string.
* @param pos1 Index of first character to replace.
* @param n1 Number of characters to be replaced.
* @param str String to insert.
* @param pos2 Index of first character of str to use.
* @param n2 Number of characters from str to use.
* @return Reference to this string.
* @throw std::out_of_range If @a pos1 > size() or @a pos2 >
* str.size().
* @throw std::length_error If new length exceeds @c max_size().
*
* Removes the characters in the range [pos1,pos1 + n) from this
* string. In place, the value of @a str is inserted. If @a pos is
* beyond end of string, out_of_range is thrown. If the length of the
* result exceeds max_size(), length_error is thrown. The value of the
* string doesn't change if an error is thrown.
*/
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 empty_line
/**
* @brief Replace characters with value of a C substring.
* @param pos Index of first character to replace.
* @param n1 Number of characters to be replaced.
* @param s C string to insert.
* @param n2 Number of characters from @a s to use.
* @return Reference to this string.
* @throw std::out_of_range If @a pos1 > size().
* @throw std::length_error If new length exceeds @c max_size().
*
* Removes the characters in the range [pos,pos + n1) from this string.
* In place, the first @a n2 characters of @a s are inserted, or all
* of @a s if @a n2 is too large. If @a pos is beyond end of string,
* out_of_range is thrown. If the length of result exceeds max_size(),
* length_error is thrown. The value of the string doesn't change if
* an error is thrown.
*/
basic_string&
replace(size_type __pos, size_type __n1, const _CharT* __s,
size_type __n2);
#pragma empty_line
/**
* @brief Replace characters with value of a C string.
* @param pos Index of first character to replace.
* @param n1 Number of characters to be replaced.
* @param s C string to insert.
* @return Reference to this string.
* @throw std::out_of_range If @a pos > size().
* @throw std::length_error If new length exceeds @c max_size().
*
* Removes the characters in the range [pos,pos + n1) from this string.
* In place, the characters of @a s are inserted. If @a pos is beyond
* end of string, out_of_range is thrown. If the length of result
* exceeds max_size(), length_error is thrown. The value of the string
* doesn't change if an error is thrown.
*/
basic_string&
replace(size_type __pos, size_type __n1, const _CharT* __s)
{
;
return this->replace(__pos, __n1, __s, traits_type::length(__s));
}
#pragma empty_line
/**
* @brief Replace characters with multiple characters.
* @param pos Index of first character to replace.
* @param n1 Number of characters to be replaced.
* @param n2 Number of characters to insert.
* @param c Character to insert.
* @return Reference to this string.
* @throw std::out_of_range If @a pos > size().
* @throw std::length_error If new length exceeds @c max_size().
*
* Removes the characters in the range [pos,pos + n1) from this string.
* In place, @a n2 copies of @a c are inserted. If @a pos is beyond
* end of string, out_of_range is thrown. If the length of result
* exceeds max_size(), length_error is thrown. The value of the string
* doesn't change if an error is thrown.
*/
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 empty_line
/**
* @brief Replace range of characters with string.
* @param i1 Iterator referencing start of range to replace.
* @param i2 Iterator referencing end of range to replace.
* @param str String value to insert.
* @return Reference to this string.
* @throw std::length_error If new length exceeds @c max_size().
*
* Removes the characters in the range [i1,i2). In place, the value of
* @a str is inserted. If the length of result exceeds max_size(),
* length_error is thrown. The value of the string doesn't change if
* an error is thrown.
*/
basic_string&
replace(iterator __i1, iterator __i2, const basic_string& __str)
{ return this->replace(__i1, __i2, __str._M_data(), __str.size()); }
#pragma empty_line
/**
* @brief Replace range of characters with C substring.
* @param i1 Iterator referencing start of range to replace.
* @param i2 Iterator referencing end of range to replace.
* @param s C string value to insert.
* @param n Number of characters from s to insert.
* @return Reference to this string.
* @throw std::length_error If new length exceeds @c max_size().
*
* Removes the characters in the range [i1,i2). In place, the first @a
* n characters of @a s are inserted. If the length of result exceeds
* max_size(), length_error is thrown. The value of the string doesn't
* change if an error is thrown.
*/
basic_string&
replace(iterator __i1, iterator __i2, const _CharT* __s, size_type __n)
{
#pragma empty_line
;
return this->replace(__i1 - _M_ibegin(), __i2 - __i1, __s, __n);
}
#pragma empty_line
/**
* @brief Replace range of characters with C string.
* @param i1 Iterator referencing start of range to replace.
* @param i2 Iterator referencing end of range to replace.
* @param s C string value to insert.
* @return Reference to this string.
* @throw std::length_error If new length exceeds @c max_size().
*
* Removes the characters in the range [i1,i2). In place, the
* characters of @a s are inserted. If the length of result exceeds
* max_size(), length_error is thrown. The value of the string doesn't
* change if an error is thrown.
*/
basic_string&
replace(iterator __i1, iterator __i2, const _CharT* __s)
{
;
return this->replace(__i1, __i2, __s, traits_type::length(__s));
}
#pragma empty_line
/**
* @brief Replace range of characters with multiple characters
* @param i1 Iterator referencing start of range to replace.
* @param i2 Iterator referencing end of range to replace.
* @param n Number of characters to insert.
* @param c Character to insert.
* @return Reference to this string.
* @throw std::length_error If new length exceeds @c max_size().
*
* Removes the characters in the range [i1,i2). In place, @a n copies
* of @a c are inserted. If the length of result exceeds max_size(),
* length_error is thrown. The value of the string doesn't change if
* an error is thrown.
*/
basic_string&
replace(iterator __i1, iterator __i2, size_type __n, _CharT __c)
{
#pragma empty_line
;
return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __c);
}
#pragma empty_line
/**
* @brief Replace range of characters with range.
* @param i1 Iterator referencing start of range to replace.
* @param i2 Iterator referencing end of range to replace.
* @param k1 Iterator referencing start of range to insert.
* @param k2 Iterator referencing end of range to insert.
* @return Reference to this string.
* @throw std::length_error If new length exceeds @c max_size().
*
* Removes the characters in the range [i1,i2). In place, characters
* in the range [k1,k2) are inserted. If the length of result exceeds
* max_size(), length_error is thrown. The value of the string doesn't
* change if an error is thrown.
*/
template<class _InputIterator>
basic_string&
replace(iterator __i1, iterator __i2,
_InputIterator __k1, _InputIterator __k2)
{
#pragma empty_line
;
;
typedef typename std::__is_integer<_InputIterator>::__type _Integral;
return _M_replace_dispatch(__i1, __i2, __k1, __k2, _Integral());
}
#pragma empty_line
// Specializations for the common case of pointer and iterator:
// useful to avoid the overhead of temporary buffering in _M_replace.
basic_string&
replace(iterator __i1, iterator __i2, _CharT* __k1, _CharT* __k2)
{
#pragma empty_line
;
;
return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
__k1, __k2 - __k1);
}
#pragma empty_line
basic_string&
replace(iterator __i1, iterator __i2,
const _CharT* __k1, const _CharT* __k2)
{
#pragma empty_line
;
;
return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
__k1, __k2 - __k1);
}
#pragma empty_line
basic_string&
replace(iterator __i1, iterator __i2, iterator __k1, iterator __k2)
{
#pragma empty_line
;
;
return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
__k1.base(), __k2 - __k1);
}
#pragma empty_line
basic_string&
replace(iterator __i1, iterator __i2,
const_iterator __k1, const_iterator __k2)
{
#pragma empty_line
;
;
return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
__k1.base(), __k2 - __k1);
}
#pragma line 1663 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
private:
template<class _Integer>
basic_string&
_M_replace_dispatch(iterator __i1, iterator __i2, _Integer __n,
_Integer __val, __true_type)
{ return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __val); }
#pragma empty_line
template<class _InputIterator>
basic_string&
_M_replace_dispatch(iterator __i1, 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_safe(size_type __pos1, size_type __n1, const _CharT* __s,
size_type __n2);
#pragma empty_line
// _S_construct_aux is used to implement the 21.3.1 para 15 which
// requires special behaviour if _InIter is an integral type
template<class _InIterator>
static _CharT*
_S_construct_aux(_InIterator __beg, _InIterator __end,
const _Alloc& __a, __false_type)
{
typedef typename iterator_traits<_InIterator>::iterator_category _Tag;
return _S_construct(__beg, __end, __a, _Tag());
}
#pragma empty_line
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 438. Ambiguity in the "do the right thing" clause
template<class _Integer>
static _CharT*
_S_construct_aux(_Integer __beg, _Integer __end,
const _Alloc& __a, __true_type)
{ return _S_construct_aux_2(static_cast<size_type>(__beg),
__end, __a); }
#pragma empty_line
static _CharT*
_S_construct_aux_2(size_type __req, _CharT __c, const _Alloc& __a)
{ return _S_construct(__req, __c, __a); }
#pragma empty_line
template<class _InIterator>
static _CharT*
_S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a)
{
typedef typename std::__is_integer<_InIterator>::__type _Integral;
return _S_construct_aux(__beg, __end, __a, _Integral());
}
#pragma empty_line
// For Input Iterators, used in istreambuf_iterators, etc.
template<class _InIterator>
static _CharT*
_S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
input_iterator_tag);
#pragma empty_line
// For forward_iterators up to random_access_iterators, used for
// string::iterator, _CharT*, etc.
template<class _FwdIterator>
static _CharT*
_S_construct(_FwdIterator __beg, _FwdIterator __end, const _Alloc& __a,
forward_iterator_tag);
#pragma empty_line
static _CharT*
_S_construct(size_type __req, _CharT __c, const _Alloc& __a);
#pragma empty_line
public:
#pragma empty_line
/**
* @brief Copy substring into C string.
* @param s C string to copy value into.
* @param n Number of characters to copy.
* @param pos Index of first character to copy.
* @return Number of characters actually copied
* @throw std::out_of_range If pos > size().
*
* Copies up to @a n characters starting at @a pos into the C string @a
* s. If @a pos is %greater than size(), out_of_range is thrown.
*/
size_type
copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
#pragma empty_line
/**
* @brief Swap contents with another string.
* @param s String to swap with.
*
* Exchanges the contents of this string with that of @a s in constant
* time.
*/
void
swap(basic_string& __s);
#pragma empty_line
// String operations:
/**
* @brief Return const pointer to null-terminated contents.
*
* This is a handle to internal data. Do not modify or dire things may
* happen.
*/
const _CharT*
c_str() const
{ return _M_data(); }
#pragma empty_line
/**
* @brief Return const pointer to contents.
*
* This is a handle to internal data. Do not modify or dire things may
* happen.
*/
const _CharT*
data() const
{ return _M_data(); }
#pragma empty_line
/**
* @brief Return copy of allocator used to construct this string.
*/
allocator_type
get_allocator() const
{ return _M_dataplus; }
#pragma empty_line
/**
* @brief Find position of a C substring.
* @param s C string to locate.
* @param pos Index of character to search from.
* @param n Number of characters from @a s to search for.
* @return Index of start of first occurrence.
*
* Starting from @a pos, searches forward for the first @a n characters
* in @a s within this string. If found, returns the index where it
* begins. If not found, returns npos.
*/
size_type
find(const _CharT* __s, size_type __pos, size_type __n) const;
#pragma empty_line
/**
* @brief Find position of a string.
* @param str String to locate.
* @param pos Index of character to search from (default 0).
* @return Index of start of first occurrence.
*
* Starting from @a pos, searches forward for value of @a str within
* this string. If found, returns the index where it begins. If not
* found, returns npos.
*/
size_type
find(const basic_string& __str, size_type __pos = 0) const
{ return this->find(__str.data(), __pos, __str.size()); }
#pragma empty_line
/**
* @brief Find position of a C string.
* @param s C string to locate.
* @param pos Index of character to search from (default 0).
* @return Index of start of first occurrence.
*
* Starting from @a pos, searches forward for the value of @a s within
* this string. If found, returns the index where it begins. If not
* found, returns npos.
*/
size_type
find(const _CharT* __s, size_type __pos = 0) const
{
;
return this->find(__s, __pos, traits_type::length(__s));
}
#pragma empty_line
/**
* @brief Find position of a character.
* @param c Character to locate.
* @param pos Index of character to search from (default 0).
* @return Index of first occurrence.
*
* Starting from @a pos, searches forward for @a c within this string.
* If found, returns the index where it was found. If not found,
* returns npos.
*/
size_type
find(_CharT __c, size_type __pos = 0) const;
#pragma empty_line
/**
* @brief Find last position of a string.
* @param str String to locate.
* @param pos Index of character to search back from (default end).
* @return Index of start of last occurrence.
*
* Starting from @a pos, searches backward for value of @a str within
* this string. If found, returns the index where it begins. If not
* found, returns npos.
*/
size_type
rfind(const basic_string& __str, size_type __pos = npos) const
{ return this->rfind(__str.data(), __pos, __str.size()); }
#pragma empty_line
/**
* @brief Find last position of a C substring.
* @param s C string to locate.
* @param pos Index of character to search back from.
* @param n Number of characters from s to search for.
* @return Index of start of last occurrence.
*
* Starting from @a pos, searches backward for the first @a n
* characters in @a s within this string. If found, returns the index
* where it begins. If not found, returns npos.
*/
size_type
rfind(const _CharT* __s, size_type __pos, size_type __n) const;
#pragma empty_line
/**
* @brief Find last position of a C string.
* @param s C string to locate.
* @param pos Index of character to start search at (default end).
* @return Index of start of last occurrence.
*
* Starting from @a pos, searches backward for the value of @a s within
* this string. If found, returns the index where it begins. If not
* found, returns npos.
*/
size_type
rfind(const _CharT* __s, size_type __pos = npos) const
{
;
return this->rfind(__s, __pos, traits_type::length(__s));
}
#pragma empty_line
/**
* @brief Find last position of a character.
* @param c Character to locate.
* @param pos Index of character to search back from (default end).
* @return Index of last occurrence.
*
* Starting from @a pos, searches backward for @a c within this string.
* If found, returns the index where it was found. If not found,
* returns npos.
*/
size_type
rfind(_CharT __c, size_type __pos = npos) const;
#pragma empty_line
/**
* @brief Find position of a character of string.
* @param str String containing characters to locate.
* @param pos Index of character to search from (default 0).
* @return Index of first occurrence.
*
* Starting from @a pos, searches forward for one of the characters of
* @a str within this string. If found, returns the index where it was
* found. If not found, returns npos.
*/
size_type
find_first_of(const basic_string& __str, size_type __pos = 0) const
{ return this->find_first_of(__str.data(), __pos, __str.size()); }
#pragma empty_line
/**
* @brief Find position of a character of C substring.
* @param s String containing characters to locate.
* @param pos Index of character to search from.
* @param n Number of characters from s to search for.
* @return Index of first occurrence.
*
* Starting from @a pos, searches forward for one of the first @a n
* characters of @a s within this string. If found, returns the index
* where it was found. If not found, returns npos.
*/
size_type
find_first_of(const _CharT* __s, size_type __pos, size_type __n) const;
#pragma empty_line
/**
* @brief Find position of a character of C string.
* @param s String containing characters to locate.
* @param pos Index of character to search from (default 0).
* @return Index of first occurrence.
*
* Starting from @a pos, searches forward for one of the characters of
* @a s within this string. If found, returns the index where it was
* found. If not found, returns npos.
*/
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 empty_line
/**
* @brief Find position of a character.
* @param c Character to locate.
* @param pos Index of character to search from (default 0).
* @return Index of first occurrence.
*
* Starting from @a pos, searches forward for the character @a c within
* this string. If found, returns the index where it was found. If
* not found, returns npos.
*
* Note: equivalent to find(c, pos).
*/
size_type
find_first_of(_CharT __c, size_type __pos = 0) const
{ return this->find(__c, __pos); }
#pragma empty_line
/**
* @brief Find last position of a character of string.
* @param str String containing characters to locate.
* @param pos Index of character to search back from (default end).
* @return Index of last occurrence.
*
* Starting from @a pos, searches backward for one of the characters of
* @a str within this string. If found, returns the index where it was
* found. If not found, returns npos.
*/
size_type
find_last_of(const basic_string& __str, size_type __pos = npos) const
{ return this->find_last_of(__str.data(), __pos, __str.size()); }
#pragma empty_line
/**
* @brief Find last position of a character of C substring.
* @param s C string containing characters to locate.
* @param pos Index of character to search back from.
* @param n Number of characters from s to search for.
* @return Index of last occurrence.
*
* Starting from @a pos, searches backward for one of the first @a n
* characters of @a s within this string. If found, returns the index
* where it was found. If not found, returns npos.
*/
size_type
find_last_of(const _CharT* __s, size_type __pos, size_type __n) const;
#pragma empty_line
/**
* @brief Find last position of a character of C string.
* @param s C string containing characters to locate.
* @param pos Index of character to search back from (default end).
* @return Index of last occurrence.
*
* Starting from @a pos, searches backward for one of the characters of
* @a s within this string. If found, returns the index where it was
* found. If not found, returns npos.
*/
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 empty_line
/**
* @brief Find last position of a character.
* @param c Character to locate.
* @param pos Index of character to search back from (default end).
* @return Index of last occurrence.
*
* Starting from @a pos, searches backward for @a c within this string.
* If found, returns the index where it was found. If not found,
* returns npos.
*
* Note: equivalent to rfind(c, pos).
*/
size_type
find_last_of(_CharT __c, size_type __pos = npos) const
{ return this->rfind(__c, __pos); }
#pragma empty_line
/**
* @brief Find position of a character not in string.
* @param str String containing characters to avoid.
* @param pos Index of character to search from (default 0).
* @return Index of first occurrence.
*
* Starting from @a pos, searches forward for a character not contained
* in @a str within this string. If found, returns the index where it
* was found. If not found, returns npos.
*/
size_type
find_first_not_of(const basic_string& __str, size_type __pos = 0) const
{ return this->find_first_not_of(__str.data(), __pos, __str.size()); }
#pragma empty_line
/**
* @brief Find position of a character not in C substring.
* @param s C string containing characters to avoid.
* @param pos Index of character to search from.
* @param n Number of characters from s to consider.
* @return Index of first occurrence.
*
* Starting from @a pos, searches forward for a character not contained
* in the first @a n characters of @a s within this string. If found,
* returns the index where it was found. If not found, returns npos.
*/
size_type
find_first_not_of(const _CharT* __s, size_type __pos,
size_type __n) const;
#pragma empty_line
/**
* @brief Find position of a character not in C string.
* @param s C string containing characters to avoid.
* @param pos Index of character to search from (default 0).
* @return Index of first occurrence.
*
* Starting from @a pos, searches forward for a character not contained
* in @a s within this string. If found, returns the index where it
* was found. If not found, returns npos.
*/
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 empty_line
/**
* @brief Find position of a different character.
* @param c Character to avoid.
* @param pos Index of character to search from (default 0).
* @return Index of first occurrence.
*
* Starting from @a pos, searches forward for a character other than @a c
* within this string. If found, returns the index where it was found.
* If not found, returns npos.
*/
size_type
find_first_not_of(_CharT __c, size_type __pos = 0) const;
#pragma empty_line
/**
* @brief Find last position of a character not in string.
* @param str String containing characters to avoid.
* @param pos Index of character to search back from (default end).
* @return Index of last occurrence.
*
* Starting from @a pos, searches backward for a character not
* contained in @a str within this string. If found, returns the index
* where it was found. If not found, returns npos.
*/
size_type
find_last_not_of(const basic_string& __str, size_type __pos = npos) const
{ return this->find_last_not_of(__str.data(), __pos, __str.size()); }
#pragma empty_line
/**
* @brief Find last position of a character not in C substring.
* @param s C string containing characters to avoid.
* @param pos Index of character to search back from.
* @param n Number of characters from s to consider.
* @return Index of last occurrence.
*
* Starting from @a pos, searches backward for a character not
* contained in the first @a n characters of @a s within this string.
* If found, returns the index where it was found. If not found,
* returns npos.
*/
size_type
find_last_not_of(const _CharT* __s, size_type __pos,
size_type __n) const;
/**
* @brief Find last position of a character not in C string.
* @param s C string containing characters to avoid.
* @param pos Index of character to search back from (default end).
* @return Index of last occurrence.
*
* Starting from @a pos, searches backward for a character not
* contained in @a s within this string. If found, returns the index
* where it was found. If not found, returns npos.
*/
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 empty_line
/**
* @brief Find last position of a different character.
* @param c Character to avoid.
* @param pos Index of character to search back from (default end).
* @return Index of last occurrence.
*
* Starting from @a pos, searches backward for a character other than
* @a c within this string. If found, returns the index where it was
* found. If not found, returns npos.
*/
size_type
find_last_not_of(_CharT __c, size_type __pos = npos) const;
#pragma empty_line
/**
* @brief Get a substring.
* @param pos Index of first character (default 0).
* @param n Number of characters in substring (default remainder).
* @return The new string.
* @throw std::out_of_range If pos > size().
*
* Construct and return a new string using the @a n characters starting
* at @a pos. If the string is too short, use the remainder of the
* characters. If @a pos is beyond the end of the string, out_of_range
* is thrown.
*/
basic_string
substr(size_type __pos = 0, size_type __n = npos) const
{ return basic_string(*this,
_M_check(__pos, "basic_string::substr"), __n); }
#pragma empty_line
/**
* @brief Compare to a string.
* @param str String to compare against.
* @return Integer < 0, 0, or > 0.
*
* Returns an integer < 0 if this string is ordered before @a str, 0 if
* their values are equivalent, or > 0 if this string is ordered after
* @a str. Determines the effective length rlen of the strings to
* compare as the smallest of size() and str.size(). The function
* then compares the two strings by calling traits::compare(data(),
* str.data(),rlen). If the result of the comparison is nonzero returns
* it, otherwise the shorter one is ordered first.
*/
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 empty_line
/**
* @brief Compare substring to a string.
* @param pos Index of first character of substring.
* @param n Number of characters in substring.
* @param str String to compare against.
* @return Integer < 0, 0, or > 0.
*
* Form the substring of this string from the @a n characters starting
* at @a pos. Returns an integer < 0 if the substring is ordered
* before @a str, 0 if their values are equivalent, or > 0 if the
* substring is ordered after @a str. Determines the effective length
* rlen of the strings to compare as the smallest of the length of the
* substring and @a str.size(). The function then compares the two
* strings by calling traits::compare(substring.data(),str.data(),rlen).
* If the result of the comparison is nonzero returns it, otherwise the
* shorter one is ordered first.
*/
int
compare(size_type __pos, size_type __n, const basic_string& __str) const;
#pragma empty_line
/**
* @brief Compare substring to a substring.
* @param pos1 Index of first character of substring.
* @param n1 Number of characters in substring.
* @param str String to compare against.
* @param pos2 Index of first character of substring of str.
* @param n2 Number of characters in substring of str.
* @return Integer < 0, 0, or > 0.
*
* Form the substring of this string from the @a n1 characters starting
* at @a pos1. Form the substring of @a str from the @a n2 characters
* starting at @a pos2. Returns an integer < 0 if this substring is
* ordered before the substring of @a str, 0 if their values are
* equivalent, or > 0 if this substring is ordered after the substring
* of @a str. Determines the effective length rlen of the strings
* to compare as the smallest of the lengths of the substrings. The
* function then compares the two strings by calling
* traits::compare(substring.data(),str.substr(pos2,n2).data(),rlen).
* If the result of the comparison is nonzero returns it, otherwise the
* shorter one is ordered first.
*/
int
compare(size_type __pos1, size_type __n1, const basic_string& __str,
size_type __pos2, size_type __n2) const;
#pragma empty_line
/**
* @brief Compare to a C string.
* @param s C string to compare against.
* @return Integer < 0, 0, or > 0.
*
* Returns an integer < 0 if this string is ordered before @a s, 0 if
* their values are equivalent, or > 0 if this string is ordered after
* @a s. Determines the effective length rlen of the strings to
* compare as the smallest of size() and the length of a string
* constructed from @a s. The function then compares the two strings
* by calling traits::compare(data(),s,rlen). If the result of the
* comparison is nonzero returns it, otherwise the shorter one is
* ordered first.
*/
int
compare(const _CharT* __s) const;
#pragma empty_line
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 5 String::compare specification questionable
/**
* @brief Compare substring to a C string.
* @param pos Index of first character of substring.
* @param n1 Number of characters in substring.
* @param s C string to compare against.
* @return Integer < 0, 0, or > 0.
*
* Form the substring of this string from the @a n1 characters starting
* at @a pos. Returns an integer < 0 if the substring is ordered
* before @a s, 0 if their values are equivalent, or > 0 if the
* substring is ordered after @a s. Determines the effective length
* rlen of the strings to compare as the smallest of the length of the
* substring and the length of a string constructed from @a s. The
* function then compares the two string by calling
* traits::compare(substring.data(),s,rlen). If the result of the
* comparison is nonzero returns it, otherwise the shorter one is
* ordered first.
*/
int
compare(size_type __pos, size_type __n1, const _CharT* __s) const;
#pragma empty_line
/**
* @brief Compare substring against a character %array.
* @param pos1 Index of first character of substring.
* @param n1 Number of characters in substring.
* @param s character %array to compare against.
* @param n2 Number of characters of s.
* @return Integer < 0, 0, or > 0.
*
* Form the substring of this string from the @a n1 characters starting
* at @a pos1. Form a string from the first @a n2 characters of @a s.
* Returns an integer < 0 if this substring is ordered before the string
* from @a s, 0 if their values are equivalent, or > 0 if this substring
* is ordered after the string from @a s. Determines the effective
* length rlen of the strings to compare as the smallest of the length
* of the substring and @a n2. The function then compares the two
* strings by calling traits::compare(substring.data(),s,rlen). If the
* result of the comparison is nonzero returns it, otherwise the shorter
* one is ordered first.
*
* NB: s must have at least n2 characters, '\\0' has
* no special meaning.
*/
int
compare(size_type __pos, size_type __n1, const _CharT* __s,
size_type __n2) const;
};
#pragma empty_line
// operator+
/**
* @brief Concatenate two strings.
* @param lhs First string.
* @param rhs Last string.
* @return New string with value of @a lhs followed by @a rhs.
*/
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
/**
* @brief Concatenate C string and string.
* @param lhs First string.
* @param rhs Last string.
* @return New string with value of @a lhs followed by @a rhs.
*/
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
/**
* @brief Concatenate character and string.
* @param lhs First string.
* @param rhs Last string.
* @return New string with @a lhs followed by @a rhs.
*/
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
/**
* @brief Concatenate string and C string.
* @param lhs First string.
* @param rhs Last string.
* @return New string with @a lhs followed by @a rhs.
*/
template<typename _CharT, typename _Traits, typename _Alloc>
inline basic_string<_CharT, _Traits, _Alloc>
operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
{
basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
__str.append(__rhs);
return __str;
}
#pragma empty_line
/**
* @brief Concatenate string and character.
* @param lhs First string.
* @param rhs Last string.
* @return New string with @a lhs followed by @a rhs.
*/
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 line 2417 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
// operator ==
/**
* @brief Test equivalence of two strings.
* @param lhs First string.
* @param rhs Second string.
* @return True if @a lhs.compare(@a rhs) == 0. False otherwise.
*/
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ 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)
{ return (__lhs.size() == __rhs.size()
&& !std::char_traits<_CharT>::compare(__lhs.data(), __rhs.data(),
__lhs.size())); }
#pragma empty_line
/**
* @brief Test equivalence of C string and string.
* @param lhs C string.
* @param rhs String.
* @return True if @a rhs.compare(@a lhs) == 0. False otherwise.
*/
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
/**
* @brief Test equivalence of string and C string.
* @param lhs String.
* @param rhs C string.
* @return True if @a lhs.compare(@a rhs) == 0. False otherwise.
*/
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
// operator !=
/**
* @brief Test difference of two strings.
* @param lhs First string.
* @param rhs Second string.
* @return True if @a lhs.compare(@a rhs) != 0. False otherwise.
*/
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ return !(__lhs == __rhs); }
#pragma empty_line
/**
* @brief Test difference of C string and string.
* @param lhs C string.
* @param rhs String.
* @return True if @a rhs.compare(@a lhs) != 0. False otherwise.
*/
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
/**
* @brief Test difference of string and C string.
* @param lhs String.
* @param rhs C string.
* @return True if @a lhs.compare(@a rhs) != 0. False otherwise.
*/
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
{ return !(__lhs == __rhs); }
#pragma empty_line
// operator <
/**
* @brief Test if string precedes string.
* @param lhs First string.
* @param rhs Second string.
* @return True if @a lhs precedes @a rhs. False otherwise.
*/
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ return __lhs.compare(__rhs) < 0; }
#pragma empty_line
/**
* @brief Test if string precedes C string.
* @param lhs String.
* @param rhs C string.
* @return True if @a lhs precedes @a rhs. False otherwise.
*/
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
/**
* @brief Test if C string precedes string.
* @param lhs C string.
* @param rhs String.
* @return True if @a lhs precedes @a rhs. False otherwise.
*/
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
// operator >
/**
* @brief Test if string follows string.
* @param lhs First string.
* @param rhs Second string.
* @return True if @a lhs follows @a rhs. False otherwise.
*/
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ return __lhs.compare(__rhs) > 0; }
#pragma empty_line
/**
* @brief Test if string follows C string.
* @param lhs String.
* @param rhs C string.
* @return True if @a lhs follows @a rhs. False otherwise.
*/
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
/**
* @brief Test if C string follows string.
* @param lhs C string.
* @param rhs String.
* @return True if @a lhs follows @a rhs. False otherwise.
*/
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
// operator <=
/**
* @brief Test if string doesn't follow string.
* @param lhs First string.
* @param rhs Second string.
* @return True if @a lhs doesn't follow @a rhs. False otherwise.
*/
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ return __lhs.compare(__rhs) <= 0; }
#pragma empty_line
/**
* @brief Test if string doesn't follow C string.
* @param lhs String.
* @param rhs C string.
* @return True if @a lhs doesn't follow @a rhs. False otherwise.
*/
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
/**
* @brief Test if C string doesn't follow string.
* @param lhs C string.
* @param rhs String.
* @return True if @a lhs doesn't follow @a rhs. False otherwise.
*/
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
// operator >=
/**
* @brief Test if string doesn't precede string.
* @param lhs First string.
* @param rhs Second string.
* @return True if @a lhs doesn't precede @a rhs. False otherwise.
*/
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ return __lhs.compare(__rhs) >= 0; }
#pragma empty_line
/**
* @brief Test if string doesn't precede C string.
* @param lhs String.
* @param rhs C string.
* @return True if @a lhs doesn't precede @a rhs. False otherwise.
*/
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
/**
* @brief Test if C string doesn't precede string.
* @param lhs C string.
* @param rhs String.
* @return True if @a lhs doesn't precede @a rhs. False otherwise.
*/
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
/**
* @brief Swap contents of two strings.
* @param lhs First string.
* @param rhs Second string.
*
* Exchanges the contents of @a lhs and @a rhs in constant time.
*/
template<typename _CharT, typename _Traits, typename _Alloc>
inline void
swap(basic_string<_CharT, _Traits, _Alloc>& __lhs,
basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ __lhs.swap(__rhs); }
#pragma empty_line
/**
* @brief Read stream into a string.
* @param is Input stream.
* @param str Buffer to store into.
* @return Reference to the input stream.
*
* Stores characters from @a is into @a str until whitespace is found, the
* end of the stream is encountered, or str.max_size() is reached. If
* is.width() is non-zero, that is the limit on the number of characters
* stored into @a str. Any previous contents of @a str are erased.
*/
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 empty_line
/**
* @brief Write string to a stream.
* @param os Output stream.
* @param str String to write out.
* @return Reference to the output stream.
*
* Output characters of @a str into os following the same rules as for
* writing a C string.
*/
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)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 586. string inserter not a formatted function
return __ostream_insert(__os, __str.data(), __str.size());
}
#pragma empty_line
/**
* @brief Read a line from stream into a string.
* @param is Input stream.
* @param str Buffer to store into.
* @param delim Character marking end of line.
* @return Reference to the input stream.
*
* Stores characters from @a is into @a str until @a delim is found, the
* end of the stream is encountered, or str.max_size() is reached. If
* is.width() is non-zero, that is the limit on the number of characters
* stored into @a str. Any previous contents of @a str are erased. If @a
* delim was encountered, it is extracted but not stored into @a str.
*/
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 empty_line
/**
* @brief Read a line from stream into a string.
* @param is Input stream.
* @param str Buffer to store into.
* @return Reference to the input stream.
*
* Stores characters from is into @a str until '\n' is
* found, the end of the stream is encountered, or str.max_size()
* is reached. If is.width() is non-zero, that is the limit on the
* number of characters stored into @a str. Any previous contents
* of @a str are erased. If end of line was encountered, it is
* extracted but not stored into @a str.
*/
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 getline(__is, __str, __is.widen('\n')); }
#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
} // namespace
#pragma line 54 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/string" 2 3
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.tcc" 1 3
// Components for manipulating sequences of characters -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010, 2011
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file bits/basic_string.tcc
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{string}
*/
#pragma empty_line
//
// ISO C++ 14882: 21 Strings library
//
#pragma empty_line
// Written by Jason Merrill based upon the specification by Takanori Adachi
// in ANSI X3J16/94-0013R2. Rewritten by Nathan Myers to ISO-14882.
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 42 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/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
template<typename _CharT, typename _Traits, typename _Alloc>
const typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
_Rep::_S_max_size = (((npos - sizeof(_Rep_base))/sizeof(_CharT)) - 1) / 4;
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
const _CharT
basic_string<_CharT, _Traits, _Alloc>::
_Rep::_S_terminal = _CharT();
#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
// Linker sets _S_empty_rep_storage to all 0s (one reference, empty string)
// at static init time (before static ctors are run).
template<typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::_Rep::_S_empty_rep_storage[
(sizeof(_Rep_base) + sizeof(_CharT) + sizeof(size_type) - 1) /
sizeof(size_type)];
#pragma empty_line
// NB: This is the special case for Input Iterators, used in
// istreambuf_iterators, etc.
// Input Iterators have a cost structure very different from
// pointers, calling for a different coding style.
template<typename _CharT, typename _Traits, typename _Alloc>
template<typename _InIterator>
_CharT*
basic_string<_CharT, _Traits, _Alloc>::
_S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
input_iterator_tag)
{
#pragma empty_line
if (__beg == __end && __a == _Alloc())
return _S_empty_rep()._M_refdata();
#pragma empty_line
// Avoid reallocation for common case.
_CharT __buf[128];
size_type __len = 0;
while (__beg != __end && __len < sizeof(__buf) / sizeof(_CharT))
{
__buf[__len++] = *__beg;
++__beg;
}
_Rep* __r = _Rep::_S_create(__len, size_type(0), __a);
_M_copy(__r->_M_refdata(), __buf, __len);
if (true)
{
while (__beg != __end)
{
if (__len == __r->_M_capacity)
{
// Allocate more space.
_Rep* __another = _Rep::_S_create(__len + 1, __len, __a);
_M_copy(__another->_M_refdata(), __r->_M_refdata(), __len);
__r->_M_destroy(__a);
__r = __another;
}
__r->_M_refdata()[__len++] = *__beg;
++__beg;
}
}
if (false)
{
__r->_M_destroy(__a);
;
}
__r->_M_set_length_and_sharable(__len);
return __r->_M_refdata();
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
template <typename _InIterator>
_CharT*
basic_string<_CharT, _Traits, _Alloc>::
_S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
forward_iterator_tag)
{
#pragma empty_line
if (__beg == __end && __a == _Alloc())
return _S_empty_rep()._M_refdata();
#pragma empty_line
// NB: Not required, but considered best practice.
if (__gnu_cxx::__is_null_pointer(__beg) && __beg != __end)
__throw_logic_error(("basic_string::_S_construct null not valid"));
#pragma empty_line
const size_type __dnew = static_cast<size_type>(std::distance(__beg,
__end));
// Check for out_of_range and length_error exceptions.
_Rep* __r = _Rep::_S_create(__dnew, size_type(0), __a);
if (true)
{ _S_copy_chars(__r->_M_refdata(), __beg, __end); }
if (false)
{
__r->_M_destroy(__a);
;
}
__r->_M_set_length_and_sharable(__dnew);
return __r->_M_refdata();
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
_CharT*
basic_string<_CharT, _Traits, _Alloc>::
_S_construct(size_type __n, _CharT __c, const _Alloc& __a)
{
#pragma empty_line
if (__n == 0 && __a == _Alloc())
return _S_empty_rep()._M_refdata();
#pragma empty_line
// Check for out_of_range and length_error exceptions.
_Rep* __r = _Rep::_S_create(__n, size_type(0), __a);
if (__n)
_M_assign(__r->_M_refdata(), __n, __c);
#pragma empty_line
__r->_M_set_length_and_sharable(__n);
return __r->_M_refdata();
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>::
basic_string(const basic_string& __str)
: _M_dataplus(__str._M_rep()->_M_grab(_Alloc(__str.get_allocator()),
__str.get_allocator()),
__str.get_allocator())
{ }
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>::
basic_string(const _Alloc& __a)
: _M_dataplus(_S_construct(size_type(), _CharT(), __a), __a)
{ }
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>::
basic_string(const basic_string& __str, size_type __pos, size_type __n)
: _M_dataplus(_S_construct(__str._M_data()
+ __str._M_check(__pos,
"basic_string::basic_string"),
__str._M_data() + __str._M_limit(__pos, __n)
+ __pos, _Alloc()), _Alloc())
{ }
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>::
basic_string(const basic_string& __str, size_type __pos,
size_type __n, const _Alloc& __a)
: _M_dataplus(_S_construct(__str._M_data()
+ __str._M_check(__pos,
"basic_string::basic_string"),
__str._M_data() + __str._M_limit(__pos, __n)
+ __pos, __a), __a)
{ }
#pragma empty_line
// TBD: DPG annotate
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>::
basic_string(const _CharT* __s, size_type __n, const _Alloc& __a)
: _M_dataplus(_S_construct(__s, __s + __n, __a), __a)
{ }
#pragma empty_line
// TBD: DPG annotate
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>::
basic_string(const _CharT* __s, const _Alloc& __a)
: _M_dataplus(_S_construct(__s, __s ? __s + traits_type::length(__s) :
__s + npos, __a), __a)
{ }
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>::
basic_string(size_type __n, _CharT __c, const _Alloc& __a)
: _M_dataplus(_S_construct(__n, __c, __a), __a)
{ }
#pragma empty_line
// TBD: DPG annotate
template<typename _CharT, typename _Traits, typename _Alloc>
template<typename _InputIterator>
basic_string<_CharT, _Traits, _Alloc>::
basic_string(_InputIterator __beg, _InputIterator __end, const _Alloc& __a)
: _M_dataplus(_S_construct(__beg, __end, __a), __a)
{ }
#pragma line 241 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.tcc" 3
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>&
basic_string<_CharT, _Traits, _Alloc>::
assign(const basic_string& __str)
{
if (_M_rep() != __str._M_rep())
{
// XXX MT
const allocator_type __a = this->get_allocator();
_CharT* __tmp = __str._M_rep()->_M_grab(__a, __str.get_allocator());
_M_rep()->_M_dispose(__a);
_M_data(__tmp);
}
return *this;
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>&
basic_string<_CharT, _Traits, _Alloc>::
assign(const _CharT* __s, size_type __n)
{
;
_M_check_length(this->size(), __n, "basic_string::assign");
if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
return _M_replace_safe(size_type(0), this->size(), __s, __n);
else
{
// Work in-place.
const size_type __pos = __s - _M_data();
if (__pos >= __n)
_M_copy(_M_data(), __s, __n);
else if (__pos)
_M_move(_M_data(), __s, __n);
_M_rep()->_M_set_length_and_sharable(__n);
return *this;
}
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>&
basic_string<_CharT, _Traits, _Alloc>::
append(size_type __n, _CharT __c)
{
if (__n)
{
_M_check_length(size_type(0), __n, "basic_string::append");
const size_type __len = __n + this->size();
if (__len > this->capacity() || _M_rep()->_M_is_shared())
this->reserve(__len);
_M_assign(_M_data() + this->size(), __n, __c);
_M_rep()->_M_set_length_and_sharable(__len);
}
return *this;
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>&
basic_string<_CharT, _Traits, _Alloc>::
append(const _CharT* __s, size_type __n)
{
;
if (__n)
{
_M_check_length(size_type(0), __n, "basic_string::append");
const size_type __len = __n + this->size();
if (__len > this->capacity() || _M_rep()->_M_is_shared())
{
if (_M_disjunct(__s))
this->reserve(__len);
else
{
const size_type __off = __s - _M_data();
this->reserve(__len);
__s = _M_data() + __off;
}
}
_M_copy(_M_data() + this->size(), __s, __n);
_M_rep()->_M_set_length_and_sharable(__len);
}
return *this;
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>&
basic_string<_CharT, _Traits, _Alloc>::
append(const basic_string& __str)
{
const size_type __size = __str.size();
if (__size)
{
const size_type __len = __size + this->size();
if (__len > this->capacity() || _M_rep()->_M_is_shared())
this->reserve(__len);
_M_copy(_M_data() + this->size(), __str._M_data(), __size);
_M_rep()->_M_set_length_and_sharable(__len);
}
return *this;
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>&
basic_string<_CharT, _Traits, _Alloc>::
append(const basic_string& __str, size_type __pos, size_type __n)
{
__str._M_check(__pos, "basic_string::append");
__n = __str._M_limit(__pos, __n);
if (__n)
{
const size_type __len = __n + this->size();
if (__len > this->capacity() || _M_rep()->_M_is_shared())
this->reserve(__len);
_M_copy(_M_data() + this->size(), __str._M_data() + __pos, __n);
_M_rep()->_M_set_length_and_sharable(__len);
}
return *this;
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>&
basic_string<_CharT, _Traits, _Alloc>::
insert(size_type __pos, const _CharT* __s, size_type __n)
{
;
_M_check(__pos, "basic_string::insert");
_M_check_length(size_type(0), __n, "basic_string::insert");
if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
return _M_replace_safe(__pos, size_type(0), __s, __n);
else
{
// Work in-place.
const size_type __off = __s - _M_data();
_M_mutate(__pos, 0, __n);
__s = _M_data() + __off;
_CharT* __p = _M_data() + __pos;
if (__s + __n <= __p)
_M_copy(__p, __s, __n);
else if (__s >= __p)
_M_copy(__p, __s + __n, __n);
else
{
const size_type __nleft = __p - __s;
_M_copy(__p, __s, __nleft);
_M_copy(__p + __nleft, __p + __n, __n - __nleft);
}
return *this;
}
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::iterator
basic_string<_CharT, _Traits, _Alloc>::
erase(iterator __first, iterator __last)
{
#pragma empty_line
;
#pragma empty_line
// NB: This isn't just an optimization (bail out early when
// there is nothing to do, really), it's also a correctness
// issue vs MT, see libstdc++/40518.
const size_type __size = __last - __first;
if (__size)
{
const size_type __pos = __first - _M_ibegin();
_M_mutate(__pos, __size, size_type(0));
_M_rep()->_M_set_leaked();
return iterator(_M_data() + __pos);
}
else
return __first;
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>&
basic_string<_CharT, _Traits, _Alloc>::
replace(size_type __pos, size_type __n1, const _CharT* __s,
size_type __n2)
{
;
_M_check(__pos, "basic_string::replace");
__n1 = _M_limit(__pos, __n1);
_M_check_length(__n1, __n2, "basic_string::replace");
bool __left;
if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
return _M_replace_safe(__pos, __n1, __s, __n2);
else if ((__left = __s + __n2 <= _M_data() + __pos)
|| _M_data() + __pos + __n1 <= __s)
{
// Work in-place: non-overlapping case.
size_type __off = __s - _M_data();
__left ? __off : (__off += __n2 - __n1);
_M_mutate(__pos, __n1, __n2);
_M_copy(_M_data() + __pos, _M_data() + __off, __n2);
return *this;
}
else
{
// Todo: overlapping case.
const basic_string __tmp(__s, __n2);
return _M_replace_safe(__pos, __n1, __tmp._M_data(), __n2);
}
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
void
basic_string<_CharT, _Traits, _Alloc>::_Rep::
_M_destroy(const _Alloc& __a) throw ()
{
const size_type __size = sizeof(_Rep_base) +
(this->_M_capacity + 1) * sizeof(_CharT);
_Raw_bytes_alloc(__a).deallocate(reinterpret_cast<char*>(this), __size);
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
void
basic_string<_CharT, _Traits, _Alloc>::
_M_leak_hard()
{
#pragma empty_line
if (_M_rep() == &_S_empty_rep())
return;
#pragma empty_line
if (_M_rep()->_M_is_shared())
_M_mutate(0, 0, 0);
_M_rep()->_M_set_leaked();
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
void
basic_string<_CharT, _Traits, _Alloc>::
_M_mutate(size_type __pos, size_type __len1, size_type __len2)
{
const size_type __old_size = this->size();
const size_type __new_size = __old_size + __len2 - __len1;
const size_type __how_much = __old_size - __pos - __len1;
#pragma empty_line
if (__new_size > this->capacity() || _M_rep()->_M_is_shared())
{
// Must reallocate.
const allocator_type __a = get_allocator();
_Rep* __r = _Rep::_S_create(__new_size, this->capacity(), __a);
#pragma empty_line
if (__pos)
_M_copy(__r->_M_refdata(), _M_data(), __pos);
if (__how_much)
_M_copy(__r->_M_refdata() + __pos + __len2,
_M_data() + __pos + __len1, __how_much);
#pragma empty_line
_M_rep()->_M_dispose(__a);
_M_data(__r->_M_refdata());
}
else if (__how_much && __len1 != __len2)
{
// Work in-place.
_M_move(_M_data() + __pos + __len2,
_M_data() + __pos + __len1, __how_much);
}
_M_rep()->_M_set_length_and_sharable(__new_size);
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
void
basic_string<_CharT, _Traits, _Alloc>::
reserve(size_type __res)
{
if (__res != this->capacity() || _M_rep()->_M_is_shared())
{
// Make sure we don't shrink below the current size
if (__res < this->size())
__res = this->size();
const allocator_type __a = get_allocator();
_CharT* __tmp = _M_rep()->_M_clone(__a, __res - this->size());
_M_rep()->_M_dispose(__a);
_M_data(__tmp);
}
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
void
basic_string<_CharT, _Traits, _Alloc>::
swap(basic_string& __s)
{
if (_M_rep()->_M_is_leaked())
_M_rep()->_M_set_sharable();
if (__s._M_rep()->_M_is_leaked())
__s._M_rep()->_M_set_sharable();
if (this->get_allocator() == __s.get_allocator())
{
_CharT* __tmp = _M_data();
_M_data(__s._M_data());
__s._M_data(__tmp);
}
// The code below can usually be optimized away.
else
{
const basic_string __tmp1(_M_ibegin(), _M_iend(),
__s.get_allocator());
const basic_string __tmp2(__s._M_ibegin(), __s._M_iend(),
this->get_allocator());
*this = __tmp2;
__s = __tmp1;
}
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::_Rep*
basic_string<_CharT, _Traits, _Alloc>::_Rep::
_S_create(size_type __capacity, size_type __old_capacity,
const _Alloc& __alloc)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 83. String::npos vs. string::max_size()
if (__capacity > _S_max_size)
__throw_length_error(("basic_string::_S_create"));
#pragma empty_line
// The standard places no restriction on allocating more memory
// than is strictly needed within this layer at the moment or as
// requested by an explicit application call to reserve().
#pragma empty_line
// Many malloc implementations perform quite poorly when an
// application attempts to allocate memory in a stepwise fashion
// growing each allocation size by only 1 char. Additionally,
// it makes little sense to allocate less linear memory than the
// natural blocking size of the malloc implementation.
// Unfortunately, we would need a somewhat low-level calculation
// with tuned parameters to get this perfect for any particular
// malloc implementation. Fortunately, generalizations about
// common features seen among implementations seems to suffice.
#pragma empty_line
// __pagesize need not match the actual VM page size for good
// results in practice, thus we pick a common value on the low
// side. __malloc_header_size is an estimate of the amount of
// overhead per memory allocation (in practice seen N * sizeof
// (void*) where N is 0, 2 or 4). According to folklore,
// picking this value on the high side is better than
// low-balling it (especially when this algorithm is used with
// malloc implementations that allocate memory blocks rounded up
// to a size which is a power of 2).
const size_type __pagesize = 4096;
const size_type __malloc_header_size = 4 * sizeof(void*);
#pragma empty_line
// The below implements an exponential growth policy, necessary to
// meet amortized linear time requirements of the library: see
// http://gcc.gnu.org/ml/libstdc++/2001-07/msg00085.html.
// It's active for allocations requiring an amount of memory above
// system pagesize. This is consistent with the requirements of the
// standard: http://gcc.gnu.org/ml/libstdc++/2001-07/msg00130.html
if (__capacity > __old_capacity && __capacity < 2 * __old_capacity)
__capacity = 2 * __old_capacity;
#pragma empty_line
// NB: Need an array of char_type[__capacity], plus a terminating
// null char_type() element, plus enough for the _Rep data structure.
// Whew. Seemingly so needy, yet so elemental.
size_type __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);
#pragma empty_line
const size_type __adj_size = __size + __malloc_header_size;
if (__adj_size > __pagesize && __capacity > __old_capacity)
{
const size_type __extra = __pagesize - __adj_size % __pagesize;
__capacity += __extra / sizeof(_CharT);
// Never allocate a string bigger than _S_max_size.
if (__capacity > _S_max_size)
__capacity = _S_max_size;
__size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);
}
#pragma empty_line
// NB: Might throw, but no worries about a leak, mate: _Rep()
// does not throw.
void* __place = _Raw_bytes_alloc(__alloc).allocate(__size);
_Rep *__p = new (__place) _Rep;
__p->_M_capacity = __capacity;
// ABI compatibility - 3.4.x set in _S_create both
// _M_refcount and _M_length. All callers of _S_create
// in basic_string.tcc then set just _M_length.
// In 4.0.x and later both _M_refcount and _M_length
// are initialized in the callers, unfortunately we can
// have 3.4.x compiled code with _S_create callers inlined
// calling 4.0.x+ _S_create.
__p->_M_set_sharable();
return __p;
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
_CharT*
basic_string<_CharT, _Traits, _Alloc>::_Rep::
_M_clone(const _Alloc& __alloc, size_type __res)
{
// Requested capacity of the clone.
const size_type __requested_cap = this->_M_length + __res;
_Rep* __r = _Rep::_S_create(__requested_cap, this->_M_capacity,
__alloc);
if (this->_M_length)
_M_copy(__r->_M_refdata(), _M_refdata(), this->_M_length);
#pragma empty_line
__r->_M_set_length_and_sharable(this->_M_length);
return __r->_M_refdata();
}
#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();
_M_check_length(__size, __n, "basic_string::resize");
if (__size < __n)
this->append(__n - __size, __c);
else if (__n < __size)
this->erase(__n);
// else nothing (in particular, avoid calling _M_mutate() unnecessarily.)
}
#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(iterator __i1, iterator __i2, _InputIterator __k1,
_InputIterator __k2, __false_type)
{
const basic_string __s(__k1, __k2);
const size_type __n1 = __i2 - __i1;
_M_check_length(__n1, __s.size(), "basic_string::_M_replace_dispatch");
return _M_replace_safe(__i1 - _M_ibegin(), __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");
_M_mutate(__pos1, __n1, __n2);
if (__n2)
_M_assign(_M_data() + __pos1, __n2, __c);
return *this;
}
#pragma empty_line
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>&
basic_string<_CharT, _Traits, _Alloc>::
_M_replace_safe(size_type __pos1, size_type __n1, const _CharT* __s,
size_type __n2)
{
_M_mutate(__pos1, __n1, __n2);
if (__n2)
_M_copy(_M_data() + __pos1, __s, __n2);
return *this;
}
#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)
{
;
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>::
copy(_CharT* __s, size_type __n, size_type __pos) const
{
_M_check(__pos, "basic_string::copy");
__n = _M_limit(__pos, __n);
;
if (__n)
_M_copy(__s, _M_data() + __pos, __n);
// 21.3.5.7 par 3: do not append null. (good.)
return __n;
}
#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
{
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
{
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
{
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
{
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
// 21.3.7.9 basic_string::getline and operators
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)
{
if (true)
{
// Avoid reallocation for common case.
__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);
}
if (false)
{
__in._M_setstate(__ios_base::badbit);
;
}
if (false)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 91. Description of operator>> and getline() for string<>
// might cause endless loop
__in._M_setstate(__ios_base::badbit);
}
}
// 211. operator>>(istream&, string&) doesn't set failbit
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)
{
if (true)
{
__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;
}
if (false)
{
__in._M_setstate(__ios_base::badbit);
;
}
if (false)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 91. Description of operator>> and getline() for string<>
// might cause endless loop
__in._M_setstate(__ios_base::badbit);
}
}
if (!__extracted)
__err |= __ios_base::failbit;
if (__err)
__in.setstate(__err);
return __in;
}
#pragma empty_line
// Inhibit implicit instantiations for required instantiations,
// which are defined via explicit instantiations elsewhere.
#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
} // namespace std
#pragma line 55 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/string" 2 3
#pragma line 42 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_classes.h" 2 3
#pragma empty_line
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
// 22.1.1 Class locale
/**
* @brief Container class for localization functionality.
* @ingroup locales
*
* The locale class is first a class wrapper for C library locales. It is
* also an extensible container for user-defined localization. A locale is
* a collection of facets that implement various localization features such
* as money, time, and number printing.
*
* Constructing C++ locales does not change the C library locale.
*
* This library supports efficient construction and copying of locales
* through a reference counting implementation of the locale class.
*/
class locale
{
public:
// Types:
/// Definition of locale::category.
typedef int category;
#pragma empty_line
// Forward decls and friends:
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 empty_line
//@{
/**
* @brief Category values.
*
* The standard category values are none, ctype, numeric, collate, time,
* monetary, and messages. They form a bitmask that supports union and
* intersection. The category all is the union of these values.
*
* NB: Order must match _S_facet_categories definition in locale.cc
*/
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 empty_line
// Construct/copy/destroy:
#pragma empty_line
/**
* @brief Default constructor.
*
* Constructs a copy of the global locale. If no locale has been
* explicitly set, this is the C locale.
*/
locale() throw();
#pragma empty_line
/**
* @brief Copy constructor.
*
* Constructs a copy of @a other.
*
* @param other The locale to copy.
*/
locale(const locale& __other) throw();
#pragma empty_line
/**
* @brief Named locale constructor.
*
* Constructs a copy of the named C library locale.
*
* @param s Name of the locale to construct.
* @throw std::runtime_error if s is null or an undefined locale.
*/
explicit
locale(const char* __s);
#pragma empty_line
/**
* @brief Construct locale with facets from another locale.
*
* Constructs a copy of the locale @a base. The facets specified by @a
* cat are replaced with those from the locale named by @a s. If base is
* named, this locale instance will also be named.
*
* @param base The locale to copy.
* @param s Name of the locale to use facets from.
* @param cat Set of categories defining the facets to use from s.
* @throw std::runtime_error if s is null or an undefined locale.
*/
locale(const locale& __base, const char* __s, category __cat);
#pragma empty_line
/**
* @brief Construct locale with facets from another locale.
*
* Constructs a copy of the locale @a base. The facets specified by @a
* cat are replaced with those from the locale @a add. If @a base and @a
* add are named, this locale instance will also be named.
*
* @param base The locale to copy.
* @param add The locale to use facets from.
* @param cat Set of categories defining the facets to use from add.
*/
locale(const locale& __base, const locale& __add, category __cat);
#pragma empty_line
/**
* @brief Construct locale with another facet.
*
* Constructs a copy of the locale @a other. The facet @f is added to
* @other, replacing an existing facet of type Facet if there is one. If
* @f is null, this locale is a copy of @a other.
*
* @param other The locale to copy.
* @param f The facet to add in.
*/
template<typename _Facet>
locale(const locale& __other, _Facet* __f);
#pragma empty_line
/// Locale destructor.
~locale() throw();
#pragma empty_line
/**
* @brief Assignment operator.
*
* Set this locale to be a copy of @a other.
*
* @param other The locale to copy.
* @return A reference to this locale.
*/
const locale&
operator=(const locale& __other) throw();
#pragma empty_line
/**
* @brief Construct locale with another facet.
*
* Constructs and returns a new copy of this locale. Adds or replaces an
* existing facet of type Facet from the locale @a other into the new
* locale.
*
* @param Facet The facet type to copy from other
* @param other The locale to copy from.
* @return Newly constructed locale.
* @throw std::runtime_error if other has no facet of type Facet.
*/
template<typename _Facet>
locale
combine(const locale& __other) const;
#pragma empty_line
// Locale operations:
/**
* @brief Return locale name.
* @return Locale name or "*" if unnamed.
*/
string
name() const;
#pragma empty_line
/**
* @brief Locale equality.
*
* @param other The locale to compare against.
* @return True if other and this refer to the same locale instance, are
* copies, or have the same name. False otherwise.
*/
bool
operator==(const locale& __other) const throw();
#pragma empty_line
/**
* @brief Locale inequality.
*
* @param other The locale to compare against.
* @return ! (*this == other)
*/
bool
operator!=(const locale& __other) const throw()
{ return !(this->operator==(__other)); }
#pragma empty_line
/**
* @brief Compare two strings according to collate.
*
* Template operator to compare two strings using the compare function of
* the collate facet in this locale. One use is to provide the locale to
* the sort function. For example, a vector v of strings could be sorted
* according to locale loc by doing:
* @code
* std::sort(v.begin(), v.end(), loc);
* @endcode
*
* @param s1 First string to compare.
* @param s2 Second string to compare.
* @return True if collate<Char> facet compares s1 < s2, else false.
*/
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 empty_line
// Global locale objects:
/**
* @brief Set global locale
*
* This function sets the global locale to the argument and returns a
* copy of the previous global locale. If the argument has a name, it
* will also call std::setlocale(LC_ALL, loc.name()).
*
* @param locale The new locale to make global.
* @return Copy of the old global locale.
*/
static locale
global(const locale&);
#pragma empty_line
/**
* @brief Return reference to the C locale.
*/
static const locale&
classic();
#pragma empty_line
private:
// The (shared) implementation
_Impl* _M_impl;
#pragma empty_line
// The "C" reference locale
static _Impl* _S_classic;
#pragma empty_line
// Current global locale
static _Impl* _S_global;
#pragma empty_line
// Names of underlying locale categories.
// NB: locale::global() has to know how to modify all the
// underlying categories, not just the ones required by the C++
// standard.
static const char* const* const _S_categories;
#pragma empty_line
// Number of standard categories. For C++, these categories are
// collate, ctype, monetary, numeric, time, and messages. These
// directly correspond to ISO C99 macros LC_COLLATE, LC_CTYPE,
// LC_MONETARY, LC_NUMERIC, and LC_TIME. In addition, POSIX (IEEE
// 1003.1-2001) specifies LC_MESSAGES.
// In addition to the standard categories, the underlying
// operating system is allowed to define extra LC_*
// macros. For GNU systems, the following are also valid:
// LC_PAPER, LC_NAME, LC_ADDRESS, LC_TELEPHONE, LC_MEASUREMENT,
// and LC_IDENTIFICATION.
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
// 22.1.1.1.2 Class locale::facet
/**
* @brief Localization functionality base class.
* @ingroup locales
*
* The facet class is the base class for a localization feature, such as
* money, time, and number printing. It provides common support for facets
* and reference management.
*
* Facets may not be copied or assigned.
*/
class locale::facet
{
private:
friend class locale;
friend class locale::_Impl;
#pragma empty_line
mutable _Atomic_word _M_refcount;
#pragma empty_line
// Contains data from the underlying "C" library for the classic locale.
static __c_locale _S_c_locale;
#pragma empty_line
// String literal for the name of the classic locale.
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:
/**
* @brief Facet constructor.
*
* This is the constructor provided by the standard. If refs is 0, the
* facet is destroyed when the last referencing locale is destroyed.
* Otherwise the facet will never be destroyed.
*
* @param refs The initial value for reference count.
*/
explicit
facet(size_t __refs = 0) throw() : _M_refcount(__refs ? 1 : 0)
{ }
#pragma empty_line
/// Facet destructor.
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
// Returns data from the underlying "C" library data for the
// classic locale.
static __c_locale
_S_get_c_locale();
#pragma empty_line
__attribute__ ((__const__)) static const char*
_S_get_c_name() throw();
#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()
{
// Be race-detector-friendly. For more info see bits/c++config.
;
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
{
;
if (true)
{ delete this; }
if (false)
{ }
}
}
#pragma empty_line
facet(const facet&); // Not defined.
#pragma empty_line
facet&
operator=(const facet&); // Not defined.
};
#pragma empty_line
#pragma empty_line
// 22.1.1.1.3 Class locale::id
/**
* @brief Facet ID class.
* @ingroup locales
*
* The ID class provides facets with an index used to identify them.
* Every facet class must define a public static member locale::id, or be
* derived from a facet that provides this member, otherwise the facet
* cannot be used in a locale. The locale::id ensures that each class
* type gets a unique identifier.
*/
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
// NB: There is no accessor for _M_index because it may be used
// before the constructor is run; the effect of calling a member
// function (even an inline) would be undefined.
mutable size_t _M_index;
#pragma empty_line
// Last id number assigned.
static _Atomic_word _S_refcount;
#pragma empty_line
void
operator=(const id&); // Not defined.
#pragma empty_line
id(const id&); // Not defined.
#pragma empty_line
public:
// NB: This class is always a static data member, and thus can be
// counted on to be zero-initialized.
/// Constructor.
id() { }
#pragma empty_line
size_t
_M_id() const throw();
};
#pragma empty_line
#pragma empty_line
// Implementation object for locale.
class locale::_Impl
{
public:
// Friends.
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:
// Data Members.
_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()
{
// Be race-detector-friendly. For more info see bits/c++config.
;
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
{
;
if (true)
{ delete this; }
if (false)
{ }
}
}
#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&); // Not defined.
#pragma empty_line
void
operator=(const _Impl&); // Not defined.
#pragma empty_line
bool
_M_check_same_name()
{
bool __ret = true;
if (_M_names[1])
// We must actually compare all the _M_names: can be all equal!
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
void
_M_install_cache(const facet*, size_t);
};
#pragma empty_line
#pragma empty_line
/**
* @brief Test for the presence of a facet.
*
* has_facet tests the locale argument for the presence of the facet type
* provided as the template parameter. Facets derived from the facet
* parameter will also return true.
*
* @param Facet The facet type to test the presence of.
* @param locale The locale to test.
* @return true if locale contains a facet of type Facet, else false.
*/
template<typename _Facet>
bool
has_facet(const locale& __loc) throw();
#pragma empty_line
/**
* @brief Return a facet.
*
* use_facet looks for and returns a reference to a facet of type Facet
* where Facet is the template parameter. If has_facet(locale) is true,
* there is a suitable facet to return. It throws std::bad_cast if the
* locale doesn't contain a facet of type Facet.
*
* @param Facet The facet type to access.
* @param locale The locale to use.
* @return Reference to facet of type Facet.
* @throw std::bad_cast if locale doesn't contain a facet of type Facet.
*/
template<typename _Facet>
const _Facet&
use_facet(const locale& __loc);
#pragma empty_line
#pragma empty_line
/**
* @brief Facet for localized string comparison.
*
* This facet encapsulates the code to compare strings in a localized
* manner.
*
* The collate template uses protected virtual functions to provide
* the actual results. The public accessors forward the call to
* the virtual functions. These virtual functions are hooks for
* developers to implement the behavior they require from the
* collate facet.
*/
template<typename _CharT>
class collate : public locale::facet
{
public:
// Types:
//@{
/// Public typedefs
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;
//@}
#pragma empty_line
protected:
// Underlying "C" library locale information saved from
// initialization, needed by collate_byname as well.
__c_locale _M_c_locale_collate;
#pragma empty_line
public:
/// Numpunct facet id.
static locale::id id;
#pragma empty_line
/**
* @brief Constructor performs initialization.
*
* This is the constructor provided by the standard.
*
* @param refs Passed to the base facet class.
*/
explicit
collate(size_t __refs = 0)
: facet(__refs), _M_c_locale_collate(_S_get_c_locale())
{ }
#pragma empty_line
/**
* @brief Internal constructor. Not for general use.
*
* This is a constructor for use by the library itself to set up new
* locales.
*
* @param cloc The C locale.
* @param refs Passed to the base facet class.
*/
explicit
collate(__c_locale __cloc, size_t __refs = 0)
: facet(__refs), _M_c_locale_collate(_S_clone_c_locale(__cloc))
{ }
#pragma empty_line
/**
* @brief Compare two strings.
*
* This function compares two strings and returns the result by calling
* collate::do_compare().
*
* @param lo1 Start of string 1.
* @param hi1 End of string 1.
* @param lo2 Start of string 2.
* @param hi2 End of string 2.
* @return 1 if string1 > string2, -1 if string1 < string2, else 0.
*/
int
compare(const _CharT* __lo1, const _CharT* __hi1,
const _CharT* __lo2, const _CharT* __hi2) const
{ return this->do_compare(__lo1, __hi1, __lo2, __hi2); }
#pragma empty_line
/**
* @brief Transform string to comparable form.
*
* This function is a wrapper for strxfrm functionality. It takes the
* input string and returns a modified string that can be directly
* compared to other transformed strings. In the C locale, this
* function just returns a copy of the input string. In some other
* locales, it may replace two chars with one, change a char for
* another, etc. It does so by returning collate::do_transform().
*
* @param lo Start of string.
* @param hi End of string.
* @return Transformed string_type.
*/
string_type
transform(const _CharT* __lo, const _CharT* __hi) const
{ return this->do_transform(__lo, __hi); }
#pragma empty_line
/**
* @brief Return hash of a string.
*
* This function computes and returns a hash on the input string. It
* does so by returning collate::do_hash().
*
* @param lo Start of string.
* @param hi End of string.
* @return Hash value.
*/
long
hash(const _CharT* __lo, const _CharT* __hi) const
{ return this->do_hash(__lo, __hi); }
#pragma empty_line
// Used to abstract out _CharT bits in virtual member functions, below.
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:
/// Destructor.
virtual
~collate()
{ _S_destroy_c_locale(_M_c_locale_collate); }
#pragma empty_line
/**
* @brief Compare two strings.
*
* This function is a hook for derived classes to change the value
* returned. @see compare().
*
* @param lo1 Start of string 1.
* @param hi1 End of string 1.
* @param lo2 Start of string 2.
* @param hi2 End of string 2.
* @return 1 if string1 > string2, -1 if string1 < string2, else 0.
*/
virtual int
do_compare(const _CharT* __lo1, const _CharT* __hi1,
const _CharT* __lo2, const _CharT* __hi2) const;
#pragma empty_line
/**
* @brief Transform string to comparable form.
*
* This function is a hook for derived classes to change the value
* returned.
*
* @param lo1 Start of string 1.
* @param hi1 End of string 1.
* @param lo2 Start of string 2.
* @param hi2 End of string 2.
* @return 1 if string1 > string2, -1 if string1 < string2, else 0.
*/
virtual string_type
do_transform(const _CharT* __lo, const _CharT* __hi) const;
#pragma empty_line
/**
* @brief Return hash of a string.
*
* This function computes and returns a hash on the input string. This
* function is a hook for derived classes to change the value returned.
*
* @param lo Start of string.
* @param hi End of string.
* @return Hash value.
*/
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
// Specializations.
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
/// class collate_byname [22.2.4.2].
template<typename _CharT>
class collate_byname : public collate<_CharT>
{
public:
//@{
/// Public typedefs
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;
//@}
#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
protected:
virtual
~collate_byname() { }
};
#pragma empty_line
#pragma empty_line
} // namespace
#pragma empty_line
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_classes.tcc" 1 3
// Locale support -*- C++ -*-
#pragma empty_line
// Copyright (C) 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file bits/locale_classes.tcc
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{locale}
*/
#pragma empty_line
//
// ISO C++ 14882: 22.1 Locales
//
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 37 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/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
if (true)
{ _M_impl->_M_install_facet(&_Facet::id, __f); }
if (false)
{
_M_impl->_M_remove_reference();
;
}
delete [] _M_impl->_M_names[0];
_M_impl->_M_names[0] = 0; // Unnamed.
}
#pragma empty_line
template<typename _Facet>
locale
locale::
combine(const locale& __other) const
{
_Impl* __tmp = new _Impl(*_M_impl, 1);
if (true)
{
__tmp->_M_replace_facet(__other._M_impl, &_Facet::id);
}
if (false)
{
__tmp->_M_remove_reference();
;
}
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 empty_line
#pragma empty_line
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 empty_line
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
// Generic version does nothing.
template<typename _CharT>
int
collate<_CharT>::_M_compare(const _CharT*, const _CharT*) const throw ()
{ return 0; }
#pragma empty_line
// Generic version does nothing.
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
{
// strcoll assumes zero-terminated strings so we make a copy
// and then put a zero at the end.
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
// strcoll stops when it sees a nul character so we break
// the strings into zero-terminated substrings and pass those
// to strcoll.
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
// strxfrm assumes zero-terminated strings so we make a copy
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
if (true)
{
// strxfrm stops when it sees a nul character so we break
// the string into zero-terminated substrings and pass those
// to strxfrm.
for (;;)
{
// First try a buffer perhaps big enough.
size_t __res = _M_transform(__c, __p, __len);
// If the buffer was not large enough, try again with the
// correct size.
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());
}
}
if (false)
{
delete [] __c;
;
}
#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
// Inhibit implicit instantiations for required instantiations,
// which are defined via explicit instantiations elsewhere.
#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
} // namespace std
#pragma line 823 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_classes.h" 2 3
#pragma line 43 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/ios_base.h" 2 3
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
// The following definitions of bitmask types are enums, not ints,
// as permitted (but not required) in the standard, in order to provide
// better type safety in iostream calls. A side effect is that
// expressions involving them are no longer compile-time constants.
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
};
#pragma empty_line
inline _Ios_Fmtflags
operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
{ return _Ios_Fmtflags(static_cast<int>(__a) & static_cast<int>(__b)); }
#pragma empty_line
inline _Ios_Fmtflags
operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
{ return _Ios_Fmtflags(static_cast<int>(__a) | static_cast<int>(__b)); }
#pragma empty_line
inline _Ios_Fmtflags
operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
{ return _Ios_Fmtflags(static_cast<int>(__a) ^ static_cast<int>(__b)); }
#pragma empty_line
inline _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
};
#pragma empty_line
inline _Ios_Openmode
operator&(_Ios_Openmode __a, _Ios_Openmode __b)
{ return _Ios_Openmode(static_cast<int>(__a) & static_cast<int>(__b)); }
#pragma empty_line
inline _Ios_Openmode
operator|(_Ios_Openmode __a, _Ios_Openmode __b)
{ return _Ios_Openmode(static_cast<int>(__a) | static_cast<int>(__b)); }
#pragma empty_line
inline _Ios_Openmode
operator^(_Ios_Openmode __a, _Ios_Openmode __b)
{ return _Ios_Openmode(static_cast<int>(__a) ^ static_cast<int>(__b)); }
#pragma empty_line
inline _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
};
#pragma empty_line
inline _Ios_Iostate
operator&(_Ios_Iostate __a, _Ios_Iostate __b)
{ return _Ios_Iostate(static_cast<int>(__a) & static_cast<int>(__b)); }
#pragma empty_line
inline _Ios_Iostate
operator|(_Ios_Iostate __a, _Ios_Iostate __b)
{ return _Ios_Iostate(static_cast<int>(__a) | static_cast<int>(__b)); }
#pragma empty_line
inline _Ios_Iostate
operator^(_Ios_Iostate __a, _Ios_Iostate __b)
{ return _Ios_Iostate(static_cast<int>(__a) ^ static_cast<int>(__b)); }
#pragma empty_line
inline _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
// 27.4.2 Class ios_base
/**
* @brief The base of the I/O class hierarchy.
* @ingroup io
*
* This class defines everything that can be defined about I/O that does
* not depend on the type of characters being input or output. Most
* people will only see @c ios_base when they need to specify the full
* name of the various I/O flags (e.g., the openmodes).
*/
class ios_base
{
public:
#pragma empty_line
/**
* @brief These are thrown to indicate problems with io.
* @ingroup exceptions
*
* 27.4.2.1.1 Class ios_base::failure
*/
class failure : public exception
{
public:
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 48. Use of non-existent exception constructor
explicit
failure(const string& __str) throw();
#pragma empty_line
// This declaration is not useless:
// http://gcc.gnu.org/onlinedocs/gcc-4.3.2/gcc/Vague-Linkage.html
virtual
~failure() throw();
#pragma empty_line
virtual const char*
what() const throw();
#pragma empty_line
private:
string _M_msg;
};
#pragma empty_line
// 27.4.2.1.2 Type ios_base::fmtflags
/**
* @brief This is a bitmask type.
*
* @c @a _Ios_Fmtflags is implementation-defined, but it is valid to
* perform bitwise operations on these values and expect the Right
* Thing to happen. Defined objects of type fmtflags are:
* - boolalpha
* - dec
* - fixed
* - hex
* - internal
* - left
* - oct
* - right
* - scientific
* - showbase
* - showpoint
* - showpos
* - skipws
* - unitbuf
* - uppercase
* - adjustfield
* - basefield
* - floatfield
*/
typedef _Ios_Fmtflags fmtflags;
#pragma empty_line
/// Insert/extract @c bool in alphabetic rather than numeric format.
static const fmtflags boolalpha = _S_boolalpha;
#pragma empty_line
/// Converts integer input or generates integer output in decimal base.
static const fmtflags dec = _S_dec;
#pragma empty_line
/// Generate floating-point output in fixed-point notation.
static const fmtflags fixed = _S_fixed;
#pragma empty_line
/// Converts integer input or generates integer output in hexadecimal base.
static const fmtflags hex = _S_hex;
#pragma empty_line
/// Adds fill characters at a designated internal point in certain
/// generated output, or identical to @c right if no such point is
/// designated.
static const fmtflags internal = _S_internal;
#pragma empty_line
/// Adds fill characters on the right (final positions) of certain
/// generated output. (I.e., the thing you print is flush left.)
static const fmtflags left = _S_left;
#pragma empty_line
/// Converts integer input or generates integer output in octal base.
static const fmtflags oct = _S_oct;
#pragma empty_line
/// Adds fill characters on the left (initial positions) of certain
/// generated output. (I.e., the thing you print is flush right.)
static const fmtflags right = _S_right;
#pragma empty_line
/// Generates floating-point output in scientific notation.
static const fmtflags scientific = _S_scientific;
#pragma empty_line
/// Generates a prefix indicating the numeric base of generated integer
/// output.
static const fmtflags showbase = _S_showbase;
#pragma empty_line
/// Generates a decimal-point character unconditionally in generated
/// floating-point output.
static const fmtflags showpoint = _S_showpoint;
#pragma empty_line
/// Generates a + sign in non-negative generated numeric output.
static const fmtflags showpos = _S_showpos;
#pragma empty_line
/// Skips leading white space before certain input operations.
static const fmtflags skipws = _S_skipws;
#pragma empty_line
/// Flushes output after each output operation.
static const fmtflags unitbuf = _S_unitbuf;
#pragma empty_line
/// Replaces certain lowercase letters with their uppercase equivalents
/// in generated output.
static const fmtflags uppercase = _S_uppercase;
#pragma empty_line
/// A mask of left|right|internal. Useful for the 2-arg form of @c setf.
static const fmtflags adjustfield = _S_adjustfield;
#pragma empty_line
/// A mask of dec|oct|hex. Useful for the 2-arg form of @c setf.
static const fmtflags basefield = _S_basefield;
#pragma empty_line
/// A mask of scientific|fixed. Useful for the 2-arg form of @c setf.
static const fmtflags floatfield = _S_floatfield;
#pragma empty_line
// 27.4.2.1.3 Type ios_base::iostate
/**
* @brief This is a bitmask type.
*
* @c @a _Ios_Iostate is implementation-defined, but it is valid to
* perform bitwise operations on these values and expect the Right
* Thing to happen. Defined objects of type iostate are:
* - badbit
* - eofbit
* - failbit
* - goodbit
*/
typedef _Ios_Iostate iostate;
#pragma empty_line
/// Indicates a loss of integrity in an input or output sequence (such
/// as an irrecoverable read error from a file).
static const iostate badbit = _S_badbit;
#pragma empty_line
/// Indicates that an input operation reached the end of an input sequence.
static const iostate eofbit = _S_eofbit;
#pragma empty_line
/// Indicates that an input operation failed to read the expected
/// characters, or that an output operation failed to generate the
/// desired characters.
static const iostate failbit = _S_failbit;
#pragma empty_line
/// Indicates all is well.
static const iostate goodbit = _S_goodbit;
#pragma empty_line
// 27.4.2.1.4 Type ios_base::openmode
/**
* @brief This is a bitmask type.
*
* @c @a _Ios_Openmode is implementation-defined, but it is valid to
* perform bitwise operations on these values and expect the Right
* Thing to happen. Defined objects of type openmode are:
* - app
* - ate
* - binary
* - in
* - out
* - trunc
*/
typedef _Ios_Openmode openmode;
#pragma empty_line
/// Seek to end before each write.
static const openmode app = _S_app;
#pragma empty_line
/// Open and seek to end immediately after opening.
static const openmode ate = _S_ate;
#pragma empty_line
/// Perform input and output in binary mode (as opposed to text mode).
/// This is probably not what you think it is; see
/// http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch27s02.html
static const openmode binary = _S_bin;
#pragma empty_line
/// Open for input. Default for @c ifstream and fstream.
static const openmode in = _S_in;
#pragma empty_line
/// Open for output. Default for @c ofstream and fstream.
static const openmode out = _S_out;
#pragma empty_line
/// Open for input. Default for @c ofstream.
static const openmode trunc = _S_trunc;
#pragma empty_line
// 27.4.2.1.5 Type ios_base::seekdir
/**
* @brief This is an enumerated type.
*
* @c @a _Ios_Seekdir is implementation-defined. Defined values
* of type seekdir are:
* - beg
* - cur, equivalent to @c SEEK_CUR in the C standard library.
* - end, equivalent to @c SEEK_END in the C standard library.
*/
typedef _Ios_Seekdir seekdir;
#pragma empty_line
/// Request a seek relative to the beginning of the stream.
static const seekdir beg = _S_beg;
#pragma empty_line
/// Request a seek relative to the current position within the sequence.
static const seekdir cur = _S_cur;
#pragma empty_line
/// Request a seek relative to the current end of the sequence.
static const seekdir end = _S_end;
#pragma empty_line
// Annex D.6
typedef int io_state;
typedef int open_mode;
typedef int seek_dir;
#pragma empty_line
typedef std::streampos streampos;
typedef std::streamoff streamoff;
#pragma empty_line
// Callbacks;
/**
* @brief The set of events that may be passed to an event callback.
*
* erase_event is used during ~ios() and copyfmt(). imbue_event is used
* during imbue(). copyfmt_event is used during copyfmt().
*/
enum event
{
erase_event,
imbue_event,
copyfmt_event
};
#pragma empty_line
/**
* @brief The type of an event callback function.
* @param event One of the members of the event enum.
* @param ios_base Reference to the ios_base object.
* @param int The integer provided when the callback was registered.
*
* Event callbacks are user defined functions that get called during
* several ios_base and basic_ios functions, specifically imbue(),
* copyfmt(), and ~ios().
*/
typedef void (*event_callback) (event, ios_base&, int);
#pragma empty_line
/**
* @brief Add the callback __fn with parameter __index.
* @param __fn The function to add.
* @param __index The integer to pass to the function when invoked.
*
* Registers a function as an event callback with an integer parameter to
* be passed to the function when invoked. Multiple copies of the
* function are allowed. If there are multiple callbacks, they are
* invoked in the order they were registered.
*/
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
// 27.4.2.6 Members for callbacks
// 27.4.2.6 ios_base callbacks
struct _Callback_list
{
// Data Members
_Callback_list* _M_next;
ios_base::event_callback _M_fn;
int _M_index;
_Atomic_word _M_refcount; // 0 means one reference.
#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
// 0 => OK to delete.
int
_M_remove_reference()
{
// Be race-detector-friendly. For more info see bits/c++config.
;
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
// 27.4.2.5 Members for iword/pword storage
struct _Words
{
void* _M_pword;
long _M_iword;
_Words() : _M_pword(0), _M_iword(0) { }
};
#pragma empty_line
// Only for failed iword/pword calls.
_Words _M_word_zero;
#pragma empty_line
// Guaranteed storage.
// The first 5 iword and pword slots are reserved for internal use.
enum { _S_local_word_size = 8 };
_Words _M_local_word[_S_local_word_size];
#pragma empty_line
// Allocated storage.
int _M_word_size;
_Words* _M_word;
#pragma empty_line
_Words&
_M_grow_words(int __index, bool __iword);
#pragma empty_line
// Members for locale and locale caching.
locale _M_ios_locale;
#pragma empty_line
void
_M_init() throw();
#pragma empty_line
public:
#pragma empty_line
// 27.4.2.1.6 Class ios_base::Init
// Used to initialize standard streams. In theory, g++ could use
// -finit-priority to order this stuff correctly without going
// through these machinations.
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
// [27.4.2.2] fmtflags state functions
/**
* @brief Access to format flags.
* @return The format control flags for both input and output.
*/
fmtflags
flags() const
{ return _M_flags; }
#pragma empty_line
/**
* @brief Setting new format flags all at once.
* @param fmtfl The new flags to set.
* @return The previous format control flags.
*
* This function overwrites all the format flags with @a fmtfl.
*/
fmtflags
flags(fmtflags __fmtfl)
{
fmtflags __old = _M_flags;
_M_flags = __fmtfl;
return __old;
}
#pragma empty_line
/**
* @brief Setting new format flags.
* @param fmtfl Additional flags to set.
* @return The previous format control flags.
*
* This function sets additional flags in format control. Flags that
* were previously set remain set.
*/
fmtflags
setf(fmtflags __fmtfl)
{
fmtflags __old = _M_flags;
_M_flags |= __fmtfl;
return __old;
}
#pragma empty_line
/**
* @brief Setting new format flags.
* @param fmtfl Additional flags to set.
* @param mask The flags mask for @a fmtfl.
* @return The previous format control flags.
*
* This function clears @a mask in the format flags, then sets
* @a fmtfl @c & @a mask. An example mask is @c ios_base::adjustfield.
*/
fmtflags
setf(fmtflags __fmtfl, fmtflags __mask)
{
fmtflags __old = _M_flags;
_M_flags &= ~__mask;
_M_flags |= (__fmtfl & __mask);
return __old;
}
#pragma empty_line
/**
* @brief Clearing format flags.
* @param mask The flags to unset.
*
* This function clears @a mask in the format flags.
*/
void
unsetf(fmtflags __mask)
{ _M_flags &= ~__mask; }
#pragma empty_line
/**
* @brief Flags access.
* @return The precision to generate on certain output operations.
*
* Be careful if you try to give a definition of @a precision here; see
* DR 189.
*/
streamsize
precision() const
{ return _M_precision; }
#pragma empty_line
/**
* @brief Changing flags.
* @param prec The new precision value.
* @return The previous value of precision().
*/
streamsize
precision(streamsize __prec)
{
streamsize __old = _M_precision;
_M_precision = __prec;
return __old;
}
#pragma empty_line
/**
* @brief Flags access.
* @return The minimum field width to generate on output operations.
*
* <em>Minimum field width</em> refers to the number of characters.
*/
streamsize
width() const
{ return _M_width; }
#pragma empty_line
/**
* @brief Changing flags.
* @param wide The new width value.
* @return The previous value of width().
*/
streamsize
width(streamsize __wide)
{
streamsize __old = _M_width;
_M_width = __wide;
return __old;
}
#pragma empty_line
// [27.4.2.4] ios_base static members
/**
* @brief Interaction with the standard C I/O objects.
* @param sync Whether to synchronize or not.
* @return True if the standard streams were previously synchronized.
*
* The synchronization referred to is @e only that between the standard
* C facilities (e.g., stdout) and the standard C++ objects (e.g.,
* cout). User-declared streams are unaffected. See
* http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch28s02.html
*/
static bool
sync_with_stdio(bool __sync = true);
#pragma empty_line
// [27.4.2.3] ios_base locale functions
/**
* @brief Setting a new locale.
* @param loc The new locale.
* @return The previous locale.
*
* Sets the new locale for this stream, and then invokes each callback
* with imbue_event.
*/
locale
imbue(const locale& __loc) throw();
#pragma empty_line
/**
* @brief Locale access
* @return A copy of the current locale.
*
* If @c imbue(loc) has previously been called, then this function
* returns @c loc. Otherwise, it returns a copy of @c std::locale(),
* the global C++ locale.
*/
locale
getloc() const
{ return _M_ios_locale; }
#pragma empty_line
/**
* @brief Locale access
* @return A reference to the current locale.
*
* Like getloc above, but returns a reference instead of
* generating a copy.
*/
const locale&
_M_getloc() const
{ return _M_ios_locale; }
#pragma empty_line
// [27.4.2.5] ios_base storage functions
/**
* @brief Access to unique indices.
* @return An integer different from all previous calls.
*
* This function returns a unique integer every time it is called. It
* can be used for any purpose, but is primarily intended to be a unique
* index for the iword and pword functions. The expectation is that an
* application calls xalloc in order to obtain an index in the iword and
* pword arrays that can be used without fear of conflict.
*
* The implementation maintains a static variable that is incremented and
* returned on each invocation. xalloc is guaranteed to return an index
* that is safe to use in the iword and pword arrays.
*/
static int
xalloc() throw();
#pragma empty_line
/**
* @brief Access to integer array.
* @param __ix Index into the array.
* @return A reference to an integer associated with the index.
*
* The iword function provides access to an array of integers that can be
* used for any purpose. The array grows as required to hold the
* supplied index. All integers in the array are initialized to 0.
*
* The implementation reserves several indices. You should use xalloc to
* obtain an index that is safe to use. Also note that since the array
* can grow dynamically, it is not safe to hold onto the reference.
*/
long&
iword(int __ix)
{
_Words& __word = (__ix < _M_word_size)
? _M_word[__ix] : _M_grow_words(__ix, true);
return __word._M_iword;
}
#pragma empty_line
/**
* @brief Access to void pointer array.
* @param __ix Index into the array.
* @return A reference to a void* associated with the index.
*
* The pword function provides access to an array of pointers that can be
* used for any purpose. The array grows as required to hold the
* supplied index. All pointers in the array are initialized to 0.
*
* The implementation reserves several indices. You should use xalloc to
* obtain an index that is safe to use. Also note that since the array
* can grow dynamically, it is not safe to hold onto the reference.
*/
void*&
pword(int __ix)
{
_Words& __word = (__ix < _M_word_size)
? _M_word[__ix] : _M_grow_words(__ix, false);
return __word._M_pword;
}
#pragma empty_line
// Destructor
/**
* Invokes each callback with erase_event. Destroys local storage.
*
* Note that the ios_base object for the standard streams never gets
* destroyed. As a result, any callbacks registered with the standard
* streams will not get invoked with erase_event (unless copyfmt is
* used).
*/
virtual ~ios_base();
#pragma empty_line
protected:
ios_base() throw ();
#pragma empty_line
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 50. Copy constructor and assignment operator of ios_base
private:
ios_base(const ios_base&);
#pragma empty_line
ios_base&
operator=(const ios_base&);
};
#pragma empty_line
// [27.4.5.1] fmtflags manipulators
/// Calls base.setf(ios_base::boolalpha).
inline ios_base&
boolalpha(ios_base& __base)
{
__base.setf(ios_base::boolalpha);
return __base;
}
#pragma empty_line
/// Calls base.unsetf(ios_base::boolalpha).
inline ios_base&
noboolalpha(ios_base& __base)
{
__base.unsetf(ios_base::boolalpha);
return __base;
}
#pragma empty_line
/// Calls base.setf(ios_base::showbase).
inline ios_base&
showbase(ios_base& __base)
{
__base.setf(ios_base::showbase);
return __base;
}
#pragma empty_line
/// Calls base.unsetf(ios_base::showbase).
inline ios_base&
noshowbase(ios_base& __base)
{
__base.unsetf(ios_base::showbase);
return __base;
}
#pragma empty_line
/// Calls base.setf(ios_base::showpoint).
inline ios_base&
showpoint(ios_base& __base)
{
__base.setf(ios_base::showpoint);
return __base;
}
#pragma empty_line
/// Calls base.unsetf(ios_base::showpoint).
inline ios_base&
noshowpoint(ios_base& __base)
{
__base.unsetf(ios_base::showpoint);
return __base;
}
#pragma empty_line
/// Calls base.setf(ios_base::showpos).
inline ios_base&
showpos(ios_base& __base)
{
__base.setf(ios_base::showpos);
return __base;
}
#pragma empty_line
/// Calls base.unsetf(ios_base::showpos).
inline ios_base&
noshowpos(ios_base& __base)
{
__base.unsetf(ios_base::showpos);
return __base;
}
#pragma empty_line
/// Calls base.setf(ios_base::skipws).
inline ios_base&
skipws(ios_base& __base)
{
__base.setf(ios_base::skipws);
return __base;
}
#pragma empty_line
/// Calls base.unsetf(ios_base::skipws).
inline ios_base&
noskipws(ios_base& __base)
{
__base.unsetf(ios_base::skipws);
return __base;
}
#pragma empty_line
/// Calls base.setf(ios_base::uppercase).
inline ios_base&
uppercase(ios_base& __base)
{
__base.setf(ios_base::uppercase);
return __base;
}
#pragma empty_line
/// Calls base.unsetf(ios_base::uppercase).
inline ios_base&
nouppercase(ios_base& __base)
{
__base.unsetf(ios_base::uppercase);
return __base;
}
#pragma empty_line
/// Calls base.setf(ios_base::unitbuf).
inline ios_base&
unitbuf(ios_base& __base)
{
__base.setf(ios_base::unitbuf);
return __base;
}
#pragma empty_line
/// Calls base.unsetf(ios_base::unitbuf).
inline ios_base&
nounitbuf(ios_base& __base)
{
__base.unsetf(ios_base::unitbuf);
return __base;
}
#pragma empty_line
// [27.4.5.2] adjustfield manipulators
/// Calls base.setf(ios_base::internal, ios_base::adjustfield).
inline ios_base&
internal(ios_base& __base)
{
__base.setf(ios_base::internal, ios_base::adjustfield);
return __base;
}
#pragma empty_line
/// Calls base.setf(ios_base::left, ios_base::adjustfield).
inline ios_base&
left(ios_base& __base)
{
__base.setf(ios_base::left, ios_base::adjustfield);
return __base;
}
#pragma empty_line
/// Calls base.setf(ios_base::right, ios_base::adjustfield).
inline ios_base&
right(ios_base& __base)
{
__base.setf(ios_base::right, ios_base::adjustfield);
return __base;
}
#pragma empty_line
// [27.4.5.3] basefield manipulators
/// Calls base.setf(ios_base::dec, ios_base::basefield).
inline ios_base&
dec(ios_base& __base)
{
__base.setf(ios_base::dec, ios_base::basefield);
return __base;
}
#pragma empty_line
/// Calls base.setf(ios_base::hex, ios_base::basefield).
inline ios_base&
hex(ios_base& __base)
{
__base.setf(ios_base::hex, ios_base::basefield);
return __base;
}
#pragma empty_line
/// Calls base.setf(ios_base::oct, ios_base::basefield).
inline ios_base&
oct(ios_base& __base)
{
__base.setf(ios_base::oct, ios_base::basefield);
return __base;
}
#pragma empty_line
// [27.4.5.4] floatfield manipulators
/// Calls base.setf(ios_base::fixed, ios_base::floatfield).
inline ios_base&
fixed(ios_base& __base)
{
__base.setf(ios_base::fixed, ios_base::floatfield);
return __base;
}
#pragma empty_line
/// Calls base.setf(ios_base::scientific, ios_base::floatfield).
inline ios_base&
scientific(ios_base& __base)
{
__base.setf(ios_base::scientific, ios_base::floatfield);
return __base;
}
#pragma empty_line
#pragma empty_line
} // namespace
#pragma line 43 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ios" 2 3
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/streambuf" 1 3
// Stream buffer classes -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file include/streambuf
* This is a Standard C++ Library header.
*/
#pragma empty_line
//
// ISO C++ 14882: 27.5 Stream buffers
//
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 37 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/streambuf" 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 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 empty_line
/**
* @brief The actual work of input and output (interface).
* @ingroup io
*
* This is a base class. Derived stream buffers each control a
* pair of character sequences: one for input, and one for output.
*
* Section [27.5.1] of the standard describes the requirements and
* behavior of stream buffer classes. That section (three paragraphs)
* is reproduced here, for simplicity and accuracy.
*
* -# Stream buffers can impose various constraints on the sequences
* they control. Some constraints are:
* - The controlled input sequence can be not readable.
* - The controlled output sequence can be not writable.
* - The controlled sequences can be associated with the contents of
* other representations for character sequences, such as external
* files.
* - The controlled sequences can support operations @e directly to or
* from associated sequences.
* - The controlled sequences can impose limitations on how the
* program can read characters from a sequence, write characters to
* a sequence, put characters back into an input sequence, or alter
* the stream position.
* .
* -# Each sequence is characterized by three pointers which, if non-null,
* all point into the same @c charT array object. The array object
* represents, at any moment, a (sub)sequence of characters from the
* sequence. Operations performed on a sequence alter the values
* stored in these pointers, perform reads and writes directly to or
* from associated sequences, and alter <em>the stream position</em> and
* conversion state as needed to maintain this subsequence relationship.
* The three pointers are:
* - the <em>beginning pointer</em>, or lowest element address in the
* array (called @e xbeg here);
* - the <em>next pointer</em>, or next element address that is a
* current candidate for reading or writing (called @e xnext here);
* - the <em>end pointer</em>, or first element address beyond the
* end of the array (called @e xend here).
* .
* -# The following semantic constraints shall always apply for any set
* of three pointers for a sequence, using the pointer names given
* immediately above:
* - If @e xnext is not a null pointer, then @e xbeg and @e xend shall
* also be non-null pointers into the same @c charT array, as
* described above; otherwise, @e xbeg and @e xend shall also be null.
* - If @e xnext is not a null pointer and @e xnext < @e xend for an
* output sequence, then a <em>write position</em> is available.
* In this case, @e *xnext shall be assignable as the next element
* to write (to put, or to store a character value, into the sequence).
* - If @e xnext is not a null pointer and @e xbeg < @e xnext for an
* input sequence, then a <em>putback position</em> is available.
* In this case, @e xnext[-1] shall have a defined value and is the
* next (preceding) element to store a character that is put back
* into the input sequence.
* - If @e xnext is not a null pointer and @e xnext< @e xend for an
* input sequence, then a <em>read position</em> is available.
* In this case, @e *xnext shall have a defined value and is the
* next element to read (to get, or to obtain a character value,
* from the sequence).
*/
template<typename _CharT, typename _Traits>
class basic_streambuf
{
public:
//@{
/**
* These are standard types. They permit a standardized way of
* referring to names of (or names dependant on) the template
* parameters, which are specific to the implementation.
*/
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
//@{
/// This is a non-standard type.
typedef basic_streambuf<char_type, traits_type> __streambuf_type;
//@}
#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<>(__streambuf_type*, __streambuf_type*, 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:
//@{
/**
* This is based on _IO_FILE, just reordered to be more consistent,
* and is intended to be the most minimal abstraction for an
* internal buffer.
* - get == input == read
* - put == output == write
*/
char_type* _M_in_beg; // Start of get area.
char_type* _M_in_cur; // Current read area.
char_type* _M_in_end; // End of get area.
char_type* _M_out_beg; // Start of put area.
char_type* _M_out_cur; // Current put area.
char_type* _M_out_end; // End of put area.
#pragma empty_line
/// Current locale setting.
locale _M_buf_locale;
#pragma empty_line
public:
/// Destructor deallocates no buffer space.
virtual
~basic_streambuf()
{ }
#pragma empty_line
// [27.5.2.2.1] locales
/**
* @brief Entry point for imbue().
* @param loc The new locale.
* @return The previous locale.
*
* Calls the derived imbue(loc).
*/
locale
pubimbue(const locale &__loc)
{
locale __tmp(this->getloc());
this->imbue(__loc);
_M_buf_locale = __loc;
return __tmp;
}
#pragma empty_line
/**
* @brief Locale access.
* @return The current locale in effect.
*
* If pubimbue(loc) has been called, then the most recent @c loc
* is returned. Otherwise the global locale in effect at the time
* of construction is returned.
*/
locale
getloc() const
{ return _M_buf_locale; }
#pragma empty_line
// [27.5.2.2.2] buffer management and positioning
//@{
/**
* @brief Entry points for derived buffer functions.
*
* The public versions of @c pubfoo dispatch to the protected
* derived @c foo member functions, passing the arguments (if any)
* and returning the result unchanged.
*/
__streambuf_type*
pubsetbuf(char_type* __s, streamsize __n)
{ return this->setbuf(__s, __n); }
#pragma empty_line
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 empty_line
pos_type
pubseekpos(pos_type __sp,
ios_base::openmode __mode = ios_base::in | ios_base::out)
{ return this->seekpos(__sp, __mode); }
#pragma empty_line
int
pubsync() { return this->sync(); }
//@}
#pragma empty_line
// [27.5.2.2.3] get area
/**
* @brief Looking ahead into the stream.
* @return The number of characters available.
*
* If a read position is available, returns the number of characters
* available for reading before the buffer must be refilled.
* Otherwise returns the derived @c showmanyc().
*/
streamsize
in_avail()
{
const streamsize __ret = this->egptr() - this->gptr();
return __ret ? __ret : this->showmanyc();
}
#pragma empty_line
/**
* @brief Getting the next character.
* @return The next character, or eof.
*
* Calls @c sbumpc(), and if that function returns
* @c traits::eof(), so does this function. Otherwise, @c sgetc().
*/
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 empty_line
/**
* @brief Getting the next character.
* @return The next character, or eof.
*
* If the input read position is available, returns that character
* and increments the read pointer, otherwise calls and returns
* @c uflow().
*/
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 empty_line
/**
* @brief Getting the next character.
* @return The next character, or eof.
*
* If the input read position is available, returns that character,
* otherwise calls and returns @c underflow(). Does not move the
* read position after fetching the character.
*/
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 empty_line
/**
* @brief Entry point for xsgetn.
* @param s A buffer area.
* @param n A count.
*
* Returns xsgetn(s,n). The effect is to fill @a s[0] through
* @a s[n-1] with characters from the input sequence, if possible.
*/
streamsize
sgetn(char_type* __s, streamsize __n)
{ return this->xsgetn(__s, __n); }
#pragma empty_line
// [27.5.2.2.4] putback
/**
* @brief Pushing characters back into the input stream.
* @param c The character to push back.
* @return The previous character, if possible.
*
* Similar to sungetc(), but @a c is pushed onto the stream
* instead of <em>the previous character.</em> If successful,
* the next character fetched from the input stream will be @a
* c.
*/
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 empty_line
/**
* @brief Moving backwards in the input stream.
* @return The previous character, if possible.
*
* If a putback position is available, this function decrements
* the input pointer and returns that character. Otherwise,
* calls and returns pbackfail(). The effect is to @a unget
* the last character @a gotten.
*/
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 empty_line
// [27.5.2.2.5] put area
/**
* @brief Entry point for all single-character output functions.
* @param c A character to output.
* @return @a c, if possible.
*
* One of two public output functions.
*
* If a write position is available for the output sequence (i.e.,
* the buffer is not full), stores @a c in that position, increments
* the position, and returns @c traits::to_int_type(c). If a write
* position is not available, returns @c overflow(c).
*/
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 empty_line
/**
* @brief Entry point for all single-character output functions.
* @param s A buffer read area.
* @param n A count.
*
* One of two public output functions.
*
*
* Returns xsputn(s,n). The effect is to write @a s[0] through
* @a s[n-1] to the output sequence, if possible.
*/
streamsize
sputn(const char_type* __s, streamsize __n)
{ return this->xsputn(__s, __n); }
#pragma empty_line
protected:
/**
* @brief Base constructor.
*
* Only called from derived constructors, and sets up all the
* buffer data to zero, including the pointers described in the
* basic_streambuf class description. Note that, as a result,
* - the class starts with no read nor write positions available,
* - this is not an error
*/
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 empty_line
// [27.5.2.3.1] get area access
//@{
/**
* @brief Access to the get area.
*
* These functions are only available to other protected functions,
* including derived classes.
*
* - eback() returns the beginning pointer for the input sequence
* - gptr() returns the next pointer for the input sequence
* - egptr() returns the end pointer for the input sequence
*/
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 empty_line
/**
* @brief Moving the read position.
* @param n The delta by which to move.
*
* This just advances the read position without returning any data.
*/
void
gbump(int __n) { _M_in_cur += __n; }
#pragma empty_line
/**
* @brief Setting the three read area pointers.
* @param gbeg A pointer.
* @param gnext A pointer.
* @param gend A pointer.
* @post @a gbeg == @c eback(), @a gnext == @c gptr(), and
* @a gend == @c egptr()
*/
void
setg(char_type* __gbeg, char_type* __gnext, char_type* __gend)
{
_M_in_beg = __gbeg;
_M_in_cur = __gnext;
_M_in_end = __gend;
}
#pragma empty_line
// [27.5.2.3.2] put area access
//@{
/**
* @brief Access to the put area.
*
* These functions are only available to other protected functions,
* including derived classes.
*
* - pbase() returns the beginning pointer for the output sequence
* - pptr() returns the next pointer for the output sequence
* - epptr() returns the end pointer for the output sequence
*/
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 empty_line
/**
* @brief Moving the write position.
* @param n The delta by which to move.
*
* This just advances the write position without returning any data.
*/
void
pbump(int __n) { _M_out_cur += __n; }
#pragma empty_line
/**
* @brief Setting the three write area pointers.
* @param pbeg A pointer.
* @param pend A pointer.
* @post @a pbeg == @c pbase(), @a pbeg == @c pptr(), and
* @a pend == @c epptr()
*/
void
setp(char_type* __pbeg, char_type* __pend)
{
_M_out_beg = _M_out_cur = __pbeg;
_M_out_end = __pend;
}
#pragma empty_line
// [27.5.2.4] virtual functions
// [27.5.2.4.1] locales
/**
* @brief Changes translations.
* @param loc A new locale.
*
* Translations done during I/O which depend on the current
* locale are changed by this call. The standard adds,
* <em>Between invocations of this function a class derived
* from streambuf can safely cache results of calls to locale
* functions and to members of facets so obtained.</em>
*
* @note Base class version does nothing.
*/
virtual void
imbue(const locale&)
{ }
#pragma empty_line
// [27.5.2.4.2] buffer management and positioning
/**
* @brief Manipulates the buffer.
*
* Each derived class provides its own appropriate behavior. See
* the next-to-last paragraph of
* http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch25s02.html
* for more on this function.
*
* @note Base class version does nothing, returns @c this.
*/
virtual basic_streambuf<char_type,_Traits>*
setbuf(char_type*, streamsize)
{ return this; }
#pragma empty_line
/**
* @brief Alters the stream positions.
*
* Each derived class provides its own appropriate behavior.
* @note Base class version does nothing, returns a @c pos_type
* that represents an invalid stream position.
*/
virtual pos_type
seekoff(off_type, ios_base::seekdir,
ios_base::openmode /*__mode*/ = ios_base::in | ios_base::out)
{ return pos_type(off_type(-1)); }
#pragma empty_line
/**
* @brief Alters the stream positions.
*
* Each derived class provides its own appropriate behavior.
* @note Base class version does nothing, returns a @c pos_type
* that represents an invalid stream position.
*/
virtual pos_type
seekpos(pos_type,
ios_base::openmode /*__mode*/ = ios_base::in | ios_base::out)
{ return pos_type(off_type(-1)); }
#pragma empty_line
/**
* @brief Synchronizes the buffer arrays with the controlled sequences.
* @return -1 on failure.
*
* Each derived class provides its own appropriate behavior,
* including the definition of @a failure.
* @note Base class version does nothing, returns zero.
*/
virtual int
sync() { return 0; }
#pragma empty_line
// [27.5.2.4.3] get area
/**
* @brief Investigating the data available.
* @return An estimate of the number of characters available in the
* input sequence, or -1.
*
* <em>If it returns a positive value, then successive calls to
* @c underflow() will not return @c traits::eof() until at
* least that number of characters have been supplied. If @c
* showmanyc() returns -1, then calls to @c underflow() or @c
* uflow() will fail.</em> [27.5.2.4.3]/1
*
* @note Base class version does nothing, returns zero.
* @note The standard adds that <em>the intention is not only that the
* calls [to underflow or uflow] will not return @c eof() but
* that they will return immediately.</em>
* @note The standard adds that <em>the morphemes of @c showmanyc are
* @b es-how-many-see, not @b show-manic.</em>
*/
virtual streamsize
showmanyc() { return 0; }
#pragma empty_line
/**
* @brief Multiple character extraction.
* @param s A buffer area.
* @param n Maximum number of characters to assign.
* @return The number of characters assigned.
*
* Fills @a s[0] through @a s[n-1] with characters from the input
* sequence, as if by @c sbumpc(). Stops when either @a n characters
* have been copied, or when @c traits::eof() would be copied.
*
* It is expected that derived classes provide a more efficient
* implementation by overriding this definition.
*/
virtual streamsize
xsgetn(char_type* __s, streamsize __n);
#pragma empty_line
/**
* @brief Fetches more data from the controlled sequence.
* @return The first character from the <em>pending sequence</em>.
*
* Informally, this function is called when the input buffer is
* exhausted (or does not exist, as buffering need not actually be
* done). If a buffer exists, it is @a refilled. In either case, the
* next available character is returned, or @c traits::eof() to
* indicate a null pending sequence.
*
* For a formal definition of the pending sequence, see a good text
* such as Langer & Kreft, or [27.5.2.4.3]/7-14.
*
* A functioning input streambuf can be created by overriding only
* this function (no buffer area will be used). For an example, see
* http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch25.html
*
* @note Base class version does nothing, returns eof().
*/
virtual int_type
underflow()
{ return traits_type::eof(); }
#pragma empty_line
/**
* @brief Fetches more data from the controlled sequence.
* @return The first character from the <em>pending sequence</em>.
*
* Informally, this function does the same thing as @c underflow(),
* and in fact is required to call that function. It also returns
* the new character, like @c underflow() does. However, this
* function also moves the read position forward by one.
*/
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 empty_line
// [27.5.2.4.4] putback
/**
* @brief Tries to back up the input sequence.
* @param c The character to be inserted back into the sequence.
* @return eof() on failure, <em>some other value</em> on success
* @post The constraints of @c gptr(), @c eback(), and @c pptr()
* are the same as for @c underflow().
*
* @note Base class version does nothing, returns eof().
*/
virtual int_type
pbackfail(int_type /* __c */ = traits_type::eof())
{ return traits_type::eof(); }
#pragma empty_line
// Put area:
/**
* @brief Multiple character insertion.
* @param s A buffer area.
* @param n Maximum number of characters to write.
* @return The number of characters written.
*
* Writes @a s[0] through @a s[n-1] to the output sequence, as if
* by @c sputc(). Stops when either @a n characters have been
* copied, or when @c sputc() would return @c traits::eof().
*
* It is expected that derived classes provide a more efficient
* implementation by overriding this definition.
*/
virtual streamsize
xsputn(const char_type* __s, streamsize __n);
#pragma empty_line
/**
* @brief Consumes data from the buffer; writes to the
* controlled sequence.
* @param c An additional character to consume.
* @return eof() to indicate failure, something else (usually
* @a c, or not_eof())
*
* Informally, this function is called when the output buffer
* is full (or does not exist, as buffering need not actually
* be done). If a buffer exists, it is @a consumed, with
* <em>some effect</em> on the controlled sequence.
* (Typically, the buffer is written out to the sequence
* verbatim.) In either case, the character @a c is also
* written out, if @a c is not @c eof().
*
* For a formal definition of this function, see a good text
* such as Langer & Kreft, or [27.5.2.4.5]/3-7.
*
* A functioning output streambuf can be created by overriding only
* this function (no buffer area will be used).
*
* @note Base class version does nothing, returns eof().
*/
virtual int_type
overflow(int_type /* __c */ = traits_type::eof())
{ return traits_type::eof(); }
#pragma empty_line
#pragma empty_line
// Annex D.6
public:
/**
* @brief Tosses a character.
*
* Advances the read pointer, ignoring the character that would have
* been read.
*
* See http://gcc.gnu.org/ml/libstdc++/2002-05/msg00168.html
*/
void
stossc()
{
if (this->gptr() < this->egptr())
this->gbump(1);
else
this->uflow();
}
#pragma empty_line
#pragma empty_line
// Also used by specializations for char and wchar_t in src.
void
__safe_gbump(streamsize __n) { _M_in_cur += __n; }
#pragma empty_line
void
__safe_pbump(streamsize __n) { _M_out_cur += __n; }
#pragma empty_line
private:
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// Side effect of DR 50.
basic_streambuf(const __streambuf_type& __sb)
: _M_in_beg(__sb._M_in_beg), _M_in_cur(__sb._M_in_cur),
_M_in_end(__sb._M_in_end), _M_out_beg(__sb._M_out_beg),
_M_out_cur(__sb._M_out_cur), _M_out_end(__sb._M_out_cur),
_M_buf_locale(__sb._M_buf_locale)
{ }
#pragma empty_line
__streambuf_type&
operator=(const __streambuf_type&) { return *this; };
};
#pragma empty_line
// Explicit specialization declarations, defined in src/streambuf.cc.
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
} // namespace
#pragma empty_line
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/streambuf.tcc" 1 3
// Stream buffer classes -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file bits/streambuf.tcc
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{streambuf}
*/
#pragma empty_line
//
// ISO C++ 14882: 27.5 Stream buffers
//
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 38 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/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
// Conceivably, this could be used to implement buffer-to-buffer
// copies, if this was ever desired in an un-ambiguous way by the
// standard.
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
// Inhibit implicit instantiations for required instantiations,
// which are defined via explicit instantiations elsewhere.
#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
} // namespace std
#pragma line 808 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/streambuf" 2 3
#pragma line 44 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ios" 2 3
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_ios.h" 1 3
// Iostreams base classes -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010, 2011
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file bits/basic_ios.h
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{ios}
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 35 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_ios.h" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 1 3
// Locale support -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010, 2011
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file bits/locale_facets.h
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{locale}
*/
#pragma empty_line
//
// ISO C++ 14882: 22.1 Locales
//
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 39 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cwctype" 1 3
// -*- C++ -*- forwarding header.
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file include/cwctype
* This is a Standard C++ Library file. You should @c \#include this file
* in your programs, rather than any of the @a *.h implementation files.
*
* This is the C++ version of the Standard C Library header @c wctype.h,
* and its contents are (mostly) the same as that header, but are all
* contained in the namespace @c std (except for names which are defined
* as macros in C).
*/
#pragma empty_line
//
// ISO C++ 14882: <cwctype>
//
#pragma empty_line
#pragma empty_line
#pragma line 41 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cwctype" 3
#pragma line 51 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cwctype" 3
#pragma line 1 "/usr/include/wctype.h" 1 3 4
/* Copyright (C) 1996-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
/*
* ISO C99 Standard: 7.25
* Wide character classification and mapping utilities <wctype.h>
*/
#pragma line 30 "/usr/include/wctype.h" 3 4
/* Constant expression of type `wint_t' whose value does not correspond
to any member of the extended character set. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Some definitions from this header also appear in <wchar.h> in
Unix98 mode. */
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/wctype-wchar.h" 1 3 4
/* Copyright (C) 1996-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
/*
* ISO C99 Standard: 7.25
* Wide character classification and mapping utilities <wctype.h>
*/
#pragma line 33 "/usr/include/x86_64-linux-gnu/bits/wctype-wchar.h" 3 4
/* The definitions in this header are specified to appear in <wctype.h>
in ISO C99, but in <wchar.h> in Unix98. _GNU_SOURCE follows C99. */
#pragma empty_line
/* Scalar type that can hold values which represent locale-specific
character classifications. */
typedef unsigned long int wctype_t;
#pragma empty_line
#pragma empty_line
/* The characteristics are stored always in network byte order (big
endian). We define the bit value interpretations here dependent on the
machine's byte order. */
#pragma line 56 "/usr/include/x86_64-linux-gnu/bits/wctype-wchar.h" 3 4
enum
{
__ISwupper = 0, /* UPPERCASE. */
__ISwlower = 1, /* lowercase. */
__ISwalpha = 2, /* Alphabetic. */
__ISwdigit = 3, /* Numeric. */
__ISwxdigit = 4, /* Hexadecimal numeric. */
__ISwspace = 5, /* Whitespace. */
__ISwprint = 6, /* Printing. */
__ISwgraph = 7, /* Graphical. */
__ISwblank = 8, /* Blank (usually SPC and TAB). */
__ISwcntrl = 9, /* Control character. */
__ISwpunct = 10, /* Punctuation. */
__ISwalnum = 11, /* Alphanumeric. */
#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)))), /* UPPERCASE. */
_ISwlower = ((__ISwlower) < 8 ? (int) ((1UL << (__ISwlower)) << 24) : ((__ISwlower) < 16 ? (int) ((1UL << (__ISwlower)) << 8) : ((__ISwlower) < 24 ? (int) ((1UL << (__ISwlower)) >> 8) : (int) ((1UL << (__ISwlower)) >> 24)))), /* lowercase. */
_ISwalpha = ((__ISwalpha) < 8 ? (int) ((1UL << (__ISwalpha)) << 24) : ((__ISwalpha) < 16 ? (int) ((1UL << (__ISwalpha)) << 8) : ((__ISwalpha) < 24 ? (int) ((1UL << (__ISwalpha)) >> 8) : (int) ((1UL << (__ISwalpha)) >> 24)))), /* Alphabetic. */
_ISwdigit = ((__ISwdigit) < 8 ? (int) ((1UL << (__ISwdigit)) << 24) : ((__ISwdigit) < 16 ? (int) ((1UL << (__ISwdigit)) << 8) : ((__ISwdigit) < 24 ? (int) ((1UL << (__ISwdigit)) >> 8) : (int) ((1UL << (__ISwdigit)) >> 24)))), /* Numeric. */
_ISwxdigit = ((__ISwxdigit) < 8 ? (int) ((1UL << (__ISwxdigit)) << 24) : ((__ISwxdigit) < 16 ? (int) ((1UL << (__ISwxdigit)) << 8) : ((__ISwxdigit) < 24 ? (int) ((1UL << (__ISwxdigit)) >> 8) : (int) ((1UL << (__ISwxdigit)) >> 24)))), /* Hexadecimal numeric. */
_ISwspace = ((__ISwspace) < 8 ? (int) ((1UL << (__ISwspace)) << 24) : ((__ISwspace) < 16 ? (int) ((1UL << (__ISwspace)) << 8) : ((__ISwspace) < 24 ? (int) ((1UL << (__ISwspace)) >> 8) : (int) ((1UL << (__ISwspace)) >> 24)))), /* Whitespace. */
_ISwprint = ((__ISwprint) < 8 ? (int) ((1UL << (__ISwprint)) << 24) : ((__ISwprint) < 16 ? (int) ((1UL << (__ISwprint)) << 8) : ((__ISwprint) < 24 ? (int) ((1UL << (__ISwprint)) >> 8) : (int) ((1UL << (__ISwprint)) >> 24)))), /* Printing. */
_ISwgraph = ((__ISwgraph) < 8 ? (int) ((1UL << (__ISwgraph)) << 24) : ((__ISwgraph) < 16 ? (int) ((1UL << (__ISwgraph)) << 8) : ((__ISwgraph) < 24 ? (int) ((1UL << (__ISwgraph)) >> 8) : (int) ((1UL << (__ISwgraph)) >> 24)))), /* Graphical. */
_ISwblank = ((__ISwblank) < 8 ? (int) ((1UL << (__ISwblank)) << 24) : ((__ISwblank) < 16 ? (int) ((1UL << (__ISwblank)) << 8) : ((__ISwblank) < 24 ? (int) ((1UL << (__ISwblank)) >> 8) : (int) ((1UL << (__ISwblank)) >> 24)))), /* Blank (usually SPC and TAB). */
_ISwcntrl = ((__ISwcntrl) < 8 ? (int) ((1UL << (__ISwcntrl)) << 24) : ((__ISwcntrl) < 16 ? (int) ((1UL << (__ISwcntrl)) << 8) : ((__ISwcntrl) < 24 ? (int) ((1UL << (__ISwcntrl)) >> 8) : (int) ((1UL << (__ISwcntrl)) >> 24)))), /* Control character. */
_ISwpunct = ((__ISwpunct) < 8 ? (int) ((1UL << (__ISwpunct)) << 24) : ((__ISwpunct) < 16 ? (int) ((1UL << (__ISwpunct)) << 8) : ((__ISwpunct) < 24 ? (int) ((1UL << (__ISwpunct)) >> 8) : (int) ((1UL << (__ISwpunct)) >> 24)))), /* Punctuation. */
_ISwalnum = ((__ISwalnum) < 8 ? (int) ((1UL << (__ISwalnum)) << 24) : ((__ISwalnum) < 16 ? (int) ((1UL << (__ISwalnum)) << 8) : ((__ISwalnum) < 24 ? (int) ((1UL << (__ISwalnum)) >> 8) : (int) ((1UL << (__ISwalnum)) >> 24)))) /* Alphanumeric. */
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern "C" {
#pragma empty_line
/*
* Wide-character classification functions: 7.15.2.1.
*/
#pragma empty_line
/* Test for any wide character for which `iswalpha' or `iswdigit' is
true. */
extern int iswalnum (wint_t __wc) throw ();
#pragma empty_line
/* Test for any wide character for which `iswupper' or 'iswlower' is
true, or any wide character that is one of a locale-specific set of
wide-characters for which none of `iswcntrl', `iswdigit',
`iswpunct', or `iswspace' is true. */
extern int iswalpha (wint_t __wc) throw ();
#pragma empty_line
/* Test for any control wide character. */
extern int iswcntrl (wint_t __wc) throw ();
#pragma empty_line
/* Test for any wide character that corresponds to a decimal-digit
character. */
extern int iswdigit (wint_t __wc) throw ();
#pragma empty_line
/* Test for any wide character for which `iswprint' is true and
`iswspace' is false. */
extern int iswgraph (wint_t __wc) throw ();
#pragma empty_line
/* Test for any wide character that corresponds to a lowercase letter
or is one of a locale-specific set of wide characters for which
none of `iswcntrl', `iswdigit', `iswpunct', or `iswspace' is true. */
extern int iswlower (wint_t __wc) throw ();
#pragma empty_line
/* Test for any printing wide character. */
extern int iswprint (wint_t __wc) throw ();
#pragma empty_line
/* Test for any printing wide character that is one of a
locale-specific et of wide characters for which neither `iswspace'
nor `iswalnum' is true. */
extern int iswpunct (wint_t __wc) throw ();
#pragma empty_line
/* Test for any wide character that corresponds to a locale-specific
set of wide characters for which none of `iswalnum', `iswgraph', or
`iswpunct' is true. */
extern int iswspace (wint_t __wc) throw ();
#pragma empty_line
/* Test for any wide character that corresponds to an uppercase letter
or is one of a locale-specific set of wide character for which none
of `iswcntrl', `iswdigit', `iswpunct', or `iswspace' is true. */
extern int iswupper (wint_t __wc) throw ();
#pragma empty_line
/* Test for any wide character that corresponds to a hexadecimal-digit
character equivalent to that performed be the functions described
in the previous subclause. */
extern int iswxdigit (wint_t __wc) throw ();
#pragma empty_line
/* Test for any wide character that corresponds to a standard blank
wide character or a locale-specific set of wide characters for
which `iswalnum' is false. */
#pragma empty_line
extern int iswblank (wint_t __wc) throw ();
#pragma empty_line
#pragma empty_line
/*
* Extensible wide-character classification functions: 7.15.2.2.
*/
#pragma empty_line
/* Construct value that describes a class of wide characters identified
by the string argument PROPERTY. */
extern wctype_t wctype (const char *__property) throw ();
#pragma empty_line
/* Determine whether the wide-character WC has the property described by
DESC. */
extern int iswctype (wint_t __wc, wctype_t __desc) throw ();
#pragma empty_line
/*
* Wide-character case-mapping functions: 7.15.3.1.
*/
#pragma empty_line
/* Converts an uppercase letter to the corresponding lowercase letter. */
extern wint_t towlower (wint_t __wc) throw ();
#pragma empty_line
/* Converts an lowercase letter to the corresponding uppercase letter. */
extern wint_t towupper (wint_t __wc) throw ();
#pragma empty_line
}
#pragma line 39 "/usr/include/wctype.h" 2 3 4
#pragma empty_line
/*
* Extensible wide-character mapping functions: 7.15.3.2.
*/
#pragma empty_line
extern "C" {
#pragma empty_line
/* Scalar type that can hold values which represent locale-specific
character mappings. */
typedef const __int32_t *wctrans_t;
#pragma empty_line
/* Construct value that describes a mapping between wide characters
identified by the string argument PROPERTY. */
extern wctrans_t wctrans (const char *__property) throw ();
#pragma empty_line
/* Map the wide character WC using the mapping described by DESC. */
extern wint_t towctrans (wint_t __wc, wctrans_t __desc) throw ();
#pragma empty_line
#pragma empty_line
/* POSIX.1-2008 extended locale interface (see locale.h). */
#pragma empty_line
#pragma empty_line
/* Test for any wide character for which `iswalpha' or `iswdigit' is
true. */
extern int iswalnum_l (wint_t __wc, locale_t __locale) throw ();
#pragma empty_line
/* Test for any wide character for which `iswupper' or 'iswlower' is
true, or any wide character that is one of a locale-specific set of
wide-characters for which none of `iswcntrl', `iswdigit',
`iswpunct', or `iswspace' is true. */
extern int iswalpha_l (wint_t __wc, locale_t __locale) throw ();
#pragma empty_line
/* Test for any control wide character. */
extern int iswcntrl_l (wint_t __wc, locale_t __locale) throw ();
#pragma empty_line
/* Test for any wide character that corresponds to a decimal-digit
character. */
extern int iswdigit_l (wint_t __wc, locale_t __locale) throw ();
#pragma empty_line
/* Test for any wide character for which `iswprint' is true and
`iswspace' is false. */
extern int iswgraph_l (wint_t __wc, locale_t __locale) throw ();
#pragma empty_line
/* Test for any wide character that corresponds to a lowercase letter
or is one of a locale-specific set of wide characters for which
none of `iswcntrl', `iswdigit', `iswpunct', or `iswspace' is true. */
extern int iswlower_l (wint_t __wc, locale_t __locale) throw ();
#pragma empty_line
/* Test for any printing wide character. */
extern int iswprint_l (wint_t __wc, locale_t __locale) throw ();
#pragma empty_line
/* Test for any printing wide character that is one of a
locale-specific et of wide characters for which neither `iswspace'
nor `iswalnum' is true. */
extern int iswpunct_l (wint_t __wc, locale_t __locale) throw ();
#pragma empty_line
/* Test for any wide character that corresponds to a locale-specific
set of wide characters for which none of `iswalnum', `iswgraph', or
`iswpunct' is true. */
extern int iswspace_l (wint_t __wc, locale_t __locale) throw ();
#pragma empty_line
/* Test for any wide character that corresponds to an uppercase letter
or is one of a locale-specific set of wide character for which none
of `iswcntrl', `iswdigit', `iswpunct', or `iswspace' is true. */
extern int iswupper_l (wint_t __wc, locale_t __locale) throw ();
#pragma empty_line
/* Test for any wide character that corresponds to a hexadecimal-digit
character equivalent to that performed be the functions described
in the previous subclause. */
extern int iswxdigit_l (wint_t __wc, locale_t __locale) throw ();
#pragma empty_line
/* Test for any wide character that corresponds to a standard blank
wide character or a locale-specific set of wide characters for
which `iswalnum' is false. */
extern int iswblank_l (wint_t __wc, locale_t __locale) throw ();
#pragma empty_line
/* Construct value that describes a class of wide characters identified
by the string argument PROPERTY. */
extern wctype_t wctype_l (const char *__property, locale_t __locale)
throw ();
#pragma empty_line
/* Determine whether the wide-character WC has the property described by
DESC. */
extern int iswctype_l (wint_t __wc, wctype_t __desc, locale_t __locale)
throw ();
#pragma empty_line
/*
* Wide-character case-mapping functions.
*/
#pragma empty_line
/* Converts an uppercase letter to the corresponding lowercase letter. */
extern wint_t towlower_l (wint_t __wc, locale_t __locale) throw ();
#pragma empty_line
/* Converts an lowercase letter to the corresponding uppercase letter. */
extern wint_t towupper_l (wint_t __wc, locale_t __locale) throw ();
#pragma empty_line
/* Construct value that describes a mapping between wide characters
identified by the string argument PROPERTY. */
extern wctrans_t wctrans_l (const char *__property, locale_t __locale)
throw ();
#pragma empty_line
/* Map the wide character WC using the mapping described by DESC. */
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 52 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cwctype" 2 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
// Get rid of those macros defined in <wctype.h> in lieu of real functions.
#pragma line 81 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/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;
} // namespace
#pragma line 41 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 2 3
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cctype" 1 3
// -*- C++ -*- forwarding header.
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file include/cctype
* This is a Standard C++ Library file. You should @c \#include this file
* in your programs, rather than any of the @a *.h implementation files.
*
* This is the C++ version of the Standard C Library header @c ctype.h,
* and its contents are (mostly) the same as that header, but are all
* contained in the namespace @c std (except for names which are defined
* as macros in C).
*/
#pragma empty_line
//
// ISO C++ 14882: <ccytpe>
//
#pragma empty_line
#pragma empty_line
#pragma line 41 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cctype" 3
#pragma line 42 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 2 3
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/ctype_base.h" 1 3
// Locale support -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2002, 2003, 2004, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file bits/ctype_base.h
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{locale}
*/
#pragma empty_line
//
// ISO C++ 14882: 22.1 Locales
//
#pragma empty_line
// Information as gleaned from /usr/include/ctype.h
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
/// @brief Base class for ctype.
struct ctype_base
{
// Non-standard typedefs.
typedef const int* __to_type;
#pragma empty_line
// NB: Offsets into ctype<char>::_M_table force a particular size
// on the mask type. Because of this, we don't use an enum.
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
#pragma empty_line
} // namespace
#pragma line 43 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/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 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/streambuf_iterator.h" 1 3
// Streambuf iterators
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2009, 2010, 2011
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file bits/streambuf_iterator.h
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{iterator}
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 35 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/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 empty_line
/**
* @addtogroup iterators
* @{
*/
#pragma empty_line
// 24.5.3 Template class istreambuf_iterator
/// Provides input iterator semantics for streambufs.
template<typename _CharT, typename _Traits>
class istreambuf_iterator
: public iterator<input_iterator_tag, _CharT, typename _Traits::off_type,
_CharT*, _CharT&>
{
public:
// Types:
//@{
/// Public typedefs
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
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:
// 24.5.3 istreambuf_iterator
// p 1
// If the end of stream is reached (streambuf_type::sgetc()
// returns traits_type::eof()), the iterator becomes equal to
// the "end of stream" iterator value.
// NB: This implementation assumes the "end of stream" value
// is EOF, or -1.
mutable streambuf_type* _M_sbuf;
mutable int_type _M_c;
#pragma empty_line
public:
/// Construct end of input stream iterator.
istreambuf_iterator() throw()
: _M_sbuf(0), _M_c(traits_type::eof()) { }
#pragma empty_line
/// Construct start of input stream iterator.
istreambuf_iterator(istream_type& __s) throw()
: _M_sbuf(__s.rdbuf()), _M_c(traits_type::eof()) { }
#pragma empty_line
/// Construct start of streambuf iterator.
istreambuf_iterator(streambuf_type* __s) throw()
: _M_sbuf(__s), _M_c(traits_type::eof()) { }
#pragma empty_line
/// Return the current character pointed to by iterator. This returns
/// streambuf.sgetc(). It cannot be assigned. NB: The result of
/// operator*() on an end of stream is undefined.
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
/// Advance the iterator. Calls streambuf.sbumpc().
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
/// Advance the iterator. Calls streambuf.sbumpc().
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
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 110 istreambuf_iterator::equal not const
// NB: there is also number 111 (NAD, Future) pending on this function.
/// Return true both iterators are end or both are not end.
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
/// Provides output iterator semantics for streambufs.
template<typename _CharT, typename _Traits>
class ostreambuf_iterator
: public iterator<output_iterator_tag, void, void, void, void>
{
public:
// Types:
//@{
/// Public typedefs
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
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:
/// Construct output iterator from ostream.
ostreambuf_iterator(ostream_type& __s) throw ()
: _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { }
#pragma empty_line
/// Construct output iterator from streambuf.
ostreambuf_iterator(streambuf_type* __s) throw ()
: _M_sbuf(__s), _M_failed(!_M_sbuf) { }
#pragma empty_line
/// Write character to streambuf. Calls streambuf.sputc().
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
/// Return *this.
ostreambuf_iterator&
operator*()
{ return *this; }
#pragma empty_line
/// Return *this.
ostreambuf_iterator&
operator++(int)
{ return *this; }
#pragma empty_line
/// Return *this.
ostreambuf_iterator&
operator++()
{ return *this; }
#pragma empty_line
/// Return true if previous operator=() failed.
bool
failed() const throw()
{ 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
// Overloads for streambuf iterators.
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
// @} group iterators
#pragma empty_line
#pragma empty_line
} // namespace
#pragma line 50 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 2 3
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
// NB: Don't instantiate required wchar_t facets if no wchar_t support.
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
// Convert string to numeric value of type _Tp and store results.
// NB: This is specialized for all required types, there is no
// generic definition.
template<typename _Tp>
void
__convert_to_v(const char*, _Tp&, ios_base::iostate&,
const __c_locale&) throw();
#pragma empty_line
// Explicit specializations for required types.
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
// NB: __pad is a struct, rather than a function, so it can be
// partially-specialized.
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
// Used by both numeric and monetary facets.
// Inserts "group separator" characters into an array of characters.
// It's recursive, one iteration per group. It moves the characters
// in the buffer this way: "xxxx12345" -> "12,345xxx". Call this
// only with __gsize != 0.
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
// This template permits specializing facet output code for
// ostreambuf_iterator. For ostreambuf_iterator, sputn is
// significantly more efficient than incrementing iterators.
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
// This is the unspecialized form of the template.
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 empty_line
#pragma empty_line
// 22.2.1.1 Template class ctype
// Include host and configuration specific ctype enums for ctype_base.
#pragma empty_line
/**
* @brief Common base for ctype facet
*
* This template class provides implementations of the public functions
* that forward to the protected virtual functions.
*
* This template also provides abstract stubs for the protected virtual
* functions.
*/
template<typename _CharT>
class __ctype_abstract_base : public locale::facet, public ctype_base
{
public:
// Types:
/// Typedef for the template parameter
typedef _CharT char_type;
#pragma empty_line
/**
* @brief Test char_type classification.
*
* This function finds a mask M for @a c and compares it to mask @a m.
* It does so by returning the value of ctype<char_type>::do_is().
*
* @param c The char_type to compare the mask of.
* @param m The mask to compare against.
* @return (M & m) != 0.
*/
bool
is(mask __m, char_type __c) const
{ return this->do_is(__m, __c); }
#pragma empty_line
/**
* @brief Return a mask array.
*
* This function finds the mask for each char_type in the range [lo,hi)
* and successively writes it to vec. vec must have as many elements
* as the char array. It does so by returning the value of
* ctype<char_type>::do_is().
*
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @param vec Pointer to an array of mask storage.
* @return @a hi.
*/
const char_type*
is(const char_type *__lo, const char_type *__hi, mask *__vec) const
{ return this->do_is(__lo, __hi, __vec); }
#pragma empty_line
/**
* @brief Find char_type matching a mask
*
* This function searches for and returns the first char_type c in
* [lo,hi) for which is(m,c) is true. It does so by returning
* ctype<char_type>::do_scan_is().
*
* @param m The mask to compare against.
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @return Pointer to matching char_type if found, else @a hi.
*/
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 empty_line
/**
* @brief Find char_type not matching a mask
*
* This function searches for and returns the first char_type c in
* [lo,hi) for which is(m,c) is false. It does so by returning
* ctype<char_type>::do_scan_not().
*
* @param m The mask to compare against.
* @param lo Pointer to first char in range.
* @param hi Pointer to end of range.
* @return Pointer to non-matching char if found, else @a hi.
*/
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 empty_line
/**
* @brief Convert to uppercase.
*
* This function converts the argument to uppercase if possible.
* If not possible (for example, '2'), returns the argument. It does
* so by returning ctype<char_type>::do_toupper().
*
* @param c The char_type to convert.
* @return The uppercase char_type if convertible, else @a c.
*/
char_type
toupper(char_type __c) const
{ return this->do_toupper(__c); }
#pragma empty_line
/**
* @brief Convert array to uppercase.
*
* This function converts each char_type in the range [lo,hi) to
* uppercase if possible. Other elements remain untouched. It does so
* by returning ctype<char_type>:: do_toupper(lo, hi).
*
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @return @a hi.
*/
const char_type*
toupper(char_type *__lo, const char_type* __hi) const
{ return this->do_toupper(__lo, __hi); }
#pragma empty_line
/**
* @brief Convert to lowercase.
*
* This function converts the argument to lowercase if possible. If
* not possible (for example, '2'), returns the argument. It does so
* by returning ctype<char_type>::do_tolower(c).
*
* @param c The char_type to convert.
* @return The lowercase char_type if convertible, else @a c.
*/
char_type
tolower(char_type __c) const
{ return this->do_tolower(__c); }
#pragma empty_line
/**
* @brief Convert array to lowercase.
*
* This function converts each char_type in the range [lo,hi) to
* lowercase if possible. Other elements remain untouched. It does so
* by returning ctype<char_type>:: do_tolower(lo, hi).
*
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @return @a hi.
*/
const char_type*
tolower(char_type* __lo, const char_type* __hi) const
{ return this->do_tolower(__lo, __hi); }
#pragma empty_line
/**
* @brief Widen char to char_type
*
* This function converts the char argument to char_type using the
* simplest reasonable transformation. It does so by returning
* ctype<char_type>::do_widen(c).
*
* Note: this is not what you want for codepage conversions. See
* codecvt for that.
*
* @param c The char to convert.
* @return The converted char_type.
*/
char_type
widen(char __c) const
{ return this->do_widen(__c); }
#pragma empty_line
/**
* @brief Widen array to char_type
*
* This function converts each char in the input to char_type using the
* simplest reasonable transformation. It does so by returning
* ctype<char_type>::do_widen(c).
*
* Note: this is not what you want for codepage conversions. See
* codecvt for that.
*
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @param to Pointer to the destination array.
* @return @a hi.
*/
const char*
widen(const char* __lo, const char* __hi, char_type* __to) const
{ return this->do_widen(__lo, __hi, __to); }
#pragma empty_line
/**
* @brief Narrow char_type to char
*
* This function converts the char_type to char using the simplest
* reasonable transformation. If the conversion fails, dfault is
* returned instead. It does so by returning
* ctype<char_type>::do_narrow(c).
*
* Note: this is not what you want for codepage conversions. See
* codecvt for that.
*
* @param c The char_type to convert.
* @param dfault Char to return if conversion fails.
* @return The converted char.
*/
char
narrow(char_type __c, char __dfault) const
{ return this->do_narrow(__c, __dfault); }
#pragma empty_line
/**
* @brief Narrow array to char array
*
* This function converts each char_type in the input to char using the
* simplest reasonable transformation and writes the results to the
* destination array. For any char_type in the input that cannot be
* converted, @a dfault is used instead. It does so by returning
* ctype<char_type>::do_narrow(lo, hi, dfault, to).
*
* Note: this is not what you want for codepage conversions. See
* codecvt for that.
*
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @param dfault Char to use if conversion fails.
* @param to Pointer to the destination array.
* @return @a hi.
*/
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 empty_line
/**
* @brief Test char_type classification.
*
* This function finds a mask M for @a c and compares it to mask @a m.
*
* do_is() is a hook for a derived facet to change the behavior of
* classifying. do_is() must always return the same result for the
* same input.
*
* @param c The char_type to find the mask of.
* @param m The mask to compare against.
* @return (M & m) != 0.
*/
virtual bool
do_is(mask __m, char_type __c) const = 0;
#pragma empty_line
/**
* @brief Return a mask array.
*
* This function finds the mask for each char_type in the range [lo,hi)
* and successively writes it to vec. vec must have as many elements
* as the input.
*
* do_is() is a hook for a derived facet to change the behavior of
* classifying. do_is() must always return the same result for the
* same input.
*
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @param vec Pointer to an array of mask storage.
* @return @a hi.
*/
virtual const char_type*
do_is(const char_type* __lo, const char_type* __hi,
mask* __vec) const = 0;
#pragma empty_line
/**
* @brief Find char_type matching mask
*
* This function searches for and returns the first char_type c in
* [lo,hi) for which is(m,c) is true.
*
* do_scan_is() is a hook for a derived facet to change the behavior of
* match searching. do_is() must always return the same result for the
* same input.
*
* @param m The mask to compare against.
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @return Pointer to a matching char_type if found, else @a hi.
*/
virtual const char_type*
do_scan_is(mask __m, const char_type* __lo,
const char_type* __hi) const = 0;
#pragma empty_line
/**
* @brief Find char_type not matching mask
*
* This function searches for and returns a pointer to the first
* char_type c of [lo,hi) for which is(m,c) is false.
*
* do_scan_is() is a hook for a derived facet to change the behavior of
* match searching. do_is() must always return the same result for the
* same input.
*
* @param m The mask to compare against.
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @return Pointer to a non-matching char_type if found, else @a hi.
*/
virtual const char_type*
do_scan_not(mask __m, const char_type* __lo,
const char_type* __hi) const = 0;
#pragma empty_line
/**
* @brief Convert to uppercase.
*
* This virtual function converts the char_type argument to uppercase
* if possible. If not possible (for example, '2'), returns the
* argument.
*
* do_toupper() is a hook for a derived facet to change the behavior of
* uppercasing. do_toupper() must always return the same result for
* the same input.
*
* @param c The char_type to convert.
* @return The uppercase char_type if convertible, else @a c.
*/
virtual char_type
do_toupper(char_type) const = 0;
#pragma empty_line
/**
* @brief Convert array to uppercase.
*
* This virtual function converts each char_type in the range [lo,hi)
* to uppercase if possible. Other elements remain untouched.
*
* do_toupper() is a hook for a derived facet to change the behavior of
* uppercasing. do_toupper() must always return the same result for
* the same input.
*
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @return @a hi.
*/
virtual const char_type*
do_toupper(char_type* __lo, const char_type* __hi) const = 0;
#pragma empty_line
/**
* @brief Convert to lowercase.
*
* This virtual function converts the argument to lowercase if
* possible. If not possible (for example, '2'), returns the argument.
*
* do_tolower() is a hook for a derived facet to change the behavior of
* lowercasing. do_tolower() must always return the same result for
* the same input.
*
* @param c The char_type to convert.
* @return The lowercase char_type if convertible, else @a c.
*/
virtual char_type
do_tolower(char_type) const = 0;
#pragma empty_line
/**
* @brief Convert array to lowercase.
*
* This virtual function converts each char_type in the range [lo,hi)
* to lowercase if possible. Other elements remain untouched.
*
* do_tolower() is a hook for a derived facet to change the behavior of
* lowercasing. do_tolower() must always return the same result for
* the same input.
*
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @return @a hi.
*/
virtual const char_type*
do_tolower(char_type* __lo, const char_type* __hi) const = 0;
#pragma empty_line
/**
* @brief Widen char
*
* This virtual function converts the char to char_type using the
* simplest reasonable transformation.
*
* do_widen() is a hook for a derived facet to change the behavior of
* widening. do_widen() must always return the same result for the
* same input.
*
* Note: this is not what you want for codepage conversions. See
* codecvt for that.
*
* @param c The char to convert.
* @return The converted char_type
*/
virtual char_type
do_widen(char) const = 0;
#pragma empty_line
/**
* @brief Widen char array
*
* This function converts each char in the input to char_type using the
* simplest reasonable transformation.
*
* do_widen() is a hook for a derived facet to change the behavior of
* widening. do_widen() must always return the same result for the
* same input.
*
* Note: this is not what you want for codepage conversions. See
* codecvt for that.
*
* @param lo Pointer to start range.
* @param hi Pointer to end of range.
* @param to Pointer to the destination array.
* @return @a hi.
*/
virtual const char*
do_widen(const char* __lo, const char* __hi,
char_type* __dest) const = 0;
#pragma empty_line
/**
* @brief Narrow char_type to char
*
* This virtual function converts the argument to char using the
* simplest reasonable transformation. If the conversion fails, dfault
* is returned instead.
*
* do_narrow() is a hook for a derived facet to change the behavior of
* narrowing. do_narrow() must always return the same result for the
* same input.
*
* Note: this is not what you want for codepage conversions. See
* codecvt for that.
*
* @param c The char_type to convert.
* @param dfault Char to return if conversion fails.
* @return The converted char.
*/
virtual char
do_narrow(char_type, char __dfault) const = 0;
#pragma empty_line
/**
* @brief Narrow char_type array to char
*
* This virtual function converts each char_type in the range [lo,hi) to
* char using the simplest reasonable transformation and writes the
* results to the destination array. For any element in the input that
* cannot be converted, @a dfault is used instead.
*
* do_narrow() is a hook for a derived facet to change the behavior of
* narrowing. do_narrow() must always return the same result for the
* same input.
*
* Note: this is not what you want for codepage conversions. See
* codecvt for that.
*
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @param dfault Char to use if conversion fails.
* @param to Pointer to the destination array.
* @return @a hi.
*/
virtual const char_type*
do_narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char* __dest) const = 0;
};
#pragma empty_line
/**
* @brief Primary class template ctype facet.
* @ingroup locales
*
* This template class defines classification and conversion functions for
* character sets. It wraps cctype functionality. Ctype gets used by
* streams for many I/O operations.
*
* This template provides the protected virtual functions the developer
* will have to replace in a derived class or specialization to make a
* working facet. The public functions that access them are defined in
* __ctype_abstract_base, to allow for implementation flexibility. See
* ctype<wchar_t> for an example. The functions are documented in
* __ctype_abstract_base.
*
* Note: implementations are provided for all the protected virtual
* functions, but will likely not be useful.
*/
template<typename _CharT>
class ctype : public __ctype_abstract_base<_CharT>
{
public:
// Types:
typedef _CharT char_type;
typedef typename __ctype_abstract_base<_CharT>::mask mask;
#pragma empty_line
/// The facet id for ctype<char_type>
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* __dest) const;
};
#pragma empty_line
template<typename _CharT>
locale::id ctype<_CharT>::id;
#pragma empty_line
/**
* @brief The ctype<char> specialization.
* @ingroup locales
*
* This class defines classification and conversion functions for
* the char type. It gets used by char streams for many I/O
* operations. The char specialization provides a number of
* optimizations as well.
*/
template<>
class ctype<char> : public locale::facet, public ctype_base
{
public:
// Types:
/// Typedef for the template parameter char.
typedef char char_type;
#pragma empty_line
protected:
// Data Members:
__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; // 0 uninitialized, 1 init,
// 2 memcpy can't be used
#pragma empty_line
public:
/// The facet id for ctype<char>
static locale::id id;
/// The size of the mask table. It is SCHAR_MAX + 1.
static const size_t table_size = 1 + static_cast<unsigned char>(-1);
#pragma empty_line
/**
* @brief Constructor performs initialization.
*
* This is the constructor provided by the standard.
*
* @param table If non-zero, table is used as the per-char mask.
* Else classic_table() is used.
* @param del If true, passes ownership of table to this facet.
* @param refs Passed to the base facet class.
*/
explicit
ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0);
#pragma empty_line
/**
* @brief Constructor performs static initialization.
*
* This constructor is used to construct the initial C locale facet.
*
* @param cloc Handle to C locale data.
* @param table If non-zero, table is used as the per-char mask.
* @param del If true, passes ownership of table to this facet.
* @param refs Passed to the base facet class.
*/
explicit
ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false,
size_t __refs = 0);
#pragma empty_line
/**
* @brief Test char classification.
*
* This function compares the mask table[c] to @a m.
*
* @param c The char to compare the mask of.
* @param m The mask to compare against.
* @return True if m & table[c] is true, false otherwise.
*/
inline bool
is(mask __m, char __c) const;
#pragma empty_line
/**
* @brief Return a mask array.
*
* This function finds the mask for each char in the range [lo, hi) and
* successively writes it to vec. vec must have as many elements as
* the char array.
*
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @param vec Pointer to an array of mask storage.
* @return @a hi.
*/
inline const char*
is(const char* __lo, const char* __hi, mask* __vec) const;
#pragma empty_line
/**
* @brief Find char matching a mask
*
* This function searches for and returns the first char in [lo,hi) for
* which is(m,char) is true.
*
* @param m The mask to compare against.
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @return Pointer to a matching char if found, else @a hi.
*/
inline const char*
scan_is(mask __m, const char* __lo, const char* __hi) const;
#pragma empty_line
/**
* @brief Find char not matching a mask
*
* This function searches for and returns a pointer to the first char
* in [lo,hi) for which is(m,char) is false.
*
* @param m The mask to compare against.
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @return Pointer to a non-matching char if found, else @a hi.
*/
inline const char*
scan_not(mask __m, const char* __lo, const char* __hi) const;
#pragma empty_line
/**
* @brief Convert to uppercase.
*
* This function converts the char argument to uppercase if possible.
* If not possible (for example, '2'), returns the argument.
*
* toupper() acts as if it returns ctype<char>::do_toupper(c).
* do_toupper() must always return the same result for the same input.
*
* @param c The char to convert.
* @return The uppercase char if convertible, else @a c.
*/
char_type
toupper(char_type __c) const
{ return this->do_toupper(__c); }
#pragma empty_line
/**
* @brief Convert array to uppercase.
*
* This function converts each char in the range [lo,hi) to uppercase
* if possible. Other chars remain untouched.
*
* toupper() acts as if it returns ctype<char>:: do_toupper(lo, hi).
* do_toupper() must always return the same result for the same input.
*
* @param lo Pointer to first char in range.
* @param hi Pointer to end of range.
* @return @a hi.
*/
const char_type*
toupper(char_type *__lo, const char_type* __hi) const
{ return this->do_toupper(__lo, __hi); }
#pragma empty_line
/**
* @brief Convert to lowercase.
*
* This function converts the char argument to lowercase if possible.
* If not possible (for example, '2'), returns the argument.
*
* tolower() acts as if it returns ctype<char>::do_tolower(c).
* do_tolower() must always return the same result for the same input.
*
* @param c The char to convert.
* @return The lowercase char if convertible, else @a c.
*/
char_type
tolower(char_type __c) const
{ return this->do_tolower(__c); }
#pragma empty_line
/**
* @brief Convert array to lowercase.
*
* This function converts each char in the range [lo,hi) to lowercase
* if possible. Other chars remain untouched.
*
* tolower() acts as if it returns ctype<char>:: do_tolower(lo, hi).
* do_tolower() must always return the same result for the same input.
*
* @param lo Pointer to first char in range.
* @param hi Pointer to end of range.
* @return @a hi.
*/
const char_type*
tolower(char_type* __lo, const char_type* __hi) const
{ return this->do_tolower(__lo, __hi); }
#pragma empty_line
/**
* @brief Widen char
*
* This function converts the char to char_type using the simplest
* reasonable transformation. For an underived ctype<char> facet, the
* argument will be returned unchanged.
*
* This function works as if it returns ctype<char>::do_widen(c).
* do_widen() must always return the same result for the same input.
*
* Note: this is not what you want for codepage conversions. See
* codecvt for that.
*
* @param c The char to convert.
* @return The converted character.
*/
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 empty_line
/**
* @brief Widen char array
*
* This function converts each char in the input to char using the
* simplest reasonable transformation. For an underived ctype<char>
* facet, the argument will be copied unchanged.
*
* This function works as if it returns ctype<char>::do_widen(c).
* do_widen() must always return the same result for the same input.
*
* Note: this is not what you want for codepage conversions. See
* codecvt for that.
*
* @param lo Pointer to first char in range.
* @param hi Pointer to end of range.
* @param to Pointer to the destination array.
* @return @a hi.
*/
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 empty_line
/**
* @brief Narrow char
*
* This function converts the char to char using the simplest
* reasonable transformation. If the conversion fails, dfault is
* returned instead. For an underived ctype<char> facet, @a c
* will be returned unchanged.
*
* This function works as if it returns ctype<char>::do_narrow(c).
* do_narrow() must always return the same result for the same input.
*
* Note: this is not what you want for codepage conversions. See
* codecvt for that.
*
* @param c The char to convert.
* @param dfault Char to return if conversion fails.
* @return The converted character.
*/
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 empty_line
/**
* @brief Narrow char array
*
* This function converts each char in the input to char using the
* simplest reasonable transformation and writes the results to the
* destination array. For any char in the input that cannot be
* converted, @a dfault is used instead. For an underived ctype<char>
* facet, the argument will be copied unchanged.
*
* This function works as if it returns ctype<char>::do_narrow(lo, hi,
* dfault, to). do_narrow() must always return the same result for the
* same input.
*
* Note: this is not what you want for codepage conversions. See
* codecvt for that.
*
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @param dfault Char to use if conversion fails.
* @param to Pointer to the destination array.
* @return @a hi.
*/
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
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 695. ctype<char>::classic_table() not accessible.
/// Returns a pointer to the mask table provided to the constructor, or
/// the default from classic_table() if none was provided.
const mask*
table() const throw()
{ return _M_table; }
#pragma empty_line
/// Returns a pointer to the C locale mask table.
static const mask*
classic_table() throw();
protected:
#pragma empty_line
/**
* @brief Destructor.
*
* This function deletes table() if @a del was true in the
* constructor.
*/
virtual
~ctype();
#pragma empty_line
/**
* @brief Convert to uppercase.
*
* This virtual function converts the char argument to uppercase if
* possible. If not possible (for example, '2'), returns the argument.
*
* do_toupper() is a hook for a derived facet to change the behavior of
* uppercasing. do_toupper() must always return the same result for
* the same input.
*
* @param c The char to convert.
* @return The uppercase char if convertible, else @a c.
*/
virtual char_type
do_toupper(char_type) const;
#pragma empty_line
/**
* @brief Convert array to uppercase.
*
* This virtual function converts each char in the range [lo,hi) to
* uppercase if possible. Other chars remain untouched.
*
* do_toupper() is a hook for a derived facet to change the behavior of
* uppercasing. do_toupper() must always return the same result for
* the same input.
*
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @return @a hi.
*/
virtual const char_type*
do_toupper(char_type* __lo, const char_type* __hi) const;
#pragma empty_line
/**
* @brief Convert to lowercase.
*
* This virtual function converts the char argument to lowercase if
* possible. If not possible (for example, '2'), returns the argument.
*
* do_tolower() is a hook for a derived facet to change the behavior of
* lowercasing. do_tolower() must always return the same result for
* the same input.
*
* @param c The char to convert.
* @return The lowercase char if convertible, else @a c.
*/
virtual char_type
do_tolower(char_type) const;
#pragma empty_line
/**
* @brief Convert array to lowercase.
*
* This virtual function converts each char in the range [lo,hi) to
* lowercase if possible. Other chars remain untouched.
*
* do_tolower() is a hook for a derived facet to change the behavior of
* lowercasing. do_tolower() must always return the same result for
* the same input.
*
* @param lo Pointer to first char in range.
* @param hi Pointer to end of range.
* @return @a hi.
*/
virtual const char_type*
do_tolower(char_type* __lo, const char_type* __hi) const;
#pragma empty_line
/**
* @brief Widen char
*
* This virtual function converts the char to char using the simplest
* reasonable transformation. For an underived ctype<char> facet, the
* argument will be returned unchanged.
*
* do_widen() is a hook for a derived facet to change the behavior of
* widening. do_widen() must always return the same result for the
* same input.
*
* Note: this is not what you want for codepage conversions. See
* codecvt for that.
*
* @param c The char to convert.
* @return The converted character.
*/
virtual char_type
do_widen(char __c) const
{ return __c; }
#pragma empty_line
/**
* @brief Widen char array
*
* This function converts each char in the range [lo,hi) to char using
* the simplest reasonable transformation. For an underived
* ctype<char> facet, the argument will be copied unchanged.
*
* do_widen() is a hook for a derived facet to change the behavior of
* widening. do_widen() must always return the same result for the
* same input.
*
* Note: this is not what you want for codepage conversions. See
* codecvt for that.
*
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @param to Pointer to the destination array.
* @return @a hi.
*/
virtual const char*
do_widen(const char* __lo, const char* __hi, char_type* __dest) const
{
__builtin_memcpy(__dest, __lo, __hi - __lo);
return __hi;
}
#pragma empty_line
/**
* @brief Narrow char
*
* This virtual function converts the char to char using the simplest
* reasonable transformation. If the conversion fails, dfault is
* returned instead. For an underived ctype<char> facet, @a c will be
* returned unchanged.
*
* do_narrow() is a hook for a derived facet to change the behavior of
* narrowing. do_narrow() must always return the same result for the
* same input.
*
* Note: this is not what you want for codepage conversions. See
* codecvt for that.
*
* @param c The char to convert.
* @param dfault Char to return if conversion fails.
* @return The converted char.
*/
virtual char
do_narrow(char_type __c, char) const
{ return __c; }
#pragma empty_line
/**
* @brief Narrow char array to char array
*
* This virtual function converts each char in the range [lo,hi) to
* char using the simplest reasonable transformation and writes the
* results to the destination array. For any char in the input that
* cannot be converted, @a dfault is used instead. For an underived
* ctype<char> facet, the argument will be copied unchanged.
*
* do_narrow() is a hook for a derived facet to change the behavior of
* narrowing. do_narrow() must always return the same result for the
* same input.
*
* Note: this is not what you want for codepage conversions. See
* codecvt for that.
*
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @param dfault Char to use if conversion fails.
* @param to Pointer to the destination array.
* @return @a hi.
*/
virtual const char_type*
do_narrow(const char_type* __lo, const char_type* __hi,
char, char* __dest) const
{
__builtin_memcpy(__dest, __lo, __hi - __lo);
return __hi;
}
#pragma empty_line
private:
void _M_narrow_init() const;
void _M_widen_init() const;
};
#pragma empty_line
#pragma empty_line
/**
* @brief The ctype<wchar_t> specialization.
* @ingroup locales
*
* This class defines classification and conversion functions for the
* wchar_t type. It gets used by wchar_t streams for many I/O operations.
* The wchar_t specialization provides a number of optimizations as well.
*
* ctype<wchar_t> inherits its public methods from
* __ctype_abstract_base<wchar_t>.
*/
template<>
class ctype<wchar_t> : public __ctype_abstract_base<wchar_t>
{
public:
// Types:
/// Typedef for the template parameter wchar_t.
typedef wchar_t char_type;
typedef wctype_t __wmask_type;
#pragma empty_line
protected:
__c_locale _M_c_locale_ctype;
#pragma empty_line
// Pre-computed narrowed and widened chars.
bool _M_narrow_ok;
char _M_narrow[128];
wint_t _M_widen[1 + static_cast<unsigned char>(-1)];
#pragma empty_line
// Pre-computed elements for do_is.
mask _M_bit[16];
__wmask_type _M_wmask[16];
#pragma empty_line
public:
// Data Members:
/// The facet id for ctype<wchar_t>
static locale::id id;
#pragma empty_line
/**
* @brief Constructor performs initialization.
*
* This is the constructor provided by the standard.
*
* @param refs Passed to the base facet class.
*/
explicit
ctype(size_t __refs = 0);
#pragma empty_line
/**
* @brief Constructor performs static initialization.
*
* This constructor is used to construct the initial C locale facet.
*
* @param cloc Handle to C locale data.
* @param refs Passed to the base facet class.
*/
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
/// Destructor
virtual
~ctype();
#pragma empty_line
/**
* @brief Test wchar_t classification.
*
* This function finds a mask M for @a c and compares it to mask @a m.
*
* do_is() is a hook for a derived facet to change the behavior of
* classifying. do_is() must always return the same result for the
* same input.
*
* @param c The wchar_t to find the mask of.
* @param m The mask to compare against.
* @return (M & m) != 0.
*/
virtual bool
do_is(mask __m, char_type __c) const;
#pragma empty_line
/**
* @brief Return a mask array.
*
* This function finds the mask for each wchar_t in the range [lo,hi)
* and successively writes it to vec. vec must have as many elements
* as the input.
*
* do_is() is a hook for a derived facet to change the behavior of
* classifying. do_is() must always return the same result for the
* same input.
*
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @param vec Pointer to an array of mask storage.
* @return @a hi.
*/
virtual const char_type*
do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
#pragma empty_line
/**
* @brief Find wchar_t matching mask
*
* This function searches for and returns the first wchar_t c in
* [lo,hi) for which is(m,c) is true.
*
* do_scan_is() is a hook for a derived facet to change the behavior of
* match searching. do_is() must always return the same result for the
* same input.
*
* @param m The mask to compare against.
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @return Pointer to a matching wchar_t if found, else @a hi.
*/
virtual const char_type*
do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
#pragma empty_line
/**
* @brief Find wchar_t not matching mask
*
* This function searches for and returns a pointer to the first
* wchar_t c of [lo,hi) for which is(m,c) is false.
*
* do_scan_is() is a hook for a derived facet to change the behavior of
* match searching. do_is() must always return the same result for the
* same input.
*
* @param m The mask to compare against.
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @return Pointer to a non-matching wchar_t if found, else @a hi.
*/
virtual const char_type*
do_scan_not(mask __m, const char_type* __lo,
const char_type* __hi) const;
#pragma empty_line
/**
* @brief Convert to uppercase.
*
* This virtual function converts the wchar_t argument to uppercase if
* possible. If not possible (for example, '2'), returns the argument.
*
* do_toupper() is a hook for a derived facet to change the behavior of
* uppercasing. do_toupper() must always return the same result for
* the same input.
*
* @param c The wchar_t to convert.
* @return The uppercase wchar_t if convertible, else @a c.
*/
virtual char_type
do_toupper(char_type) const;
#pragma empty_line
/**
* @brief Convert array to uppercase.
*
* This virtual function converts each wchar_t in the range [lo,hi) to
* uppercase if possible. Other elements remain untouched.
*
* do_toupper() is a hook for a derived facet to change the behavior of
* uppercasing. do_toupper() must always return the same result for
* the same input.
*
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @return @a hi.
*/
virtual const char_type*
do_toupper(char_type* __lo, const char_type* __hi) const;
#pragma empty_line
/**
* @brief Convert to lowercase.
*
* This virtual function converts the argument to lowercase if
* possible. If not possible (for example, '2'), returns the argument.
*
* do_tolower() is a hook for a derived facet to change the behavior of
* lowercasing. do_tolower() must always return the same result for
* the same input.
*
* @param c The wchar_t to convert.
* @return The lowercase wchar_t if convertible, else @a c.
*/
virtual char_type
do_tolower(char_type) const;
#pragma empty_line
/**
* @brief Convert array to lowercase.
*
* This virtual function converts each wchar_t in the range [lo,hi) to
* lowercase if possible. Other elements remain untouched.
*
* do_tolower() is a hook for a derived facet to change the behavior of
* lowercasing. do_tolower() must always return the same result for
* the same input.
*
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @return @a hi.
*/
virtual const char_type*
do_tolower(char_type* __lo, const char_type* __hi) const;
#pragma empty_line
/**
* @brief Widen char to wchar_t
*
* This virtual function converts the char to wchar_t using the
* simplest reasonable transformation. For an underived ctype<wchar_t>
* facet, the argument will be cast to wchar_t.
*
* do_widen() is a hook for a derived facet to change the behavior of
* widening. do_widen() must always return the same result for the
* same input.
*
* Note: this is not what you want for codepage conversions. See
* codecvt for that.
*
* @param c The char to convert.
* @return The converted wchar_t.
*/
virtual char_type
do_widen(char) const;
#pragma empty_line
/**
* @brief Widen char array to wchar_t array
*
* This function converts each char in the input to wchar_t using the
* simplest reasonable transformation. For an underived ctype<wchar_t>
* facet, the argument will be copied, casting each element to wchar_t.
*
* do_widen() is a hook for a derived facet to change the behavior of
* widening. do_widen() must always return the same result for the
* same input.
*
* Note: this is not what you want for codepage conversions. See
* codecvt for that.
*
* @param lo Pointer to start range.
* @param hi Pointer to end of range.
* @param to Pointer to the destination array.
* @return @a hi.
*/
virtual const char*
do_widen(const char* __lo, const char* __hi, char_type* __dest) const;
#pragma empty_line
/**
* @brief Narrow wchar_t to char
*
* This virtual function converts the argument to char using
* the simplest reasonable transformation. If the conversion
* fails, dfault is returned instead. For an underived
* ctype<wchar_t> facet, @a c will be cast to char and
* returned.
*
* do_narrow() is a hook for a derived facet to change the
* behavior of narrowing. do_narrow() must always return the
* same result for the same input.
*
* Note: this is not what you want for codepage conversions. See
* codecvt for that.
*
* @param c The wchar_t to convert.
* @param dfault Char to return if conversion fails.
* @return The converted char.
*/
virtual char
do_narrow(char_type, char __dfault) const;
#pragma empty_line
/**
* @brief Narrow wchar_t array to char array
*
* This virtual function converts each wchar_t in the range [lo,hi) to
* char using the simplest reasonable transformation and writes the
* results to the destination array. For any wchar_t in the input that
* cannot be converted, @a dfault is used instead. For an underived
* ctype<wchar_t> facet, the argument will be copied, casting each
* element to char.
*
* do_narrow() is a hook for a derived facet to change the behavior of
* narrowing. do_narrow() must always return the same result for the
* same input.
*
* Note: this is not what you want for codepage conversions. See
* codecvt for that.
*
* @param lo Pointer to start of range.
* @param hi Pointer to end of range.
* @param dfault Char to use if conversion fails.
* @param to Pointer to the destination array.
* @return @a hi.
*/
virtual const char_type*
do_narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char* __dest) const;
#pragma empty_line
// For use at construction time only.
void
_M_initialize_ctype() throw();
};
#pragma empty_line
#pragma empty_line
/// class ctype_byname [22.2.1.2].
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
protected:
virtual
~ctype_byname() { };
};
#pragma empty_line
/// 22.2.1.4 Class ctype_byname specializations.
template<>
class ctype_byname<char> : public ctype<char>
{
public:
explicit
ctype_byname(const char* __s, size_t __refs = 0);
#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
protected:
virtual
~ctype_byname();
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
} // namespace
#pragma empty_line
// Include host and configuration specific ctype inlines.
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/ctype_inline.h" 1 3
// Locale support -*- C++ -*-
#pragma empty_line
// Copyright (C) 2000, 2002, 2009, 2010 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file bits/ctype_inline.h
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{locale}
*/
#pragma empty_line
//
// ISO C++ 14882: 22.1 Locales
//
#pragma empty_line
// ctype bits to be inlined go here. Non-inlinable (ie virtual do_*)
// functions go in ctype.cc
#pragma empty_line
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
} // namespace
#pragma line 1512 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 2 3
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
// 22.2.2 The numeric category.
class __num_base
{
public:
// NB: Code depends on the order of _S_atoms_out elements.
// Below are the indices into _S_atoms_out.
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, // For scientific notation, 'e'
_S_oE = _S_oudigits + 14, // For scientific notation, 'E'
_S_oend = _S_oudigits_end
};
#pragma empty_line
// A list of valid numeric literals for output. This array
// contains chars that will be passed through the current locale's
// ctype<_CharT>.widen() and then used to render numbers.
// For the standard "C" locale, this is
// "-+xX0123456789abcdef0123456789ABCDEF".
static const char* _S_atoms_out;
#pragma empty_line
// String literal of acceptable (narrow) input, for num_get.
// "-+xX0123456789abcdefABCDEF"
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
// num_put
// Construct and return valid scanf format for floating point types.
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
// A list of valid numeric literals for output: in the standard
// "C" locale, this is "-+xX0123456789abcdef0123456789ABCDEF".
// This array contains the chars after having been passed
// through the current locale's ctype<_CharT>.widen().
_CharT _M_atoms_out[__num_base::_S_oend];
#pragma empty_line
// A list of valid numeric literals for input: in the standard
// "C" locale, this is "-+xX0123456789abcdefABCDEF"
// This array contains the chars after having been passed
// through the current locale's ctype<_CharT>.widen().
_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
/**
* @brief Primary class template numpunct.
* @ingroup locales
*
* This facet stores several pieces of information related to printing and
* scanning numbers, such as the decimal point character. It takes a
* template parameter specifying the char type. The numpunct facet is
* used by streams for many I/O operations involving numbers.
*
* The numpunct template uses protected virtual functions to provide the
* actual results. The public accessors forward the call to the virtual
* functions. These virtual functions are hooks for developers to
* implement the behavior they require from a numpunct facet.
*/
template<typename _CharT>
class numpunct : public locale::facet
{
public:
// Types:
//@{
/// Public typedefs
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;
//@}
typedef __numpunct_cache<_CharT> __cache_type;
#pragma empty_line
protected:
__cache_type* _M_data;
#pragma empty_line
public:
/// Numpunct facet id.
static locale::id id;
#pragma empty_line
/**
* @brief Numpunct constructor.
*
* @param refs Refcount to pass to the base class.
*/
explicit
numpunct(size_t __refs = 0)
: facet(__refs), _M_data(0)
{ _M_initialize_numpunct(); }
#pragma empty_line
/**
* @brief Internal constructor. Not for general use.
*
* This is a constructor for use by the library itself to set up the
* predefined locale facets.
*
* @param cache __numpunct_cache object.
* @param refs Refcount to pass to the base class.
*/
explicit
numpunct(__cache_type* __cache, size_t __refs = 0)
: facet(__refs), _M_data(__cache)
{ _M_initialize_numpunct(); }
#pragma empty_line
/**
* @brief Internal constructor. Not for general use.
*
* This is a constructor for use by the library itself to set up new
* locales.
*
* @param cloc The C locale.
* @param refs Refcount to pass to the base class.
*/
explicit
numpunct(__c_locale __cloc, size_t __refs = 0)
: facet(__refs), _M_data(0)
{ _M_initialize_numpunct(__cloc); }
#pragma empty_line
/**
* @brief Return decimal point character.
*
* This function returns a char_type to use as a decimal point. It
* does so by returning returning
* numpunct<char_type>::do_decimal_point().
*
* @return @a char_type representing a decimal point.
*/
char_type
decimal_point() const
{ return this->do_decimal_point(); }
#pragma empty_line
/**
* @brief Return thousands separator character.
*
* This function returns a char_type to use as a thousands
* separator. It does so by returning returning
* numpunct<char_type>::do_thousands_sep().
*
* @return char_type representing a thousands separator.
*/
char_type
thousands_sep() const
{ return this->do_thousands_sep(); }
#pragma empty_line
/**
* @brief Return grouping specification.
*
* This function returns a string representing groupings for the
* integer part of a number. Groupings indicate where thousands
* separators should be inserted in the integer part of a number.
*
* Each char in the return string is interpret as an integer
* rather than a character. These numbers represent the number
* of digits in a group. The first char in the string
* represents the number of digits in the least significant
* group. If a char is negative, it indicates an unlimited
* number of digits for the group. If more chars from the
* string are required to group a number, the last char is used
* repeatedly.
*
* For example, if the grouping() returns "\003\002" and is
* applied to the number 123456789, this corresponds to
* 12,34,56,789. Note that if the string was "32", this would
* put more than 50 digits into the least significant group if
* the character set is ASCII.
*
* The string is returned by calling
* numpunct<char_type>::do_grouping().
*
* @return string representing grouping specification.
*/
string
grouping() const
{ return this->do_grouping(); }
#pragma empty_line
/**
* @brief Return string representation of bool true.
*
* This function returns a string_type containing the text
* representation for true bool variables. It does so by calling
* numpunct<char_type>::do_truename().
*
* @return string_type representing printed form of true.
*/
string_type
truename() const
{ return this->do_truename(); }
#pragma empty_line
/**
* @brief Return string representation of bool false.
*
* This function returns a string_type containing the text
* representation for false bool variables. It does so by calling
* numpunct<char_type>::do_falsename().
*
* @return string_type representing printed form of false.
*/
string_type
falsename() const
{ return this->do_falsename(); }
#pragma empty_line
protected:
/// Destructor.
virtual
~numpunct();
#pragma empty_line
/**
* @brief Return decimal point character.
*
* Returns a char_type to use as a decimal point. This function is a
* hook for derived classes to change the value returned.
*
* @return @a char_type representing a decimal point.
*/
virtual char_type
do_decimal_point() const
{ return _M_data->_M_decimal_point; }
#pragma empty_line
/**
* @brief Return thousands separator character.
*
* Returns a char_type to use as a thousands separator. This function
* is a hook for derived classes to change the value returned.
*
* @return @a char_type representing a thousands separator.
*/
virtual char_type
do_thousands_sep() const
{ return _M_data->_M_thousands_sep; }
#pragma empty_line
/**
* @brief Return grouping specification.
*
* Returns a string representing groupings for the integer part of a
* number. This function is a hook for derived classes to change the
* value returned. @see grouping() for details.
*
* @return String representing grouping specification.
*/
virtual string
do_grouping() const
{ return _M_data->_M_grouping; }
#pragma empty_line
/**
* @brief Return string representation of bool true.
*
* Returns a string_type containing the text representation for true
* bool variables. This function is a hook for derived classes to
* change the value returned.
*
* @return string_type representing printed form of true.
*/
virtual string_type
do_truename() const
{ return _M_data->_M_truename; }
#pragma empty_line
/**
* @brief Return string representation of bool false.
*
* Returns a string_type containing the text representation for false
* bool variables. This function is a hook for derived classes to
* change the value returned.
*
* @return string_type representing printed form of false.
*/
virtual string_type
do_falsename() const
{ return _M_data->_M_falsename; }
#pragma empty_line
// For use at construction time only.
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
/// class numpunct_byname [22.2.3.2].
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
protected:
virtual
~numpunct_byname() { }
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
/**
* @brief Primary class template num_get.
* @ingroup locales
*
* This facet encapsulates the code to parse and return a number
* from a string. It is used by the istream numeric extraction
* operators.
*
* The num_get template uses protected virtual functions to provide the
* actual results. The public accessors forward the call to the virtual
* functions. These virtual functions are hooks for developers to
* implement the behavior they require from the num_get facet.
*/
template<typename _CharT, typename _InIter>
class num_get : public locale::facet
{
public:
// Types:
//@{
/// Public typedefs
typedef _CharT char_type;
typedef _InIter iter_type;
//@}
#pragma empty_line
/// Numpunct facet id.
static locale::id id;
#pragma empty_line
/**
* @brief Constructor performs initialization.
*
* This is the constructor provided by the standard.
*
* @param refs Passed to the base facet class.
*/
explicit
num_get(size_t __refs = 0) : facet(__refs) { }
#pragma empty_line
/**
* @brief Numeric parsing.
*
* Parses the input stream into the bool @a v. It does so by calling
* num_get::do_get().
*
* If ios_base::boolalpha is set, attempts to read
* ctype<CharT>::truename() or ctype<CharT>::falsename(). Sets
* @a v to true or false if successful. Sets err to
* ios_base::failbit if reading the string fails. Sets err to
* ios_base::eofbit if the stream is emptied.
*
* If ios_base::boolalpha is not set, proceeds as with reading a long,
* except if the value is 1, sets @a v to true, if the value is 0, sets
* @a v to false, and otherwise set err to ios_base::failbit.
*
* @param in Start of input stream.
* @param end End of input stream.
* @param io Source of locale and flags.
* @param err Error flags to set.
* @param v Value to format and insert.
* @return Iterator after reading.
*/
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 empty_line
//@{
/**
* @brief Numeric parsing.
*
* Parses the input stream into the integral variable @a v. It does so
* by calling num_get::do_get().
*
* Parsing is affected by the flag settings in @a io.
*
* The basic parse is affected by the value of io.flags() &
* ios_base::basefield. If equal to ios_base::oct, parses like the
* scanf %o specifier. Else if equal to ios_base::hex, parses like %X
* specifier. Else if basefield equal to 0, parses like the %i
* specifier. Otherwise, parses like %d for signed and %u for unsigned
* types. The matching type length modifier is also used.
*
* Digit grouping is interpreted according to numpunct::grouping() and
* numpunct::thousands_sep(). If the pattern of digit groups isn't
* consistent, sets err to ios_base::failbit.
*
* If parsing the string yields a valid value for @a v, @a v is set.
* Otherwise, sets err to ios_base::failbit and leaves @a v unaltered.
* Sets err to ios_base::eofbit if the stream is emptied.
*
* @param in Start of input stream.
* @param end End of input stream.
* @param io Source of locale and flags.
* @param err Error flags to set.
* @param v Value to format and insert.
* @return Iterator after reading.
*/
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 empty_line
//@}
#pragma empty_line
//@{
/**
* @brief Numeric parsing.
*
* Parses the input stream into the integral variable @a v. It does so
* by calling num_get::do_get().
*
* The input characters are parsed like the scanf %g specifier. The
* matching type length modifier is also used.
*
* The decimal point character used is numpunct::decimal_point().
* Digit grouping is interpreted according to numpunct::grouping() and
* numpunct::thousands_sep(). If the pattern of digit groups isn't
* consistent, sets err to ios_base::failbit.
*
* If parsing the string yields a valid value for @a v, @a v is set.
* Otherwise, sets err to ios_base::failbit and leaves @a v unaltered.
* Sets err to ios_base::eofbit if the stream is emptied.
*
* @param in Start of input stream.
* @param end End of input stream.
* @param io Source of locale and flags.
* @param err Error flags to set.
* @param v Value to format and insert.
* @return Iterator after reading.
*/
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 empty_line
/**
* @brief Numeric parsing.
*
* Parses the input stream into the pointer variable @a v. It does so
* by calling num_get::do_get().
*
* The input characters are parsed like the scanf %p specifier.
*
* Digit grouping is interpreted according to numpunct::grouping() and
* numpunct::thousands_sep(). If the pattern of digit groups isn't
* consistent, sets err to ios_base::failbit.
*
* Note that the digit grouping effect for pointers is a bit ambiguous
* in the standard and shouldn't be relied on. See DR 344.
*
* If parsing the string yields a valid value for @a v, @a v is set.
* Otherwise, sets err to ios_base::failbit and leaves @a v unaltered.
* Sets err to ios_base::eofbit if the stream is emptied.
*
* @param in Start of input stream.
* @param end End of input stream.
* @param io Source of locale and flags.
* @param err Error flags to set.
* @param v Value to format and insert.
* @return Iterator after reading.
*/
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:
/// Destructor.
virtual ~num_get() { }
#pragma empty_line
iter_type
_M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&,
string&) const;
#pragma empty_line
template<typename _ValueT>
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 empty_line
//@{
/**
* @brief Numeric parsing.
*
* Parses the input stream into the variable @a v. This function is a
* hook for derived classes to change the value returned. @see get()
* for more details.
*
* @param in Start of input stream.
* @param end End of input stream.
* @param io Source of locale and flags.
* @param err Error flags to set.
* @param v Value to format and insert.
* @return Iterator after reading.
*/
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& __err,
float&) const;
#pragma empty_line
virtual iter_type
do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
double&) const;
#pragma empty_line
// XXX GLIBCXX_ABI Deprecated
#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& __err,
long double&) const;
#pragma empty_line
#pragma empty_line
virtual iter_type
do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
void*&) const;
#pragma empty_line
// XXX GLIBCXX_ABI Deprecated
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
//@}
};
#pragma empty_line
template<typename _CharT, typename _InIter>
locale::id num_get<_CharT, _InIter>::id;
#pragma empty_line
#pragma empty_line
/**
* @brief Primary class template num_put.
* @ingroup locales
*
* This facet encapsulates the code to convert a number to a string. It is
* used by the ostream numeric insertion operators.
*
* The num_put template uses protected virtual functions to provide the
* actual results. The public accessors forward the call to the virtual
* functions. These virtual functions are hooks for developers to
* implement the behavior they require from the num_put facet.
*/
template<typename _CharT, typename _OutIter>
class num_put : public locale::facet
{
public:
// Types:
//@{
/// Public typedefs
typedef _CharT char_type;
typedef _OutIter iter_type;
//@}
#pragma empty_line
/// Numpunct facet id.
static locale::id id;
#pragma empty_line
/**
* @brief Constructor performs initialization.
*
* This is the constructor provided by the standard.
*
* @param refs Passed to the base facet class.
*/
explicit
num_put(size_t __refs = 0) : facet(__refs) { }
#pragma empty_line
/**
* @brief Numeric formatting.
*
* Formats the boolean @a v and inserts it into a stream. It does so
* by calling num_put::do_put().
*
* If ios_base::boolalpha is set, writes ctype<CharT>::truename() or
* ctype<CharT>::falsename(). Otherwise formats @a v as an int.
*
* @param s Stream to write to.
* @param io Source of locale and flags.
* @param fill Char_type to use for filling.
* @param v Value to format and insert.
* @return Iterator after writing.
*/
iter_type
put(iter_type __s, ios_base& __f, char_type __fill, bool __v) const
{ return this->do_put(__s, __f, __fill, __v); }
#pragma empty_line
//@{
/**
* @brief Numeric formatting.
*
* Formats the integral value @a v and inserts it into a
* stream. It does so by calling num_put::do_put().
*
* Formatting is affected by the flag settings in @a io.
*
* The basic format is affected by the value of io.flags() &
* ios_base::basefield. If equal to ios_base::oct, formats like the
* printf %o specifier. Else if equal to ios_base::hex, formats like
* %x or %X with ios_base::uppercase unset or set respectively.
* Otherwise, formats like %d, %ld, %lld for signed and %u, %lu, %llu
* for unsigned values. Note that if both oct and hex are set, neither
* will take effect.
*
* If ios_base::showpos is set, '+' is output before positive values.
* If ios_base::showbase is set, '0' precedes octal values (except 0)
* and '0[xX]' precedes hex values.
*
* Thousands separators are inserted according to numpunct::grouping()
* and numpunct::thousands_sep(). The decimal point character used is
* numpunct::decimal_point().
*
* If io.width() is non-zero, enough @a fill characters are inserted to
* make the result at least that wide. If
* (io.flags() & ios_base::adjustfield) == ios_base::left, result is
* padded at the end. If ios_base::internal, then padding occurs
* immediately after either a '+' or '-' or after '0x' or '0X'.
* Otherwise, padding occurs at the beginning.
*
* @param s Stream to write to.
* @param io Source of locale and flags.
* @param fill Char_type to use for filling.
* @param v Value to format and insert.
* @return Iterator after writing.
*/
iter_type
put(iter_type __s, ios_base& __f, char_type __fill, long __v) const
{ return this->do_put(__s, __f, __fill, __v); }
#pragma empty_line
iter_type
put(iter_type __s, ios_base& __f, char_type __fill,
unsigned long __v) const
{ return this->do_put(__s, __f, __fill, __v); }
#pragma empty_line
#pragma empty_line
iter_type
put(iter_type __s, ios_base& __f, char_type __fill, long long __v) const
{ return this->do_put(__s, __f, __fill, __v); }
#pragma empty_line
iter_type
put(iter_type __s, ios_base& __f, char_type __fill,
unsigned long long __v) const
{ return this->do_put(__s, __f, __fill, __v); }
#pragma empty_line
//@}
#pragma empty_line
//@{
/**
* @brief Numeric formatting.
*
* Formats the floating point value @a v and inserts it into a stream.
* It does so by calling num_put::do_put().
*
* Formatting is affected by the flag settings in @a io.
*
* The basic format is affected by the value of io.flags() &
* ios_base::floatfield. If equal to ios_base::fixed, formats like the
* printf %f specifier. Else if equal to ios_base::scientific, formats
* like %e or %E with ios_base::uppercase unset or set respectively.
* Otherwise, formats like %g or %G depending on uppercase. Note that
* if both fixed and scientific are set, the effect will also be like
* %g or %G.
*
* The output precision is given by io.precision(). This precision is
* capped at numeric_limits::digits10 + 2 (different for double and
* long double). The default precision is 6.
*
* If ios_base::showpos is set, '+' is output before positive values.
* If ios_base::showpoint is set, a decimal point will always be
* output.
*
* Thousands separators are inserted according to numpunct::grouping()
* and numpunct::thousands_sep(). The decimal point character used is
* numpunct::decimal_point().
*
* If io.width() is non-zero, enough @a fill characters are inserted to
* make the result at least that wide. If
* (io.flags() & ios_base::adjustfield) == ios_base::left, result is
* padded at the end. If ios_base::internal, then padding occurs
* immediately after either a '+' or '-' or after '0x' or '0X'.
* Otherwise, padding occurs at the beginning.
*
* @param s Stream to write to.
* @param io Source of locale and flags.
* @param fill Char_type to use for filling.
* @param v Value to format and insert.
* @return Iterator after writing.
*/
iter_type
put(iter_type __s, ios_base& __f, char_type __fill, double __v) const
{ return this->do_put(__s, __f, __fill, __v); }
#pragma empty_line
iter_type
put(iter_type __s, ios_base& __f, char_type __fill,
long double __v) const
{ return this->do_put(__s, __f, __fill, __v); }
//@}
#pragma empty_line
/**
* @brief Numeric formatting.
*
* Formats the pointer value @a v and inserts it into a stream. It
* does so by calling num_put::do_put().
*
* This function formats @a v as an unsigned long with ios_base::hex
* and ios_base::showbase set.
*
* @param s Stream to write to.
* @param io Source of locale and flags.
* @param fill Char_type to use for filling.
* @param v Value to format and insert.
* @return Iterator after writing.
*/
iter_type
put(iter_type __s, ios_base& __f, char_type __fill,
const void* __v) const
{ return this->do_put(__s, __f, __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
/// Destructor.
virtual
~num_put() { };
#pragma empty_line
//@{
/**
* @brief Numeric formatting.
*
* These functions do the work of formatting numeric values and
* inserting them into a stream. This function is a hook for derived
* classes to change the value returned.
*
* @param s Stream to write to.
* @param io Source of locale and flags.
* @param fill Char_type to use for filling.
* @param v Value to format and insert.
* @return Iterator after writing.
*/
virtual iter_type
do_put(iter_type, ios_base&, 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 __fill, double __v) const;
#pragma empty_line
// XXX GLIBCXX_ABI Deprecated
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
virtual iter_type
do_put(iter_type, ios_base&, char_type __fill, long double __v) const;
#pragma empty_line
#pragma empty_line
virtual iter_type
do_put(iter_type, ios_base&, char_type __fill, const void* __v) const;
#pragma empty_line
// XXX GLIBCXX_ABI Deprecated
#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
// Subclause convenience interfaces, inlines.
// NB: These are inline because, when used in a loop, some compilers
// can hoist the body out of the loop; then it's just as fast as the
// C is*() function.
#pragma empty_line
/// Convenience interface to ctype.is(ctype_base::space, __c).
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
/// Convenience interface to ctype.is(ctype_base::print, __c).
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
/// Convenience interface to ctype.is(ctype_base::cntrl, __c).
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
/// Convenience interface to ctype.is(ctype_base::upper, __c).
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
/// Convenience interface to ctype.is(ctype_base::lower, __c).
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
/// Convenience interface to ctype.is(ctype_base::alpha, __c).
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
/// Convenience interface to ctype.is(ctype_base::digit, __c).
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
/// Convenience interface to ctype.is(ctype_base::punct, __c).
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
/// Convenience interface to ctype.is(ctype_base::xdigit, __c).
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
/// Convenience interface to ctype.is(ctype_base::alnum, __c).
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
/// Convenience interface to ctype.is(ctype_base::graph, __c).
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
/// Convenience interface to ctype.toupper(__c).
template<typename _CharT>
inline _CharT
toupper(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).toupper(__c); }
#pragma empty_line
/// Convenience interface to ctype.tolower(__c).
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
} // namespace
#pragma empty_line
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.tcc" 1 3
// Locale support -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010, 2011
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file bits/locale_facets.tcc
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{locale}
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 35 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.tcc" 3
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
// Routine to access a cache for the facet. If the cache didn't
// exist before, it gets constructed on the fly.
template<typename _Facet>
struct __use_cache
{
const _Facet*
operator() (const locale& __loc) const;
};
#pragma empty_line
// Specializations.
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;
if (true)
{
__tmp = new __numpunct_cache<_CharT>;
__tmp->_M_cache(__loc);
}
if (false)
{
delete __tmp;
;
}
__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)
{
_M_allocated = true;
#pragma empty_line
const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
#pragma empty_line
char* __grouping = 0;
_CharT* __truename = 0;
_CharT* __falsename = 0;
if (true)
{
_M_grouping_size = __np.grouping().size();
__grouping = new char[_M_grouping_size];
__np.grouping().copy(__grouping, _M_grouping_size);
_M_grouping = __grouping;
_M_use_grouping = (_M_grouping_size
&& static_cast<signed char>(_M_grouping[0]) > 0
&& (_M_grouping[0]
!= __gnu_cxx::__numeric_traits<char>::__max));
#pragma empty_line
_M_truename_size = __np.truename().size();
__truename = new _CharT[_M_truename_size];
__np.truename().copy(__truename, _M_truename_size);
_M_truename = __truename;
#pragma empty_line
_M_falsename_size = __np.falsename().size();
__falsename = new _CharT[_M_falsename_size];
__np.falsename().copy(__falsename, _M_falsename_size);
_M_falsename = __falsename;
#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);
}
if (false)
{
delete [] __grouping;
delete [] __truename;
delete [] __falsename;
;
}
}
#pragma empty_line
// Used by both numeric and monetary facets.
// Check to make sure that the __grouping_tmp string constructed in
// money_get or num_get matches the canonical grouping for a given
// locale.
// __grouping_tmp is parsed L to R
// 1,222,444 == __grouping_tmp of "\1\3\3"
// __grouping is parsed R to L
// 1,222,444 == __grouping of "\3" == "\3\3\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>
_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
// True if __beg becomes equal to __end.
bool __testeof = __beg == __end;
#pragma empty_line
// First check for sign.
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
// Next, look for leading zeros.
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
// Only need acceptable digits for floating point numbers.
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)
// "C" locale
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)
{
// Scientific notation.
__xtrc += 'e';
__found_sci = true;
#pragma empty_line
// Remove optional plus or minus sign, if they exist.
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)
{
// According to 22.2.2.1.2, p8-9, first look for thousands_sep
// and decimal_point.
if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
{
if (!__found_dec && !__found_sci)
{
// NB: Thousands separator at the beginning of a string
// is a no-no, as is two consecutive thousands separators.
if (__sep_pos)
{
__found_grouping += static_cast<char>(__sep_pos);
__sep_pos = 0;
}
else
{
// NB: __convert_to_v will not assign __v and will
// set the failbit.
__xtrc.clear();
break;
}
}
else
break;
}
else if (__c == __lc->_M_decimal_point)
{
if (!__found_dec && !__found_sci)
{
// If no grouping chars are seen, no grouping check
// is applied. Therefore __found_grouping is adjusted
// only if decimal_point comes after some thousands_sep.
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)
{
// Scientific notation.
if (__found_grouping.size() && !__found_dec)
__found_grouping += static_cast<char>(__sep_pos);
__xtrc += 'e';
__found_sci = true;
#pragma empty_line
// Remove optional plus or minus sign, if they exist.
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
// Digit grouping is checked. If grouping and found_grouping don't
// match, then get very very upset, and set failbit.
if (__found_grouping.size())
{
// Add the ending grouping if a decimal or 'e'/'E' wasn't found.
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>
_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
// NB: Iff __basefield == 0, __base can change based on contents.
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
// True if __beg becomes equal to __end.
bool __testeof = __beg == __end;
#pragma empty_line
// First check for sign.
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
// Next, look for leading zeros and check required digits
// for base formats.
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
// At this point, base is determined. If not hex, only allow
// base digits as valid input.
const size_t __len = (__base == 16 ? __num_base::_S_iend
- __num_base::_S_izero : __base);
#pragma empty_line
// Extract.
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)
// "C" locale
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)
{
// According to 22.2.2.1.2, p8-9, first look for thousands_sep
// and decimal_point.
if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
{
// NB: Thousands separator at the beginning of a string
// is a no-no, as is two consecutive thousands separators.
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
// Digit grouping is checked. If grouping and found_grouping don't
// match, then get very very upset, and set failbit.
if (__found_grouping.size())
{
// Add the ending grouping.
__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
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 23. Num_get overflow result.
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
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 17. Bad bool parsing
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))
{
// Parse bool values as long.
// NB: We can't just call do_get(long) here, as it might
// refer to a derived class.
long __l = -1;
__beg = _M_extract_int(__beg, __end, __io, __err, __l);
if (__l == 0 || __l == 1)
__v = bool(__l);
else
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 23. Num_get overflow result.
__v = true;
__err = ios_base::failbit;
if (__beg == __end)
__err |= ios_base::eofbit;
}
}
else
{
// Parse bool values as alphanumeric.
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
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 23. Num_get overflow result.
__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 731 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/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
{
// Prepare for hex formatted input.
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
// Reset from hex formatted input.
__io.flags(__fmt);
#pragma empty_line
__v = reinterpret_cast<void*>(__ul);
return __beg;
}
#pragma empty_line
// For use by integer and floating-point types after they have been
// converted into a char_type string.
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
{
// [22.2.2.2.2] Stage 3.
// If necessary, pad.
__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))
{
// Decimal.
do
{
*--__buf = __lit[(__v % 10) + __num_base::_S_odigits];
__v /= 10;
}
while (__v != 0);
}
else if ((__flags & ios_base::basefield) == ios_base::oct)
{
// Octal.
do
{
*--__buf = __lit[(__v & 0x7) + __num_base::_S_odigits];
__v >>= 3;
}
while (__v != 0);
}
else
{
// Hex.
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
// Long enough to hold hex, dec, and octal representations.
const int __ilen = 5 * sizeof(_ValueT);
_CharT* __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
* __ilen));
#pragma empty_line
// [22.2.2.2.2] Stage 1, numeric conversion to character.
// Result is returned right-justified in the buffer.
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
// Add grouping, if necessary.
if (__lc->_M_use_grouping)
{
// Grouping can add (almost) as many separators as the number
// of digits + space is reserved for numeric base or sign.
_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
// Complete Stage 1, prepend numeric base or sign.
if (__builtin_expect(__dec, true))
{
// Decimal.
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
{
// 'x' or 'X'
const bool __uppercase = __flags & ios_base::uppercase;
*--__cs = __lit[__num_base::_S_ox + __uppercase];
// '0'
*--__cs = __lit[__num_base::_S_odigits];
__len += 2;
}
}
#pragma empty_line
// Pad.
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
// [22.2.2.2.2] Stage 4.
// Write resulting, fully-formatted string to output iterator.
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
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 282. What types does numpunct grouping refer to?
// Add grouping, if necessary.
const int __declen = __p ? __p - __cs : __len;
_CharT* __p2 = std::__add_grouping(__new, __sep, __grouping,
__grouping_size,
__cs, __cs + __declen);
#pragma empty_line
// Tack on decimal part.
int __newlen = __p2 - __new;
if (__p)
{
char_traits<_CharT>::copy(__p2, __p, __len - __declen);
__newlen += __len - __declen;
}
__len = __newlen;
}
#pragma empty_line
// The following code uses vsnprintf (or vsprintf(), when
// _GLIBCXX_USE_C99 is not defined) to convert floating point values
// for insertion into a stream. An optimization would be to replace
// them with code that works directly on a wide buffer and then use
// __pad to do the padding. It would be good to replace them anyway
// to gain back the efficiency that C++ provides by knowing up front
// the type of the values to insert. Also, sprintf is dangerous
// since may lead to accidental buffer overruns. This
// implementation follows the C++ standard fairly directly as
// outlined in 22.2.2.2 [lib.locale.num.put]
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
// Use default precision if out of range.
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
// [22.2.2.2.2] Stage 1, numeric conversion to character.
int __len;
// Long enough for the max format spec.
char __fbuf[16];
__num_base::_S_format_float(__io, __fbuf, __mod);
#pragma empty_line
#pragma empty_line
// First try a buffer perhaps big enough (most probably sufficient
// for non-ios_base::fixed outputs)
int __cs_size = __max_digits * 3;
char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
__len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
__fbuf, __prec, __v);
#pragma empty_line
// If the buffer was not large enough, try again with the correct size.
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,
__fbuf, __prec, __v);
}
#pragma line 1026 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.tcc" 3
// [22.2.2.2.2] Stage 2, convert to char_type, using correct
// numpunct.decimal_point() values for '.' and adding grouping.
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
// Replace decimal point.
_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
// Add grouping, if necessary.
// N.B. Make sure to not group things like 2e20, i.e., no decimal
// point, scientific notation.
if (__lc->_M_use_grouping
&& (__wp || __len < 3 || (__cs[1] <= '9' && __cs[2] <= '9'
&& __cs[1] >= '0' && __cs[2] >= '0')))
{
// Grouping can add (almost) as many separators as the
// number of digits, but no more.
_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
// Pad.
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
// [22.2.2.2.2] Stage 4.
// Write resulting, fully-formatted string to output iterator.
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 1153 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/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 empty_line
// Construct correctly padded string, as per 22.2.2.2.2
// Assumes
// __newlen > __oldlen
// __news is allocated for __newlen size
#pragma empty_line
// NB: Of the two parameters, _CharT can be deduced from the
// function arguments. The other (_Traits) has to be explicitly specified.
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
// Padding last.
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)
{
// Pad after the sign, if there is one.
// Pad after 0[xX], if there is one.
// Who came up with these rules, anyway? Jeeze.
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;
}
// else Padding first.
}
_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
// Inhibit implicit instantiations for required instantiations,
// which are defined via explicit instantiations elsewhere.
#pragma empty_line
extern template class numpunct<char>;
extern template class 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 numpunct<wchar_t>;
extern template class 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
} // namespace
#pragma line 2608 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 2 3
#pragma line 39 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_ios.h" 2 3
#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 empty_line
// 27.4.5 Template class basic_ios
/**
* @brief Virtual base class for all stream classes.
* @ingroup io
*
* Most of the member functions called dispatched on stream objects
* (e.g., @c std::cout.foo(bar);) are consolidated in this class.
*/
template<typename _CharT, typename _Traits>
class basic_ios : public ios_base
{
public:
//@{
/**
* These are standard types. They permit a standardized way of
* referring to names of (or names dependant on) the template
* parameters, which are specific to the implementation.
*/
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
//@{
/**
* These are non-standard types.
*/
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
// Data members:
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
// Cached use_facet<ctype>, which is based on the current locale info.
const __ctype_type* _M_ctype;
// For ostream.
const __num_put_type* _M_num_put;
// For istream.
const __num_get_type* _M_num_get;
#pragma empty_line
public:
//@{
/**
* @brief The quick-and-easy status check.
*
* This allows you to write constructs such as
* <code>if (!a_stream) ...</code> and <code>while (a_stream) ...</code>
*/
operator void*() const
{ return this->fail() ? 0 : const_cast<basic_ios*>(this); }
#pragma empty_line
bool
operator!() const
{ return this->fail(); }
//@}
#pragma empty_line
/**
* @brief Returns the error state of the stream buffer.
* @return A bit pattern (well, isn't everything?)
*
* See std::ios_base::iostate for the possible bit values. Most
* users will call one of the interpreting wrappers, e.g., good().
*/
iostate
rdstate() const
{ return _M_streambuf_state; }
#pragma empty_line
/**
* @brief [Re]sets the error state.
* @param state The new state flag(s) to set.
*
* See std::ios_base::iostate for the possible bit values. Most
* users will not need to pass an argument.
*/
void
clear(iostate __state = goodbit);
#pragma empty_line
/**
* @brief Sets additional flags in the error state.
* @param state The additional state flag(s) to set.
*
* See std::ios_base::iostate for the possible bit values.
*/
void
setstate(iostate __state)
{ this->clear(this->rdstate() | __state); }
#pragma empty_line
// Flip the internal state on for the proper state bits, then re
// throws the propagated exception if bit also set in
// exceptions().
void
_M_setstate(iostate __state)
{
// 27.6.1.2.1 Common requirements.
// Turn this on without causing an ios::failure to be thrown.
_M_streambuf_state |= __state;
if (this->exceptions() & __state)
;
}
#pragma empty_line
/**
* @brief Fast error checking.
* @return True if no error flags are set.
*
* A wrapper around rdstate.
*/
bool
good() const
{ return this->rdstate() == 0; }
#pragma empty_line
/**
* @brief Fast error checking.
* @return True if the eofbit is set.
*
* Note that other iostate flags may also be set.
*/
bool
eof() const
{ return (this->rdstate() & eofbit) != 0; }
#pragma empty_line
/**
* @brief Fast error checking.
* @return True if either the badbit or the failbit is set.
*
* Checking the badbit in fail() is historical practice.
* Note that other iostate flags may also be set.
*/
bool
fail() const
{ return (this->rdstate() & (badbit | failbit)) != 0; }
#pragma empty_line
/**
* @brief Fast error checking.
* @return True if the badbit is set.
*
* Note that other iostate flags may also be set.
*/
bool
bad() const
{ return (this->rdstate() & badbit) != 0; }
#pragma empty_line
/**
* @brief Throwing exceptions on errors.
* @return The current exceptions mask.
*
* This changes nothing in the stream. See the one-argument version
* of exceptions(iostate) for the meaning of the return value.
*/
iostate
exceptions() const
{ return _M_exception; }
#pragma empty_line
/**
* @brief Throwing exceptions on errors.
* @param except The new exceptions mask.
*
* By default, error flags are set silently. You can set an
* exceptions mask for each stream; if a bit in the mask becomes set
* in the error flags, then an exception of type
* std::ios_base::failure is thrown.
*
* If the error flag is already set when the exceptions mask is
* added, the exception is immediately thrown. Try running the
* following under GCC 3.1 or later:
* @code
* #include <iostream>
* #include <fstream>
* #include <exception>
*
* int main()
* {
* std::set_terminate (__gnu_cxx::__verbose_terminate_handler);
*
* std::ifstream f ("/etc/motd");
*
* std::cerr << "Setting badbit\n";
* f.setstate (std::ios_base::badbit);
*
* std::cerr << "Setting exception mask\n";
* f.exceptions (std::ios_base::badbit);
* }
* @endcode
*/
void
exceptions(iostate __except)
{
_M_exception = __except;
this->clear(_M_streambuf_state);
}
#pragma empty_line
// Constructor/destructor:
/**
* @brief Constructor performs initialization.
*
* The parameter is passed by derived streams.
*/
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
/**
* @brief Empty.
*
* The destructor does nothing. More specifically, it does not
* destroy the streambuf held by rdbuf().
*/
virtual
~basic_ios() { }
#pragma empty_line
// Members:
/**
* @brief Fetches the current @e tied stream.
* @return A pointer to the tied stream, or NULL if the stream is
* not tied.
*
* A stream may be @e tied (or synchronized) to a second output
* stream. When this stream performs any I/O, the tied stream is
* first flushed. For example, @c std::cin is tied to @c std::cout.
*/
basic_ostream<_CharT, _Traits>*
tie() const
{ return _M_tie; }
#pragma empty_line
/**
* @brief Ties this stream to an output stream.
* @param tiestr The output stream.
* @return The previously tied output stream, or NULL if the stream
* was not tied.
*
* This sets up a new tie; see tie() for more.
*/
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
/**
* @brief Accessing the underlying buffer.
* @return The current stream buffer.
*
* This does not change the state of the stream.
*/
basic_streambuf<_CharT, _Traits>*
rdbuf() const
{ return _M_streambuf; }
#pragma empty_line
/**
* @brief Changing the underlying buffer.
* @param sb The new stream buffer.
* @return The previous stream buffer.
*
* Associates a new buffer with the current stream, and clears the
* error state.
*
* Due to historical accidents which the LWG refuses to correct, the
* I/O library suffers from a design error: this function is hidden
* in derived classes by overrides of the zero-argument @c rdbuf(),
* which is non-virtual for hysterical raisins. As a result, you
* must use explicit qualifications to access this function via any
* derived class. For example:
*
* @code
* std::fstream foo; // or some other derived type
* std::streambuf* p = .....;
*
* foo.ios::rdbuf(p); // ios == basic_ios<char>
* @endcode
*/
basic_streambuf<_CharT, _Traits>*
rdbuf(basic_streambuf<_CharT, _Traits>* __sb);
#pragma empty_line
/**
* @brief Copies fields of __rhs into this.
* @param __rhs The source values for the copies.
* @return Reference to this object.
*
* All fields of __rhs are copied into this object except that rdbuf()
* and rdstate() remain unchanged. All values in the pword and iword
* arrays are copied. Before copying, each callback is invoked with
* erase_event. After copying, each (new) callback is invoked with
* copyfmt_event. The final step is to copy exceptions().
*/
basic_ios&
copyfmt(const basic_ios& __rhs);
#pragma empty_line
/**
* @brief Retrieves the @a empty character.
* @return The current fill character.
*
* It defaults to a space (' ') in the current locale.
*/
char_type
fill() const
{
if (!_M_fill_init)
{
_M_fill = this->widen(' ');
_M_fill_init = true;
}
return _M_fill;
}
#pragma empty_line
/**
* @brief Sets a new @a empty character.
* @param ch The new character.
* @return The previous fill character.
*
* The fill character is used to fill out space when P+ characters
* have been requested (e.g., via setw), Q characters are actually
* used, and Q<P. It defaults to a space (' ') in the current locale.
*/
char_type
fill(char_type __ch)
{
char_type __old = this->fill();
_M_fill = __ch;
return __old;
}
#pragma empty_line
// Locales:
/**
* @brief Moves to a new locale.
* @param loc The new locale.
* @return The previous locale.
*
* Calls @c ios_base::imbue(loc), and if a stream buffer is associated
* with this stream, calls that buffer's @c pubimbue(loc).
*
* Additional l10n notes are at
* http://gcc.gnu.org/onlinedocs/libstdc++/manual/localization.html
*/
locale
imbue(const locale& __loc);
#pragma empty_line
/**
* @brief Squeezes characters.
* @param c The character to narrow.
* @param dfault The character to narrow.
* @return The narrowed character.
*
* Maps a character of @c char_type to a character of @c char,
* if possible.
*
* Returns the result of
* @code
* std::use_facet<ctype<char_type> >(getloc()).narrow(c,dfault)
* @endcode
*
* Additional l10n notes are at
* http://gcc.gnu.org/onlinedocs/libstdc++/manual/localization.html
*/
char
narrow(char_type __c, char __dfault) const
{ return __check_facet(_M_ctype).narrow(__c, __dfault); }
#pragma empty_line
/**
* @brief Widens characters.
* @param c The character to widen.
* @return The widened character.
*
* Maps a character of @c char to a character of @c char_type.
*
* Returns the result of
* @code
* std::use_facet<ctype<char_type> >(getloc()).widen(c)
* @endcode
*
* Additional l10n notes are at
* http://gcc.gnu.org/onlinedocs/libstdc++/manual/localization.html
*/
char_type
widen(char __c) const
{ return __check_facet(_M_ctype).widen(__c); }
#pragma empty_line
protected:
// 27.4.5.1 basic_ios constructors
/**
* @brief Empty.
*
* The default constructor does nothing and is not normally
* accessible to users.
*/
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
/**
* @brief All setup is performed here.
*
* This is called from the public constructor. It is not virtual and
* cannot be redefined.
*/
void
init(basic_streambuf<_CharT, _Traits>* __sb);
#pragma empty_line
void
_M_cache_locale(const locale& __loc);
};
#pragma empty_line
#pragma empty_line
} // namespace
#pragma empty_line
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_ios.tcc" 1 3
// basic_ios member functions -*- C++ -*-
#pragma empty_line
// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
// 2009, 2010, 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file bits/basic_ios.tcc
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{ios}
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 34 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/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)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 292. effects of a.copyfmt (a)
if (this != &__rhs)
{
// Per 27.1.1, do not call imbue, yet must trash all caches
// associated with imbue()
#pragma empty_line
// Alloc any new word array first, so if it fails we have "rollback".
_Words* __words = (__rhs._M_word_size <= _S_local_word_size) ?
_M_local_word : new _Words[__rhs._M_word_size];
#pragma empty_line
// Bump refs before doing callbacks, for safety.
_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
// NB: Don't want any added during above.
_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
// The next is required to be the last assignment.
this->exceptions(__rhs.exceptions());
}
return *this;
}
#pragma empty_line
// Locales:
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)
{
// NB: This may be called more than once on the same object.
ios_base::_M_init();
#pragma empty_line
// Cache locale data and specific facets used by iostreams.
_M_cache_locale(_M_ios_locale);
#pragma empty_line
// NB: The 27.4.4.1 Postconditions Table specifies requirements
// after basic_ios::init() has been called. As part of this,
// fill() must return widen(' ') any time after init() has been
// called, which needs an imbued ctype facet of char_type to
// return without throwing an exception. Unfortunately,
// ctype<char_type> is not necessarily a required facet, so
// streams with char_type != [char, wchar_t] will not have it by
// default. Because of this, the correct value for _M_fill is
// constructed on the first call of fill(). That way,
// unformatted input and output with non-required basic_ios
// instantiations is possible even without imbuing the expected
// ctype<char_type> facet.
_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
// Inhibit implicit instantiations for required instantiations,
// which are defined via explicit instantiations elsewhere.
#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
} // namespace std
#pragma line 473 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_ios.h" 2 3
#pragma line 45 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ios" 2 3
#pragma line 40 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ostream" 2 3
#pragma empty_line
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
// [27.6.2.1] Template class basic_ostream
/**
* @brief Controlling output.
* @ingroup io
*
* This is the base class for all output streams. It provides text
* formatting of all builtin types, and communicates with any class
* derived from basic_streambuf to do the actual output.
*/
template<typename _CharT, typename _Traits>
class basic_ostream : virtual public basic_ios<_CharT, _Traits>
{
public:
// Types (inherited from basic_ios (27.4.4)):
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
// Non-standard Types:
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 empty_line
// [27.6.2.2] constructor/destructor
/**
* @brief Base constructor.
*
* This ctor is almost never called by the user directly, rather from
* derived classes' initialization lists, which pass a pointer to
* their own stream buffer.
*/
explicit
basic_ostream(__streambuf_type* __sb)
{ this->init(__sb); }
#pragma empty_line
/**
* @brief Base destructor.
*
* This does very little apart from providing a virtual base dtor.
*/
virtual
~basic_ostream() { }
#pragma empty_line
// [27.6.2.3] prefix/suffix
class sentry;
friend class sentry;
#pragma empty_line
// [27.6.2.5] formatted output
// [27.6.2.5.3] basic_ostream::operator<<
//@{
/**
* @brief Interface for manipulators.
*
* Manipulators such as @c std::endl and @c std::hex use these
* functions in constructs like "std::cout << std::endl". For more
* information, see the iomanip header.
*/
__ostream_type&
operator<<(__ostream_type& (*__pf)(__ostream_type&))
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 60. What is a formatted input function?
// The inserters for manipulators are *not* formatted output functions.
return __pf(*this);
}
#pragma empty_line
__ostream_type&
operator<<(__ios_type& (*__pf)(__ios_type&))
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 60. What is a formatted input function?
// The inserters for manipulators are *not* formatted output functions.
__pf(*this);
return *this;
}
#pragma empty_line
__ostream_type&
operator<<(ios_base& (*__pf) (ios_base&))
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 60. What is a formatted input function?
// The inserters for manipulators are *not* formatted output functions.
__pf(*this);
return *this;
}
//@}
#pragma empty_line
// [27.6.2.5.2] arithmetic inserters
/**
* @name Arithmetic Inserters
*
* All the @c operator<< functions (aka <em>formatted output
* functions</em>) have some common behavior. Each starts by
* constructing a temporary object of type std::basic_ostream::sentry.
* This can have several effects, concluding with the setting of a
* status flag; see the sentry documentation for more.
*
* If the sentry status is good, the function tries to generate
* whatever data is appropriate for the type of the argument.
*
* If an exception is thrown during insertion, ios_base::badbit
* will be turned on in the stream's error state without causing an
* ios_base::failure to be thrown. The original exception will then
* be rethrown.
*/
//@{
/**
* @brief Basic arithmetic inserters
* @param A variable of builtin type.
* @return @c *this if successful
*
* These functions use the stream's current locale (specifically, the
* @c num_get facet) to perform numeric formatting.
*/
__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)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 117. basic_ostream uses nonexistent num_put member functions.
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)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 117. basic_ostream uses nonexistent num_put member functions.
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 empty_line
#pragma empty_line
__ostream_type&
operator<<(double __f)
{ return _M_insert(__f); }
#pragma empty_line
__ostream_type&
operator<<(float __f)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 117. basic_ostream uses nonexistent num_put member functions.
return _M_insert(static_cast<double>(__f));
}
#pragma empty_line
__ostream_type&
operator<<(long double __f)
{ return _M_insert(__f); }
#pragma empty_line
__ostream_type&
operator<<(const void* __p)
{ return _M_insert(__p); }
#pragma empty_line
/**
* @brief Extracting from another streambuf.
* @param sb A pointer to a streambuf
*
* This function behaves like one of the basic arithmetic extractors,
* in that it also constructs a sentry object and has the same error
* handling behavior.
*
* If @a sb is NULL, the stream will set failbit in its error state.
*
* Characters are extracted from @a sb and inserted into @c *this
* until one of the following occurs:
*
* - the input stream reaches end-of-file,
* - insertion into the output sequence fails (in this case, the
* character that would have been inserted is not extracted), or
* - an exception occurs while getting a character from @a sb, which
* sets failbit in the error state
*
* If the function inserts no characters, failbit is set.
*/
__ostream_type&
operator<<(__streambuf_type* __sb);
//@}
#pragma empty_line
// [27.6.2.6] unformatted output functions
/**
* @name Unformatted Output Functions
*
* All the unformatted output functions have some common behavior.
* Each starts by constructing a temporary object of type
* std::basic_ostream::sentry. This has several effects, concluding
* with the setting of a status flag; see the sentry documentation
* for more.
*
* If the sentry status is good, the function tries to generate
* whatever data is appropriate for the type of the argument.
*
* If an exception is thrown during insertion, ios_base::badbit
* will be turned on in the stream's error state. If badbit is on in
* the stream's exceptions mask, the exception will be rethrown
* without completing its actions.
*/
//@{
/**
* @brief Simple insertion.
* @param c The character to insert.
* @return *this
*
* Tries to insert @a c.
*
* @note This function is not overloaded on signed char and
* unsigned char.
*/
__ostream_type&
put(char_type __c);
#pragma empty_line
// Core write functionality, without sentry.
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 empty_line
/**
* @brief Character string insertion.
* @param s The array to insert.
* @param n Maximum number of characters to insert.
* @return *this
*
* Characters are copied from @a s and inserted into the stream until
* one of the following happens:
*
* - @a n characters are inserted
* - inserting into the output sequence fails (in this case, badbit
* will be set in the stream's error state)
*
* @note This function is not overloaded on signed char and
* unsigned char.
*/
__ostream_type&
write(const char_type* __s, streamsize __n);
//@}
#pragma empty_line
/**
* @brief Synchronizing the stream buffer.
* @return *this
*
* If @c rdbuf() is a null pointer, changes nothing.
*
* Otherwise, calls @c rdbuf()->pubsync(), and if that returns -1,
* sets badbit.
*/
__ostream_type&
flush();
#pragma empty_line
// [27.6.2.4] seek members
/**
* @brief Getting the current write position.
* @return A file position object.
*
* If @c fail() is not false, returns @c pos_type(-1) to indicate
* failure. Otherwise returns @c rdbuf()->pubseekoff(0,cur,out).
*/
pos_type
tellp();
#pragma empty_line
/**
* @brief Changing the current write position.
* @param pos A file position object.
* @return *this
*
* If @c fail() is not true, calls @c rdbuf()->pubseekpos(pos). If
* that function fails, sets failbit.
*/
__ostream_type&
seekp(pos_type);
#pragma empty_line
/**
* @brief Changing the current write position.
* @param off A file offset object.
* @param dir The direction in which to seek.
* @return *this
*
* If @c fail() is not true, calls @c rdbuf()->pubseekoff(off,dir).
* If that function fails, sets failbit.
*/
__ostream_type&
seekp(off_type, ios_base::seekdir);
#pragma empty_line
protected:
basic_ostream()
{ this->init(0); }
#pragma empty_line
template<typename _ValueT>
__ostream_type&
_M_insert(_ValueT __v);
};
#pragma empty_line
/**
* @brief Performs setup work for output streams.
*
* Objects of this class are created before all of the standard
* inserters are run. It is responsible for <em>exception-safe prefix and
* suffix operations</em>.
*/
template <typename _CharT, typename _Traits>
class basic_ostream<_CharT, _Traits>::sentry
{
// Data Members.
bool _M_ok;
basic_ostream<_CharT, _Traits>& _M_os;
#pragma empty_line
public:
/**
* @brief The constructor performs preparatory work.
* @param os The output stream to guard.
*
* If the stream state is good (@a os.good() is true), then if the
* stream is tied to another output stream, @c is.tie()->flush()
* is called to synchronize the output sequences.
*
* If the stream state is still good, then the sentry state becomes
* true (@a okay).
*/
explicit
sentry(basic_ostream<_CharT, _Traits>& __os);
#pragma empty_line
/**
* @brief Possibly flushes the stream.
*
* If @c ios_base::unitbuf is set in @c os.flags(), and
* @c std::uncaught_exception() is true, the sentry destructor calls
* @c flush() on the output stream.
*/
~sentry()
{
// XXX MT
if (bool(_M_os.flags() & ios_base::unitbuf) && !uncaught_exception())
{
// Can't call flush directly or else will get into recursive lock.
if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() == -1)
_M_os.setstate(ios_base::badbit);
}
}
#pragma empty_line
/**
* @brief Quick status checking.
* @return The sentry state.
*
* For ease of use, sentries may be converted to booleans. The
* return value is that of the sentry state (true == okay).
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
operator bool() const
{ return _M_ok; }
};
#pragma empty_line
// [27.6.2.5.4] character insertion templates
//@{
/**
* @brief Character inserters
* @param out An output stream.
* @param c A character.
* @return out
*
* Behaves like one of the formatted arithmetic inserters described in
* std::basic_ostream. After constructing a sentry object with good
* status, this function inserts a single character and any required
* padding (as determined by [22.2.2.2.2]). @c out.width(0) is then
* called.
*
* If @a c is of type @c char and the character type of the stream is not
* @c char, the character is widened before insertion.
*/
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
// Specialization
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
// Signed and unsigned
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 empty_line
//@{
/**
* @brief String inserters
* @param out An output stream.
* @param s A character string.
* @return out
* @pre @a s must be a non-NULL pointer
*
* Behaves like one of the formatted arithmetic inserters described in
* std::basic_ostream. After constructing a sentry object with good
* status, this function inserts @c traits::length(s) characters starting
* at @a s, widened if necessary, followed by any required padding (as
* determined by [22.2.2.2.2]). @c out.width(0) is then called.
*/
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
// Partial specializations
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
// Signed and unsigned
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 empty_line
// [27.6.2.7] standard basic_ostream manipulators
/**
* @brief Write a newline and flush the stream.
*
* This manipulator is often mistakenly used when a simple newline is
* desired, leading to poor buffering performance. See
* http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch25s02.html
* for more on this subject.
*/
template<typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits>&
endl(basic_ostream<_CharT, _Traits>& __os)
{ return flush(__os.put(__os.widen('\n'))); }
#pragma empty_line
/**
* @brief Write a null character into the output sequence.
*
* <em>Null character</em> is @c CharT() by definition. For CharT of @c char,
* this correctly writes the ASCII @c NUL character string terminator.
*/
template<typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits>&
ends(basic_ostream<_CharT, _Traits>& __os)
{ return __os.put(_CharT()); }
#pragma empty_line
/**
* @brief Flushes the output stream.
*
* This manipulator simply calls the stream's @c flush() member function.
*/
template<typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits>&
flush(basic_ostream<_CharT, _Traits>& __os)
{ return __os.flush(); }
#pragma line 585 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ostream" 3
} // namespace
#pragma empty_line
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/ostream.tcc" 1 3
// ostream classes -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010, 2011
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file bits/ostream.tcc
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{ostream}
*/
#pragma empty_line
//
// ISO C++ 14882: 27.6.2 Output streams
//
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 39 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/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)
{
// XXX MT
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;
if (true)
{
const __num_put_type& __np = __check_facet(this->_M_num_put);
if (__np.put(*this, *this, this->fill(), __v).failed())
__err |= ios_base::badbit;
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ 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)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 117. basic_ostream uses nonexistent num_put member functions.
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)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 117. basic_ostream uses nonexistent num_put member functions.
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)
{
if (true)
{
if (!__copy_streambufs(__sbin, this->rdbuf()))
__err |= ios_base::failbit;
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ 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)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 60. What is a formatted input function?
// basic_ostream::put(char_type) is an unformatted output function.
// DR 63. Exception-handling policy for unformatted output.
// Unformatted output functions should catch exceptions thrown
// from streambuf members.
sentry __cerb(*this);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
if (true)
{
const int_type __put = this->rdbuf()->sputc(__c);
if (traits_type::eq_int_type(__put, traits_type::eof()))
__err |= ios_base::badbit;
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ 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)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 60. What is a formatted input function?
// basic_ostream::write(const char_type*, streamsize) is an
// unformatted output function.
// DR 63. Exception-handling policy for unformatted output.
// Unformatted output functions should catch exceptions thrown
// from streambuf members.
sentry __cerb(*this);
if (__cerb)
{
if (true)
{ _M_write(__s, __n); }
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ 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()
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 60. What is a formatted input function?
// basic_ostream::flush() is *not* an unformatted output function.
ios_base::iostate __err = ios_base::goodbit;
if (true)
{
if (this->rdbuf() && this->rdbuf()->pubsync() == -1)
__err |= ios_base::badbit;
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ 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);
if (true)
{
if (!this->fail())
__ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ 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;
if (true)
{
if (!this->fail())
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 136. seekp, seekg setting wrong streams?
const pos_type __p = this->rdbuf()->pubseekpos(__pos,
ios_base::out);
#pragma empty_line
// 129. Need error indication from seekp() and seekg()
if (__p == pos_type(off_type(-1)))
__err |= ios_base::failbit;
}
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ 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;
if (true)
{
if (!this->fail())
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 136. seekp, seekg setting wrong streams?
const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
ios_base::out);
#pragma empty_line
// 129. Need error indication from seekp() and seekg()
if (__p == pos_type(off_type(-1)))
__err |= ios_base::failbit;
}
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ 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
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 167. Improper use of traits_type::length()
const size_t __clen = char_traits<char>::length(__s);
if (true)
{
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);
}
if (false)
{
__out._M_setstate(ios_base::badbit);
;
}
if (false)
{ __out._M_setstate(ios_base::badbit); }
}
return __out;
}
#pragma empty_line
// Inhibit implicit instantiations for required instantiations,
// which are defined via explicit instantiations elsewhere.
#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
} // namespace std
#pragma line 588 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ostream" 2 3
#pragma line 40 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/iostream" 2 3
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/istream" 1 3
// Input streams -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010, 2011
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
//
// ISO C++ 14882: 27.6.1 Input streams
//
#pragma empty_line
/** @file include/istream
* This is a Standard C++ Library header.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 38 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/istream" 3
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
// [27.6.1.1] Template class basic_istream
/**
* @brief Controlling input.
* @ingroup io
*
* This is the base class for all input streams. It provides text
* formatting of all builtin types, and communicates with any class
* derived from basic_streambuf to do the actual input.
*/
template<typename _CharT, typename _Traits>
class basic_istream : virtual public basic_ios<_CharT, _Traits>
{
public:
// Types (inherited from basic_ios (27.4.4)):
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
// Non-standard Types:
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:
// Data Members:
/**
* The number of characters extracted in the previous unformatted
* function; see gcount().
*/
streamsize _M_gcount;
#pragma empty_line
public:
// [27.6.1.1.1] constructor/destructor
/**
* @brief Base constructor.
*
* This ctor is almost never called by the user directly, rather from
* derived classes' initialization lists, which pass a pointer to
* their own stream buffer.
*/
explicit
basic_istream(__streambuf_type* __sb)
: _M_gcount(streamsize(0))
{ this->init(__sb); }
#pragma empty_line
/**
* @brief Base destructor.
*
* This does very little apart from providing a virtual base dtor.
*/
virtual
~basic_istream()
{ _M_gcount = streamsize(0); }
#pragma empty_line
// [27.6.1.1.2] prefix/suffix
class sentry;
friend class sentry;
#pragma empty_line
// [27.6.1.2] formatted input
// [27.6.1.2.3] basic_istream::operator>>
//@{
/**
* @brief Interface for manipulators.
*
* Manipulators such as @c std::ws and @c std::dec use these
* functions in constructs like
* <code>std::cin >> std::ws</code>.
* For more information, see the iomanip header.
*/
__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 empty_line
// [27.6.1.2.2] arithmetic extractors
/**
* @name Arithmetic Extractors
*
* All the @c operator>> functions (aka <em>formatted input
* functions</em>) have some common behavior. Each starts by
* constructing a temporary object of type std::basic_istream::sentry
* with the second argument (noskipws) set to false. This has several
* effects, concluding with the setting of a status flag; see the
* sentry documentation for more.
*
* If the sentry status is good, the function tries to extract
* whatever data is appropriate for the type of the argument.
*
* If an exception is thrown during extraction, ios_base::badbit
* will be turned on in the stream's error state without causing an
* ios_base::failure to be thrown. The original exception will then
* be rethrown.
*/
//@{
/**
* @brief Basic arithmetic extractors
* @param A variable of builtin type.
* @return @c *this if successful
*
* These functions use the stream's current locale (specifically, the
* @c num_get facet) to parse the input data.
*/
__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 empty_line
#pragma empty_line
__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 empty_line
__istream_type&
operator>>(void*& __p)
{ return _M_extract(__p); }
#pragma empty_line
/**
* @brief Extracting into another streambuf.
* @param sb A pointer to a streambuf
*
* This function behaves like one of the basic arithmetic extractors,
* in that it also constructs a sentry object and has the same error
* handling behavior.
*
* If @a sb is NULL, the stream will set failbit in its error state.
*
* Characters are extracted from this stream and inserted into the
* @a sb streambuf until one of the following occurs:
*
* - the input stream reaches end-of-file,
* - insertion into the output buffer fails (in this case, the
* character that would have been inserted is not extracted), or
* - an exception occurs (and in this case is caught)
*
* If the function inserts no characters, failbit is set.
*/
__istream_type&
operator>>(__streambuf_type* __sb);
//@}
#pragma empty_line
// [27.6.1.3] unformatted input
/**
* @brief Character counting
* @return The number of characters extracted by the previous
* unformatted input function dispatched for this stream.
*/
streamsize
gcount() const
{ return _M_gcount; }
#pragma empty_line
/**
* @name Unformatted Input Functions
*
* All the unformatted input functions have some common behavior.
* Each starts by constructing a temporary object of type
* std::basic_istream::sentry with the second argument (noskipws)
* set to true. This has several effects, concluding with the
* setting of a status flag; see the sentry documentation for more.
*
* If the sentry status is good, the function tries to extract
* whatever data is appropriate for the type of the argument.
*
* The number of characters extracted is stored for later retrieval
* by gcount().
*
* If an exception is thrown during extraction, ios_base::badbit
* will be turned on in the stream's error state without causing an
* ios_base::failure to be thrown. The original exception will then
* be rethrown.
*/
//@{
/**
* @brief Simple extraction.
* @return A character, or eof().
*
* Tries to extract a character. If none are available, sets failbit
* and returns traits::eof().
*/
int_type
get();
#pragma empty_line
/**
* @brief Simple extraction.
* @param c The character in which to store data.
* @return *this
*
* Tries to extract a character and store it in @a c. If none are
* available, sets failbit and returns traits::eof().
*
* @note This function is not overloaded on signed char and
* unsigned char.
*/
__istream_type&
get(char_type& __c);
#pragma empty_line
/**
* @brief Simple multiple-character extraction.
* @param s Pointer to an array.
* @param n Maximum number of characters to store in @a s.
* @param delim A "stop" character.
* @return *this
*
* Characters are extracted and stored into @a s until one of the
* following happens:
*
* - @c n-1 characters are stored
* - the input sequence reaches EOF
* - the next character equals @a delim, in which case the character
* is not extracted
*
* If no characters are stored, failbit is set in the stream's error
* state.
*
* In any case, a null character is stored into the next location in
* the array.
*
* @note This function is not overloaded on signed char and
* unsigned char.
*/
__istream_type&
get(char_type* __s, streamsize __n, char_type __delim);
#pragma empty_line
/**
* @brief Simple multiple-character extraction.
* @param s Pointer to an array.
* @param n Maximum number of characters to store in @a s.
* @return *this
*
* Returns @c get(s,n,widen('\\n')).
*/
__istream_type&
get(char_type* __s, streamsize __n)
{ return this->get(__s, __n, this->widen('\n')); }
#pragma empty_line
/**
* @brief Extraction into another streambuf.
* @param sb A streambuf in which to store data.
* @param delim A "stop" character.
* @return *this
*
* Characters are extracted and inserted into @a sb until one of the
* following happens:
*
* - the input sequence reaches EOF
* - insertion into the output buffer fails (in this case, the
* character that would have been inserted is not extracted)
* - the next character equals @a delim (in this case, the character
* is not extracted)
* - an exception occurs (and in this case is caught)
*
* If no characters are stored, failbit is set in the stream's error
* state.
*/
__istream_type&
get(__streambuf_type& __sb, char_type __delim);
#pragma empty_line
/**
* @brief Extraction into another streambuf.
* @param sb A streambuf in which to store data.
* @return *this
*
* Returns @c get(sb,widen('\\n')).
*/
__istream_type&
get(__streambuf_type& __sb)
{ return this->get(__sb, this->widen('\n')); }
#pragma empty_line
/**
* @brief String extraction.
* @param s A character array in which to store the data.
* @param n Maximum number of characters to extract.
* @param delim A "stop" character.
* @return *this
*
* Extracts and stores characters into @a s until one of the
* following happens. Note that these criteria are required to be
* tested in the order listed here, to allow an input line to exactly
* fill the @a s array without setting failbit.
*
* -# the input sequence reaches end-of-file, in which case eofbit
* is set in the stream error state
* -# the next character equals @c delim, in which case the character
* is extracted (and therefore counted in @c gcount()) but not stored
* -# @c n-1 characters are stored, in which case failbit is set
* in the stream error state
*
* If no characters are extracted, failbit is set. (An empty line of
* input should therefore not cause failbit to be set.)
*
* In any case, a null character is stored in the next location in
* the array.
*/
__istream_type&
getline(char_type* __s, streamsize __n, char_type __delim);
#pragma empty_line
/**
* @brief String extraction.
* @param s A character array in which to store the data.
* @param n Maximum number of characters to extract.
* @return *this
*
* Returns @c getline(s,n,widen('\\n')).
*/
__istream_type&
getline(char_type* __s, streamsize __n)
{ return this->getline(__s, __n, this->widen('\n')); }
#pragma empty_line
/**
* @brief Discarding characters
* @param n Number of characters to discard.
* @param delim A "stop" character.
* @return *this
*
* Extracts characters and throws them away until one of the
* following happens:
* - if @a n @c != @c std::numeric_limits<int>::max(), @a n
* characters are extracted
* - the input sequence reaches end-of-file
* - the next character equals @a delim (in this case, the character
* is extracted); note that this condition will never occur if
* @a delim equals @c traits::eof().
*
* NB: Provide three overloads, instead of the single function
* (with defaults) mandated by the Standard: this leads to a
* better performing implementation, while still conforming to
* the Standard.
*/
__istream_type&
ignore();
#pragma empty_line
__istream_type&
ignore(streamsize __n);
#pragma empty_line
__istream_type&
ignore(streamsize __n, int_type __delim);
#pragma empty_line
/**
* @brief Looking ahead in the stream
* @return The next character, or eof().
*
* If, after constructing the sentry object, @c good() is false,
* returns @c traits::eof(). Otherwise reads but does not extract
* the next input character.
*/
int_type
peek();
#pragma empty_line
/**
* @brief Extraction without delimiters.
* @param s A character array.
* @param n Maximum number of characters to store.
* @return *this
*
* If the stream state is @c good(), extracts characters and stores
* them into @a s until one of the following happens:
* - @a n characters are stored
* - the input sequence reaches end-of-file, in which case the error
* state is set to @c failbit|eofbit.
*
* @note This function is not overloaded on signed char and
* unsigned char.
*/
__istream_type&
read(char_type* __s, streamsize __n);
#pragma empty_line
/**
* @brief Extraction until the buffer is exhausted, but no more.
* @param s A character array.
* @param n Maximum number of characters to store.
* @return The number of characters extracted.
*
* Extracts characters and stores them into @a s depending on the
* number of characters remaining in the streambuf's buffer,
* @c rdbuf()->in_avail(), called @c A here:
* - if @c A @c == @c -1, sets eofbit and extracts no characters
* - if @c A @c == @c 0, extracts no characters
* - if @c A @c > @c 0, extracts @c min(A,n)
*
* The goal is to empty the current buffer, and to not request any
* more from the external input sequence controlled by the streambuf.
*/
streamsize
readsome(char_type* __s, streamsize __n);
#pragma empty_line
/**
* @brief Unextracting a single character.
* @param c The character to push back into the input stream.
* @return *this
*
* If @c rdbuf() is not null, calls @c rdbuf()->sputbackc(c).
*
* If @c rdbuf() is null or if @c sputbackc() fails, sets badbit in
* the error state.
*
* @note This function first clears eofbit. Since no characters
* are extracted, the next call to @c gcount() will return 0,
* as required by DR 60.
*/
__istream_type&
putback(char_type __c);
#pragma empty_line
/**
* @brief Unextracting the previous character.
* @return *this
*
* If @c rdbuf() is not null, calls @c rdbuf()->sungetc(c).
*
* If @c rdbuf() is null or if @c sungetc() fails, sets badbit in
* the error state.
*
* @note This function first clears eofbit. Since no characters
* are extracted, the next call to @c gcount() will return 0,
* as required by DR 60.
*/
__istream_type&
unget();
#pragma empty_line
/**
* @brief Synchronizing the stream buffer.
* @return 0 on success, -1 on failure
*
* If @c rdbuf() is a null pointer, returns -1.
*
* Otherwise, calls @c rdbuf()->pubsync(), and if that returns -1,
* sets badbit and returns -1.
*
* Otherwise, returns 0.
*
* @note This function does not count the number of characters
* extracted, if any, and therefore does not affect the next
* call to @c gcount().
*/
int
sync();
#pragma empty_line
/**
* @brief Getting the current read position.
* @return A file position object.
*
* If @c fail() is not false, returns @c pos_type(-1) to indicate
* failure. Otherwise returns @c rdbuf()->pubseekoff(0,cur,in).
*
* @note This function does not count the number of characters
* extracted, if any, and therefore does not affect the next
* call to @c gcount(). At variance with putback, unget and
* seekg, eofbit is not cleared first.
*/
pos_type
tellg();
#pragma empty_line
/**
* @brief Changing the current read position.
* @param pos A file position object.
* @return *this
*
* If @c fail() is not true, calls @c rdbuf()->pubseekpos(pos). If
* that function fails, sets failbit.
*
* @note This function first clears eofbit. It does not count the
* number of characters extracted, if any, and therefore does
* not affect the next call to @c gcount().
*/
__istream_type&
seekg(pos_type);
#pragma empty_line
/**
* @brief Changing the current read position.
* @param off A file offset object.
* @param dir The direction in which to seek.
* @return *this
*
* If @c fail() is not true, calls @c rdbuf()->pubseekoff(off,dir).
* If that function fails, sets failbit.
*
* @note This function first clears eofbit. It does not count the
* number of characters extracted, if any, and therefore does
* not affect the next call to @c gcount().
*/
__istream_type&
seekg(off_type, ios_base::seekdir);
//@}
#pragma empty_line
protected:
basic_istream()
: _M_gcount(streamsize(0))
{ this->init(0); }
#pragma empty_line
template<typename _ValueT>
__istream_type&
_M_extract(_ValueT& __v);
};
#pragma empty_line
// Explicit specialization declarations, defined in src/istream.cc.
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 empty_line
#pragma empty_line
/**
* @brief Performs setup work for input streams.
*
* Objects of this class are created before all of the standard
* extractors are run. It is responsible for <em>exception-safe
* prefix and suffix operations,</em> although only prefix actions
* are currently required by the standard.
*/
template<typename _CharT, typename _Traits>
class basic_istream<_CharT, _Traits>::sentry
{
// Data Members.
bool _M_ok;
#pragma empty_line
public:
/// Easy access to dependant types.
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 empty_line
/**
* @brief The constructor performs all the work.
* @param is The input stream to guard.
* @param noskipws Whether to consume whitespace or not.
*
* If the stream state is good (@a is.good() is true), then the
* following actions are performed, otherwise the sentry state
* is false (<em>not okay</em>) and failbit is set in the
* stream state.
*
* The sentry's preparatory actions are:
*
* -# if the stream is tied to an output stream, @c is.tie()->flush()
* is called to synchronize the output sequence
* -# if @a noskipws is false, and @c ios_base::skipws is set in
* @c is.flags(), the sentry extracts and discards whitespace
* characters from the stream. The currently imbued locale is
* used to determine whether each character is whitespace.
*
* If the stream state is still good, then the sentry state becomes
* true (@a okay).
*/
explicit
sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
#pragma empty_line
/**
* @brief Quick status checking.
* @return The sentry state.
*
* For ease of use, sentries may be converted to booleans. The
* return value is that of the sentry state (true == okay).
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
operator bool() const
{ return _M_ok; }
};
#pragma empty_line
// [27.6.1.2.3] character extraction templates
//@{
/**
* @brief Character extractors
* @param in An input stream.
* @param c A character reference.
* @return in
*
* Behaves like one of the formatted arithmetic extractors described in
* std::basic_istream. After constructing a sentry object with good
* status, this function extracts a character (if one is available) and
* stores it in @a c. Otherwise, sets failbit in the input stream.
*/
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 empty_line
//@{
/**
* @brief Character string extractors
* @param in An input stream.
* @param s A pointer to a character array.
* @return in
*
* Behaves like one of the formatted arithmetic extractors described in
* std::basic_istream. After constructing a sentry object with good
* status, this function extracts up to @c n characters and stores them
* into the array starting at @a s. @c n is defined as:
*
* - if @c width() is greater than zero, @c n is width() otherwise
* - @c n is <em>the number of elements of the largest array of *
* - @c char_type that can store a terminating @c eos.</em>
* - [27.6.1.2.3]/6
*
* Characters are extracted and stored until one of the following happens:
* - @c n-1 characters are stored
* - EOF is reached
* - the next character is whitespace according to the current locale
* - the next character is a null byte (i.e., @c charT() )
*
* @c width(0) is then called for the input stream.
*
* If no characters are extracted, sets failbit.
*/
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s);
#pragma empty_line
// Explicit specialization declaration, defined in src/istream.cc.
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 empty_line
// 27.6.1.5 Template class basic_iostream
/**
* @brief Merging istream and ostream capabilities.
* @ingroup io
*
* This class multiply inherits from the input and output stream classes
* simply to provide a single interface.
*/
template<typename _CharT, typename _Traits>
class basic_iostream
: public basic_istream<_CharT, _Traits>,
public basic_ostream<_CharT, _Traits>
{
public:
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 271. basic_iostream missing typedefs
// Types (inherited):
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
// Non-standard Types:
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef basic_ostream<_CharT, _Traits> __ostream_type;
#pragma empty_line
/**
* @brief Constructor does nothing.
*
* Both of the parent classes are initialized with the same
* streambuf pointer passed to this constructor.
*/
explicit
basic_iostream(basic_streambuf<_CharT, _Traits>* __sb)
: __istream_type(__sb), __ostream_type(__sb) { }
#pragma empty_line
/**
* @brief Destructor does nothing.
*/
virtual
~basic_iostream() { }
#pragma empty_line
protected:
basic_iostream()
: __istream_type(), __ostream_type() { }
};
#pragma empty_line
// [27.6.1.4] standard basic_istream manipulators
/**
* @brief Quick and easy way to eat whitespace
*
* This manipulator extracts whitespace characters, stopping when the
* next character is non-whitespace, or when the input sequence is empty.
* If the sequence is empty, @c eofbit is set in the stream, but not
* @c failbit.
*
* The current locale is used to distinguish whitespace characters.
*
* Example:
* @code
* MyClass mc;
*
* std::cin >> std::ws >> mc;
* @endcode
* will skip leading whitespace before calling operator>> on cin and your
* object. Note that the same effect can be achieved by creating a
* std::basic_istream::sentry inside your definition of operator>>.
*/
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
ws(basic_istream<_CharT, _Traits>& __is);
#pragma line 856 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/istream" 3
} // namespace
#pragma empty_line
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/istream.tcc" 1 3
// istream classes -*- C++ -*-
#pragma empty_line
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010, 2011
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
#pragma empty_line
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#pragma empty_line
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
#pragma empty_line
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
#pragma empty_line
/** @file bits/istream.tcc
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{istream}
*/
#pragma empty_line
//
// ISO C++ 14882: 27.6.1 Input streams
//
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 39 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/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
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 195. Should basic_istream::sentry's constructor ever
// set eofbit?
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;
if (true)
{
const __num_get_type& __ng = __check_facet(this->_M_num_get);
__ng.get(*this, 0, *this, __err, __v);
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ 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)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 118. basic_istream uses nonexistent num_get member functions.
sentry __cerb(*this, false);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
if (true)
{
long __l;
const __num_get_type& __ng = __check_facet(this->_M_num_get);
__ng.get(*this, 0, *this, __err, __l);
#pragma empty_line
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 696. istream::operator>>(int&) broken.
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);
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ 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)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 118. basic_istream uses nonexistent num_get member functions.
sentry __cerb(*this, false);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
if (true)
{
long __l;
const __num_get_type& __ng = __check_facet(this->_M_num_get);
__ng.get(*this, 0, *this, __err, __l);
#pragma empty_line
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 696. istream::operator>>(int&) broken.
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);
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ 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)
{
if (true)
{
bool __ineof;
if (!__copy_streambufs_eof(this->rdbuf(), __sbout, __ineof))
__err |= ios_base::failbit;
if (__ineof)
__err |= ios_base::eofbit;
}
if (false)
{
this->_M_setstate(ios_base::failbit);
;
}
if (false)
{ 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)
{
if (true)
{
__c = this->rdbuf()->sbumpc();
// 27.6.1.1 paragraph 3
if (!traits_type::eq_int_type(__c, __eof))
_M_gcount = 1;
else
__err |= ios_base::eofbit;
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ 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)
{
if (true)
{
const int_type __cb = this->rdbuf()->sbumpc();
// 27.6.1.1 paragraph 3
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;
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ 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)
{
if (true)
{
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;
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ this->_M_setstate(ios_base::badbit); }
}
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 243. get and getline when sentry reports failure.
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)
{
if (true)
{
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;
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ 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)
{
if (true)
{
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;
}
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ this->_M_setstate(ios_base::badbit); }
}
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 243. get and getline when sentry reports failure.
if (__n > 0)
*__s = char_type();
if (!_M_gcount)
__err |= ios_base::failbit;
if (__err)
this->setstate(__err);
return *this;
}
#pragma empty_line
// We provide three overloads, since the first two are much simpler
// than the general case. Also, the latter two can thus adopt the
// same "batchy" strategy used by getline above.
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;
if (true)
{
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;
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ 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;
if (true)
{
const int_type __eof = traits_type::eof();
__streambuf_type* __sb = this->rdbuf();
int_type __c = __sb->sgetc();
#pragma empty_line
// N.B. On LFS-enabled platforms streamsize is still 32 bits
// wide: if we want to implement the standard mandated behavior
// for n == max() (see 27.6.1.3/24) we are at risk of signed
// integer overflow: thus these contortions. Also note that,
// by definition, when more than 2G chars are actually ignored,
// _M_gcount (the return value of gcount, that is) cannot be
// really correct, being unavoidably too small.
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;
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ 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;
if (true)
{
const int_type __eof = traits_type::eof();
__streambuf_type* __sb = this->rdbuf();
int_type __c = __sb->sgetc();
#pragma empty_line
// See comment above.
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();
}
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ 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;
if (true)
{
__c = this->rdbuf()->sgetc();
if (traits_type::eq_int_type(__c, traits_type::eof()))
__err |= ios_base::eofbit;
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ 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;
if (true)
{
_M_gcount = this->rdbuf()->sgetn(__s, __n);
if (_M_gcount != __n)
__err |= (ios_base::eofbit | ios_base::failbit);
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ 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;
if (true)
{
// Cannot compare int_type with streamsize generically.
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;
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ 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)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 60. What is a formatted input function?
_M_gcount = 0;
// Clear eofbit per N3168.
this->clear(this->rdstate() & ~ios_base::eofbit);
sentry __cerb(*this, true);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
if (true)
{
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;
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ 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)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 60. What is a formatted input function?
_M_gcount = 0;
// Clear eofbit per N3168.
this->clear(this->rdstate() & ~ios_base::eofbit);
sentry __cerb(*this, true);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
if (true)
{
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;
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ 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)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR60. Do not change _M_gcount.
int __ret = -1;
sentry __cerb(*this, true);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
if (true)
{
__streambuf_type* __sb = this->rdbuf();
if (__sb)
{
if (__sb->pubsync() == -1)
__err |= ios_base::badbit;
else
__ret = 0;
}
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ 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)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR60. Do not change _M_gcount.
pos_type __ret = pos_type(-1);
sentry __cerb(*this, true);
if (__cerb)
{
if (true)
{
if (!this->fail())
__ret = this->rdbuf()->pubseekoff(0, ios_base::cur,
ios_base::in);
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ 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)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR60. Do not change _M_gcount.
// Clear eofbit per N3168.
this->clear(this->rdstate() & ~ios_base::eofbit);
sentry __cerb(*this, true);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
if (true)
{
if (!this->fail())
{
// 136. seekp, seekg setting wrong streams?
const pos_type __p = this->rdbuf()->pubseekpos(__pos,
ios_base::in);
#pragma empty_line
// 129. Need error indication from seekp() and seekg()
if (__p == pos_type(off_type(-1)))
__err |= ios_base::failbit;
}
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ 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)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR60. Do not change _M_gcount.
// Clear eofbit per N3168.
this->clear(this->rdstate() & ~ios_base::eofbit);
sentry __cerb(*this, true);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
if (true)
{
if (!this->fail())
{
// 136. seekp, seekg setting wrong streams?
const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
ios_base::in);
#pragma empty_line
// 129. Need error indication from seekp() and seekg()
if (__p == pos_type(off_type(-1)))
__err |= ios_base::failbit;
}
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
}
return *this;
}
#pragma empty_line
// 27.6.1.2.3 Character extraction templates
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;
if (true)
{
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);
}
if (false)
{
__in._M_setstate(ios_base::badbit);
;
}
if (false)
{ __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)
{
if (true)
{
// Figure out how many characters to extract.
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
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 68. Extractors for char* should store null at end
*__s = char_type();
__in.width(0);
}
if (false)
{
__in._M_setstate(ios_base::badbit);
;
}
if (false)
{ __in._M_setstate(ios_base::badbit); }
}
if (!__extracted)
__err |= ios_base::failbit;
if (__err)
__in.setstate(__err);
return __in;
}
#pragma empty_line
// 27.6.1.4 Standard basic_istream manipulators
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
// Inhibit implicit instantiations for required instantiations,
// which are defined via explicit instantiations elsewhere.
#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
} // namespace std
#pragma line 859 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/istream" 2 3
#pragma line 41 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/iostream" 2 3
#pragma empty_line
namespace std __attribute__ ((__visibility__ ("default")))
{
#pragma empty_line
#pragma empty_line
/**
* @name Standard Stream Objects
*
* The <iostream> header declares the eight <em>standard stream
* objects</em>. For other declarations, see
* http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch24.html
* and the @link iosfwd I/O forward declarations @endlink
*
* They are required by default to cooperate with the global C
* library's @c FILE streams, and to be available during program
* startup and termination. For more information, see the HOWTO
* linked to above.
*/
//@{
extern istream cin; /// Linked to standard input
extern ostream cout; /// Linked to standard output
extern ostream cerr; /// Linked to standard error (unbuffered)
extern ostream clog; /// Linked to standard error (buffered)
#pragma empty_line
#pragma empty_line
extern wistream wcin; /// Linked to standard input
extern wostream wcout; /// Linked to standard output
extern wostream wcerr; /// Linked to standard error (unbuffered)
extern wostream wclog; /// Linked to standard error (buffered)
#pragma empty_line
//@}
#pragma empty_line
// For construction of filebuffers for cout, cin, cerr, clog et. al.
static ios_base::Init __ioinit;
#pragma empty_line
#pragma empty_line
} // namespace
#pragma line 69 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_int_syn.h" 2
#pragma line 1 "/usr/include/math.h" 1 3 4
/* Declarations for math functions.
Copyright (C) 1991-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
/*
* ISO C99 Standard: 7.12 Mathematics <math.h>
*/
#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/libc-header-start.h" 1 3 4
/* Handle feature test macros at the start of a header.
Copyright (C) 2016-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
/* This header is internal to glibc and should not be included outside
of glibc headers. Headers including it must define
__GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION first. This header
cannot have multiple include guards because ISO C feature test
macros depend on the definition of the macro when an affected
header is included, not when the first system header is
included. */
#pragma line 35 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 3 4
/* ISO/IEC TR 24731-2:2010 defines the __STDC_WANT_LIB_EXT2__
macro. */
#pragma line 45 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 3 4
/* ISO/IEC TS 18661-1:2014 defines the __STDC_WANT_IEC_60559_BFP_EXT__
macro. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* ISO/IEC TS 18661-4:2015 defines the
__STDC_WANT_IEC_60559_FUNCS_EXT__ macro. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* ISO/IEC TS 18661-3:2015 defines the
__STDC_WANT_IEC_60559_TYPES_EXT__ macro. */
#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
extern "C" {
#pragma empty_line
/* Get definitions of __intmax_t and __uintmax_t. */
#pragma empty_line
#pragma empty_line
/* Get machine-dependent vector math functions declarations. */
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/math-vector.h" 1 3 4
/* Platform-specific SIMD declarations of math functions.
Copyright (C) 2014-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Get default empty definitions for simd declarations. */
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h" 1 3 4
/* Empty definitions required for __MATHCALL_VEC unfolding in mathcalls.h.
Copyright (C) 2014-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Needed definitions could be generated with:
for func in $(grep __MATHCALL_VEC math/bits/mathcalls.h |\
sed -r "s|__MATHCALL_VEC.?\(||; s|,.*||"); do
echo "#define __DECL_SIMD_${func}";
echo "#define __DECL_SIMD_${func}f";
echo "#define __DECL_SIMD_${func}l";
done
*/
#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 empty_line
/* Gather machine dependent type support. */
#pragma empty_line
#pragma empty_line
/* Value returned on overflow. With IEEE 754 floating point, this is
+Infinity, otherwise the largest representable positive value. */
#pragma line 89 "/usr/include/math.h" 3 4
/* IEEE positive infinity. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* IEEE Not A Number. */
#pragma line 108 "/usr/include/math.h" 3 4
/* Signaling NaN macros, if supported. */
#pragma line 137 "/usr/include/math.h" 3 4
/* Get __GLIBC_FLT_EVAL_METHOD. */
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/flt-eval-method.h" 1 3 4
/* Define __GLIBC_FLT_EVAL_METHOD. x86 version.
Copyright (C) 2016-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma line 139 "/usr/include/math.h" 2 3 4
#pragma empty_line
#pragma empty_line
/* Define the following typedefs.
#pragma empty_line
float_t floating-point type at least as wide as `float' used
to evaluate `float' expressions
double_t floating-point type at least as wide as `double' used
to evaluate `double' expressions
*/
#pragma empty_line
typedef float float_t;
typedef double double_t;
#pragma line 180 "/usr/include/math.h" 3 4
/* Define macros for the return values of ilogb and llogb, based on
__FP_LOGB0_IS_MIN and __FP_LOGBNAN_IS_MIN.
#pragma empty_line
FP_ILOGB0 Expands to a value returned by `ilogb (0.0)'.
FP_ILOGBNAN Expands to a value returned by `ilogb (NAN)'.
FP_LLOGB0 Expands to a value returned by `llogb (0.0)'.
FP_LLOGBNAN Expands to a value returned by `llogb (NAN)'.
#pragma empty_line
*/
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/fp-logb.h" 1 3 4
/* Define __FP_LOGB0_IS_MIN and __FP_LOGBNAN_IS_MIN. x86 version.
Copyright (C) 2016-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma line 191 "/usr/include/math.h" 2 3 4
#pragma line 221 "/usr/include/math.h" 3 4
/* Get the architecture specific values describing the floating-point
evaluation. The following symbols will get defined:
#pragma empty_line
FP_FAST_FMA
FP_FAST_FMAF
FP_FAST_FMAL
If defined it indicates that the `fma' function
generally executes about as fast as a multiply and an add.
This macro is defined only iff the `fma' function is
implemented directly with a hardware multiply-add instructions.
*/
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/fp-fast.h" 1 3 4
/* Define FP_FAST_* macros.
Copyright (C) 2016-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* The GCC 4.6 compiler will define __FP_FAST_FMA{,F,L} if the fma{,f,l}
builtins are supported. */
#pragma line 234 "/usr/include/math.h" 2 3 4
#pragma empty_line
#pragma empty_line
/* Rounding direction macros for fromfp functions. */
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 empty_line
#pragma empty_line
/* The file <bits/mathcalls.h> contains the prototypes for all the
actual math functions. These macros are used for those prototypes,
so we can easily declare each function as both `name' and `__name',
and can declare the float versions `namef' and `__namef'. */
#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
/* Prototype declarations for math classification macros helpers.
Copyright (C) 2017-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
#pragma empty_line
/* Classify given number. */
extern int __fpclassify (double __value) throw ()
__attribute__ ((__const__));
#pragma empty_line
/* Test for negative number. */
extern int __signbit (double __value) throw ()
__attribute__ ((__const__));
#pragma empty_line
/* Return 0 if VALUE is finite or NaN, +1 if it
is +Infinity, -1 if it is -Infinity. */
extern int __isinf (double __value) throw () __attribute__ ((__const__));
#pragma empty_line
/* Return nonzero if VALUE is finite and not NaN. Used by isfinite macro. */
extern int __finite (double __value) throw () __attribute__ ((__const__));
#pragma empty_line
/* Return nonzero if VALUE is not a number. */
extern int __isnan (double __value) throw () __attribute__ ((__const__));
#pragma empty_line
/* Test equality. */
extern int __iseqsig (double __x, double __y) throw ();
#pragma empty_line
/* Test for signaling NaN. */
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
/* Prototype declarations for math functions; helper file for <math.h>.
Copyright (C) 1996-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
/* NOTE: Because of the special way this file is used by <math.h>, this
file must NOT be protected from multiple inclusion as header files
usually are.
#pragma empty_line
This file provides prototype declarations for the math functions.
Most functions are declared using the macro:
#pragma empty_line
__MATHCALL (NAME,[_r], (ARGS...));
#pragma empty_line
This means there is a function `NAME' returning `double' and a function
`NAMEf' returning `float'. Each place `_Mdouble_' appears in the
prototype, that is actually `double' in the prototype for `NAME' and
`float' in the prototype for `NAMEf'. Reentrant variant functions are
called `NAME_r' and `NAMEf_r'.
#pragma empty_line
Functions returning other types like `int' are declared using the macro:
#pragma empty_line
__MATHDECL (TYPE, NAME,[_r], (ARGS...));
#pragma empty_line
This is just like __MATHCALL but for a function returning `TYPE'
instead of `_Mdouble_'. In all of these cases, there is still
both a `NAME' and a `NAMEf' that takes `float' arguments.
#pragma empty_line
Note that there must be no whitespace before the argument passed for
NAME, to make token pasting work with -traditional. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Trigonometric functions. */
#pragma empty_line
/* Arc cosine of X. */
extern double acos (double __x) throw (); extern double __acos (double __x) throw ();
/* Arc sine of X. */
extern double asin (double __x) throw (); extern double __asin (double __x) throw ();
/* Arc tangent of X. */
extern double atan (double __x) throw (); extern double __atan (double __x) throw ();
/* Arc tangent of Y/X. */
extern double atan2 (double __y, double __x) throw (); extern double __atan2 (double __y, double __x) throw ();
#pragma empty_line
/* Cosine of X. */
extern double cos (double __x) throw (); extern double __cos (double __x) throw ();
/* Sine of X. */
extern double sin (double __x) throw (); extern double __sin (double __x) throw ();
/* Tangent of X. */
extern double tan (double __x) throw (); extern double __tan (double __x) throw ();
#pragma empty_line
/* Hyperbolic functions. */
#pragma empty_line
/* Hyperbolic cosine of X. */
extern double cosh (double __x) throw (); extern double __cosh (double __x) throw ();
/* Hyperbolic sine of X. */
extern double sinh (double __x) throw (); extern double __sinh (double __x) throw ();
/* Hyperbolic tangent of X. */
extern double tanh (double __x) throw (); extern double __tanh (double __x) throw ();
#pragma empty_line
#pragma empty_line
/* Cosine and sine of X. */
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
/* Hyperbolic arc cosine of X. */
extern double acosh (double __x) throw (); extern double __acosh (double __x) throw ();
/* Hyperbolic arc sine of X. */
extern double asinh (double __x) throw (); extern double __asinh (double __x) throw ();
/* Hyperbolic arc tangent of X. */
extern double atanh (double __x) throw (); extern double __atanh (double __x) throw ();
#pragma empty_line
#pragma empty_line
/* Exponential and logarithmic functions. */
#pragma empty_line
/* Exponential function of X. */
extern double exp (double __x) throw (); extern double __exp (double __x) throw ();
#pragma empty_line
/* Break VALUE into a normalized fraction and an integral power of 2. */
extern double frexp (double __x, int *__exponent) throw (); extern double __frexp (double __x, int *__exponent) throw ();
#pragma empty_line
/* X times (two to the EXP power). */
extern double ldexp (double __x, int __exponent) throw (); extern double __ldexp (double __x, int __exponent) throw ();
#pragma empty_line
/* Natural logarithm of X. */
extern double log (double __x) throw (); extern double __log (double __x) throw ();
#pragma empty_line
/* Base-ten logarithm of X. */
extern double log10 (double __x) throw (); extern double __log10 (double __x) throw ();
#pragma empty_line
/* Break VALUE into integral and fractional parts. */
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
/* Compute exponent to base ten. */
extern double exp10 (double __x) throw (); extern double __exp10 (double __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Return exp(X) - 1. */
extern double expm1 (double __x) throw (); extern double __expm1 (double __x) throw ();
#pragma empty_line
/* Return log(1 + X). */
extern double log1p (double __x) throw (); extern double __log1p (double __x) throw ();
#pragma empty_line
/* Return the base 2 signed integral exponent of X. */
extern double logb (double __x) throw (); extern double __logb (double __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Compute base-2 exponential of X. */
extern double exp2 (double __x) throw (); extern double __exp2 (double __x) throw ();
#pragma empty_line
/* Compute base-2 logarithm of X. */
extern double log2 (double __x) throw (); extern double __log2 (double __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Power functions. */
#pragma empty_line
/* Return X to the Y power. */
extern double pow (double __x, double __y) throw (); extern double __pow (double __x, double __y) throw ();
#pragma empty_line
/* Return the square root of X. */
extern double sqrt (double __x) throw (); extern double __sqrt (double __x) throw ();
#pragma empty_line
#pragma empty_line
/* Return `sqrt(X*X + Y*Y)'. */
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
/* Return the cube root of X. */
extern double cbrt (double __x) throw (); extern double __cbrt (double __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Nearest integer, absolute value, and remainder functions. */
#pragma empty_line
/* Smallest integral value not less than X. */
extern double ceil (double __x) throw () __attribute__ ((__const__)); extern double __ceil (double __x) throw () __attribute__ ((__const__));
#pragma empty_line
/* Absolute value of X. */
extern double fabs (double __x) throw () __attribute__ ((__const__)); extern double __fabs (double __x) throw () __attribute__ ((__const__));
#pragma empty_line
/* Largest integer not greater than X. */
extern double floor (double __x) throw () __attribute__ ((__const__)); extern double __floor (double __x) throw () __attribute__ ((__const__));
#pragma empty_line
/* Floating-point modulo remainder of X/Y. */
extern double fmod (double __x, double __y) throw (); extern double __fmod (double __x, double __y) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Return 0 if VALUE is finite or NaN, +1 if it
is +Infinity, -1 if it is -Infinity. */
extern int isinf (double __value) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Return nonzero if VALUE is finite and not NaN. */
extern int finite (double __value) throw () __attribute__ ((__const__));
#pragma empty_line
/* Return the remainder of X/Y. */
extern double drem (double __x, double __y) throw (); extern double __drem (double __x, double __y) throw ();
#pragma empty_line
#pragma empty_line
/* Return the fractional part of X after dividing out `ilogb (X)'. */
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
/* Return X with its signed changed to Y's. */
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
/* Return representation of qNaN for double type. */
extern double nan (const char *__tagb) throw () __attribute__ ((__const__)); extern double __nan (const char *__tagb) throw () __attribute__ ((__const__));
#pragma line 210 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
/* Return nonzero if VALUE is not a number. */
extern int isnan (double __value) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Bessel functions. */
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
/* Error and gamma functions. */
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
/* True gamma function. */
extern double tgamma (double) throw (); extern double __tgamma (double) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Obsolete alias for `lgamma'. */
extern double gamma (double) throw (); extern double __gamma (double) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Reentrant version of lgamma. This function uses the global variable
`signgam'. The reentrant version instead takes a pointer and stores
the value through it. */
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
/* Return the integer nearest X in the direction of the
prevailing rounding mode. */
extern double rint (double __x) throw (); extern double __rint (double __x) throw ();
#pragma empty_line
/* Return X + epsilon if X < Y, X - epsilon if X > Y. */
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
/* Return X - epsilon. */
extern double nextdown (double __x) throw (); extern double __nextdown (double __x) throw ();
/* Return X + epsilon. */
extern double nextup (double __x) throw (); extern double __nextup (double __x) throw ();
#pragma empty_line
#pragma empty_line
/* Return the remainder of integer divison X / Y with infinite precision. */
extern double remainder (double __x, double __y) throw (); extern double __remainder (double __x, double __y) throw ();
#pragma empty_line
#pragma empty_line
/* Return X times (2 to the Nth power). */
extern double scalbn (double __x, int __n) throw (); extern double __scalbn (double __x, int __n) throw ();
#pragma empty_line
#pragma empty_line
/* Return the binary exponent of X, which must be nonzero. */
extern int ilogb (double __x) throw (); extern int __ilogb (double __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Like ilogb, but returning long int. */
extern long int llogb (double __x) throw (); extern long int __llogb (double __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Return X times (2 to the Nth power). */
extern double scalbln (double __x, long int __n) throw (); extern double __scalbln (double __x, long int __n) throw ();
#pragma empty_line
/* Round X to integral value in floating-point format using current
rounding direction, but do not raise inexact exception. */
extern double nearbyint (double __x) throw (); extern double __nearbyint (double __x) throw ();
#pragma empty_line
/* Round X to nearest integral value, rounding halfway cases away from
zero. */
extern double round (double __x) throw () __attribute__ ((__const__)); extern double __round (double __x) throw () __attribute__ ((__const__));
#pragma empty_line
/* Round X to the integral value in floating-point format nearest but
not larger in magnitude. */
extern double trunc (double __x) throw () __attribute__ ((__const__)); extern double __trunc (double __x) throw () __attribute__ ((__const__));
#pragma empty_line
/* Compute remainder of X and Y and put in *QUO a value with sign of x/y
and magnitude congruent `mod 2^n' to the magnitude of the integral
quotient x/y, with n >= 3. */
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
/* Conversion functions. */
#pragma empty_line
/* Round X to nearest integral value according to current rounding
direction. */
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
/* Round X to nearest integral value, rounding halfway cases away from
zero. */
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
/* Return positive difference between X and Y. */
extern double fdim (double __x, double __y) throw (); extern double __fdim (double __x, double __y) throw ();
#pragma empty_line
/* Return maximum numeric value from X and Y. */
extern double fmax (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmax (double __x, double __y) throw () __attribute__ ((__const__));
#pragma empty_line
/* Return minimum numeric value from X and Y. */
extern double fmin (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmin (double __x, double __y) throw () __attribute__ ((__const__));
#pragma empty_line
/* Multiply-add function computed as a ternary operation. */
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
/* Round X to nearest integer value, rounding halfway cases to even. */
extern double roundeven (double __x) throw () __attribute__ ((__const__)); extern double __roundeven (double __x) throw () __attribute__ ((__const__));
#pragma empty_line
/* Round X to nearest signed integer value, not raising inexact, with
control of rounding direction and width of result. */
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
/* Round X to nearest unsigned integer value, not raising inexact,
with control of rounding direction and width of result. */
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
/* Round X to nearest signed integer value, raising inexact for
non-integers, with control of rounding direction and width of
result. */
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
/* Round X to nearest unsigned integer value, raising inexact for
non-integers, with control of rounding direction and width of
result. */
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
/* Return value with maximum magnitude. */
extern double fmaxmag (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmaxmag (double __x, double __y) throw () __attribute__ ((__const__));
#pragma empty_line
/* Return value with minimum magnitude. */
extern double fminmag (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fminmag (double __x, double __y) throw () __attribute__ ((__const__));
#pragma empty_line
/* Total order operation. */
extern int totalorder (double __x, double __y) throw ()
__attribute__ ((__const__));
#pragma empty_line
/* Total order operation on absolute values. */
extern int totalordermag (double __x, double __y) throw ()
__attribute__ ((__const__));
#pragma empty_line
/* Canonicalize floating-point representation. */
extern int canonicalize (double *__cx, const double *__x) throw ();
#pragma empty_line
/* Get NaN payload. */
extern double getpayload (const double *__x) throw (); extern double __getpayload (const double *__x) throw ();
#pragma empty_line
/* Set quiet NaN payload. */
extern int setpayload (double *__x, double __payload) throw ();
#pragma empty_line
/* Set signaling NaN payload. */
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
/* Return X times (2 to the Nth power). */
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 empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Include the file of declarations again, this time using `float'
instead of `double' and appending f to each function name. */
#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/mathcalls-helper-functions.h" 1 3 4
/* Prototype declarations for math classification macros helpers.
Copyright (C) 2017-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
#pragma empty_line
/* Classify given number. */
extern int __fpclassifyf (float __value) throw ()
__attribute__ ((__const__));
#pragma empty_line
/* Test for negative number. */
extern int __signbitf (float __value) throw ()
__attribute__ ((__const__));
#pragma empty_line
/* Return 0 if VALUE is finite or NaN, +1 if it
is +Infinity, -1 if it is -Infinity. */
extern int __isinff (float __value) throw () __attribute__ ((__const__));
#pragma empty_line
/* Return nonzero if VALUE is finite and not NaN. Used by isfinite macro. */
extern int __finitef (float __value) throw () __attribute__ ((__const__));
#pragma empty_line
/* Return nonzero if VALUE is not a number. */
extern int __isnanf (float __value) throw () __attribute__ ((__const__));
#pragma empty_line
/* Test equality. */
extern int __iseqsigf (float __x, float __y) throw ();
#pragma empty_line
/* Test for signaling NaN. */
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
/* Prototype declarations for math functions; helper file for <math.h>.
Copyright (C) 1996-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
/* NOTE: Because of the special way this file is used by <math.h>, this
file must NOT be protected from multiple inclusion as header files
usually are.
#pragma empty_line
This file provides prototype declarations for the math functions.
Most functions are declared using the macro:
#pragma empty_line
__MATHCALL (NAME,[_r], (ARGS...));
#pragma empty_line
This means there is a function `NAME' returning `double' and a function
`NAMEf' returning `float'. Each place `_Mdouble_' appears in the
prototype, that is actually `double' in the prototype for `NAME' and
`float' in the prototype for `NAMEf'. Reentrant variant functions are
called `NAME_r' and `NAMEf_r'.
#pragma empty_line
Functions returning other types like `int' are declared using the macro:
#pragma empty_line
__MATHDECL (TYPE, NAME,[_r], (ARGS...));
#pragma empty_line
This is just like __MATHCALL but for a function returning `TYPE'
instead of `_Mdouble_'. In all of these cases, there is still
both a `NAME' and a `NAMEf' that takes `float' arguments.
#pragma empty_line
Note that there must be no whitespace before the argument passed for
NAME, to make token pasting work with -traditional. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Trigonometric functions. */
#pragma empty_line
/* Arc cosine of X. */
extern float acosf (float __x) throw (); extern float __acosf (float __x) throw ();
/* Arc sine of X. */
extern float asinf (float __x) throw (); extern float __asinf (float __x) throw ();
/* Arc tangent of X. */
extern float atanf (float __x) throw (); extern float __atanf (float __x) throw ();
/* Arc tangent of Y/X. */
extern float atan2f (float __y, float __x) throw (); extern float __atan2f (float __y, float __x) throw ();
#pragma empty_line
/* Cosine of X. */
extern float cosf (float __x) throw (); extern float __cosf (float __x) throw ();
/* Sine of X. */
extern float sinf (float __x) throw (); extern float __sinf (float __x) throw ();
/* Tangent of X. */
extern float tanf (float __x) throw (); extern float __tanf (float __x) throw ();
#pragma empty_line
/* Hyperbolic functions. */
#pragma empty_line
/* Hyperbolic cosine of X. */
extern float coshf (float __x) throw (); extern float __coshf (float __x) throw ();
/* Hyperbolic sine of X. */
extern float sinhf (float __x) throw (); extern float __sinhf (float __x) throw ();
/* Hyperbolic tangent of X. */
extern float tanhf (float __x) throw (); extern float __tanhf (float __x) throw ();
#pragma empty_line
#pragma empty_line
/* Cosine and sine of X. */
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
/* Hyperbolic arc cosine of X. */
extern float acoshf (float __x) throw (); extern float __acoshf (float __x) throw ();
/* Hyperbolic arc sine of X. */
extern float asinhf (float __x) throw (); extern float __asinhf (float __x) throw ();
/* Hyperbolic arc tangent of X. */
extern float atanhf (float __x) throw (); extern float __atanhf (float __x) throw ();
#pragma empty_line
#pragma empty_line
/* Exponential and logarithmic functions. */
#pragma empty_line
/* Exponential function of X. */
extern float expf (float __x) throw (); extern float __expf (float __x) throw ();
#pragma empty_line
/* Break VALUE into a normalized fraction and an integral power of 2. */
extern float frexpf (float __x, int *__exponent) throw (); extern float __frexpf (float __x, int *__exponent) throw ();
#pragma empty_line
/* X times (two to the EXP power). */
extern float ldexpf (float __x, int __exponent) throw (); extern float __ldexpf (float __x, int __exponent) throw ();
#pragma empty_line
/* Natural logarithm of X. */
extern float logf (float __x) throw (); extern float __logf (float __x) throw ();
#pragma empty_line
/* Base-ten logarithm of X. */
extern float log10f (float __x) throw (); extern float __log10f (float __x) throw ();
#pragma empty_line
/* Break VALUE into integral and fractional parts. */
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
/* Compute exponent to base ten. */
extern float exp10f (float __x) throw (); extern float __exp10f (float __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Return exp(X) - 1. */
extern float expm1f (float __x) throw (); extern float __expm1f (float __x) throw ();
#pragma empty_line
/* Return log(1 + X). */
extern float log1pf (float __x) throw (); extern float __log1pf (float __x) throw ();
#pragma empty_line
/* Return the base 2 signed integral exponent of X. */
extern float logbf (float __x) throw (); extern float __logbf (float __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Compute base-2 exponential of X. */
extern float exp2f (float __x) throw (); extern float __exp2f (float __x) throw ();
#pragma empty_line
/* Compute base-2 logarithm of X. */
extern float log2f (float __x) throw (); extern float __log2f (float __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Power functions. */
#pragma empty_line
/* Return X to the Y power. */
extern float powf (float __x, float __y) throw (); extern float __powf (float __x, float __y) throw ();
#pragma empty_line
/* Return the square root of X. */
extern float sqrtf (float __x) throw (); extern float __sqrtf (float __x) throw ();
#pragma empty_line
#pragma empty_line
/* Return `sqrt(X*X + Y*Y)'. */
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
/* Return the cube root of X. */
extern float cbrtf (float __x) throw (); extern float __cbrtf (float __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Nearest integer, absolute value, and remainder functions. */
#pragma empty_line
/* Smallest integral value not less than X. */
extern float ceilf (float __x) throw () __attribute__ ((__const__)); extern float __ceilf (float __x) throw () __attribute__ ((__const__));
#pragma empty_line
/* Absolute value of X. */
extern float fabsf (float __x) throw () __attribute__ ((__const__)); extern float __fabsf (float __x) throw () __attribute__ ((__const__));
#pragma empty_line
/* Largest integer not greater than X. */
extern float floorf (float __x) throw () __attribute__ ((__const__)); extern float __floorf (float __x) throw () __attribute__ ((__const__));
#pragma empty_line
/* Floating-point modulo remainder of X/Y. */
extern float fmodf (float __x, float __y) throw (); extern float __fmodf (float __x, float __y) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Return 0 if VALUE is finite or NaN, +1 if it
is +Infinity, -1 if it is -Infinity. */
extern int isinff (float __value) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Return nonzero if VALUE is finite and not NaN. */
extern int finitef (float __value) throw () __attribute__ ((__const__));
#pragma empty_line
/* Return the remainder of X/Y. */
extern float dremf (float __x, float __y) throw (); extern float __dremf (float __x, float __y) throw ();
#pragma empty_line
#pragma empty_line
/* Return the fractional part of X after dividing out `ilogb (X)'. */
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
/* Return X with its signed changed to Y's. */
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
/* Return representation of qNaN for double type. */
extern float nanf (const char *__tagb) throw () __attribute__ ((__const__)); extern float __nanf (const char *__tagb) throw () __attribute__ ((__const__));
#pragma line 210 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
/* Return nonzero if VALUE is not a number. */
extern int isnanf (float __value) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Bessel functions. */
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
/* Error and gamma functions. */
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
/* True gamma function. */
extern float tgammaf (float) throw (); extern float __tgammaf (float) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Obsolete alias for `lgamma'. */
extern float gammaf (float) throw (); extern float __gammaf (float) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Reentrant version of lgamma. This function uses the global variable
`signgam'. The reentrant version instead takes a pointer and stores
the value through it. */
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
/* Return the integer nearest X in the direction of the
prevailing rounding mode. */
extern float rintf (float __x) throw (); extern float __rintf (float __x) throw ();
#pragma empty_line
/* Return X + epsilon if X < Y, X - epsilon if X > Y. */
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
/* Return X - epsilon. */
extern float nextdownf (float __x) throw (); extern float __nextdownf (float __x) throw ();
/* Return X + epsilon. */
extern float nextupf (float __x) throw (); extern float __nextupf (float __x) throw ();
#pragma empty_line
#pragma empty_line
/* Return the remainder of integer divison X / Y with infinite precision. */
extern float remainderf (float __x, float __y) throw (); extern float __remainderf (float __x, float __y) throw ();
#pragma empty_line
#pragma empty_line
/* Return X times (2 to the Nth power). */
extern float scalbnf (float __x, int __n) throw (); extern float __scalbnf (float __x, int __n) throw ();
#pragma empty_line
#pragma empty_line
/* Return the binary exponent of X, which must be nonzero. */
extern int ilogbf (float __x) throw (); extern int __ilogbf (float __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Like ilogb, but returning long int. */
extern long int llogbf (float __x) throw (); extern long int __llogbf (float __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Return X times (2 to the Nth power). */
extern float scalblnf (float __x, long int __n) throw (); extern float __scalblnf (float __x, long int __n) throw ();
#pragma empty_line
/* Round X to integral value in floating-point format using current
rounding direction, but do not raise inexact exception. */
extern float nearbyintf (float __x) throw (); extern float __nearbyintf (float __x) throw ();
#pragma empty_line
/* Round X to nearest integral value, rounding halfway cases away from
zero. */
extern float roundf (float __x) throw () __attribute__ ((__const__)); extern float __roundf (float __x) throw () __attribute__ ((__const__));
#pragma empty_line
/* Round X to the integral value in floating-point format nearest but
not larger in magnitude. */
extern float truncf (float __x) throw () __attribute__ ((__const__)); extern float __truncf (float __x) throw () __attribute__ ((__const__));
#pragma empty_line
/* Compute remainder of X and Y and put in *QUO a value with sign of x/y
and magnitude congruent `mod 2^n' to the magnitude of the integral
quotient x/y, with n >= 3. */
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
/* Conversion functions. */
#pragma empty_line
/* Round X to nearest integral value according to current rounding
direction. */
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
/* Round X to nearest integral value, rounding halfway cases away from
zero. */
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
/* Return positive difference between X and Y. */
extern float fdimf (float __x, float __y) throw (); extern float __fdimf (float __x, float __y) throw ();
#pragma empty_line
/* Return maximum numeric value from X and Y. */
extern float fmaxf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fmaxf (float __x, float __y) throw () __attribute__ ((__const__));
#pragma empty_line
/* Return minimum numeric value from X and Y. */
extern float fminf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fminf (float __x, float __y) throw () __attribute__ ((__const__));
#pragma empty_line
/* Multiply-add function computed as a ternary operation. */
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
/* Round X to nearest integer value, rounding halfway cases to even. */
extern float roundevenf (float __x) throw () __attribute__ ((__const__)); extern float __roundevenf (float __x) throw () __attribute__ ((__const__));
#pragma empty_line
/* Round X to nearest signed integer value, not raising inexact, with
control of rounding direction and width of result. */
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
/* Round X to nearest unsigned integer value, not raising inexact,
with control of rounding direction and width of result. */
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
/* Round X to nearest signed integer value, raising inexact for
non-integers, with control of rounding direction and width of
result. */
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
/* Round X to nearest unsigned integer value, raising inexact for
non-integers, with control of rounding direction and width of
result. */
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
/* Return value with maximum magnitude. */
extern float fmaxmagf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fmaxmagf (float __x, float __y) throw () __attribute__ ((__const__));
#pragma empty_line
/* Return value with minimum magnitude. */
extern float fminmagf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fminmagf (float __x, float __y) throw () __attribute__ ((__const__));
#pragma empty_line
/* Total order operation. */
extern int totalorderf (float __x, float __y) throw ()
__attribute__ ((__const__));
#pragma empty_line
/* Total order operation on absolute values. */
extern int totalordermagf (float __x, float __y) throw ()
__attribute__ ((__const__));
#pragma empty_line
/* Canonicalize floating-point representation. */
extern int canonicalizef (float *__cx, const float *__x) throw ();
#pragma empty_line
/* Get NaN payload. */
extern float getpayloadf (const float *__x) throw (); extern float __getpayloadf (const float *__x) throw ();
#pragma empty_line
/* Set quiet NaN payload. */
extern int setpayloadf (float *__x, float __payload) throw ();
#pragma empty_line
/* Set signaling NaN payload. */
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
/* Return X times (2 to the Nth power). */
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 341 "/usr/include/math.h" 3 4
/* Include the file of declarations again, this time using `long double'
instead of `double' and appending l to each function name. */
#pragma empty_line
#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/mathcalls-helper-functions.h" 1 3 4
/* Prototype declarations for math classification macros helpers.
Copyright (C) 2017-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
#pragma empty_line
/* Classify given number. */
extern int __fpclassifyl (long double __value) throw ()
__attribute__ ((__const__));
#pragma empty_line
/* Test for negative number. */
extern int __signbitl (long double __value) throw ()
__attribute__ ((__const__));
#pragma empty_line
/* Return 0 if VALUE is finite or NaN, +1 if it
is +Infinity, -1 if it is -Infinity. */
extern int __isinfl (long double __value) throw () __attribute__ ((__const__));
#pragma empty_line
/* Return nonzero if VALUE is finite and not NaN. Used by isfinite macro. */
extern int __finitel (long double __value) throw () __attribute__ ((__const__));
#pragma empty_line
/* Return nonzero if VALUE is not a number. */
extern int __isnanl (long double __value) throw () __attribute__ ((__const__));
#pragma empty_line
/* Test equality. */
extern int __iseqsigl (long double __x, long double __y) throw ();
#pragma empty_line
/* Test for signaling NaN. */
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
/* Prototype declarations for math functions; helper file for <math.h>.
Copyright (C) 1996-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
/* NOTE: Because of the special way this file is used by <math.h>, this
file must NOT be protected from multiple inclusion as header files
usually are.
#pragma empty_line
This file provides prototype declarations for the math functions.
Most functions are declared using the macro:
#pragma empty_line
__MATHCALL (NAME,[_r], (ARGS...));
#pragma empty_line
This means there is a function `NAME' returning `double' and a function
`NAMEf' returning `float'. Each place `_Mdouble_' appears in the
prototype, that is actually `double' in the prototype for `NAME' and
`float' in the prototype for `NAMEf'. Reentrant variant functions are
called `NAME_r' and `NAMEf_r'.
#pragma empty_line
Functions returning other types like `int' are declared using the macro:
#pragma empty_line
__MATHDECL (TYPE, NAME,[_r], (ARGS...));
#pragma empty_line
This is just like __MATHCALL but for a function returning `TYPE'
instead of `_Mdouble_'. In all of these cases, there is still
both a `NAME' and a `NAMEf' that takes `float' arguments.
#pragma empty_line
Note that there must be no whitespace before the argument passed for
NAME, to make token pasting work with -traditional. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Trigonometric functions. */
#pragma empty_line
/* Arc cosine of X. */
extern long double acosl (long double __x) throw (); extern long double __acosl (long double __x) throw ();
/* Arc sine of X. */
extern long double asinl (long double __x) throw (); extern long double __asinl (long double __x) throw ();
/* Arc tangent of X. */
extern long double atanl (long double __x) throw (); extern long double __atanl (long double __x) throw ();
/* Arc tangent of Y/X. */
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
/* Cosine of X. */
extern long double cosl (long double __x) throw (); extern long double __cosl (long double __x) throw ();
/* Sine of X. */
extern long double sinl (long double __x) throw (); extern long double __sinl (long double __x) throw ();
/* Tangent of X. */
extern long double tanl (long double __x) throw (); extern long double __tanl (long double __x) throw ();
#pragma empty_line
/* Hyperbolic functions. */
#pragma empty_line
/* Hyperbolic cosine of X. */
extern long double coshl (long double __x) throw (); extern long double __coshl (long double __x) throw ();
/* Hyperbolic sine of X. */
extern long double sinhl (long double __x) throw (); extern long double __sinhl (long double __x) throw ();
/* Hyperbolic tangent of X. */
extern long double tanhl (long double __x) throw (); extern long double __tanhl (long double __x) throw ();
#pragma empty_line
#pragma empty_line
/* Cosine and sine of X. */
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
/* Hyperbolic arc cosine of X. */
extern long double acoshl (long double __x) throw (); extern long double __acoshl (long double __x) throw ();
/* Hyperbolic arc sine of X. */
extern long double asinhl (long double __x) throw (); extern long double __asinhl (long double __x) throw ();
/* Hyperbolic arc tangent of X. */
extern long double atanhl (long double __x) throw (); extern long double __atanhl (long double __x) throw ();
#pragma empty_line
#pragma empty_line
/* Exponential and logarithmic functions. */
#pragma empty_line
/* Exponential function of X. */
extern long double expl (long double __x) throw (); extern long double __expl (long double __x) throw ();
#pragma empty_line
/* Break VALUE into a normalized fraction and an integral power of 2. */
extern long double frexpl (long double __x, int *__exponent) throw (); extern long double __frexpl (long double __x, int *__exponent) throw ();
#pragma empty_line
/* X times (two to the EXP power). */
extern long double ldexpl (long double __x, int __exponent) throw (); extern long double __ldexpl (long double __x, int __exponent) throw ();
#pragma empty_line
/* Natural logarithm of X. */
extern long double logl (long double __x) throw (); extern long double __logl (long double __x) throw ();
#pragma empty_line
/* Base-ten logarithm of X. */
extern long double log10l (long double __x) throw (); extern long double __log10l (long double __x) throw ();
#pragma empty_line
/* Break VALUE into integral and fractional parts. */
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
/* Compute exponent to base ten. */
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
/* Return exp(X) - 1. */
extern long double expm1l (long double __x) throw (); extern long double __expm1l (long double __x) throw ();
#pragma empty_line
/* Return log(1 + X). */
extern long double log1pl (long double __x) throw (); extern long double __log1pl (long double __x) throw ();
#pragma empty_line
/* Return the base 2 signed integral exponent of X. */
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
/* Compute base-2 exponential of X. */
extern long double exp2l (long double __x) throw (); extern long double __exp2l (long double __x) throw ();
#pragma empty_line
/* Compute base-2 logarithm of X. */
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
/* Power functions. */
#pragma empty_line
/* Return X to the Y power. */
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
/* Return the square root of X. */
extern long double sqrtl (long double __x) throw (); extern long double __sqrtl (long double __x) throw ();
#pragma empty_line
#pragma empty_line
/* Return `sqrt(X*X + Y*Y)'. */
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
/* Return the cube root of X. */
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
/* Nearest integer, absolute value, and remainder functions. */
#pragma empty_line
/* Smallest integral value not less than X. */
extern long double ceill (long double __x) throw () __attribute__ ((__const__)); extern long double __ceill (long double __x) throw () __attribute__ ((__const__));
#pragma empty_line
/* Absolute value of X. */
extern long double fabsl (long double __x) throw () __attribute__ ((__const__)); extern long double __fabsl (long double __x) throw () __attribute__ ((__const__));
#pragma empty_line
/* Largest integer not greater than X. */
extern long double floorl (long double __x) throw () __attribute__ ((__const__)); extern long double __floorl (long double __x) throw () __attribute__ ((__const__));
#pragma empty_line
/* Floating-point modulo remainder of X/Y. */
extern long double fmodl (long double __x, long double __y) throw (); extern long double __fmodl (long double __x, long double __y) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Return 0 if VALUE is finite or NaN, +1 if it
is +Infinity, -1 if it is -Infinity. */
extern int isinfl (long double __value) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Return nonzero if VALUE is finite and not NaN. */
extern int finitel (long double __value) throw () __attribute__ ((__const__));
#pragma empty_line
/* Return the remainder of X/Y. */
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
/* Return the fractional part of X after dividing out `ilogb (X)'. */
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
/* Return X with its signed changed to Y's. */
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
/* Return representation of qNaN for double type. */
extern long double nanl (const char *__tagb) throw () __attribute__ ((__const__)); extern long double __nanl (const char *__tagb) throw () __attribute__ ((__const__));
#pragma line 210 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
/* Return nonzero if VALUE is not a number. */
extern int isnanl (long double __value) throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Bessel functions. */
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
/* Error and gamma functions. */
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
/* True gamma function. */
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
/* Obsolete alias for `lgamma'. */
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
/* Reentrant version of lgamma. This function uses the global variable
`signgam'. The reentrant version instead takes a pointer and stores
the value through it. */
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
/* Return the integer nearest X in the direction of the
prevailing rounding mode. */
extern long double rintl (long double __x) throw (); extern long double __rintl (long double __x) throw ();
#pragma empty_line
/* Return X + epsilon if X < Y, X - epsilon if X > Y. */
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
/* Return X - epsilon. */
extern long double nextdownl (long double __x) throw (); extern long double __nextdownl (long double __x) throw ();
/* Return X + epsilon. */
extern long double nextupl (long double __x) throw (); extern long double __nextupl (long double __x) throw ();
#pragma empty_line
#pragma empty_line
/* Return the remainder of integer divison X / Y with infinite precision. */
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
/* Return X times (2 to the Nth power). */
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
/* Return the binary exponent of X, which must be nonzero. */
extern int ilogbl (long double __x) throw (); extern int __ilogbl (long double __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Like ilogb, but returning long int. */
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
/* Return X times (2 to the Nth power). */
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
/* Round X to integral value in floating-point format using current
rounding direction, but do not raise inexact exception. */
extern long double nearbyintl (long double __x) throw (); extern long double __nearbyintl (long double __x) throw ();
#pragma empty_line
/* Round X to nearest integral value, rounding halfway cases away from
zero. */
extern long double roundl (long double __x) throw () __attribute__ ((__const__)); extern long double __roundl (long double __x) throw () __attribute__ ((__const__));
#pragma empty_line
/* Round X to the integral value in floating-point format nearest but
not larger in magnitude. */
extern long double truncl (long double __x) throw () __attribute__ ((__const__)); extern long double __truncl (long double __x) throw () __attribute__ ((__const__));
#pragma empty_line
/* Compute remainder of X and Y and put in *QUO a value with sign of x/y
and magnitude congruent `mod 2^n' to the magnitude of the integral
quotient x/y, with n >= 3. */
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
/* Conversion functions. */
#pragma empty_line
/* Round X to nearest integral value according to current rounding
direction. */
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
/* Round X to nearest integral value, rounding halfway cases away from
zero. */
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
/* Return positive difference between X and Y. */
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
/* Return maximum numeric value from X and Y. */
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
/* Return minimum numeric value from X and Y. */
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
/* Multiply-add function computed as a ternary operation. */
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
/* Round X to nearest integer value, rounding halfway cases to even. */
extern long double roundevenl (long double __x) throw () __attribute__ ((__const__)); extern long double __roundevenl (long double __x) throw () __attribute__ ((__const__));
#pragma empty_line
/* Round X to nearest signed integer value, not raising inexact, with
control of rounding direction and width of result. */
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
/* Round X to nearest unsigned integer value, not raising inexact,
with control of rounding direction and width of result. */
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
/* Round X to nearest signed integer value, raising inexact for
non-integers, with control of rounding direction and width of
result. */
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
/* Round X to nearest unsigned integer value, raising inexact for
non-integers, with control of rounding direction and width of
result. */
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
/* Return value with maximum magnitude. */
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
/* Return value with minimum magnitude. */
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
/* Total order operation. */
extern int totalorderl (long double __x, long double __y) throw ()
__attribute__ ((__const__));
#pragma empty_line
/* Total order operation on absolute values. */
extern int totalordermagl (long double __x, long double __y) throw ()
__attribute__ ((__const__));
#pragma empty_line
/* Canonicalize floating-point representation. */
extern int canonicalizel (long double *__cx, const long double *__x) throw ();
#pragma empty_line
/* Get NaN payload. */
extern long double getpayloadl (const long double *__x) throw (); extern long double __getpayloadl (const long double *__x) throw ();
#pragma empty_line
/* Set quiet NaN payload. */
extern int setpayloadl (long double *__x, long double __payload) throw ();
#pragma empty_line
/* Set signaling NaN payload. */
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
/* Return X times (2 to the Nth power). */
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 360 "/usr/include/math.h" 3 4
/* Include the file of declarations for _FloatN and _FloatNx
types. */
#pragma line 389 "/usr/include/math.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4
/* Prototype declarations for math functions; helper file for <math.h>.
Copyright (C) 1996-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
/* NOTE: Because of the special way this file is used by <math.h>, this
file must NOT be protected from multiple inclusion as header files
usually are.
#pragma empty_line
This file provides prototype declarations for the math functions.
Most functions are declared using the macro:
#pragma empty_line
__MATHCALL (NAME,[_r], (ARGS...));
#pragma empty_line
This means there is a function `NAME' returning `double' and a function
`NAMEf' returning `float'. Each place `_Mdouble_' appears in the
prototype, that is actually `double' in the prototype for `NAME' and
`float' in the prototype for `NAMEf'. Reentrant variant functions are
called `NAME_r' and `NAMEf_r'.
#pragma empty_line
Functions returning other types like `int' are declared using the macro:
#pragma empty_line
__MATHDECL (TYPE, NAME,[_r], (ARGS...));
#pragma empty_line
This is just like __MATHCALL but for a function returning `TYPE'
instead of `_Mdouble_'. In all of these cases, there is still
both a `NAME' and a `NAMEf' that takes `float' arguments.
#pragma empty_line
Note that there must be no whitespace before the argument passed for
NAME, to make token pasting work with -traditional. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Trigonometric functions. */
#pragma empty_line
/* Arc cosine of X. */
extern _Float32 acosf32 (_Float32 __x) throw (); extern _Float32 __acosf32 (_Float32 __x) throw ();
/* Arc sine of X. */
extern _Float32 asinf32 (_Float32 __x) throw (); extern _Float32 __asinf32 (_Float32 __x) throw ();
/* Arc tangent of X. */
extern _Float32 atanf32 (_Float32 __x) throw (); extern _Float32 __atanf32 (_Float32 __x) throw ();
/* Arc tangent of Y/X. */
extern _Float32 atan2f32 (_Float32 __y, _Float32 __x) throw (); extern _Float32 __atan2f32 (_Float32 __y, _Float32 __x) throw ();
#pragma empty_line
/* Cosine of X. */
extern _Float32 cosf32 (_Float32 __x) throw (); extern _Float32 __cosf32 (_Float32 __x) throw ();
/* Sine of X. */
extern _Float32 sinf32 (_Float32 __x) throw (); extern _Float32 __sinf32 (_Float32 __x) throw ();
/* Tangent of X. */
extern _Float32 tanf32 (_Float32 __x) throw (); extern _Float32 __tanf32 (_Float32 __x) throw ();
#pragma empty_line
/* Hyperbolic functions. */
#pragma empty_line
/* Hyperbolic cosine of X. */
extern _Float32 coshf32 (_Float32 __x) throw (); extern _Float32 __coshf32 (_Float32 __x) throw ();
/* Hyperbolic sine of X. */
extern _Float32 sinhf32 (_Float32 __x) throw (); extern _Float32 __sinhf32 (_Float32 __x) throw ();
/* Hyperbolic tangent of X. */
extern _Float32 tanhf32 (_Float32 __x) throw (); extern _Float32 __tanhf32 (_Float32 __x) throw ();
#pragma empty_line
#pragma empty_line
/* Cosine and sine of X. */
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
/* Hyperbolic arc cosine of X. */
extern _Float32 acoshf32 (_Float32 __x) throw (); extern _Float32 __acoshf32 (_Float32 __x) throw ();
/* Hyperbolic arc sine of X. */
extern _Float32 asinhf32 (_Float32 __x) throw (); extern _Float32 __asinhf32 (_Float32 __x) throw ();
/* Hyperbolic arc tangent of X. */
extern _Float32 atanhf32 (_Float32 __x) throw (); extern _Float32 __atanhf32 (_Float32 __x) throw ();
#pragma empty_line
#pragma empty_line
/* Exponential and logarithmic functions. */
#pragma empty_line
/* Exponential function of X. */
extern _Float32 expf32 (_Float32 __x) throw (); extern _Float32 __expf32 (_Float32 __x) throw ();
#pragma empty_line
/* Break VALUE into a normalized fraction and an integral power of 2. */
extern _Float32 frexpf32 (_Float32 __x, int *__exponent) throw (); extern _Float32 __frexpf32 (_Float32 __x, int *__exponent) throw ();
#pragma empty_line
/* X times (two to the EXP power). */
extern _Float32 ldexpf32 (_Float32 __x, int __exponent) throw (); extern _Float32 __ldexpf32 (_Float32 __x, int __exponent) throw ();
#pragma empty_line
/* Natural logarithm of X. */
extern _Float32 logf32 (_Float32 __x) throw (); extern _Float32 __logf32 (_Float32 __x) throw ();
#pragma empty_line
/* Base-ten logarithm of X. */
extern _Float32 log10f32 (_Float32 __x) throw (); extern _Float32 __log10f32 (_Float32 __x) throw ();
#pragma empty_line
/* Break VALUE into integral and fractional parts. */
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
/* Compute exponent to base ten. */
extern _Float32 exp10f32 (_Float32 __x) throw (); extern _Float32 __exp10f32 (_Float32 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Return exp(X) - 1. */
extern _Float32 expm1f32 (_Float32 __x) throw (); extern _Float32 __expm1f32 (_Float32 __x) throw ();
#pragma empty_line
/* Return log(1 + X). */
extern _Float32 log1pf32 (_Float32 __x) throw (); extern _Float32 __log1pf32 (_Float32 __x) throw ();
#pragma empty_line
/* Return the base 2 signed integral exponent of X. */
extern _Float32 logbf32 (_Float32 __x) throw (); extern _Float32 __logbf32 (_Float32 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Compute base-2 exponential of X. */
extern _Float32 exp2f32 (_Float32 __x) throw (); extern _Float32 __exp2f32 (_Float32 __x) throw ();
#pragma empty_line
/* Compute base-2 logarithm of X. */
extern _Float32 log2f32 (_Float32 __x) throw (); extern _Float32 __log2f32 (_Float32 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Power functions. */
#pragma empty_line
/* Return X to the Y power. */
extern _Float32 powf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __powf32 (_Float32 __x, _Float32 __y) throw ();
#pragma empty_line
/* Return the square root of X. */
extern _Float32 sqrtf32 (_Float32 __x) throw (); extern _Float32 __sqrtf32 (_Float32 __x) throw ();
#pragma empty_line
#pragma empty_line
/* Return `sqrt(X*X + Y*Y)'. */
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
/* Return the cube root of X. */
extern _Float32 cbrtf32 (_Float32 __x) throw (); extern _Float32 __cbrtf32 (_Float32 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Nearest integer, absolute value, and remainder functions. */
#pragma empty_line
/* Smallest integral value not less than X. */
extern _Float32 ceilf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __ceilf32 (_Float32 __x) throw () __attribute__ ((__const__));
#pragma empty_line
/* Absolute value of X. */
extern _Float32 fabsf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __fabsf32 (_Float32 __x) throw () __attribute__ ((__const__));
#pragma empty_line
/* Largest integer not greater than X. */
extern _Float32 floorf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __floorf32 (_Float32 __x) throw () __attribute__ ((__const__));
#pragma empty_line
/* Floating-point modulo remainder of X/Y. */
extern _Float32 fmodf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __fmodf32 (_Float32 __x, _Float32 __y) throw ();
#pragma line 195 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
/* Return X with its signed changed to Y's. */
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
/* Return representation of qNaN for double type. */
extern _Float32 nanf32 (const char *__tagb) throw () __attribute__ ((__const__)); extern _Float32 __nanf32 (const char *__tagb) throw () __attribute__ ((__const__));
#pragma line 216 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
/* Bessel functions. */
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
/* Error and gamma functions. */
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
/* True gamma function. */
extern _Float32 tgammaf32 (_Float32) throw (); extern _Float32 __tgammaf32 (_Float32) throw ();
#pragma line 246 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
/* Reentrant version of lgamma. This function uses the global variable
`signgam'. The reentrant version instead takes a pointer and stores
the value through it. */
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
/* Return the integer nearest X in the direction of the
prevailing rounding mode. */
extern _Float32 rintf32 (_Float32 __x) throw (); extern _Float32 __rintf32 (_Float32 __x) throw ();
#pragma empty_line
/* Return X + epsilon if X < Y, X - epsilon if X > Y. */
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
/* Return X - epsilon. */
extern _Float32 nextdownf32 (_Float32 __x) throw (); extern _Float32 __nextdownf32 (_Float32 __x) throw ();
/* Return X + epsilon. */
extern _Float32 nextupf32 (_Float32 __x) throw (); extern _Float32 __nextupf32 (_Float32 __x) throw ();
#pragma empty_line
#pragma empty_line
/* Return the remainder of integer divison X / Y with infinite precision. */
extern _Float32 remainderf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __remainderf32 (_Float32 __x, _Float32 __y) throw ();
#pragma empty_line
#pragma empty_line
/* Return X times (2 to the Nth power). */
extern _Float32 scalbnf32 (_Float32 __x, int __n) throw (); extern _Float32 __scalbnf32 (_Float32 __x, int __n) throw ();
#pragma empty_line
#pragma empty_line
/* Return the binary exponent of X, which must be nonzero. */
extern int ilogbf32 (_Float32 __x) throw (); extern int __ilogbf32 (_Float32 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Like ilogb, but returning long int. */
extern long int llogbf32 (_Float32 __x) throw (); extern long int __llogbf32 (_Float32 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Return X times (2 to the Nth power). */
extern _Float32 scalblnf32 (_Float32 __x, long int __n) throw (); extern _Float32 __scalblnf32 (_Float32 __x, long int __n) throw ();
#pragma empty_line
/* Round X to integral value in floating-point format using current
rounding direction, but do not raise inexact exception. */
extern _Float32 nearbyintf32 (_Float32 __x) throw (); extern _Float32 __nearbyintf32 (_Float32 __x) throw ();
#pragma empty_line
/* Round X to nearest integral value, rounding halfway cases away from
zero. */
extern _Float32 roundf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __roundf32 (_Float32 __x) throw () __attribute__ ((__const__));
#pragma empty_line
/* Round X to the integral value in floating-point format nearest but
not larger in magnitude. */
extern _Float32 truncf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __truncf32 (_Float32 __x) throw () __attribute__ ((__const__));
#pragma empty_line
/* Compute remainder of X and Y and put in *QUO a value with sign of x/y
and magnitude congruent `mod 2^n' to the magnitude of the integral
quotient x/y, with n >= 3. */
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
/* Conversion functions. */
#pragma empty_line
/* Round X to nearest integral value according to current rounding
direction. */
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
/* Round X to nearest integral value, rounding halfway cases away from
zero. */
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
/* Return positive difference between X and Y. */
extern _Float32 fdimf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __fdimf32 (_Float32 __x, _Float32 __y) throw ();
#pragma empty_line
/* Return maximum numeric value from X and Y. */
extern _Float32 fmaxf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern _Float32 __fmaxf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__));
#pragma empty_line
/* Return minimum numeric value from X and Y. */
extern _Float32 fminf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern _Float32 __fminf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__));
#pragma empty_line
/* Multiply-add function computed as a ternary operation. */
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
/* Round X to nearest integer value, rounding halfway cases to even. */
extern _Float32 roundevenf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __roundevenf32 (_Float32 __x) throw () __attribute__ ((__const__));
#pragma empty_line
/* Round X to nearest signed integer value, not raising inexact, with
control of rounding direction and width of result. */
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
/* Round X to nearest unsigned integer value, not raising inexact,
with control of rounding direction and width of result. */
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
/* Round X to nearest signed integer value, raising inexact for
non-integers, with control of rounding direction and width of
result. */
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
/* Round X to nearest unsigned integer value, raising inexact for
non-integers, with control of rounding direction and width of
result. */
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
/* Return value with maximum magnitude. */
extern _Float32 fmaxmagf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern _Float32 __fmaxmagf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__));
#pragma empty_line
/* Return value with minimum magnitude. */
extern _Float32 fminmagf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern _Float32 __fminmagf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__));
#pragma empty_line
/* Total order operation. */
extern int totalorderf32 (_Float32 __x, _Float32 __y) throw ()
__attribute__ ((__const__));
#pragma empty_line
/* Total order operation on absolute values. */
extern int totalordermagf32 (_Float32 __x, _Float32 __y) throw ()
__attribute__ ((__const__));
#pragma empty_line
/* Canonicalize floating-point representation. */
extern int canonicalizef32 (_Float32 *__cx, const _Float32 *__x) throw ();
#pragma empty_line
/* Get NaN payload. */
extern _Float32 getpayloadf32 (const _Float32 *__x) throw (); extern _Float32 __getpayloadf32 (const _Float32 *__x) throw ();
#pragma empty_line
/* Set quiet NaN payload. */
extern int setpayloadf32 (_Float32 *__x, _Float32 __payload) throw ();
#pragma empty_line
/* Set signaling NaN payload. */
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
/* Prototype declarations for math functions; helper file for <math.h>.
Copyright (C) 1996-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
/* NOTE: Because of the special way this file is used by <math.h>, this
file must NOT be protected from multiple inclusion as header files
usually are.
#pragma empty_line
This file provides prototype declarations for the math functions.
Most functions are declared using the macro:
#pragma empty_line
__MATHCALL (NAME,[_r], (ARGS...));
#pragma empty_line
This means there is a function `NAME' returning `double' and a function
`NAMEf' returning `float'. Each place `_Mdouble_' appears in the
prototype, that is actually `double' in the prototype for `NAME' and
`float' in the prototype for `NAMEf'. Reentrant variant functions are
called `NAME_r' and `NAMEf_r'.
#pragma empty_line
Functions returning other types like `int' are declared using the macro:
#pragma empty_line
__MATHDECL (TYPE, NAME,[_r], (ARGS...));
#pragma empty_line
This is just like __MATHCALL but for a function returning `TYPE'
instead of `_Mdouble_'. In all of these cases, there is still
both a `NAME' and a `NAMEf' that takes `float' arguments.
#pragma empty_line
Note that there must be no whitespace before the argument passed for
NAME, to make token pasting work with -traditional. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Trigonometric functions. */
#pragma empty_line
/* Arc cosine of X. */
extern _Float64 acosf64 (_Float64 __x) throw (); extern _Float64 __acosf64 (_Float64 __x) throw ();
/* Arc sine of X. */
extern _Float64 asinf64 (_Float64 __x) throw (); extern _Float64 __asinf64 (_Float64 __x) throw ();
/* Arc tangent of X. */
extern _Float64 atanf64 (_Float64 __x) throw (); extern _Float64 __atanf64 (_Float64 __x) throw ();
/* Arc tangent of Y/X. */
extern _Float64 atan2f64 (_Float64 __y, _Float64 __x) throw (); extern _Float64 __atan2f64 (_Float64 __y, _Float64 __x) throw ();
#pragma empty_line
/* Cosine of X. */
extern _Float64 cosf64 (_Float64 __x) throw (); extern _Float64 __cosf64 (_Float64 __x) throw ();
/* Sine of X. */
extern _Float64 sinf64 (_Float64 __x) throw (); extern _Float64 __sinf64 (_Float64 __x) throw ();
/* Tangent of X. */
extern _Float64 tanf64 (_Float64 __x) throw (); extern _Float64 __tanf64 (_Float64 __x) throw ();
#pragma empty_line
/* Hyperbolic functions. */
#pragma empty_line
/* Hyperbolic cosine of X. */
extern _Float64 coshf64 (_Float64 __x) throw (); extern _Float64 __coshf64 (_Float64 __x) throw ();
/* Hyperbolic sine of X. */
extern _Float64 sinhf64 (_Float64 __x) throw (); extern _Float64 __sinhf64 (_Float64 __x) throw ();
/* Hyperbolic tangent of X. */
extern _Float64 tanhf64 (_Float64 __x) throw (); extern _Float64 __tanhf64 (_Float64 __x) throw ();
#pragma empty_line
#pragma empty_line
/* Cosine and sine of X. */
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
/* Hyperbolic arc cosine of X. */
extern _Float64 acoshf64 (_Float64 __x) throw (); extern _Float64 __acoshf64 (_Float64 __x) throw ();
/* Hyperbolic arc sine of X. */
extern _Float64 asinhf64 (_Float64 __x) throw (); extern _Float64 __asinhf64 (_Float64 __x) throw ();
/* Hyperbolic arc tangent of X. */
extern _Float64 atanhf64 (_Float64 __x) throw (); extern _Float64 __atanhf64 (_Float64 __x) throw ();
#pragma empty_line
#pragma empty_line
/* Exponential and logarithmic functions. */
#pragma empty_line
/* Exponential function of X. */
extern _Float64 expf64 (_Float64 __x) throw (); extern _Float64 __expf64 (_Float64 __x) throw ();
#pragma empty_line
/* Break VALUE into a normalized fraction and an integral power of 2. */
extern _Float64 frexpf64 (_Float64 __x, int *__exponent) throw (); extern _Float64 __frexpf64 (_Float64 __x, int *__exponent) throw ();
#pragma empty_line
/* X times (two to the EXP power). */
extern _Float64 ldexpf64 (_Float64 __x, int __exponent) throw (); extern _Float64 __ldexpf64 (_Float64 __x, int __exponent) throw ();
#pragma empty_line
/* Natural logarithm of X. */
extern _Float64 logf64 (_Float64 __x) throw (); extern _Float64 __logf64 (_Float64 __x) throw ();
#pragma empty_line
/* Base-ten logarithm of X. */
extern _Float64 log10f64 (_Float64 __x) throw (); extern _Float64 __log10f64 (_Float64 __x) throw ();
#pragma empty_line
/* Break VALUE into integral and fractional parts. */
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
/* Compute exponent to base ten. */
extern _Float64 exp10f64 (_Float64 __x) throw (); extern _Float64 __exp10f64 (_Float64 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Return exp(X) - 1. */
extern _Float64 expm1f64 (_Float64 __x) throw (); extern _Float64 __expm1f64 (_Float64 __x) throw ();
#pragma empty_line
/* Return log(1 + X). */
extern _Float64 log1pf64 (_Float64 __x) throw (); extern _Float64 __log1pf64 (_Float64 __x) throw ();
#pragma empty_line
/* Return the base 2 signed integral exponent of X. */
extern _Float64 logbf64 (_Float64 __x) throw (); extern _Float64 __logbf64 (_Float64 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Compute base-2 exponential of X. */
extern _Float64 exp2f64 (_Float64 __x) throw (); extern _Float64 __exp2f64 (_Float64 __x) throw ();
#pragma empty_line
/* Compute base-2 logarithm of X. */
extern _Float64 log2f64 (_Float64 __x) throw (); extern _Float64 __log2f64 (_Float64 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Power functions. */
#pragma empty_line
/* Return X to the Y power. */
extern _Float64 powf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __powf64 (_Float64 __x, _Float64 __y) throw ();
#pragma empty_line
/* Return the square root of X. */
extern _Float64 sqrtf64 (_Float64 __x) throw (); extern _Float64 __sqrtf64 (_Float64 __x) throw ();
#pragma empty_line
#pragma empty_line
/* Return `sqrt(X*X + Y*Y)'. */
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
/* Return the cube root of X. */
extern _Float64 cbrtf64 (_Float64 __x) throw (); extern _Float64 __cbrtf64 (_Float64 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Nearest integer, absolute value, and remainder functions. */
#pragma empty_line
/* Smallest integral value not less than X. */
extern _Float64 ceilf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __ceilf64 (_Float64 __x) throw () __attribute__ ((__const__));
#pragma empty_line
/* Absolute value of X. */
extern _Float64 fabsf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __fabsf64 (_Float64 __x) throw () __attribute__ ((__const__));
#pragma empty_line
/* Largest integer not greater than X. */
extern _Float64 floorf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __floorf64 (_Float64 __x) throw () __attribute__ ((__const__));
#pragma empty_line
/* Floating-point modulo remainder of X/Y. */
extern _Float64 fmodf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __fmodf64 (_Float64 __x, _Float64 __y) throw ();
#pragma line 195 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
/* Return X with its signed changed to Y's. */
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
/* Return representation of qNaN for double type. */
extern _Float64 nanf64 (const char *__tagb) throw () __attribute__ ((__const__)); extern _Float64 __nanf64 (const char *__tagb) throw () __attribute__ ((__const__));
#pragma line 216 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
/* Bessel functions. */
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
/* Error and gamma functions. */
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
/* True gamma function. */
extern _Float64 tgammaf64 (_Float64) throw (); extern _Float64 __tgammaf64 (_Float64) throw ();
#pragma line 246 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
/* Reentrant version of lgamma. This function uses the global variable
`signgam'. The reentrant version instead takes a pointer and stores
the value through it. */
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
/* Return the integer nearest X in the direction of the
prevailing rounding mode. */
extern _Float64 rintf64 (_Float64 __x) throw (); extern _Float64 __rintf64 (_Float64 __x) throw ();
#pragma empty_line
/* Return X + epsilon if X < Y, X - epsilon if X > Y. */
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
/* Return X - epsilon. */
extern _Float64 nextdownf64 (_Float64 __x) throw (); extern _Float64 __nextdownf64 (_Float64 __x) throw ();
/* Return X + epsilon. */
extern _Float64 nextupf64 (_Float64 __x) throw (); extern _Float64 __nextupf64 (_Float64 __x) throw ();
#pragma empty_line
#pragma empty_line
/* Return the remainder of integer divison X / Y with infinite precision. */
extern _Float64 remainderf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __remainderf64 (_Float64 __x, _Float64 __y) throw ();
#pragma empty_line
#pragma empty_line
/* Return X times (2 to the Nth power). */
extern _Float64 scalbnf64 (_Float64 __x, int __n) throw (); extern _Float64 __scalbnf64 (_Float64 __x, int __n) throw ();
#pragma empty_line
#pragma empty_line
/* Return the binary exponent of X, which must be nonzero. */
extern int ilogbf64 (_Float64 __x) throw (); extern int __ilogbf64 (_Float64 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Like ilogb, but returning long int. */
extern long int llogbf64 (_Float64 __x) throw (); extern long int __llogbf64 (_Float64 __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Return X times (2 to the Nth power). */
extern _Float64 scalblnf64 (_Float64 __x, long int __n) throw (); extern _Float64 __scalblnf64 (_Float64 __x, long int __n) throw ();
#pragma empty_line
/* Round X to integral value in floating-point format using current
rounding direction, but do not raise inexact exception. */
extern _Float64 nearbyintf64 (_Float64 __x) throw (); extern _Float64 __nearbyintf64 (_Float64 __x) throw ();
#pragma empty_line
/* Round X to nearest integral value, rounding halfway cases away from
zero. */
extern _Float64 roundf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __roundf64 (_Float64 __x) throw () __attribute__ ((__const__));
#pragma empty_line
/* Round X to the integral value in floating-point format nearest but
not larger in magnitude. */
extern _Float64 truncf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __truncf64 (_Float64 __x) throw () __attribute__ ((__const__));
#pragma empty_line
/* Compute remainder of X and Y and put in *QUO a value with sign of x/y
and magnitude congruent `mod 2^n' to the magnitude of the integral
quotient x/y, with n >= 3. */
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
/* Conversion functions. */
#pragma empty_line
/* Round X to nearest integral value according to current rounding
direction. */
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
/* Round X to nearest integral value, rounding halfway cases away from
zero. */
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
/* Return positive difference between X and Y. */
extern _Float64 fdimf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __fdimf64 (_Float64 __x, _Float64 __y) throw ();
#pragma empty_line
/* Return maximum numeric value from X and Y. */
extern _Float64 fmaxf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern _Float64 __fmaxf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__));
#pragma empty_line
/* Return minimum numeric value from X and Y. */
extern _Float64 fminf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern _Float64 __fminf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__));
#pragma empty_line
/* Multiply-add function computed as a ternary operation. */
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
/* Round X to nearest integer value, rounding halfway cases to even. */
extern _Float64 roundevenf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __roundevenf64 (_Float64 __x) throw () __attribute__ ((__const__));
#pragma empty_line
/* Round X to nearest signed integer value, not raising inexact, with
control of rounding direction and width of result. */
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
/* Round X to nearest unsigned integer value, not raising inexact,
with control of rounding direction and width of result. */
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
/* Round X to nearest signed integer value, raising inexact for
non-integers, with control of rounding direction and width of
result. */
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
/* Round X to nearest unsigned integer value, raising inexact for
non-integers, with control of rounding direction and width of
result. */
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
/* Return value with maximum magnitude. */
extern _Float64 fmaxmagf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern _Float64 __fmaxmagf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__));
#pragma empty_line
/* Return value with minimum magnitude. */
extern _Float64 fminmagf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern _Float64 __fminmagf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__));
#pragma empty_line
/* Total order operation. */
extern int totalorderf64 (_Float64 __x, _Float64 __y) throw ()
__attribute__ ((__const__));
#pragma empty_line
/* Total order operation on absolute values. */
extern int totalordermagf64 (_Float64 __x, _Float64 __y) throw ()
__attribute__ ((__const__));
#pragma empty_line
/* Canonicalize floating-point representation. */
extern int canonicalizef64 (_Float64 *__cx, const _Float64 *__x) throw ();
#pragma empty_line
/* Get NaN payload. */
extern _Float64 getpayloadf64 (const _Float64 *__x) throw (); extern _Float64 __getpayloadf64 (const _Float64 *__x) throw ();
#pragma empty_line
/* Set quiet NaN payload. */
extern int setpayloadf64 (_Float64 *__x, _Float64 __payload) throw ();
#pragma empty_line
/* Set signaling NaN payload. */
extern int setpayloadsigf64 (_Float64 *__x, _Float64 __payload) throw ();
#pragma line 407 "/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
/* Prototype declarations for math functions; helper file for <math.h>.
Copyright (C) 1996-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
/* NOTE: Because of the special way this file is used by <math.h>, this
file must NOT be protected from multiple inclusion as header files
usually are.
#pragma empty_line
This file provides prototype declarations for the math functions.
Most functions are declared using the macro:
#pragma empty_line
__MATHCALL (NAME,[_r], (ARGS...));
#pragma empty_line
This means there is a function `NAME' returning `double' and a function
`NAMEf' returning `float'. Each place `_Mdouble_' appears in the
prototype, that is actually `double' in the prototype for `NAME' and
`float' in the prototype for `NAMEf'. Reentrant variant functions are
called `NAME_r' and `NAMEf_r'.
#pragma empty_line
Functions returning other types like `int' are declared using the macro:
#pragma empty_line
__MATHDECL (TYPE, NAME,[_r], (ARGS...));
#pragma empty_line
This is just like __MATHCALL but for a function returning `TYPE'
instead of `_Mdouble_'. In all of these cases, there is still
both a `NAME' and a `NAMEf' that takes `float' arguments.
#pragma empty_line
Note that there must be no whitespace before the argument passed for
NAME, to make token pasting work with -traditional. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Trigonometric functions. */
#pragma empty_line
/* Arc cosine of X. */
extern _Float32x acosf32x (_Float32x __x) throw (); extern _Float32x __acosf32x (_Float32x __x) throw ();
/* Arc sine of X. */
extern _Float32x asinf32x (_Float32x __x) throw (); extern _Float32x __asinf32x (_Float32x __x) throw ();
/* Arc tangent of X. */
extern _Float32x atanf32x (_Float32x __x) throw (); extern _Float32x __atanf32x (_Float32x __x) throw ();
/* Arc tangent of Y/X. */
extern _Float32x atan2f32x (_Float32x __y, _Float32x __x) throw (); extern _Float32x __atan2f32x (_Float32x __y, _Float32x __x) throw ();
#pragma empty_line
/* Cosine of X. */
extern _Float32x cosf32x (_Float32x __x) throw (); extern _Float32x __cosf32x (_Float32x __x) throw ();
/* Sine of X. */
extern _Float32x sinf32x (_Float32x __x) throw (); extern _Float32x __sinf32x (_Float32x __x) throw ();
/* Tangent of X. */
extern _Float32x tanf32x (_Float32x __x) throw (); extern _Float32x __tanf32x (_Float32x __x) throw ();
#pragma empty_line
/* Hyperbolic functions. */
#pragma empty_line
/* Hyperbolic cosine of X. */
extern _Float32x coshf32x (_Float32x __x) throw (); extern _Float32x __coshf32x (_Float32x __x) throw ();
/* Hyperbolic sine of X. */
extern _Float32x sinhf32x (_Float32x __x) throw (); extern _Float32x __sinhf32x (_Float32x __x) throw ();
/* Hyperbolic tangent of X. */
extern _Float32x tanhf32x (_Float32x __x) throw (); extern _Float32x __tanhf32x (_Float32x __x) throw ();
#pragma empty_line
#pragma empty_line
/* Cosine and sine of X. */
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
/* Hyperbolic arc cosine of X. */
extern _Float32x acoshf32x (_Float32x __x) throw (); extern _Float32x __acoshf32x (_Float32x __x) throw ();
/* Hyperbolic arc sine of X. */
extern _Float32x asinhf32x (_Float32x __x) throw (); extern _Float32x __asinhf32x (_Float32x __x) throw ();
/* Hyperbolic arc tangent of X. */
extern _Float32x atanhf32x (_Float32x __x) throw (); extern _Float32x __atanhf32x (_Float32x __x) throw ();
#pragma empty_line
#pragma empty_line
/* Exponential and logarithmic functions. */
#pragma empty_line
/* Exponential function of X. */
extern _Float32x expf32x (_Float32x __x) throw (); extern _Float32x __expf32x (_Float32x __x) throw ();
#pragma empty_line
/* Break VALUE into a normalized fraction and an integral power of 2. */
extern _Float32x frexpf32x (_Float32x __x, int *__exponent) throw (); extern _Float32x __frexpf32x (_Float32x __x, int *__exponent) throw ();
#pragma empty_line
/* X times (two to the EXP power). */
extern _Float32x ldexpf32x (_Float32x __x, int __exponent) throw (); extern _Float32x __ldexpf32x (_Float32x __x, int __exponent) throw ();
#pragma empty_line
/* Natural logarithm of X. */
extern _Float32x logf32x (_Float32x __x) throw (); extern _Float32x __logf32x (_Float32x __x) throw ();
#pragma empty_line
/* Base-ten logarithm of X. */
extern _Float32x log10f32x (_Float32x __x) throw (); extern _Float32x __log10f32x (_Float32x __x) throw ();
#pragma empty_line
/* Break VALUE into integral and fractional parts. */
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
/* Compute exponent to base ten. */
extern _Float32x exp10f32x (_Float32x __x) throw (); extern _Float32x __exp10f32x (_Float32x __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Return exp(X) - 1. */
extern _Float32x expm1f32x (_Float32x __x) throw (); extern _Float32x __expm1f32x (_Float32x __x) throw ();
#pragma empty_line
/* Return log(1 + X). */
extern _Float32x log1pf32x (_Float32x __x) throw (); extern _Float32x __log1pf32x (_Float32x __x) throw ();
#pragma empty_line
/* Return the base 2 signed integral exponent of X. */
extern _Float32x logbf32x (_Float32x __x) throw (); extern _Float32x __logbf32x (_Float32x __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Compute base-2 exponential of X. */
extern _Float32x exp2f32x (_Float32x __x) throw (); extern _Float32x __exp2f32x (_Float32x __x) throw ();
#pragma empty_line
/* Compute base-2 logarithm of X. */
extern _Float32x log2f32x (_Float32x __x) throw (); extern _Float32x __log2f32x (_Float32x __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Power functions. */
#pragma empty_line
/* Return X to the Y power. */
extern _Float32x powf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __powf32x (_Float32x __x, _Float32x __y) throw ();
#pragma empty_line
/* Return the square root of X. */
extern _Float32x sqrtf32x (_Float32x __x) throw (); extern _Float32x __sqrtf32x (_Float32x __x) throw ();
#pragma empty_line
#pragma empty_line
/* Return `sqrt(X*X + Y*Y)'. */
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
/* Return the cube root of X. */
extern _Float32x cbrtf32x (_Float32x __x) throw (); extern _Float32x __cbrtf32x (_Float32x __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Nearest integer, absolute value, and remainder functions. */
#pragma empty_line
/* Smallest integral value not less than X. */
extern _Float32x ceilf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __ceilf32x (_Float32x __x) throw () __attribute__ ((__const__));
#pragma empty_line
/* Absolute value of X. */
extern _Float32x fabsf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __fabsf32x (_Float32x __x) throw () __attribute__ ((__const__));
#pragma empty_line
/* Largest integer not greater than X. */
extern _Float32x floorf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __floorf32x (_Float32x __x) throw () __attribute__ ((__const__));
#pragma empty_line
/* Floating-point modulo remainder of X/Y. */
extern _Float32x fmodf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __fmodf32x (_Float32x __x, _Float32x __y) throw ();
#pragma line 195 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
/* Return X with its signed changed to Y's. */
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
/* Return representation of qNaN for double type. */
extern _Float32x nanf32x (const char *__tagb) throw () __attribute__ ((__const__)); extern _Float32x __nanf32x (const char *__tagb) throw () __attribute__ ((__const__));
#pragma line 216 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
/* Bessel functions. */
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
/* Error and gamma functions. */
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
/* True gamma function. */
extern _Float32x tgammaf32x (_Float32x) throw (); extern _Float32x __tgammaf32x (_Float32x) throw ();
#pragma line 246 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
/* Reentrant version of lgamma. This function uses the global variable
`signgam'. The reentrant version instead takes a pointer and stores
the value through it. */
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
/* Return the integer nearest X in the direction of the
prevailing rounding mode. */
extern _Float32x rintf32x (_Float32x __x) throw (); extern _Float32x __rintf32x (_Float32x __x) throw ();
#pragma empty_line
/* Return X + epsilon if X < Y, X - epsilon if X > Y. */
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
/* Return X - epsilon. */
extern _Float32x nextdownf32x (_Float32x __x) throw (); extern _Float32x __nextdownf32x (_Float32x __x) throw ();
/* Return X + epsilon. */
extern _Float32x nextupf32x (_Float32x __x) throw (); extern _Float32x __nextupf32x (_Float32x __x) throw ();
#pragma empty_line
#pragma empty_line
/* Return the remainder of integer divison X / Y with infinite precision. */
extern _Float32x remainderf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __remainderf32x (_Float32x __x, _Float32x __y) throw ();
#pragma empty_line
#pragma empty_line
/* Return X times (2 to the Nth power). */
extern _Float32x scalbnf32x (_Float32x __x, int __n) throw (); extern _Float32x __scalbnf32x (_Float32x __x, int __n) throw ();
#pragma empty_line
#pragma empty_line
/* Return the binary exponent of X, which must be nonzero. */
extern int ilogbf32x (_Float32x __x) throw (); extern int __ilogbf32x (_Float32x __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Like ilogb, but returning long int. */
extern long int llogbf32x (_Float32x __x) throw (); extern long int __llogbf32x (_Float32x __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Return X times (2 to the Nth power). */
extern _Float32x scalblnf32x (_Float32x __x, long int __n) throw (); extern _Float32x __scalblnf32x (_Float32x __x, long int __n) throw ();
#pragma empty_line
/* Round X to integral value in floating-point format using current
rounding direction, but do not raise inexact exception. */
extern _Float32x nearbyintf32x (_Float32x __x) throw (); extern _Float32x __nearbyintf32x (_Float32x __x) throw ();
#pragma empty_line
/* Round X to nearest integral value, rounding halfway cases away from
zero. */
extern _Float32x roundf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __roundf32x (_Float32x __x) throw () __attribute__ ((__const__));
#pragma empty_line
/* Round X to the integral value in floating-point format nearest but
not larger in magnitude. */
extern _Float32x truncf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __truncf32x (_Float32x __x) throw () __attribute__ ((__const__));
#pragma empty_line
/* Compute remainder of X and Y and put in *QUO a value with sign of x/y
and magnitude congruent `mod 2^n' to the magnitude of the integral
quotient x/y, with n >= 3. */
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
/* Conversion functions. */
#pragma empty_line
/* Round X to nearest integral value according to current rounding
direction. */
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
/* Round X to nearest integral value, rounding halfway cases away from
zero. */
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
/* Return positive difference between X and Y. */
extern _Float32x fdimf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __fdimf32x (_Float32x __x, _Float32x __y) throw ();
#pragma empty_line
/* Return maximum numeric value from X and Y. */
extern _Float32x fmaxf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern _Float32x __fmaxf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__));
#pragma empty_line
/* Return minimum numeric value from X and Y. */
extern _Float32x fminf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern _Float32x __fminf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__));
#pragma empty_line
/* Multiply-add function computed as a ternary operation. */
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
/* Round X to nearest integer value, rounding halfway cases to even. */
extern _Float32x roundevenf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __roundevenf32x (_Float32x __x) throw () __attribute__ ((__const__));
#pragma empty_line
/* Round X to nearest signed integer value, not raising inexact, with
control of rounding direction and width of result. */
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
/* Round X to nearest unsigned integer value, not raising inexact,
with control of rounding direction and width of result. */
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
/* Round X to nearest signed integer value, raising inexact for
non-integers, with control of rounding direction and width of
result. */
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
/* Round X to nearest unsigned integer value, raising inexact for
non-integers, with control of rounding direction and width of
result. */
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
/* Return value with maximum magnitude. */
extern _Float32x fmaxmagf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern _Float32x __fmaxmagf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__));
#pragma empty_line
/* Return value with minimum magnitude. */
extern _Float32x fminmagf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern _Float32x __fminmagf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__));
#pragma empty_line
/* Total order operation. */
extern int totalorderf32x (_Float32x __x, _Float32x __y) throw ()
__attribute__ ((__const__));
#pragma empty_line
/* Total order operation on absolute values. */
extern int totalordermagf32x (_Float32x __x, _Float32x __y) throw ()
__attribute__ ((__const__));
#pragma empty_line
/* Canonicalize floating-point representation. */
extern int canonicalizef32x (_Float32x *__cx, const _Float32x *__x) throw ();
#pragma empty_line
/* Get NaN payload. */
extern _Float32x getpayloadf32x (const _Float32x *__x) throw (); extern _Float32x __getpayloadf32x (const _Float32x *__x) throw ();
#pragma empty_line
/* Set quiet NaN payload. */
extern int setpayloadf32x (_Float32x *__x, _Float32x __payload) throw ();
#pragma empty_line
/* Set signaling NaN payload. */
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
/* Prototype declarations for math functions; helper file for <math.h>.
Copyright (C) 1996-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
/* NOTE: Because of the special way this file is used by <math.h>, this
file must NOT be protected from multiple inclusion as header files
usually are.
#pragma empty_line
This file provides prototype declarations for the math functions.
Most functions are declared using the macro:
#pragma empty_line
__MATHCALL (NAME,[_r], (ARGS...));
#pragma empty_line
This means there is a function `NAME' returning `double' and a function
`NAMEf' returning `float'. Each place `_Mdouble_' appears in the
prototype, that is actually `double' in the prototype for `NAME' and
`float' in the prototype for `NAMEf'. Reentrant variant functions are
called `NAME_r' and `NAMEf_r'.
#pragma empty_line
Functions returning other types like `int' are declared using the macro:
#pragma empty_line
__MATHDECL (TYPE, NAME,[_r], (ARGS...));
#pragma empty_line
This is just like __MATHCALL but for a function returning `TYPE'
instead of `_Mdouble_'. In all of these cases, there is still
both a `NAME' and a `NAMEf' that takes `float' arguments.
#pragma empty_line
Note that there must be no whitespace before the argument passed for
NAME, to make token pasting work with -traditional. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Trigonometric functions. */
#pragma empty_line
/* Arc cosine of X. */
extern _Float64x acosf64x (_Float64x __x) throw (); extern _Float64x __acosf64x (_Float64x __x) throw ();
/* Arc sine of X. */
extern _Float64x asinf64x (_Float64x __x) throw (); extern _Float64x __asinf64x (_Float64x __x) throw ();
/* Arc tangent of X. */
extern _Float64x atanf64x (_Float64x __x) throw (); extern _Float64x __atanf64x (_Float64x __x) throw ();
/* Arc tangent of Y/X. */
extern _Float64x atan2f64x (_Float64x __y, _Float64x __x) throw (); extern _Float64x __atan2f64x (_Float64x __y, _Float64x __x) throw ();
#pragma empty_line
/* Cosine of X. */
extern _Float64x cosf64x (_Float64x __x) throw (); extern _Float64x __cosf64x (_Float64x __x) throw ();
/* Sine of X. */
extern _Float64x sinf64x (_Float64x __x) throw (); extern _Float64x __sinf64x (_Float64x __x) throw ();
/* Tangent of X. */
extern _Float64x tanf64x (_Float64x __x) throw (); extern _Float64x __tanf64x (_Float64x __x) throw ();
#pragma empty_line
/* Hyperbolic functions. */
#pragma empty_line
/* Hyperbolic cosine of X. */
extern _Float64x coshf64x (_Float64x __x) throw (); extern _Float64x __coshf64x (_Float64x __x) throw ();
/* Hyperbolic sine of X. */
extern _Float64x sinhf64x (_Float64x __x) throw (); extern _Float64x __sinhf64x (_Float64x __x) throw ();
/* Hyperbolic tangent of X. */
extern _Float64x tanhf64x (_Float64x __x) throw (); extern _Float64x __tanhf64x (_Float64x __x) throw ();
#pragma empty_line
#pragma empty_line
/* Cosine and sine of X. */
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
/* Hyperbolic arc cosine of X. */
extern _Float64x acoshf64x (_Float64x __x) throw (); extern _Float64x __acoshf64x (_Float64x __x) throw ();
/* Hyperbolic arc sine of X. */
extern _Float64x asinhf64x (_Float64x __x) throw (); extern _Float64x __asinhf64x (_Float64x __x) throw ();
/* Hyperbolic arc tangent of X. */
extern _Float64x atanhf64x (_Float64x __x) throw (); extern _Float64x __atanhf64x (_Float64x __x) throw ();
#pragma empty_line
#pragma empty_line
/* Exponential and logarithmic functions. */
#pragma empty_line
/* Exponential function of X. */
extern _Float64x expf64x (_Float64x __x) throw (); extern _Float64x __expf64x (_Float64x __x) throw ();
#pragma empty_line
/* Break VALUE into a normalized fraction and an integral power of 2. */
extern _Float64x frexpf64x (_Float64x __x, int *__exponent) throw (); extern _Float64x __frexpf64x (_Float64x __x, int *__exponent) throw ();
#pragma empty_line
/* X times (two to the EXP power). */
extern _Float64x ldexpf64x (_Float64x __x, int __exponent) throw (); extern _Float64x __ldexpf64x (_Float64x __x, int __exponent) throw ();
#pragma empty_line
/* Natural logarithm of X. */
extern _Float64x logf64x (_Float64x __x) throw (); extern _Float64x __logf64x (_Float64x __x) throw ();
#pragma empty_line
/* Base-ten logarithm of X. */
extern _Float64x log10f64x (_Float64x __x) throw (); extern _Float64x __log10f64x (_Float64x __x) throw ();
#pragma empty_line
/* Break VALUE into integral and fractional parts. */
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
/* Compute exponent to base ten. */
extern _Float64x exp10f64x (_Float64x __x) throw (); extern _Float64x __exp10f64x (_Float64x __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Return exp(X) - 1. */
extern _Float64x expm1f64x (_Float64x __x) throw (); extern _Float64x __expm1f64x (_Float64x __x) throw ();
#pragma empty_line
/* Return log(1 + X). */
extern _Float64x log1pf64x (_Float64x __x) throw (); extern _Float64x __log1pf64x (_Float64x __x) throw ();
#pragma empty_line
/* Return the base 2 signed integral exponent of X. */
extern _Float64x logbf64x (_Float64x __x) throw (); extern _Float64x __logbf64x (_Float64x __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Compute base-2 exponential of X. */
extern _Float64x exp2f64x (_Float64x __x) throw (); extern _Float64x __exp2f64x (_Float64x __x) throw ();
#pragma empty_line
/* Compute base-2 logarithm of X. */
extern _Float64x log2f64x (_Float64x __x) throw (); extern _Float64x __log2f64x (_Float64x __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Power functions. */
#pragma empty_line
/* Return X to the Y power. */
extern _Float64x powf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __powf64x (_Float64x __x, _Float64x __y) throw ();
#pragma empty_line
/* Return the square root of X. */
extern _Float64x sqrtf64x (_Float64x __x) throw (); extern _Float64x __sqrtf64x (_Float64x __x) throw ();
#pragma empty_line
#pragma empty_line
/* Return `sqrt(X*X + Y*Y)'. */
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
/* Return the cube root of X. */
extern _Float64x cbrtf64x (_Float64x __x) throw (); extern _Float64x __cbrtf64x (_Float64x __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Nearest integer, absolute value, and remainder functions. */
#pragma empty_line
/* Smallest integral value not less than X. */
extern _Float64x ceilf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __ceilf64x (_Float64x __x) throw () __attribute__ ((__const__));
#pragma empty_line
/* Absolute value of X. */
extern _Float64x fabsf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __fabsf64x (_Float64x __x) throw () __attribute__ ((__const__));
#pragma empty_line
/* Largest integer not greater than X. */
extern _Float64x floorf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __floorf64x (_Float64x __x) throw () __attribute__ ((__const__));
#pragma empty_line
/* Floating-point modulo remainder of X/Y. */
extern _Float64x fmodf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __fmodf64x (_Float64x __x, _Float64x __y) throw ();
#pragma line 195 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
/* Return X with its signed changed to Y's. */
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
/* Return representation of qNaN for double type. */
extern _Float64x nanf64x (const char *__tagb) throw () __attribute__ ((__const__)); extern _Float64x __nanf64x (const char *__tagb) throw () __attribute__ ((__const__));
#pragma line 216 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
/* Bessel functions. */
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
/* Error and gamma functions. */
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
/* True gamma function. */
extern _Float64x tgammaf64x (_Float64x) throw (); extern _Float64x __tgammaf64x (_Float64x) throw ();
#pragma line 246 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
/* Reentrant version of lgamma. This function uses the global variable
`signgam'. The reentrant version instead takes a pointer and stores
the value through it. */
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
/* Return the integer nearest X in the direction of the
prevailing rounding mode. */
extern _Float64x rintf64x (_Float64x __x) throw (); extern _Float64x __rintf64x (_Float64x __x) throw ();
#pragma empty_line
/* Return X + epsilon if X < Y, X - epsilon if X > Y. */
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
/* Return X - epsilon. */
extern _Float64x nextdownf64x (_Float64x __x) throw (); extern _Float64x __nextdownf64x (_Float64x __x) throw ();
/* Return X + epsilon. */
extern _Float64x nextupf64x (_Float64x __x) throw (); extern _Float64x __nextupf64x (_Float64x __x) throw ();
#pragma empty_line
#pragma empty_line
/* Return the remainder of integer divison X / Y with infinite precision. */
extern _Float64x remainderf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __remainderf64x (_Float64x __x, _Float64x __y) throw ();
#pragma empty_line
#pragma empty_line
/* Return X times (2 to the Nth power). */
extern _Float64x scalbnf64x (_Float64x __x, int __n) throw (); extern _Float64x __scalbnf64x (_Float64x __x, int __n) throw ();
#pragma empty_line
#pragma empty_line
/* Return the binary exponent of X, which must be nonzero. */
extern int ilogbf64x (_Float64x __x) throw (); extern int __ilogbf64x (_Float64x __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Like ilogb, but returning long int. */
extern long int llogbf64x (_Float64x __x) throw (); extern long int __llogbf64x (_Float64x __x) throw ();
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Return X times (2 to the Nth power). */
extern _Float64x scalblnf64x (_Float64x __x, long int __n) throw (); extern _Float64x __scalblnf64x (_Float64x __x, long int __n) throw ();
#pragma empty_line
/* Round X to integral value in floating-point format using current
rounding direction, but do not raise inexact exception. */
extern _Float64x nearbyintf64x (_Float64x __x) throw (); extern _Float64x __nearbyintf64x (_Float64x __x) throw ();
#pragma empty_line
/* Round X to nearest integral value, rounding halfway cases away from
zero. */
extern _Float64x roundf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __roundf64x (_Float64x __x) throw () __attribute__ ((__const__));
#pragma empty_line
/* Round X to the integral value in floating-point format nearest but
not larger in magnitude. */
extern _Float64x truncf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __truncf64x (_Float64x __x) throw () __attribute__ ((__const__));
#pragma empty_line
/* Compute remainder of X and Y and put in *QUO a value with sign of x/y
and magnitude congruent `mod 2^n' to the magnitude of the integral
quotient x/y, with n >= 3. */
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
/* Conversion functions. */
#pragma empty_line
/* Round X to nearest integral value according to current rounding
direction. */
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
/* Round X to nearest integral value, rounding halfway cases away from
zero. */
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
/* Return positive difference between X and Y. */
extern _Float64x fdimf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __fdimf64x (_Float64x __x, _Float64x __y) throw ();
#pragma empty_line
/* Return maximum numeric value from X and Y. */
extern _Float64x fmaxf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern _Float64x __fmaxf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__));
#pragma empty_line
/* Return minimum numeric value from X and Y. */
extern _Float64x fminf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern _Float64x __fminf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__));
#pragma empty_line
/* Multiply-add function computed as a ternary operation. */
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
/* Round X to nearest integer value, rounding halfway cases to even. */
extern _Float64x roundevenf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __roundevenf64x (_Float64x __x) throw () __attribute__ ((__const__));
#pragma empty_line
/* Round X to nearest signed integer value, not raising inexact, with
control of rounding direction and width of result. */
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
/* Round X to nearest unsigned integer value, not raising inexact,
with control of rounding direction and width of result. */
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
/* Round X to nearest signed integer value, raising inexact for
non-integers, with control of rounding direction and width of
result. */
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
/* Round X to nearest unsigned integer value, raising inexact for
non-integers, with control of rounding direction and width of
result. */
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
/* Return value with maximum magnitude. */
extern _Float64x fmaxmagf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern _Float64x __fmaxmagf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__));
#pragma empty_line
/* Return value with minimum magnitude. */
extern _Float64x fminmagf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern _Float64x __fminmagf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__));
#pragma empty_line
/* Total order operation. */
extern int totalorderf64x (_Float64x __x, _Float64x __y) throw ()
__attribute__ ((__const__));
#pragma empty_line
/* Total order operation on absolute values. */
extern int totalordermagf64x (_Float64x __x, _Float64x __y) throw ()
__attribute__ ((__const__));
#pragma empty_line
/* Canonicalize floating-point representation. */
extern int canonicalizef64x (_Float64x *__cx, const _Float64x *__x) throw ();
#pragma empty_line
/* Get NaN payload. */
extern _Float64x getpayloadf64x (const _Float64x *__x) throw (); extern _Float64x __getpayloadf64x (const _Float64x *__x) throw ();
#pragma empty_line
/* Set quiet NaN payload. */
extern int setpayloadf64x (_Float64x *__x, _Float64x __payload) throw ();
#pragma empty_line
/* Set signaling NaN payload. */
extern int setpayloadsigf64x (_Float64x *__x, _Float64x __payload) throw ();
#pragma line 458 "/usr/include/math.h" 2 3 4
#pragma line 488 "/usr/include/math.h" 3 4
/* This variable is used by `gamma' and `lgamma'. */
extern int signgam;
#pragma line 501 "/usr/include/math.h" 3 4
/* Depending on the type of TG_ARG, call an appropriately suffixed
version of FUNC with arguments (including parentheses) ARGS.
Suffixed functions may not exist for long double if it has the same
format as double, or for other types with the same format as float,
double or long double. The behavior is undefined if the argument
does not have a real floating type. The definition may use a
conditional expression, so all suffixed versions of FUNC must
return the same type (FUNC may include a cast if necessary rather
than being a single identifier). */
#pragma line 565 "/usr/include/math.h" 3 4
/* ISO C99 defines some generic macros which work on any data type. */
#pragma empty_line
#pragma empty_line
/* All floating-point numbers can be put in one of these categories. */
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 empty_line
/* GCC bug 66462 means we cannot use the math builtins with -fsignaling-nan,
so disable builtins if this is enabled. When fixed in a newer GCC,
the __SUPPORT_SNAN__ check may be skipped for those versions. */
#pragma empty_line
/* Return number of classification appropriate for X. */
#pragma line 607 "/usr/include/math.h" 3 4
/* Return nonzero value if sign of X is negative. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* In C++ mode, __MATH_TG cannot be used, because it relies on
__builtin_types_compatible_p, which is a C-only builtin.
The check for __cplusplus allows the use of the builtin instead of
__MATH_TG. This is provided for libstdc++, only to let its configure
test work. No further use of this definition of signbit is expected
in C++ mode, since libstdc++ provides its own version of signbit
in cmath (which undefines signbit). */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Return nonzero value if X is not +-Inf or NaN. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Return nonzero value if X is neither zero, subnormal, Inf, nor NaN. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Return nonzero value if X is a NaN. We could use `fpclassify' but
we already have this functions `__isnan' and it is faster. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Return nonzero value if X is positive or negative infinity. */
#pragma line 664 "/usr/include/math.h" 3 4
/* Bitmasks for the math_errhandling macro. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* By default all math functions support both errno and exception handling
(except for soft floating point implementations which may only support
errno handling). If errno handling is disabled, exceptions are still
supported by GLIBC. Set math_errhandling to 0 with -ffast-math (this is
nonconforming but it is more useful than leaving it undefined). */
#pragma line 684 "/usr/include/math.h" 3 4
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/iscanonical.h" 1 3 4
/* Define iscanonical macro. ldbl-96 version.
Copyright (C) 2016-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern int __iscanonicall (long double __x)
throw () __attribute__ ((__const__));
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Return nonzero value if X is canonical. In IEEE interchange binary
formats, all values are canonical, but the argument must still be
converted to its semantic type for any exceptions arising from the
conversion, before being discarded; in extended precision, there
are encodings that are not consistently handled as corresponding to
any particular value of the type, and we return 0 for those. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* In C++ mode, __MATH_TG cannot be used, because it relies on
__builtin_types_compatible_p, which is a C-only builtin. On the
other hand, overloading provides the means to distinguish between
the floating-point types. The overloading resolution will match
the correct parameter (regardless of type qualifiers (i.e.: const
and volatile)). */
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
#pragma empty_line
#pragma empty_line
}
#pragma line 685 "/usr/include/math.h" 2 3 4
#pragma empty_line
/* Return nonzero value if X is a signaling NaN. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* In C++ mode, __MATH_TG cannot be used, because it relies on
__builtin_types_compatible_p, which is a C-only builtin. On the
other hand, overloading provides the means to distinguish between
the floating-point types. The overloading resolution will match
the correct parameter (regardless of type qualifiers (i.e.: const
and volatile)). */
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
} /* extern C++ */
#pragma empty_line
#pragma empty_line
/* Return nonzero value if X is subnormal. */
#pragma empty_line
#pragma empty_line
/* Return nonzero value if X is zero. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
extern "C++" {
#pragma line 754 "/usr/include/math.h" 3 4
template <class __T> inline bool
iszero (__T __val)
{
return __val == 0;
}
#pragma empty_line
} /* extern C++ */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* X/Open wants another strange constant. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Some useful constants. */
#pragma line 787 "/usr/include/math.h" 3 4
/* The above constants are not adequate for computation using `long double's.
Therefore we provide as an extension constants with similar names as a
GNU extension. Provide enough digits for the 128-bit IEEE quad. */
#pragma line 906 "/usr/include/math.h" 3 4
/* When compiling in strict ISO C compatible mode we must not use the
inline functions since they, among other things, do not set the
`errno' variable correctly. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* ISO C99 defines some macros to compare number while taking care for
unordered numbers. Many FPUs provide special instructions to support
these operations. Generic support in GCC for these as builtins went
in 2.97, but not all cpus added their patterns until 3.1. Therefore
we enable the builtins from 3.1 onwards and use a generic implementation
othwerwise. */
#pragma line 950 "/usr/include/math.h" 3 4
/* Get machine-dependent inline versions (if there are any). */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Define special entry points to use when the compiler got told to
only expect finite results. */
#pragma line 1177 "/usr/include/math.h" 3 4
/* An expression whose type has the widest of the evaluation formats
of X and Y (which are of floating-point types). */
#pragma line 1189 "/usr/include/math.h" 3 4
/* Return X == Y but raising "invalid" and setting errno if X or Y is
a NaN. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* In C++ mode, __MATH_TG cannot be used, because it relies on
__builtin_types_compatible_p, which is a C-only builtin. Moreover,
the comparison macros from ISO C take two floating-point arguments,
which need not have the same type. Choosing what underlying function
to call requires evaluating the formats of the arguments, then
selecting which is wider. The macro __MATH_EVAL_FMT2 provides this
information, however, only the type of the macro expansion is
relevant (actually evaluating the expression would be incorrect).
Thus, the type is used as a template parameter for __iseqsig_type,
which calls the appropriate underlying function. */
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 (double __x, double __y) throw ()
{
#pragma empty_line
return __iseqsigl (__x, __y);
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
};
#pragma line 1246 "/usr/include/math.h" 3 4
template<typename _T1, typename _T2>
inline int
iseqsig (_T1 __x, _T2 __y) throw ()
{
#pragma empty_line
#pragma empty_line
#pragma empty_line
typedef __typeof (((__x) + (__y) + 0.0f)) _T3;
#pragma empty_line
return __iseqsig_type<_T3>::__call (__x, __y);
}
#pragma empty_line
} /* extern "C++" */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 70 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_int_syn.h" 2
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/clang/bin/../lib/clang/3.1/include/limits.h" 1 3
/*===---- limits.h - Standard header for integer sizes --------------------===*\
*
* Copyright (c) 2009 Chris Lattner
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
\*===----------------------------------------------------------------------===*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* The system's limits.h may, in turn, try to #include_next GCC's limits.h.
Avert this #include_next madness. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* System headers include a number of constants from POSIX in <limits.h>.
Include it if we're hosted. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/limits.h" 1 3 4
/* Copyright (C) 1991-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
/*
* ISO C99 Standard: 7.10/5.2.4.2.1 Sizes of integer types <limits.h>
*/
#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/libc-header-start.h" 1 3 4
/* Handle feature test macros at the start of a header.
Copyright (C) 2016-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
/* This header is internal to glibc and should not be included outside
of glibc headers. Headers including it must define
__GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION first. This header
cannot have multiple include guards because ISO C feature test
macros depend on the definition of the macro when an affected
header is included, not when the first system header is
included. */
#pragma line 35 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 3 4
/* ISO/IEC TR 24731-2:2010 defines the __STDC_WANT_LIB_EXT2__
macro. */
#pragma line 45 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 3 4
/* ISO/IEC TS 18661-1:2014 defines the __STDC_WANT_IEC_60559_BFP_EXT__
macro. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* ISO/IEC TS 18661-4:2015 defines the
__STDC_WANT_IEC_60559_FUNCS_EXT__ macro. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* ISO/IEC TS 18661-3:2015 defines the
__STDC_WANT_IEC_60559_TYPES_EXT__ macro. */
#pragma line 27 "/usr/include/limits.h" 2 3 4
#pragma empty_line
#pragma empty_line
/* Maximum length of any multibyte character in any locale.
We define this value here since the gcc header does not define
the correct value. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* If we are not using GNU CC we have to define all the symbols ourself.
Otherwise use gcc's definitions (see below). */
#pragma line 117 "/usr/include/limits.h" 3 4
/* Get the compiler's limits.h, which defines almost all the ISO constants.
#pragma empty_line
We put this #include_next outside the double inclusion check because
it should be possible to include this file more than once and still get
the definitions from gcc's header. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* The <limits.h> files in some gcc versions don't define LLONG_MIN,
LLONG_MAX, and ULLONG_MAX. Instead only the values gcc defined for
ages are available. */
#pragma line 142 "/usr/include/limits.h" 3 4
/* The integer width macros are not defined by GCC's <limits.h> before
GCC 7, or if _GNU_SOURCE rather than
__STDC_WANT_IEC_60559_BFP_EXT__ is used to enable this feature. */
#pragma line 182 "/usr/include/limits.h" 3 4
/* POSIX adds things to <limits.h>. */
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 1 3 4
/* Copyright (C) 1991-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
/*
* POSIX Standard: 2.9.2 Minimum Values Added to <limits.h>
*
* Never include this file directly; use <limits.h> instead.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* These are the standard-mandated minimum values. */
#pragma empty_line
/* Minimum number of operations in one list I/O call. */
#pragma empty_line
#pragma empty_line
/* Minimal number of outstanding asynchronous I/O operations. */
#pragma empty_line
#pragma empty_line
/* Maximum length of arguments to `execve', including environment. */
#pragma empty_line
#pragma empty_line
/* Maximum simultaneous processes per real user ID. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Minimal number of timer expiration overruns. */
#pragma empty_line
#pragma empty_line
/* Maximum length of a host name (not including the terminating null)
as returned from the GETHOSTNAME function. */
#pragma empty_line
#pragma empty_line
/* Maximum link count of a file. */
#pragma empty_line
#pragma empty_line
/* Maximum length of login name. */
#pragma empty_line
#pragma empty_line
/* Number of bytes in a terminal canonical input queue. */
#pragma empty_line
#pragma empty_line
/* Number of bytes for which space will be
available in a terminal input queue. */
#pragma empty_line
#pragma empty_line
/* Maximum number of message queues open for a process. */
#pragma empty_line
#pragma empty_line
/* Maximum number of supported message priorities. */
#pragma empty_line
#pragma empty_line
/* Number of bytes in a filename. */
#pragma empty_line
#pragma empty_line
/* Number of simultaneous supplementary group IDs per process. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Number of files one process can have open at once. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Number of descriptors that a process may examine with `pselect' or
`select'. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Number of bytes in a pathname. */
#pragma empty_line
#pragma empty_line
/* Number of bytes than can be written atomically to a pipe. */
#pragma empty_line
#pragma empty_line
/* The number of repeated occurrences of a BRE permitted by the
REGEXEC and REGCOMP functions when using the interval notation. */
#pragma empty_line
#pragma empty_line
/* Minimal number of realtime signals reserved for the application. */
#pragma empty_line
#pragma empty_line
/* Number of semaphores a process can have. */
#pragma empty_line
#pragma empty_line
/* Maximal value of a semaphore. */
#pragma empty_line
#pragma empty_line
/* Number of pending realtime signals. */
#pragma empty_line
#pragma empty_line
/* Largest value of a `ssize_t'. */
#pragma empty_line
#pragma empty_line
/* Number of streams a process can have open at once. */
#pragma empty_line
#pragma empty_line
/* The number of bytes in a symbolic link. */
#pragma empty_line
#pragma empty_line
/* The number of symbolic links that can be traversed in the
resolution of a pathname in the absence of a loop. */
#pragma empty_line
#pragma empty_line
/* Number of timer for a process. */
#pragma empty_line
#pragma empty_line
/* Maximum number of characters in a tty name. */
#pragma empty_line
#pragma empty_line
/* Maximum length of a timezone name (element of `tzname'). */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Maximum number of connections that can be queued on a socket. */
#pragma empty_line
#pragma empty_line
/* Maximum number of bytes that can be buffered on a socket for send
or receive. */
#pragma empty_line
#pragma empty_line
/* Maximum number of elements in an `iovec' array. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Maximum clock resolution in nanoseconds. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Get the implementation-specific values for the above. */
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/local_lim.h" 1 3 4
/* Minimum guaranteed maximum values for system limits. Linux version.
Copyright (C) 1993-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public License as
published by the Free Software Foundation; either version 2.1 of the
License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; see the file COPYING.LIB. If
not, see <http://www.gnu.org/licenses/>. */
#pragma empty_line
/* The kernel header pollutes the namespace with the NR_OPEN symbol
and defines LINK_MAX although filesystems have different maxima. A
similar thing is true for OPEN_MAX: the limit can be changed at
runtime and therefore the macro must not be defined. Remove this
after including the header if necessary. */
#pragma line 37 "/usr/include/x86_64-linux-gnu/bits/local_lim.h" 3 4
/* The kernel sources contain a file with all the needed information. */
#pragma empty_line
#pragma line 1 "/usr/include/linux/limits.h" 1 3 4
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
#pragma line 39 "/usr/include/x86_64-linux-gnu/bits/local_lim.h" 2 3 4
#pragma empty_line
/* Have to remove NR_OPEN? */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Have to remove LINK_MAX? */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Have to remove OPEN_MAX? */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Have to remove ARG_MAX? */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* The number of data keys per process. */
#pragma empty_line
/* This is the value this implementation supports. */
#pragma empty_line
#pragma empty_line
/* Controlling the iterations of destructors for thread-specific data. */
#pragma empty_line
/* Number of iterations this implementation does. */
#pragma empty_line
#pragma empty_line
/* The number of threads per process. */
#pragma empty_line
/* We have no predefined limit on the number of threads. */
#pragma empty_line
#pragma empty_line
/* Maximum amount by which a process can descrease its asynchronous I/O
priority level. */
#pragma empty_line
#pragma empty_line
/* Minimum size for a thread. We are free to choose a reasonable value. */
#pragma empty_line
#pragma empty_line
/* Maximum number of timer expiration overruns. */
#pragma empty_line
#pragma empty_line
/* Maximum tty name length. */
#pragma empty_line
#pragma empty_line
/* Maximum login name length. This is arbitrary. */
#pragma empty_line
#pragma empty_line
/* Maximum host name length. */
#pragma empty_line
#pragma empty_line
/* Maximum message queue priority level. */
#pragma empty_line
#pragma empty_line
/* Maximum value the semaphore can have. */
#pragma line 161 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.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
/* This value is a guaranteed minimum maximum.
The current maximum can be got from `sysconf'. */
#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
/* Copyright (C) 1991-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
/*
* Never include this file directly; include <limits.h> instead.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* The maximum `ibase' and `obase' values allowed by the `bc' utility. */
#pragma empty_line
#pragma empty_line
/* The maximum number of elements allowed in an array by the `bc' utility. */
#pragma empty_line
#pragma empty_line
/* The maximum `scale' value allowed by the `bc' utility. */
#pragma empty_line
#pragma empty_line
/* The maximum length of a string constant accepted by the `bc' utility. */
#pragma empty_line
#pragma empty_line
/* The maximum number of weights that can be assigned to an entry of
the LC_COLLATE `order' keyword in the locale definition file. */
#pragma empty_line
#pragma empty_line
/* The maximum number of expressions that can be nested
within parentheses by the `expr' utility. */
#pragma empty_line
#pragma empty_line
/* The maximum length, in bytes, of an input line. */
#pragma empty_line
#pragma empty_line
/* The maximum number of repeated occurrences of a regular expression
permitted when using the interval notation `\{M,N\}'. */
#pragma empty_line
#pragma empty_line
/* The maximum number of bytes in a character class name. We have no
fixed limit, 2048 is a high number. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* These values are implementation-specific,
and may vary within the implementation.
Their precise values can be obtained from sysconf. */
#pragma line 87 "/usr/include/x86_64-linux-gnu/bits/posix2_lim.h" 3 4
/* This value is defined like this in regex.h. */
#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
/* Copyright (C) 1996-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
/*
* Never include this file directly; use <limits.h> instead.
*/
#pragma empty_line
/* Additional definitions from X/Open Portability Guide, Issue 4, Version 2
System Interfaces and Headers, 4.16 <limits.h>
#pragma empty_line
Please note only the values which are not greater than the minimum
stated in the standard document are listed. The `sysconf' functions
should be used to obtain the actual value. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* We do not provide fixed values for
#pragma empty_line
ARG_MAX Maximum length of argument to the `exec' function
including environment data.
#pragma empty_line
ATEXIT_MAX Maximum number of functions that may be registered
with `atexit'.
#pragma empty_line
CHILD_MAX Maximum number of simultaneous processes per real
user ID.
#pragma empty_line
OPEN_MAX Maximum number of files that one process can have open
at anyone time.
#pragma empty_line
PAGESIZE
PAGE_SIZE Size of bytes of a page.
#pragma empty_line
PASS_MAX Maximum number of significant bytes in a password.
#pragma empty_line
We only provide a fixed limit for
#pragma empty_line
IOV_MAX Maximum number of `iovec' structures that one process has
available for use with `readv' or writev'.
#pragma empty_line
if this is indeed fixed by the underlying system.
*/
#pragma empty_line
#pragma empty_line
/* Maximum number of `iovec' structures that may be used in a single call
to `readv', `writev', etc. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma line 1 "/usr/include/x86_64-linux-gnu/bits/uio_lim.h" 1 3 4
/* Implementation limits related to sys/uio.h - Linux version.
Copyright (C) 2017-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
#pragma empty_line
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
#pragma empty_line
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
#pragma empty_line
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Maximum length of the 'struct iovec' array in a single call to
readv or writev.
#pragma empty_line
This macro has different values in different kernel versions. The
latest versions of the kernel use 1024 and this is good choice. Since
the C library implementation of readv/writev is able to emulate the
functionality even if the currently running kernel does not support
this large value the readv/writev call will not fail because of this. */
#pragma line 65 "/usr/include/x86_64-linux-gnu/bits/xopen_lim.h" 2 3 4
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Maximum value of `digit' in calls to the `printf' and `scanf'
functions. We have no limit, so return a reasonable value. */
#pragma empty_line
#pragma empty_line
/* Maximum number of bytes in a `LANG' name. We have no limit. */
#pragma empty_line
#pragma empty_line
/* Maximum message number. We have no limit. */
#pragma empty_line
#pragma empty_line
/* Maximum number of bytes in N-to-1 collation mapping. We have no
limit. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Maximum set number. We have no limit. */
#pragma empty_line
#pragma empty_line
/* Maximum number of bytes in a message. We have no limit. */
#pragma empty_line
#pragma empty_line
/* Default process priority. */
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Number of bits in a word of type `int'. */
#pragma line 124 "/usr/include/x86_64-linux-gnu/bits/xopen_lim.h" 3 4
/* Number of bits in a word of type `long int'. */
#pragma line 136 "/usr/include/x86_64-linux-gnu/bits/xopen_lim.h" 3 4
/* Safe assumption. */
#pragma line 192 "/usr/include/limits.h" 2 3 4
#pragma line 39 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/clang/bin/../lib/clang/3.1/include/limits.h" 2 3
#pragma empty_line
#pragma empty_line
/* Many system headers try to "help us out" by defining these. No really, we
know how big each datatype is. */
#pragma line 60 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/clang/bin/../lib/clang/3.1/include/limits.h" 3
/* C90/99 5.2.4.2.1 */
#pragma line 90 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/clang/bin/../lib/clang/3.1/include/limits.h" 3
/* C99 5.2.4.2.1: Added long long. */
#pragma line 102 "/opt/Xilinx/Vivado_HLS/2016.4/lnx64/tools/clang/bin/../lib/clang/3.1/include/limits.h" 3
/* LONG_LONG_MIN/LONG_LONG_MAX/ULONG_LONG_MAX are a GNU extension. It's too bad
that we don't have something like #pragma poison that could be used to
deprecate a macro - the code should just use LLONG_MAX and friends.
*/
#pragma line 74 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_int_syn.h" 2
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* for safety*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* for safety*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/*for safety*/
#pragma line 110 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_int_syn.h"
typedef unsigned long long ap_ulong;
typedef signed long long ap_slong;
#pragma line 128 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_int_syn.h"
/*support SC mode*/
#pragma line 146 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_int_syn.h"
extern "C" void _ssdm_string2bits(...);
//#ifdef C99STRING
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Basic AP data types.
----------------------------------------------------------------
*/
template<int _AP_N, bool _AP_S> struct ssdm_int;
#pragma line 183 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_int_syn.h"
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/etc/autopilot_dt.def" 1
#pragma empty_line
#pragma empty_line
template<> struct ssdm_int<1 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<2 + 1024 * 0,true> { int V __attribute__ ((bitwidth(2 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<2 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<2 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(2 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<2 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<3 + 1024 * 0,true> { int V __attribute__ ((bitwidth(3 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<3 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<3 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(3 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<3 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<4 + 1024 * 0,true> { int V __attribute__ ((bitwidth(4 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<4 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<4 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(4 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<4 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<5 + 1024 * 0,true> { int V __attribute__ ((bitwidth(5 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<5 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<5 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(5 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<5 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<6 + 1024 * 0,true> { int V __attribute__ ((bitwidth(6 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<6 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<6 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(6 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<6 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<7 + 1024 * 0,true> { int V __attribute__ ((bitwidth(7 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<7 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<7 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(7 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<7 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<8 + 1024 * 0,true> { int V __attribute__ ((bitwidth(8 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<8 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<8 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(8 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<8 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<9 + 1024 * 0,true> { int V __attribute__ ((bitwidth(9 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<9 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<9 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(9 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<9 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<10 + 1024 * 0,true> { int V __attribute__ ((bitwidth(10 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<10 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<10 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(10 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<10 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<11 + 1024 * 0,true> { int V __attribute__ ((bitwidth(11 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<11 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<11 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(11 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<11 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<12 + 1024 * 0,true> { int V __attribute__ ((bitwidth(12 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<12 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<12 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(12 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<12 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<13 + 1024 * 0,true> { int V __attribute__ ((bitwidth(13 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<13 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<13 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(13 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<13 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<14 + 1024 * 0,true> { int V __attribute__ ((bitwidth(14 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<14 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<14 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(14 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<14 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<15 + 1024 * 0,true> { int V __attribute__ ((bitwidth(15 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<15 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<15 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(15 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<15 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<16 + 1024 * 0,true> { int V __attribute__ ((bitwidth(16 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<16 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<16 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(16 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<16 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<17 + 1024 * 0,true> { int V __attribute__ ((bitwidth(17 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<17 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<17 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(17 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<17 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<18 + 1024 * 0,true> { int V __attribute__ ((bitwidth(18 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<18 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<18 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(18 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<18 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<19 + 1024 * 0,true> { int V __attribute__ ((bitwidth(19 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<19 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<19 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(19 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<19 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<20 + 1024 * 0,true> { int V __attribute__ ((bitwidth(20 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<20 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<20 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(20 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<20 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<21 + 1024 * 0,true> { int V __attribute__ ((bitwidth(21 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<21 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<21 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(21 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<21 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<22 + 1024 * 0,true> { int V __attribute__ ((bitwidth(22 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<22 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<22 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(22 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<22 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<23 + 1024 * 0,true> { int V __attribute__ ((bitwidth(23 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<23 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<23 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(23 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<23 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<24 + 1024 * 0,true> { int V __attribute__ ((bitwidth(24 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<24 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<24 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(24 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<24 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<25 + 1024 * 0,true> { int V __attribute__ ((bitwidth(25 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<25 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<25 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(25 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<25 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<26 + 1024 * 0,true> { int V __attribute__ ((bitwidth(26 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<26 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<26 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(26 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<26 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<27 + 1024 * 0,true> { int V __attribute__ ((bitwidth(27 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<27 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<27 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(27 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<27 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<28 + 1024 * 0,true> { int V __attribute__ ((bitwidth(28 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<28 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<28 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(28 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<28 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<29 + 1024 * 0,true> { int V __attribute__ ((bitwidth(29 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<29 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<29 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(29 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<29 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<30 + 1024 * 0,true> { int V __attribute__ ((bitwidth(30 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<30 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<30 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(30 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<30 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<31 + 1024 * 0,true> { int V __attribute__ ((bitwidth(31 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<31 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<31 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(31 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<31 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<32 + 1024 * 0,true> { int V __attribute__ ((bitwidth(32 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<32 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<32 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(32 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<32 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<33 + 1024 * 0,true> { int V __attribute__ ((bitwidth(33 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<33 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<33 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(33 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<33 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<34 + 1024 * 0,true> { int V __attribute__ ((bitwidth(34 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<34 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<34 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(34 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<34 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<35 + 1024 * 0,true> { int V __attribute__ ((bitwidth(35 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<35 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<35 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(35 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<35 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<36 + 1024 * 0,true> { int V __attribute__ ((bitwidth(36 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<36 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<36 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(36 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<36 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<37 + 1024 * 0,true> { int V __attribute__ ((bitwidth(37 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<37 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<37 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(37 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<37 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<38 + 1024 * 0,true> { int V __attribute__ ((bitwidth(38 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<38 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<38 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(38 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<38 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<39 + 1024 * 0,true> { int V __attribute__ ((bitwidth(39 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<39 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<39 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(39 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<39 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<40 + 1024 * 0,true> { int V __attribute__ ((bitwidth(40 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<40 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<40 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(40 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<40 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<41 + 1024 * 0,true> { int V __attribute__ ((bitwidth(41 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<41 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<41 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(41 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<41 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<42 + 1024 * 0,true> { int V __attribute__ ((bitwidth(42 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<42 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<42 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(42 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<42 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<43 + 1024 * 0,true> { int V __attribute__ ((bitwidth(43 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<43 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<43 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(43 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<43 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<44 + 1024 * 0,true> { int V __attribute__ ((bitwidth(44 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<44 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<44 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(44 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<44 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<45 + 1024 * 0,true> { int V __attribute__ ((bitwidth(45 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<45 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<45 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(45 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<45 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<46 + 1024 * 0,true> { int V __attribute__ ((bitwidth(46 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<46 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<46 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(46 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<46 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<47 + 1024 * 0,true> { int V __attribute__ ((bitwidth(47 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<47 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<47 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(47 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<47 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<48 + 1024 * 0,true> { int V __attribute__ ((bitwidth(48 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<48 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<48 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(48 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<48 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<49 + 1024 * 0,true> { int V __attribute__ ((bitwidth(49 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<49 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<49 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(49 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<49 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<50 + 1024 * 0,true> { int V __attribute__ ((bitwidth(50 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<50 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<50 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(50 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<50 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<51 + 1024 * 0,true> { int V __attribute__ ((bitwidth(51 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<51 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<51 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(51 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<51 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<52 + 1024 * 0,true> { int V __attribute__ ((bitwidth(52 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<52 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<52 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(52 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<52 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<53 + 1024 * 0,true> { int V __attribute__ ((bitwidth(53 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<53 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<53 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(53 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<53 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<54 + 1024 * 0,true> { int V __attribute__ ((bitwidth(54 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<54 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<54 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(54 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<54 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<55 + 1024 * 0,true> { int V __attribute__ ((bitwidth(55 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<55 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<55 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(55 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<55 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<56 + 1024 * 0,true> { int V __attribute__ ((bitwidth(56 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<56 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<56 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(56 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<56 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<57 + 1024 * 0,true> { int V __attribute__ ((bitwidth(57 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<57 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<57 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(57 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<57 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<58 + 1024 * 0,true> { int V __attribute__ ((bitwidth(58 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<58 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<58 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(58 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<58 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<59 + 1024 * 0,true> { int V __attribute__ ((bitwidth(59 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<59 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<59 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(59 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<59 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<60 + 1024 * 0,true> { int V __attribute__ ((bitwidth(60 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<60 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<60 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(60 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<60 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<61 + 1024 * 0,true> { int V __attribute__ ((bitwidth(61 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<61 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<61 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(61 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<61 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<62 + 1024 * 0,true> { int V __attribute__ ((bitwidth(62 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<62 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<62 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(62 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<62 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<63 + 1024 * 0,true> { int V __attribute__ ((bitwidth(63 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<63 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<63 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(63 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<63 + 1024 * 0 , false>() { }; };
#pragma empty_line
#pragma empty_line
template<> struct ssdm_int<64 + 1024 * 0,true> { int V __attribute__ ((bitwidth(64 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<64 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<64 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(64 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<64 + 1024 * 0 , false>() { }; };
#pragma empty_line
#pragma empty_line
/*#if AUTOPILOT_VERSION >= 1 */
#pragma empty_line
template<> struct ssdm_int<65 + 1024 * 0,true> { int V __attribute__ ((bitwidth(65 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<65 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<65 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(65 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<65 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<66 + 1024 * 0,true> { int V __attribute__ ((bitwidth(66 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<66 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<66 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(66 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<66 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<67 + 1024 * 0,true> { int V __attribute__ ((bitwidth(67 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<67 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<67 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(67 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<67 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<68 + 1024 * 0,true> { int V __attribute__ ((bitwidth(68 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<68 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<68 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(68 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<68 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<69 + 1024 * 0,true> { int V __attribute__ ((bitwidth(69 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<69 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<69 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(69 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<69 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<70 + 1024 * 0,true> { int V __attribute__ ((bitwidth(70 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<70 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<70 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(70 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<70 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<71 + 1024 * 0,true> { int V __attribute__ ((bitwidth(71 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<71 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<71 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(71 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<71 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<72 + 1024 * 0,true> { int V __attribute__ ((bitwidth(72 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<72 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<72 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(72 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<72 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<73 + 1024 * 0,true> { int V __attribute__ ((bitwidth(73 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<73 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<73 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(73 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<73 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<74 + 1024 * 0,true> { int V __attribute__ ((bitwidth(74 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<74 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<74 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(74 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<74 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<75 + 1024 * 0,true> { int V __attribute__ ((bitwidth(75 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<75 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<75 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(75 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<75 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<76 + 1024 * 0,true> { int V __attribute__ ((bitwidth(76 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<76 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<76 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(76 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<76 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<77 + 1024 * 0,true> { int V __attribute__ ((bitwidth(77 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<77 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<77 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(77 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<77 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<78 + 1024 * 0,true> { int V __attribute__ ((bitwidth(78 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<78 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<78 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(78 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<78 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<79 + 1024 * 0,true> { int V __attribute__ ((bitwidth(79 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<79 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<79 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(79 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<79 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<80 + 1024 * 0,true> { int V __attribute__ ((bitwidth(80 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<80 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<80 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(80 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<80 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<81 + 1024 * 0,true> { int V __attribute__ ((bitwidth(81 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<81 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<81 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(81 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<81 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<82 + 1024 * 0,true> { int V __attribute__ ((bitwidth(82 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<82 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<82 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(82 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<82 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<83 + 1024 * 0,true> { int V __attribute__ ((bitwidth(83 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<83 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<83 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(83 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<83 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<84 + 1024 * 0,true> { int V __attribute__ ((bitwidth(84 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<84 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<84 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(84 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<84 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<85 + 1024 * 0,true> { int V __attribute__ ((bitwidth(85 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<85 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<85 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(85 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<85 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<86 + 1024 * 0,true> { int V __attribute__ ((bitwidth(86 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<86 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<86 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(86 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<86 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<87 + 1024 * 0,true> { int V __attribute__ ((bitwidth(87 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<87 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<87 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(87 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<87 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<88 + 1024 * 0,true> { int V __attribute__ ((bitwidth(88 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<88 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<88 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(88 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<88 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<89 + 1024 * 0,true> { int V __attribute__ ((bitwidth(89 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<89 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<89 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(89 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<89 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<90 + 1024 * 0,true> { int V __attribute__ ((bitwidth(90 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<90 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<90 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(90 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<90 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<91 + 1024 * 0,true> { int V __attribute__ ((bitwidth(91 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<91 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<91 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(91 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<91 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<92 + 1024 * 0,true> { int V __attribute__ ((bitwidth(92 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<92 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<92 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(92 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<92 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<93 + 1024 * 0,true> { int V __attribute__ ((bitwidth(93 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<93 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<93 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(93 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<93 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<94 + 1024 * 0,true> { int V __attribute__ ((bitwidth(94 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<94 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<94 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(94 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<94 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<95 + 1024 * 0,true> { int V __attribute__ ((bitwidth(95 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<95 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<95 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(95 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<95 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<96 + 1024 * 0,true> { int V __attribute__ ((bitwidth(96 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<96 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<96 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(96 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<96 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<97 + 1024 * 0,true> { int V __attribute__ ((bitwidth(97 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<97 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<97 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(97 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<97 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<98 + 1024 * 0,true> { int V __attribute__ ((bitwidth(98 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<98 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<98 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(98 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<98 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<99 + 1024 * 0,true> { int V __attribute__ ((bitwidth(99 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<99 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<99 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(99 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<99 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<100 + 1024 * 0,true> { int V __attribute__ ((bitwidth(100 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<100 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<100 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(100 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<100 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<101 + 1024 * 0,true> { int V __attribute__ ((bitwidth(101 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<101 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<101 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(101 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<101 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<102 + 1024 * 0,true> { int V __attribute__ ((bitwidth(102 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<102 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<102 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(102 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<102 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<103 + 1024 * 0,true> { int V __attribute__ ((bitwidth(103 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<103 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<103 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(103 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<103 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<104 + 1024 * 0,true> { int V __attribute__ ((bitwidth(104 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<104 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<104 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(104 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<104 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<105 + 1024 * 0,true> { int V __attribute__ ((bitwidth(105 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<105 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<105 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(105 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<105 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<106 + 1024 * 0,true> { int V __attribute__ ((bitwidth(106 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<106 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<106 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(106 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<106 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<107 + 1024 * 0,true> { int V __attribute__ ((bitwidth(107 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<107 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<107 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(107 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<107 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<108 + 1024 * 0,true> { int V __attribute__ ((bitwidth(108 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<108 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<108 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(108 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<108 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<109 + 1024 * 0,true> { int V __attribute__ ((bitwidth(109 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<109 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<109 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(109 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<109 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<110 + 1024 * 0,true> { int V __attribute__ ((bitwidth(110 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<110 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<110 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(110 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<110 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<111 + 1024 * 0,true> { int V __attribute__ ((bitwidth(111 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<111 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<111 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(111 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<111 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<112 + 1024 * 0,true> { int V __attribute__ ((bitwidth(112 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<112 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<112 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(112 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<112 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<113 + 1024 * 0,true> { int V __attribute__ ((bitwidth(113 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<113 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<113 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(113 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<113 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<114 + 1024 * 0,true> { int V __attribute__ ((bitwidth(114 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<114 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<114 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(114 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<114 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<115 + 1024 * 0,true> { int V __attribute__ ((bitwidth(115 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<115 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<115 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(115 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<115 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<116 + 1024 * 0,true> { int V __attribute__ ((bitwidth(116 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<116 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<116 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(116 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<116 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<117 + 1024 * 0,true> { int V __attribute__ ((bitwidth(117 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<117 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<117 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(117 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<117 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<118 + 1024 * 0,true> { int V __attribute__ ((bitwidth(118 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<118 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<118 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(118 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<118 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<119 + 1024 * 0,true> { int V __attribute__ ((bitwidth(119 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<119 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<119 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(119 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<119 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<120 + 1024 * 0,true> { int V __attribute__ ((bitwidth(120 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<120 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<120 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(120 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<120 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<121 + 1024 * 0,true> { int V __attribute__ ((bitwidth(121 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<121 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<121 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(121 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<121 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<122 + 1024 * 0,true> { int V __attribute__ ((bitwidth(122 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<122 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<122 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(122 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<122 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<123 + 1024 * 0,true> { int V __attribute__ ((bitwidth(123 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<123 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<123 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(123 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<123 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<124 + 1024 * 0,true> { int V __attribute__ ((bitwidth(124 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<124 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<124 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(124 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<124 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<125 + 1024 * 0,true> { int V __attribute__ ((bitwidth(125 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<125 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<125 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(125 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<125 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<126 + 1024 * 0,true> { int V __attribute__ ((bitwidth(126 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<126 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<126 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(126 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<126 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<127 + 1024 * 0,true> { int V __attribute__ ((bitwidth(127 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<127 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<127 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(127 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<127 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<128 + 1024 * 0,true> { int V __attribute__ ((bitwidth(128 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<128 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<128 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(128 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<128 + 1024 * 0 , false>() { }; };
#pragma empty_line
/*#endif*/
#pragma empty_line
#pragma empty_line
/*#ifdef EXTENDED_GCC*/
#pragma empty_line
template<> struct ssdm_int<129 + 1024 * 0,true> { int V __attribute__ ((bitwidth(129 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<129 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<129 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(129 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<129 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<130 + 1024 * 0,true> { int V __attribute__ ((bitwidth(130 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<130 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<130 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(130 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<130 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<131 + 1024 * 0,true> { int V __attribute__ ((bitwidth(131 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<131 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<131 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(131 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<131 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<132 + 1024 * 0,true> { int V __attribute__ ((bitwidth(132 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<132 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<132 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(132 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<132 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<133 + 1024 * 0,true> { int V __attribute__ ((bitwidth(133 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<133 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<133 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(133 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<133 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<134 + 1024 * 0,true> { int V __attribute__ ((bitwidth(134 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<134 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<134 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(134 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<134 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<135 + 1024 * 0,true> { int V __attribute__ ((bitwidth(135 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<135 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<135 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(135 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<135 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<136 + 1024 * 0,true> { int V __attribute__ ((bitwidth(136 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<136 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<136 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(136 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<136 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<137 + 1024 * 0,true> { int V __attribute__ ((bitwidth(137 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<137 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<137 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(137 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<137 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<138 + 1024 * 0,true> { int V __attribute__ ((bitwidth(138 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<138 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<138 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(138 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<138 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<139 + 1024 * 0,true> { int V __attribute__ ((bitwidth(139 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<139 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<139 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(139 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<139 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<140 + 1024 * 0,true> { int V __attribute__ ((bitwidth(140 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<140 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<140 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(140 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<140 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<141 + 1024 * 0,true> { int V __attribute__ ((bitwidth(141 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<141 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<141 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(141 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<141 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<142 + 1024 * 0,true> { int V __attribute__ ((bitwidth(142 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<142 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<142 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(142 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<142 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<143 + 1024 * 0,true> { int V __attribute__ ((bitwidth(143 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<143 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<143 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(143 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<143 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<144 + 1024 * 0,true> { int V __attribute__ ((bitwidth(144 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<144 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<144 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(144 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<144 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<145 + 1024 * 0,true> { int V __attribute__ ((bitwidth(145 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<145 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<145 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(145 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<145 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<146 + 1024 * 0,true> { int V __attribute__ ((bitwidth(146 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<146 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<146 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(146 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<146 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<147 + 1024 * 0,true> { int V __attribute__ ((bitwidth(147 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<147 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<147 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(147 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<147 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<148 + 1024 * 0,true> { int V __attribute__ ((bitwidth(148 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<148 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<148 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(148 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<148 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<149 + 1024 * 0,true> { int V __attribute__ ((bitwidth(149 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<149 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<149 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(149 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<149 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<150 + 1024 * 0,true> { int V __attribute__ ((bitwidth(150 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<150 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<150 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(150 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<150 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<151 + 1024 * 0,true> { int V __attribute__ ((bitwidth(151 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<151 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<151 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(151 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<151 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<152 + 1024 * 0,true> { int V __attribute__ ((bitwidth(152 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<152 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<152 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(152 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<152 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<153 + 1024 * 0,true> { int V __attribute__ ((bitwidth(153 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<153 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<153 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(153 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<153 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<154 + 1024 * 0,true> { int V __attribute__ ((bitwidth(154 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<154 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<154 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(154 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<154 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<155 + 1024 * 0,true> { int V __attribute__ ((bitwidth(155 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<155 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<155 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(155 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<155 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<156 + 1024 * 0,true> { int V __attribute__ ((bitwidth(156 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<156 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<156 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(156 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<156 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<157 + 1024 * 0,true> { int V __attribute__ ((bitwidth(157 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<157 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<157 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(157 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<157 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<158 + 1024 * 0,true> { int V __attribute__ ((bitwidth(158 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<158 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<158 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(158 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<158 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<159 + 1024 * 0,true> { int V __attribute__ ((bitwidth(159 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<159 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<159 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(159 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<159 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<160 + 1024 * 0,true> { int V __attribute__ ((bitwidth(160 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<160 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<160 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(160 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<160 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<161 + 1024 * 0,true> { int V __attribute__ ((bitwidth(161 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<161 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<161 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(161 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<161 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<162 + 1024 * 0,true> { int V __attribute__ ((bitwidth(162 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<162 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<162 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(162 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<162 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<163 + 1024 * 0,true> { int V __attribute__ ((bitwidth(163 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<163 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<163 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(163 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<163 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<164 + 1024 * 0,true> { int V __attribute__ ((bitwidth(164 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<164 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<164 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(164 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<164 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<165 + 1024 * 0,true> { int V __attribute__ ((bitwidth(165 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<165 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<165 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(165 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<165 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<166 + 1024 * 0,true> { int V __attribute__ ((bitwidth(166 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<166 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<166 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(166 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<166 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<167 + 1024 * 0,true> { int V __attribute__ ((bitwidth(167 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<167 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<167 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(167 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<167 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<168 + 1024 * 0,true> { int V __attribute__ ((bitwidth(168 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<168 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<168 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(168 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<168 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<169 + 1024 * 0,true> { int V __attribute__ ((bitwidth(169 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<169 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<169 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(169 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<169 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<170 + 1024 * 0,true> { int V __attribute__ ((bitwidth(170 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<170 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<170 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(170 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<170 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<171 + 1024 * 0,true> { int V __attribute__ ((bitwidth(171 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<171 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<171 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(171 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<171 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<172 + 1024 * 0,true> { int V __attribute__ ((bitwidth(172 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<172 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<172 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(172 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<172 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<173 + 1024 * 0,true> { int V __attribute__ ((bitwidth(173 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<173 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<173 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(173 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<173 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<174 + 1024 * 0,true> { int V __attribute__ ((bitwidth(174 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<174 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<174 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(174 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<174 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<175 + 1024 * 0,true> { int V __attribute__ ((bitwidth(175 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<175 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<175 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(175 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<175 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<176 + 1024 * 0,true> { int V __attribute__ ((bitwidth(176 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<176 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<176 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(176 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<176 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<177 + 1024 * 0,true> { int V __attribute__ ((bitwidth(177 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<177 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<177 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(177 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<177 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<178 + 1024 * 0,true> { int V __attribute__ ((bitwidth(178 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<178 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<178 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(178 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<178 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<179 + 1024 * 0,true> { int V __attribute__ ((bitwidth(179 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<179 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<179 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(179 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<179 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<180 + 1024 * 0,true> { int V __attribute__ ((bitwidth(180 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<180 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<180 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(180 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<180 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<181 + 1024 * 0,true> { int V __attribute__ ((bitwidth(181 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<181 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<181 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(181 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<181 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<182 + 1024 * 0,true> { int V __attribute__ ((bitwidth(182 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<182 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<182 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(182 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<182 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<183 + 1024 * 0,true> { int V __attribute__ ((bitwidth(183 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<183 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<183 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(183 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<183 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<184 + 1024 * 0,true> { int V __attribute__ ((bitwidth(184 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<184 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<184 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(184 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<184 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<185 + 1024 * 0,true> { int V __attribute__ ((bitwidth(185 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<185 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<185 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(185 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<185 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<186 + 1024 * 0,true> { int V __attribute__ ((bitwidth(186 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<186 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<186 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(186 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<186 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<187 + 1024 * 0,true> { int V __attribute__ ((bitwidth(187 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<187 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<187 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(187 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<187 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<188 + 1024 * 0,true> { int V __attribute__ ((bitwidth(188 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<188 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<188 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(188 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<188 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<189 + 1024 * 0,true> { int V __attribute__ ((bitwidth(189 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<189 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<189 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(189 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<189 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<190 + 1024 * 0,true> { int V __attribute__ ((bitwidth(190 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<190 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<190 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(190 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<190 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<191 + 1024 * 0,true> { int V __attribute__ ((bitwidth(191 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<191 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<191 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(191 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<191 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<192 + 1024 * 0,true> { int V __attribute__ ((bitwidth(192 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<192 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<192 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(192 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<192 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<193 + 1024 * 0,true> { int V __attribute__ ((bitwidth(193 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<193 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<193 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(193 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<193 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<194 + 1024 * 0,true> { int V __attribute__ ((bitwidth(194 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<194 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<194 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(194 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<194 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<195 + 1024 * 0,true> { int V __attribute__ ((bitwidth(195 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<195 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<195 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(195 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<195 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<196 + 1024 * 0,true> { int V __attribute__ ((bitwidth(196 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<196 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<196 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(196 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<196 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<197 + 1024 * 0,true> { int V __attribute__ ((bitwidth(197 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<197 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<197 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(197 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<197 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<198 + 1024 * 0,true> { int V __attribute__ ((bitwidth(198 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<198 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<198 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(198 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<198 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<199 + 1024 * 0,true> { int V __attribute__ ((bitwidth(199 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<199 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<199 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(199 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<199 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<200 + 1024 * 0,true> { int V __attribute__ ((bitwidth(200 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<200 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<200 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(200 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<200 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<201 + 1024 * 0,true> { int V __attribute__ ((bitwidth(201 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<201 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<201 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(201 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<201 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<202 + 1024 * 0,true> { int V __attribute__ ((bitwidth(202 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<202 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<202 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(202 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<202 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<203 + 1024 * 0,true> { int V __attribute__ ((bitwidth(203 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<203 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<203 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(203 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<203 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<204 + 1024 * 0,true> { int V __attribute__ ((bitwidth(204 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<204 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<204 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(204 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<204 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<205 + 1024 * 0,true> { int V __attribute__ ((bitwidth(205 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<205 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<205 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(205 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<205 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<206 + 1024 * 0,true> { int V __attribute__ ((bitwidth(206 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<206 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<206 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(206 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<206 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<207 + 1024 * 0,true> { int V __attribute__ ((bitwidth(207 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<207 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<207 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(207 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<207 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<208 + 1024 * 0,true> { int V __attribute__ ((bitwidth(208 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<208 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<208 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(208 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<208 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<209 + 1024 * 0,true> { int V __attribute__ ((bitwidth(209 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<209 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<209 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(209 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<209 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<210 + 1024 * 0,true> { int V __attribute__ ((bitwidth(210 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<210 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<210 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(210 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<210 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<211 + 1024 * 0,true> { int V __attribute__ ((bitwidth(211 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<211 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<211 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(211 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<211 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<212 + 1024 * 0,true> { int V __attribute__ ((bitwidth(212 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<212 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<212 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(212 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<212 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<213 + 1024 * 0,true> { int V __attribute__ ((bitwidth(213 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<213 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<213 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(213 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<213 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<214 + 1024 * 0,true> { int V __attribute__ ((bitwidth(214 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<214 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<214 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(214 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<214 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<215 + 1024 * 0,true> { int V __attribute__ ((bitwidth(215 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<215 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<215 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(215 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<215 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<216 + 1024 * 0,true> { int V __attribute__ ((bitwidth(216 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<216 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<216 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(216 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<216 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<217 + 1024 * 0,true> { int V __attribute__ ((bitwidth(217 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<217 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<217 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(217 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<217 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<218 + 1024 * 0,true> { int V __attribute__ ((bitwidth(218 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<218 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<218 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(218 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<218 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<219 + 1024 * 0,true> { int V __attribute__ ((bitwidth(219 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<219 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<219 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(219 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<219 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<220 + 1024 * 0,true> { int V __attribute__ ((bitwidth(220 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<220 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<220 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(220 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<220 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<221 + 1024 * 0,true> { int V __attribute__ ((bitwidth(221 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<221 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<221 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(221 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<221 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<222 + 1024 * 0,true> { int V __attribute__ ((bitwidth(222 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<222 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<222 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(222 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<222 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<223 + 1024 * 0,true> { int V __attribute__ ((bitwidth(223 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<223 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<223 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(223 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<223 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<224 + 1024 * 0,true> { int V __attribute__ ((bitwidth(224 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<224 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<224 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(224 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<224 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<225 + 1024 * 0,true> { int V __attribute__ ((bitwidth(225 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<225 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<225 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(225 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<225 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<226 + 1024 * 0,true> { int V __attribute__ ((bitwidth(226 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<226 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<226 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(226 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<226 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<227 + 1024 * 0,true> { int V __attribute__ ((bitwidth(227 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<227 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<227 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(227 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<227 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<228 + 1024 * 0,true> { int V __attribute__ ((bitwidth(228 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<228 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<228 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(228 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<228 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<229 + 1024 * 0,true> { int V __attribute__ ((bitwidth(229 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<229 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<229 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(229 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<229 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<230 + 1024 * 0,true> { int V __attribute__ ((bitwidth(230 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<230 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<230 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(230 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<230 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<231 + 1024 * 0,true> { int V __attribute__ ((bitwidth(231 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<231 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<231 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(231 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<231 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<232 + 1024 * 0,true> { int V __attribute__ ((bitwidth(232 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<232 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<232 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(232 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<232 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<233 + 1024 * 0,true> { int V __attribute__ ((bitwidth(233 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<233 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<233 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(233 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<233 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<234 + 1024 * 0,true> { int V __attribute__ ((bitwidth(234 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<234 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<234 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(234 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<234 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<235 + 1024 * 0,true> { int V __attribute__ ((bitwidth(235 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<235 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<235 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(235 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<235 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<236 + 1024 * 0,true> { int V __attribute__ ((bitwidth(236 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<236 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<236 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(236 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<236 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<237 + 1024 * 0,true> { int V __attribute__ ((bitwidth(237 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<237 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<237 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(237 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<237 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<238 + 1024 * 0,true> { int V __attribute__ ((bitwidth(238 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<238 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<238 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(238 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<238 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<239 + 1024 * 0,true> { int V __attribute__ ((bitwidth(239 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<239 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<239 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(239 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<239 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<240 + 1024 * 0,true> { int V __attribute__ ((bitwidth(240 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<240 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<240 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(240 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<240 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<241 + 1024 * 0,true> { int V __attribute__ ((bitwidth(241 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<241 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<241 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(241 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<241 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<242 + 1024 * 0,true> { int V __attribute__ ((bitwidth(242 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<242 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<242 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(242 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<242 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<243 + 1024 * 0,true> { int V __attribute__ ((bitwidth(243 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<243 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<243 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(243 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<243 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<244 + 1024 * 0,true> { int V __attribute__ ((bitwidth(244 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<244 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<244 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(244 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<244 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<245 + 1024 * 0,true> { int V __attribute__ ((bitwidth(245 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<245 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<245 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(245 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<245 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<246 + 1024 * 0,true> { int V __attribute__ ((bitwidth(246 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<246 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<246 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(246 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<246 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<247 + 1024 * 0,true> { int V __attribute__ ((bitwidth(247 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<247 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<247 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(247 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<247 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<248 + 1024 * 0,true> { int V __attribute__ ((bitwidth(248 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<248 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<248 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(248 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<248 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<249 + 1024 * 0,true> { int V __attribute__ ((bitwidth(249 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<249 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<249 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(249 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<249 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<250 + 1024 * 0,true> { int V __attribute__ ((bitwidth(250 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<250 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<250 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(250 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<250 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<251 + 1024 * 0,true> { int V __attribute__ ((bitwidth(251 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<251 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<251 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(251 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<251 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<252 + 1024 * 0,true> { int V __attribute__ ((bitwidth(252 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<252 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<252 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(252 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<252 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<253 + 1024 * 0,true> { int V __attribute__ ((bitwidth(253 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<253 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<253 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(253 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<253 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<254 + 1024 * 0,true> { int V __attribute__ ((bitwidth(254 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<254 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<254 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(254 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<254 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<255 + 1024 * 0,true> { int V __attribute__ ((bitwidth(255 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<255 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<255 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(255 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<255 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<256 + 1024 * 0,true> { int V __attribute__ ((bitwidth(256 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<256 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<256 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(256 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<256 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<257 + 1024 * 0,true> { int V __attribute__ ((bitwidth(257 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<257 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<257 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(257 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<257 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<258 + 1024 * 0,true> { int V __attribute__ ((bitwidth(258 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<258 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<258 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(258 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<258 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<259 + 1024 * 0,true> { int V __attribute__ ((bitwidth(259 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<259 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<259 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(259 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<259 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<260 + 1024 * 0,true> { int V __attribute__ ((bitwidth(260 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<260 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<260 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(260 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<260 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<261 + 1024 * 0,true> { int V __attribute__ ((bitwidth(261 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<261 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<261 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(261 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<261 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<262 + 1024 * 0,true> { int V __attribute__ ((bitwidth(262 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<262 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<262 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(262 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<262 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<263 + 1024 * 0,true> { int V __attribute__ ((bitwidth(263 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<263 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<263 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(263 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<263 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<264 + 1024 * 0,true> { int V __attribute__ ((bitwidth(264 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<264 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<264 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(264 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<264 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<265 + 1024 * 0,true> { int V __attribute__ ((bitwidth(265 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<265 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<265 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(265 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<265 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<266 + 1024 * 0,true> { int V __attribute__ ((bitwidth(266 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<266 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<266 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(266 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<266 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<267 + 1024 * 0,true> { int V __attribute__ ((bitwidth(267 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<267 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<267 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(267 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<267 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<268 + 1024 * 0,true> { int V __attribute__ ((bitwidth(268 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<268 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<268 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(268 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<268 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<269 + 1024 * 0,true> { int V __attribute__ ((bitwidth(269 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<269 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<269 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(269 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<269 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<270 + 1024 * 0,true> { int V __attribute__ ((bitwidth(270 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<270 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<270 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(270 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<270 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<271 + 1024 * 0,true> { int V __attribute__ ((bitwidth(271 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<271 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<271 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(271 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<271 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<272 + 1024 * 0,true> { int V __attribute__ ((bitwidth(272 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<272 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<272 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(272 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<272 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<273 + 1024 * 0,true> { int V __attribute__ ((bitwidth(273 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<273 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<273 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(273 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<273 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<274 + 1024 * 0,true> { int V __attribute__ ((bitwidth(274 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<274 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<274 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(274 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<274 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<275 + 1024 * 0,true> { int V __attribute__ ((bitwidth(275 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<275 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<275 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(275 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<275 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<276 + 1024 * 0,true> { int V __attribute__ ((bitwidth(276 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<276 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<276 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(276 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<276 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<277 + 1024 * 0,true> { int V __attribute__ ((bitwidth(277 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<277 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<277 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(277 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<277 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<278 + 1024 * 0,true> { int V __attribute__ ((bitwidth(278 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<278 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<278 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(278 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<278 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<279 + 1024 * 0,true> { int V __attribute__ ((bitwidth(279 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<279 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<279 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(279 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<279 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<280 + 1024 * 0,true> { int V __attribute__ ((bitwidth(280 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<280 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<280 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(280 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<280 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<281 + 1024 * 0,true> { int V __attribute__ ((bitwidth(281 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<281 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<281 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(281 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<281 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<282 + 1024 * 0,true> { int V __attribute__ ((bitwidth(282 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<282 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<282 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(282 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<282 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<283 + 1024 * 0,true> { int V __attribute__ ((bitwidth(283 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<283 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<283 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(283 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<283 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<284 + 1024 * 0,true> { int V __attribute__ ((bitwidth(284 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<284 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<284 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(284 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<284 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<285 + 1024 * 0,true> { int V __attribute__ ((bitwidth(285 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<285 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<285 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(285 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<285 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<286 + 1024 * 0,true> { int V __attribute__ ((bitwidth(286 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<286 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<286 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(286 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<286 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<287 + 1024 * 0,true> { int V __attribute__ ((bitwidth(287 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<287 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<287 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(287 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<287 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<288 + 1024 * 0,true> { int V __attribute__ ((bitwidth(288 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<288 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<288 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(288 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<288 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<289 + 1024 * 0,true> { int V __attribute__ ((bitwidth(289 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<289 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<289 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(289 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<289 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<290 + 1024 * 0,true> { int V __attribute__ ((bitwidth(290 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<290 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<290 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(290 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<290 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<291 + 1024 * 0,true> { int V __attribute__ ((bitwidth(291 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<291 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<291 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(291 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<291 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<292 + 1024 * 0,true> { int V __attribute__ ((bitwidth(292 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<292 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<292 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(292 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<292 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<293 + 1024 * 0,true> { int V __attribute__ ((bitwidth(293 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<293 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<293 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(293 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<293 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<294 + 1024 * 0,true> { int V __attribute__ ((bitwidth(294 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<294 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<294 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(294 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<294 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<295 + 1024 * 0,true> { int V __attribute__ ((bitwidth(295 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<295 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<295 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(295 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<295 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<296 + 1024 * 0,true> { int V __attribute__ ((bitwidth(296 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<296 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<296 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(296 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<296 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<297 + 1024 * 0,true> { int V __attribute__ ((bitwidth(297 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<297 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<297 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(297 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<297 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<298 + 1024 * 0,true> { int V __attribute__ ((bitwidth(298 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<298 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<298 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(298 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<298 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<299 + 1024 * 0,true> { int V __attribute__ ((bitwidth(299 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<299 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<299 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(299 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<299 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<300 + 1024 * 0,true> { int V __attribute__ ((bitwidth(300 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<300 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<300 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(300 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<300 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<301 + 1024 * 0,true> { int V __attribute__ ((bitwidth(301 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<301 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<301 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(301 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<301 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<302 + 1024 * 0,true> { int V __attribute__ ((bitwidth(302 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<302 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<302 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(302 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<302 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<303 + 1024 * 0,true> { int V __attribute__ ((bitwidth(303 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<303 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<303 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(303 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<303 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<304 + 1024 * 0,true> { int V __attribute__ ((bitwidth(304 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<304 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<304 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(304 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<304 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<305 + 1024 * 0,true> { int V __attribute__ ((bitwidth(305 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<305 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<305 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(305 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<305 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<306 + 1024 * 0,true> { int V __attribute__ ((bitwidth(306 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<306 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<306 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(306 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<306 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<307 + 1024 * 0,true> { int V __attribute__ ((bitwidth(307 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<307 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<307 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(307 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<307 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<308 + 1024 * 0,true> { int V __attribute__ ((bitwidth(308 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<308 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<308 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(308 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<308 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<309 + 1024 * 0,true> { int V __attribute__ ((bitwidth(309 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<309 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<309 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(309 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<309 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<310 + 1024 * 0,true> { int V __attribute__ ((bitwidth(310 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<310 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<310 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(310 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<310 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<311 + 1024 * 0,true> { int V __attribute__ ((bitwidth(311 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<311 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<311 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(311 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<311 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<312 + 1024 * 0,true> { int V __attribute__ ((bitwidth(312 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<312 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<312 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(312 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<312 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<313 + 1024 * 0,true> { int V __attribute__ ((bitwidth(313 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<313 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<313 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(313 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<313 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<314 + 1024 * 0,true> { int V __attribute__ ((bitwidth(314 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<314 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<314 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(314 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<314 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<315 + 1024 * 0,true> { int V __attribute__ ((bitwidth(315 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<315 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<315 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(315 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<315 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<316 + 1024 * 0,true> { int V __attribute__ ((bitwidth(316 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<316 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<316 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(316 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<316 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<317 + 1024 * 0,true> { int V __attribute__ ((bitwidth(317 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<317 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<317 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(317 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<317 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<318 + 1024 * 0,true> { int V __attribute__ ((bitwidth(318 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<318 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<318 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(318 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<318 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<319 + 1024 * 0,true> { int V __attribute__ ((bitwidth(319 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<319 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<319 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(319 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<319 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<320 + 1024 * 0,true> { int V __attribute__ ((bitwidth(320 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<320 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<320 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(320 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<320 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<321 + 1024 * 0,true> { int V __attribute__ ((bitwidth(321 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<321 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<321 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(321 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<321 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<322 + 1024 * 0,true> { int V __attribute__ ((bitwidth(322 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<322 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<322 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(322 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<322 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<323 + 1024 * 0,true> { int V __attribute__ ((bitwidth(323 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<323 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<323 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(323 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<323 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<324 + 1024 * 0,true> { int V __attribute__ ((bitwidth(324 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<324 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<324 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(324 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<324 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<325 + 1024 * 0,true> { int V __attribute__ ((bitwidth(325 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<325 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<325 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(325 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<325 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<326 + 1024 * 0,true> { int V __attribute__ ((bitwidth(326 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<326 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<326 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(326 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<326 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<327 + 1024 * 0,true> { int V __attribute__ ((bitwidth(327 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<327 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<327 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(327 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<327 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<328 + 1024 * 0,true> { int V __attribute__ ((bitwidth(328 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<328 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<328 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(328 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<328 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<329 + 1024 * 0,true> { int V __attribute__ ((bitwidth(329 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<329 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<329 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(329 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<329 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<330 + 1024 * 0,true> { int V __attribute__ ((bitwidth(330 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<330 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<330 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(330 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<330 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<331 + 1024 * 0,true> { int V __attribute__ ((bitwidth(331 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<331 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<331 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(331 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<331 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<332 + 1024 * 0,true> { int V __attribute__ ((bitwidth(332 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<332 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<332 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(332 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<332 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<333 + 1024 * 0,true> { int V __attribute__ ((bitwidth(333 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<333 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<333 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(333 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<333 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<334 + 1024 * 0,true> { int V __attribute__ ((bitwidth(334 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<334 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<334 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(334 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<334 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<335 + 1024 * 0,true> { int V __attribute__ ((bitwidth(335 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<335 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<335 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(335 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<335 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<336 + 1024 * 0,true> { int V __attribute__ ((bitwidth(336 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<336 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<336 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(336 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<336 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<337 + 1024 * 0,true> { int V __attribute__ ((bitwidth(337 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<337 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<337 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(337 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<337 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<338 + 1024 * 0,true> { int V __attribute__ ((bitwidth(338 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<338 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<338 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(338 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<338 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<339 + 1024 * 0,true> { int V __attribute__ ((bitwidth(339 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<339 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<339 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(339 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<339 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<340 + 1024 * 0,true> { int V __attribute__ ((bitwidth(340 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<340 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<340 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(340 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<340 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<341 + 1024 * 0,true> { int V __attribute__ ((bitwidth(341 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<341 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<341 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(341 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<341 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<342 + 1024 * 0,true> { int V __attribute__ ((bitwidth(342 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<342 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<342 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(342 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<342 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<343 + 1024 * 0,true> { int V __attribute__ ((bitwidth(343 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<343 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<343 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(343 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<343 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<344 + 1024 * 0,true> { int V __attribute__ ((bitwidth(344 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<344 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<344 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(344 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<344 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<345 + 1024 * 0,true> { int V __attribute__ ((bitwidth(345 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<345 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<345 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(345 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<345 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<346 + 1024 * 0,true> { int V __attribute__ ((bitwidth(346 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<346 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<346 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(346 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<346 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<347 + 1024 * 0,true> { int V __attribute__ ((bitwidth(347 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<347 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<347 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(347 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<347 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<348 + 1024 * 0,true> { int V __attribute__ ((bitwidth(348 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<348 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<348 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(348 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<348 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<349 + 1024 * 0,true> { int V __attribute__ ((bitwidth(349 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<349 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<349 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(349 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<349 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<350 + 1024 * 0,true> { int V __attribute__ ((bitwidth(350 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<350 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<350 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(350 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<350 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<351 + 1024 * 0,true> { int V __attribute__ ((bitwidth(351 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<351 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<351 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(351 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<351 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<352 + 1024 * 0,true> { int V __attribute__ ((bitwidth(352 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<352 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<352 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(352 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<352 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<353 + 1024 * 0,true> { int V __attribute__ ((bitwidth(353 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<353 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<353 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(353 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<353 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<354 + 1024 * 0,true> { int V __attribute__ ((bitwidth(354 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<354 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<354 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(354 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<354 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<355 + 1024 * 0,true> { int V __attribute__ ((bitwidth(355 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<355 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<355 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(355 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<355 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<356 + 1024 * 0,true> { int V __attribute__ ((bitwidth(356 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<356 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<356 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(356 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<356 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<357 + 1024 * 0,true> { int V __attribute__ ((bitwidth(357 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<357 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<357 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(357 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<357 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<358 + 1024 * 0,true> { int V __attribute__ ((bitwidth(358 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<358 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<358 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(358 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<358 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<359 + 1024 * 0,true> { int V __attribute__ ((bitwidth(359 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<359 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<359 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(359 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<359 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<360 + 1024 * 0,true> { int V __attribute__ ((bitwidth(360 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<360 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<360 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(360 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<360 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<361 + 1024 * 0,true> { int V __attribute__ ((bitwidth(361 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<361 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<361 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(361 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<361 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<362 + 1024 * 0,true> { int V __attribute__ ((bitwidth(362 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<362 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<362 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(362 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<362 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<363 + 1024 * 0,true> { int V __attribute__ ((bitwidth(363 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<363 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<363 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(363 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<363 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<364 + 1024 * 0,true> { int V __attribute__ ((bitwidth(364 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<364 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<364 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(364 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<364 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<365 + 1024 * 0,true> { int V __attribute__ ((bitwidth(365 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<365 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<365 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(365 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<365 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<366 + 1024 * 0,true> { int V __attribute__ ((bitwidth(366 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<366 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<366 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(366 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<366 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<367 + 1024 * 0,true> { int V __attribute__ ((bitwidth(367 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<367 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<367 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(367 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<367 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<368 + 1024 * 0,true> { int V __attribute__ ((bitwidth(368 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<368 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<368 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(368 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<368 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<369 + 1024 * 0,true> { int V __attribute__ ((bitwidth(369 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<369 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<369 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(369 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<369 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<370 + 1024 * 0,true> { int V __attribute__ ((bitwidth(370 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<370 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<370 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(370 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<370 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<371 + 1024 * 0,true> { int V __attribute__ ((bitwidth(371 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<371 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<371 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(371 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<371 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<372 + 1024 * 0,true> { int V __attribute__ ((bitwidth(372 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<372 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<372 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(372 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<372 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<373 + 1024 * 0,true> { int V __attribute__ ((bitwidth(373 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<373 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<373 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(373 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<373 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<374 + 1024 * 0,true> { int V __attribute__ ((bitwidth(374 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<374 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<374 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(374 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<374 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<375 + 1024 * 0,true> { int V __attribute__ ((bitwidth(375 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<375 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<375 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(375 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<375 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<376 + 1024 * 0,true> { int V __attribute__ ((bitwidth(376 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<376 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<376 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(376 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<376 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<377 + 1024 * 0,true> { int V __attribute__ ((bitwidth(377 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<377 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<377 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(377 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<377 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<378 + 1024 * 0,true> { int V __attribute__ ((bitwidth(378 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<378 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<378 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(378 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<378 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<379 + 1024 * 0,true> { int V __attribute__ ((bitwidth(379 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<379 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<379 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(379 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<379 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<380 + 1024 * 0,true> { int V __attribute__ ((bitwidth(380 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<380 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<380 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(380 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<380 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<381 + 1024 * 0,true> { int V __attribute__ ((bitwidth(381 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<381 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<381 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(381 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<381 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<382 + 1024 * 0,true> { int V __attribute__ ((bitwidth(382 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<382 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<382 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(382 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<382 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<383 + 1024 * 0,true> { int V __attribute__ ((bitwidth(383 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<383 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<383 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(383 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<383 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<384 + 1024 * 0,true> { int V __attribute__ ((bitwidth(384 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<384 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<384 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(384 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<384 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<385 + 1024 * 0,true> { int V __attribute__ ((bitwidth(385 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<385 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<385 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(385 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<385 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<386 + 1024 * 0,true> { int V __attribute__ ((bitwidth(386 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<386 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<386 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(386 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<386 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<387 + 1024 * 0,true> { int V __attribute__ ((bitwidth(387 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<387 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<387 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(387 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<387 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<388 + 1024 * 0,true> { int V __attribute__ ((bitwidth(388 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<388 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<388 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(388 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<388 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<389 + 1024 * 0,true> { int V __attribute__ ((bitwidth(389 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<389 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<389 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(389 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<389 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<390 + 1024 * 0,true> { int V __attribute__ ((bitwidth(390 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<390 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<390 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(390 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<390 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<391 + 1024 * 0,true> { int V __attribute__ ((bitwidth(391 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<391 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<391 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(391 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<391 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<392 + 1024 * 0,true> { int V __attribute__ ((bitwidth(392 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<392 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<392 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(392 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<392 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<393 + 1024 * 0,true> { int V __attribute__ ((bitwidth(393 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<393 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<393 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(393 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<393 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<394 + 1024 * 0,true> { int V __attribute__ ((bitwidth(394 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<394 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<394 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(394 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<394 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<395 + 1024 * 0,true> { int V __attribute__ ((bitwidth(395 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<395 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<395 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(395 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<395 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<396 + 1024 * 0,true> { int V __attribute__ ((bitwidth(396 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<396 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<396 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(396 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<396 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<397 + 1024 * 0,true> { int V __attribute__ ((bitwidth(397 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<397 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<397 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(397 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<397 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<398 + 1024 * 0,true> { int V __attribute__ ((bitwidth(398 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<398 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<398 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(398 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<398 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<399 + 1024 * 0,true> { int V __attribute__ ((bitwidth(399 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<399 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<399 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(399 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<399 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<400 + 1024 * 0,true> { int V __attribute__ ((bitwidth(400 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<400 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<400 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(400 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<400 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<401 + 1024 * 0,true> { int V __attribute__ ((bitwidth(401 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<401 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<401 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(401 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<401 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<402 + 1024 * 0,true> { int V __attribute__ ((bitwidth(402 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<402 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<402 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(402 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<402 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<403 + 1024 * 0,true> { int V __attribute__ ((bitwidth(403 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<403 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<403 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(403 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<403 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<404 + 1024 * 0,true> { int V __attribute__ ((bitwidth(404 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<404 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<404 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(404 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<404 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<405 + 1024 * 0,true> { int V __attribute__ ((bitwidth(405 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<405 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<405 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(405 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<405 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<406 + 1024 * 0,true> { int V __attribute__ ((bitwidth(406 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<406 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<406 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(406 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<406 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<407 + 1024 * 0,true> { int V __attribute__ ((bitwidth(407 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<407 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<407 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(407 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<407 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<408 + 1024 * 0,true> { int V __attribute__ ((bitwidth(408 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<408 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<408 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(408 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<408 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<409 + 1024 * 0,true> { int V __attribute__ ((bitwidth(409 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<409 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<409 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(409 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<409 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<410 + 1024 * 0,true> { int V __attribute__ ((bitwidth(410 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<410 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<410 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(410 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<410 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<411 + 1024 * 0,true> { int V __attribute__ ((bitwidth(411 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<411 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<411 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(411 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<411 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<412 + 1024 * 0,true> { int V __attribute__ ((bitwidth(412 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<412 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<412 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(412 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<412 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<413 + 1024 * 0,true> { int V __attribute__ ((bitwidth(413 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<413 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<413 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(413 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<413 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<414 + 1024 * 0,true> { int V __attribute__ ((bitwidth(414 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<414 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<414 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(414 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<414 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<415 + 1024 * 0,true> { int V __attribute__ ((bitwidth(415 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<415 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<415 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(415 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<415 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<416 + 1024 * 0,true> { int V __attribute__ ((bitwidth(416 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<416 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<416 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(416 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<416 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<417 + 1024 * 0,true> { int V __attribute__ ((bitwidth(417 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<417 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<417 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(417 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<417 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<418 + 1024 * 0,true> { int V __attribute__ ((bitwidth(418 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<418 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<418 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(418 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<418 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<419 + 1024 * 0,true> { int V __attribute__ ((bitwidth(419 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<419 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<419 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(419 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<419 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<420 + 1024 * 0,true> { int V __attribute__ ((bitwidth(420 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<420 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<420 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(420 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<420 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<421 + 1024 * 0,true> { int V __attribute__ ((bitwidth(421 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<421 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<421 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(421 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<421 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<422 + 1024 * 0,true> { int V __attribute__ ((bitwidth(422 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<422 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<422 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(422 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<422 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<423 + 1024 * 0,true> { int V __attribute__ ((bitwidth(423 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<423 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<423 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(423 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<423 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<424 + 1024 * 0,true> { int V __attribute__ ((bitwidth(424 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<424 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<424 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(424 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<424 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<425 + 1024 * 0,true> { int V __attribute__ ((bitwidth(425 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<425 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<425 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(425 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<425 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<426 + 1024 * 0,true> { int V __attribute__ ((bitwidth(426 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<426 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<426 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(426 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<426 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<427 + 1024 * 0,true> { int V __attribute__ ((bitwidth(427 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<427 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<427 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(427 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<427 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<428 + 1024 * 0,true> { int V __attribute__ ((bitwidth(428 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<428 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<428 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(428 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<428 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<429 + 1024 * 0,true> { int V __attribute__ ((bitwidth(429 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<429 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<429 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(429 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<429 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<430 + 1024 * 0,true> { int V __attribute__ ((bitwidth(430 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<430 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<430 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(430 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<430 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<431 + 1024 * 0,true> { int V __attribute__ ((bitwidth(431 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<431 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<431 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(431 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<431 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<432 + 1024 * 0,true> { int V __attribute__ ((bitwidth(432 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<432 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<432 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(432 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<432 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<433 + 1024 * 0,true> { int V __attribute__ ((bitwidth(433 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<433 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<433 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(433 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<433 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<434 + 1024 * 0,true> { int V __attribute__ ((bitwidth(434 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<434 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<434 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(434 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<434 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<435 + 1024 * 0,true> { int V __attribute__ ((bitwidth(435 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<435 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<435 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(435 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<435 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<436 + 1024 * 0,true> { int V __attribute__ ((bitwidth(436 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<436 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<436 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(436 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<436 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<437 + 1024 * 0,true> { int V __attribute__ ((bitwidth(437 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<437 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<437 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(437 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<437 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<438 + 1024 * 0,true> { int V __attribute__ ((bitwidth(438 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<438 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<438 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(438 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<438 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<439 + 1024 * 0,true> { int V __attribute__ ((bitwidth(439 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<439 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<439 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(439 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<439 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<440 + 1024 * 0,true> { int V __attribute__ ((bitwidth(440 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<440 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<440 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(440 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<440 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<441 + 1024 * 0,true> { int V __attribute__ ((bitwidth(441 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<441 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<441 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(441 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<441 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<442 + 1024 * 0,true> { int V __attribute__ ((bitwidth(442 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<442 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<442 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(442 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<442 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<443 + 1024 * 0,true> { int V __attribute__ ((bitwidth(443 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<443 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<443 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(443 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<443 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<444 + 1024 * 0,true> { int V __attribute__ ((bitwidth(444 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<444 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<444 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(444 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<444 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<445 + 1024 * 0,true> { int V __attribute__ ((bitwidth(445 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<445 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<445 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(445 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<445 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<446 + 1024 * 0,true> { int V __attribute__ ((bitwidth(446 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<446 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<446 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(446 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<446 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<447 + 1024 * 0,true> { int V __attribute__ ((bitwidth(447 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<447 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<447 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(447 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<447 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<448 + 1024 * 0,true> { int V __attribute__ ((bitwidth(448 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<448 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<448 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(448 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<448 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<449 + 1024 * 0,true> { int V __attribute__ ((bitwidth(449 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<449 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<449 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(449 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<449 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<450 + 1024 * 0,true> { int V __attribute__ ((bitwidth(450 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<450 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<450 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(450 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<450 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<451 + 1024 * 0,true> { int V __attribute__ ((bitwidth(451 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<451 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<451 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(451 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<451 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<452 + 1024 * 0,true> { int V __attribute__ ((bitwidth(452 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<452 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<452 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(452 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<452 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<453 + 1024 * 0,true> { int V __attribute__ ((bitwidth(453 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<453 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<453 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(453 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<453 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<454 + 1024 * 0,true> { int V __attribute__ ((bitwidth(454 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<454 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<454 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(454 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<454 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<455 + 1024 * 0,true> { int V __attribute__ ((bitwidth(455 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<455 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<455 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(455 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<455 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<456 + 1024 * 0,true> { int V __attribute__ ((bitwidth(456 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<456 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<456 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(456 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<456 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<457 + 1024 * 0,true> { int V __attribute__ ((bitwidth(457 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<457 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<457 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(457 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<457 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<458 + 1024 * 0,true> { int V __attribute__ ((bitwidth(458 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<458 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<458 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(458 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<458 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<459 + 1024 * 0,true> { int V __attribute__ ((bitwidth(459 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<459 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<459 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(459 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<459 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<460 + 1024 * 0,true> { int V __attribute__ ((bitwidth(460 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<460 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<460 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(460 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<460 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<461 + 1024 * 0,true> { int V __attribute__ ((bitwidth(461 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<461 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<461 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(461 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<461 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<462 + 1024 * 0,true> { int V __attribute__ ((bitwidth(462 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<462 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<462 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(462 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<462 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<463 + 1024 * 0,true> { int V __attribute__ ((bitwidth(463 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<463 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<463 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(463 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<463 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<464 + 1024 * 0,true> { int V __attribute__ ((bitwidth(464 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<464 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<464 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(464 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<464 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<465 + 1024 * 0,true> { int V __attribute__ ((bitwidth(465 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<465 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<465 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(465 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<465 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<466 + 1024 * 0,true> { int V __attribute__ ((bitwidth(466 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<466 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<466 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(466 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<466 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<467 + 1024 * 0,true> { int V __attribute__ ((bitwidth(467 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<467 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<467 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(467 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<467 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<468 + 1024 * 0,true> { int V __attribute__ ((bitwidth(468 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<468 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<468 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(468 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<468 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<469 + 1024 * 0,true> { int V __attribute__ ((bitwidth(469 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<469 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<469 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(469 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<469 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<470 + 1024 * 0,true> { int V __attribute__ ((bitwidth(470 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<470 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<470 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(470 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<470 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<471 + 1024 * 0,true> { int V __attribute__ ((bitwidth(471 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<471 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<471 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(471 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<471 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<472 + 1024 * 0,true> { int V __attribute__ ((bitwidth(472 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<472 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<472 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(472 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<472 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<473 + 1024 * 0,true> { int V __attribute__ ((bitwidth(473 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<473 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<473 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(473 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<473 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<474 + 1024 * 0,true> { int V __attribute__ ((bitwidth(474 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<474 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<474 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(474 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<474 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<475 + 1024 * 0,true> { int V __attribute__ ((bitwidth(475 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<475 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<475 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(475 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<475 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<476 + 1024 * 0,true> { int V __attribute__ ((bitwidth(476 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<476 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<476 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(476 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<476 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<477 + 1024 * 0,true> { int V __attribute__ ((bitwidth(477 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<477 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<477 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(477 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<477 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<478 + 1024 * 0,true> { int V __attribute__ ((bitwidth(478 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<478 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<478 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(478 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<478 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<479 + 1024 * 0,true> { int V __attribute__ ((bitwidth(479 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<479 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<479 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(479 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<479 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<480 + 1024 * 0,true> { int V __attribute__ ((bitwidth(480 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<480 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<480 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(480 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<480 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<481 + 1024 * 0,true> { int V __attribute__ ((bitwidth(481 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<481 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<481 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(481 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<481 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<482 + 1024 * 0,true> { int V __attribute__ ((bitwidth(482 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<482 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<482 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(482 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<482 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<483 + 1024 * 0,true> { int V __attribute__ ((bitwidth(483 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<483 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<483 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(483 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<483 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<484 + 1024 * 0,true> { int V __attribute__ ((bitwidth(484 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<484 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<484 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(484 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<484 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<485 + 1024 * 0,true> { int V __attribute__ ((bitwidth(485 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<485 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<485 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(485 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<485 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<486 + 1024 * 0,true> { int V __attribute__ ((bitwidth(486 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<486 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<486 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(486 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<486 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<487 + 1024 * 0,true> { int V __attribute__ ((bitwidth(487 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<487 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<487 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(487 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<487 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<488 + 1024 * 0,true> { int V __attribute__ ((bitwidth(488 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<488 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<488 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(488 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<488 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<489 + 1024 * 0,true> { int V __attribute__ ((bitwidth(489 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<489 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<489 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(489 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<489 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<490 + 1024 * 0,true> { int V __attribute__ ((bitwidth(490 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<490 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<490 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(490 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<490 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<491 + 1024 * 0,true> { int V __attribute__ ((bitwidth(491 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<491 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<491 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(491 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<491 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<492 + 1024 * 0,true> { int V __attribute__ ((bitwidth(492 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<492 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<492 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(492 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<492 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<493 + 1024 * 0,true> { int V __attribute__ ((bitwidth(493 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<493 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<493 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(493 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<493 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<494 + 1024 * 0,true> { int V __attribute__ ((bitwidth(494 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<494 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<494 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(494 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<494 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<495 + 1024 * 0,true> { int V __attribute__ ((bitwidth(495 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<495 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<495 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(495 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<495 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<496 + 1024 * 0,true> { int V __attribute__ ((bitwidth(496 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<496 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<496 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(496 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<496 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<497 + 1024 * 0,true> { int V __attribute__ ((bitwidth(497 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<497 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<497 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(497 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<497 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<498 + 1024 * 0,true> { int V __attribute__ ((bitwidth(498 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<498 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<498 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(498 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<498 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<499 + 1024 * 0,true> { int V __attribute__ ((bitwidth(499 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<499 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<499 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(499 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<499 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<500 + 1024 * 0,true> { int V __attribute__ ((bitwidth(500 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<500 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<500 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(500 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<500 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<501 + 1024 * 0,true> { int V __attribute__ ((bitwidth(501 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<501 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<501 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(501 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<501 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<502 + 1024 * 0,true> { int V __attribute__ ((bitwidth(502 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<502 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<502 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(502 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<502 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<503 + 1024 * 0,true> { int V __attribute__ ((bitwidth(503 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<503 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<503 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(503 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<503 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<504 + 1024 * 0,true> { int V __attribute__ ((bitwidth(504 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<504 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<504 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(504 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<504 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<505 + 1024 * 0,true> { int V __attribute__ ((bitwidth(505 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<505 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<505 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(505 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<505 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<506 + 1024 * 0,true> { int V __attribute__ ((bitwidth(506 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<506 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<506 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(506 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<506 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<507 + 1024 * 0,true> { int V __attribute__ ((bitwidth(507 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<507 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<507 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(507 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<507 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<508 + 1024 * 0,true> { int V __attribute__ ((bitwidth(508 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<508 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<508 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(508 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<508 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<509 + 1024 * 0,true> { int V __attribute__ ((bitwidth(509 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<509 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<509 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(509 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<509 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<510 + 1024 * 0,true> { int V __attribute__ ((bitwidth(510 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<510 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<510 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(510 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<510 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<511 + 1024 * 0,true> { int V __attribute__ ((bitwidth(511 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<511 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<511 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(511 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<511 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<512 + 1024 * 0,true> { int V __attribute__ ((bitwidth(512 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<512 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<512 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(512 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<512 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<513 + 1024 * 0,true> { int V __attribute__ ((bitwidth(513 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<513 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<513 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(513 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<513 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<514 + 1024 * 0,true> { int V __attribute__ ((bitwidth(514 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<514 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<514 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(514 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<514 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<515 + 1024 * 0,true> { int V __attribute__ ((bitwidth(515 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<515 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<515 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(515 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<515 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<516 + 1024 * 0,true> { int V __attribute__ ((bitwidth(516 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<516 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<516 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(516 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<516 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<517 + 1024 * 0,true> { int V __attribute__ ((bitwidth(517 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<517 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<517 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(517 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<517 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<518 + 1024 * 0,true> { int V __attribute__ ((bitwidth(518 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<518 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<518 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(518 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<518 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<519 + 1024 * 0,true> { int V __attribute__ ((bitwidth(519 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<519 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<519 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(519 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<519 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<520 + 1024 * 0,true> { int V __attribute__ ((bitwidth(520 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<520 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<520 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(520 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<520 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<521 + 1024 * 0,true> { int V __attribute__ ((bitwidth(521 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<521 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<521 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(521 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<521 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<522 + 1024 * 0,true> { int V __attribute__ ((bitwidth(522 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<522 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<522 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(522 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<522 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<523 + 1024 * 0,true> { int V __attribute__ ((bitwidth(523 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<523 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<523 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(523 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<523 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<524 + 1024 * 0,true> { int V __attribute__ ((bitwidth(524 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<524 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<524 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(524 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<524 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<525 + 1024 * 0,true> { int V __attribute__ ((bitwidth(525 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<525 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<525 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(525 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<525 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<526 + 1024 * 0,true> { int V __attribute__ ((bitwidth(526 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<526 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<526 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(526 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<526 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<527 + 1024 * 0,true> { int V __attribute__ ((bitwidth(527 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<527 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<527 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(527 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<527 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<528 + 1024 * 0,true> { int V __attribute__ ((bitwidth(528 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<528 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<528 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(528 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<528 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<529 + 1024 * 0,true> { int V __attribute__ ((bitwidth(529 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<529 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<529 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(529 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<529 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<530 + 1024 * 0,true> { int V __attribute__ ((bitwidth(530 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<530 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<530 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(530 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<530 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<531 + 1024 * 0,true> { int V __attribute__ ((bitwidth(531 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<531 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<531 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(531 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<531 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<532 + 1024 * 0,true> { int V __attribute__ ((bitwidth(532 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<532 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<532 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(532 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<532 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<533 + 1024 * 0,true> { int V __attribute__ ((bitwidth(533 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<533 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<533 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(533 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<533 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<534 + 1024 * 0,true> { int V __attribute__ ((bitwidth(534 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<534 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<534 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(534 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<534 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<535 + 1024 * 0,true> { int V __attribute__ ((bitwidth(535 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<535 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<535 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(535 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<535 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<536 + 1024 * 0,true> { int V __attribute__ ((bitwidth(536 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<536 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<536 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(536 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<536 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<537 + 1024 * 0,true> { int V __attribute__ ((bitwidth(537 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<537 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<537 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(537 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<537 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<538 + 1024 * 0,true> { int V __attribute__ ((bitwidth(538 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<538 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<538 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(538 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<538 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<539 + 1024 * 0,true> { int V __attribute__ ((bitwidth(539 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<539 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<539 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(539 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<539 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<540 + 1024 * 0,true> { int V __attribute__ ((bitwidth(540 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<540 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<540 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(540 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<540 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<541 + 1024 * 0,true> { int V __attribute__ ((bitwidth(541 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<541 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<541 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(541 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<541 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<542 + 1024 * 0,true> { int V __attribute__ ((bitwidth(542 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<542 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<542 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(542 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<542 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<543 + 1024 * 0,true> { int V __attribute__ ((bitwidth(543 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<543 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<543 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(543 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<543 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<544 + 1024 * 0,true> { int V __attribute__ ((bitwidth(544 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<544 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<544 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(544 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<544 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<545 + 1024 * 0,true> { int V __attribute__ ((bitwidth(545 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<545 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<545 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(545 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<545 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<546 + 1024 * 0,true> { int V __attribute__ ((bitwidth(546 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<546 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<546 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(546 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<546 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<547 + 1024 * 0,true> { int V __attribute__ ((bitwidth(547 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<547 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<547 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(547 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<547 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<548 + 1024 * 0,true> { int V __attribute__ ((bitwidth(548 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<548 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<548 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(548 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<548 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<549 + 1024 * 0,true> { int V __attribute__ ((bitwidth(549 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<549 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<549 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(549 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<549 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<550 + 1024 * 0,true> { int V __attribute__ ((bitwidth(550 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<550 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<550 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(550 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<550 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<551 + 1024 * 0,true> { int V __attribute__ ((bitwidth(551 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<551 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<551 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(551 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<551 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<552 + 1024 * 0,true> { int V __attribute__ ((bitwidth(552 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<552 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<552 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(552 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<552 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<553 + 1024 * 0,true> { int V __attribute__ ((bitwidth(553 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<553 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<553 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(553 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<553 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<554 + 1024 * 0,true> { int V __attribute__ ((bitwidth(554 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<554 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<554 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(554 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<554 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<555 + 1024 * 0,true> { int V __attribute__ ((bitwidth(555 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<555 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<555 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(555 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<555 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<556 + 1024 * 0,true> { int V __attribute__ ((bitwidth(556 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<556 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<556 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(556 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<556 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<557 + 1024 * 0,true> { int V __attribute__ ((bitwidth(557 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<557 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<557 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(557 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<557 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<558 + 1024 * 0,true> { int V __attribute__ ((bitwidth(558 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<558 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<558 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(558 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<558 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<559 + 1024 * 0,true> { int V __attribute__ ((bitwidth(559 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<559 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<559 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(559 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<559 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<560 + 1024 * 0,true> { int V __attribute__ ((bitwidth(560 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<560 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<560 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(560 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<560 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<561 + 1024 * 0,true> { int V __attribute__ ((bitwidth(561 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<561 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<561 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(561 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<561 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<562 + 1024 * 0,true> { int V __attribute__ ((bitwidth(562 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<562 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<562 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(562 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<562 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<563 + 1024 * 0,true> { int V __attribute__ ((bitwidth(563 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<563 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<563 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(563 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<563 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<564 + 1024 * 0,true> { int V __attribute__ ((bitwidth(564 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<564 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<564 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(564 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<564 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<565 + 1024 * 0,true> { int V __attribute__ ((bitwidth(565 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<565 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<565 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(565 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<565 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<566 + 1024 * 0,true> { int V __attribute__ ((bitwidth(566 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<566 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<566 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(566 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<566 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<567 + 1024 * 0,true> { int V __attribute__ ((bitwidth(567 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<567 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<567 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(567 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<567 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<568 + 1024 * 0,true> { int V __attribute__ ((bitwidth(568 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<568 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<568 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(568 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<568 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<569 + 1024 * 0,true> { int V __attribute__ ((bitwidth(569 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<569 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<569 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(569 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<569 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<570 + 1024 * 0,true> { int V __attribute__ ((bitwidth(570 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<570 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<570 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(570 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<570 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<571 + 1024 * 0,true> { int V __attribute__ ((bitwidth(571 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<571 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<571 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(571 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<571 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<572 + 1024 * 0,true> { int V __attribute__ ((bitwidth(572 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<572 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<572 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(572 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<572 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<573 + 1024 * 0,true> { int V __attribute__ ((bitwidth(573 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<573 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<573 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(573 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<573 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<574 + 1024 * 0,true> { int V __attribute__ ((bitwidth(574 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<574 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<574 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(574 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<574 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<575 + 1024 * 0,true> { int V __attribute__ ((bitwidth(575 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<575 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<575 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(575 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<575 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<576 + 1024 * 0,true> { int V __attribute__ ((bitwidth(576 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<576 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<576 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(576 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<576 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<577 + 1024 * 0,true> { int V __attribute__ ((bitwidth(577 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<577 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<577 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(577 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<577 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<578 + 1024 * 0,true> { int V __attribute__ ((bitwidth(578 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<578 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<578 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(578 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<578 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<579 + 1024 * 0,true> { int V __attribute__ ((bitwidth(579 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<579 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<579 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(579 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<579 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<580 + 1024 * 0,true> { int V __attribute__ ((bitwidth(580 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<580 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<580 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(580 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<580 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<581 + 1024 * 0,true> { int V __attribute__ ((bitwidth(581 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<581 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<581 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(581 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<581 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<582 + 1024 * 0,true> { int V __attribute__ ((bitwidth(582 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<582 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<582 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(582 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<582 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<583 + 1024 * 0,true> { int V __attribute__ ((bitwidth(583 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<583 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<583 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(583 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<583 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<584 + 1024 * 0,true> { int V __attribute__ ((bitwidth(584 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<584 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<584 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(584 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<584 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<585 + 1024 * 0,true> { int V __attribute__ ((bitwidth(585 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<585 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<585 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(585 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<585 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<586 + 1024 * 0,true> { int V __attribute__ ((bitwidth(586 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<586 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<586 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(586 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<586 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<587 + 1024 * 0,true> { int V __attribute__ ((bitwidth(587 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<587 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<587 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(587 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<587 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<588 + 1024 * 0,true> { int V __attribute__ ((bitwidth(588 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<588 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<588 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(588 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<588 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<589 + 1024 * 0,true> { int V __attribute__ ((bitwidth(589 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<589 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<589 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(589 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<589 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<590 + 1024 * 0,true> { int V __attribute__ ((bitwidth(590 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<590 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<590 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(590 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<590 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<591 + 1024 * 0,true> { int V __attribute__ ((bitwidth(591 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<591 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<591 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(591 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<591 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<592 + 1024 * 0,true> { int V __attribute__ ((bitwidth(592 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<592 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<592 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(592 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<592 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<593 + 1024 * 0,true> { int V __attribute__ ((bitwidth(593 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<593 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<593 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(593 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<593 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<594 + 1024 * 0,true> { int V __attribute__ ((bitwidth(594 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<594 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<594 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(594 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<594 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<595 + 1024 * 0,true> { int V __attribute__ ((bitwidth(595 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<595 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<595 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(595 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<595 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<596 + 1024 * 0,true> { int V __attribute__ ((bitwidth(596 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<596 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<596 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(596 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<596 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<597 + 1024 * 0,true> { int V __attribute__ ((bitwidth(597 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<597 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<597 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(597 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<597 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<598 + 1024 * 0,true> { int V __attribute__ ((bitwidth(598 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<598 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<598 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(598 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<598 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<599 + 1024 * 0,true> { int V __attribute__ ((bitwidth(599 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<599 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<599 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(599 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<599 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<600 + 1024 * 0,true> { int V __attribute__ ((bitwidth(600 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<600 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<600 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(600 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<600 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<601 + 1024 * 0,true> { int V __attribute__ ((bitwidth(601 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<601 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<601 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(601 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<601 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<602 + 1024 * 0,true> { int V __attribute__ ((bitwidth(602 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<602 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<602 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(602 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<602 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<603 + 1024 * 0,true> { int V __attribute__ ((bitwidth(603 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<603 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<603 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(603 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<603 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<604 + 1024 * 0,true> { int V __attribute__ ((bitwidth(604 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<604 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<604 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(604 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<604 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<605 + 1024 * 0,true> { int V __attribute__ ((bitwidth(605 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<605 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<605 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(605 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<605 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<606 + 1024 * 0,true> { int V __attribute__ ((bitwidth(606 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<606 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<606 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(606 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<606 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<607 + 1024 * 0,true> { int V __attribute__ ((bitwidth(607 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<607 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<607 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(607 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<607 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<608 + 1024 * 0,true> { int V __attribute__ ((bitwidth(608 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<608 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<608 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(608 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<608 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<609 + 1024 * 0,true> { int V __attribute__ ((bitwidth(609 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<609 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<609 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(609 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<609 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<610 + 1024 * 0,true> { int V __attribute__ ((bitwidth(610 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<610 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<610 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(610 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<610 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<611 + 1024 * 0,true> { int V __attribute__ ((bitwidth(611 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<611 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<611 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(611 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<611 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<612 + 1024 * 0,true> { int V __attribute__ ((bitwidth(612 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<612 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<612 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(612 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<612 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<613 + 1024 * 0,true> { int V __attribute__ ((bitwidth(613 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<613 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<613 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(613 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<613 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<614 + 1024 * 0,true> { int V __attribute__ ((bitwidth(614 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<614 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<614 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(614 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<614 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<615 + 1024 * 0,true> { int V __attribute__ ((bitwidth(615 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<615 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<615 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(615 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<615 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<616 + 1024 * 0,true> { int V __attribute__ ((bitwidth(616 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<616 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<616 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(616 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<616 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<617 + 1024 * 0,true> { int V __attribute__ ((bitwidth(617 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<617 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<617 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(617 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<617 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<618 + 1024 * 0,true> { int V __attribute__ ((bitwidth(618 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<618 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<618 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(618 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<618 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<619 + 1024 * 0,true> { int V __attribute__ ((bitwidth(619 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<619 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<619 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(619 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<619 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<620 + 1024 * 0,true> { int V __attribute__ ((bitwidth(620 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<620 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<620 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(620 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<620 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<621 + 1024 * 0,true> { int V __attribute__ ((bitwidth(621 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<621 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<621 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(621 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<621 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<622 + 1024 * 0,true> { int V __attribute__ ((bitwidth(622 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<622 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<622 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(622 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<622 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<623 + 1024 * 0,true> { int V __attribute__ ((bitwidth(623 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<623 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<623 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(623 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<623 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<624 + 1024 * 0,true> { int V __attribute__ ((bitwidth(624 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<624 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<624 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(624 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<624 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<625 + 1024 * 0,true> { int V __attribute__ ((bitwidth(625 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<625 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<625 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(625 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<625 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<626 + 1024 * 0,true> { int V __attribute__ ((bitwidth(626 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<626 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<626 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(626 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<626 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<627 + 1024 * 0,true> { int V __attribute__ ((bitwidth(627 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<627 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<627 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(627 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<627 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<628 + 1024 * 0,true> { int V __attribute__ ((bitwidth(628 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<628 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<628 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(628 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<628 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<629 + 1024 * 0,true> { int V __attribute__ ((bitwidth(629 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<629 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<629 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(629 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<629 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<630 + 1024 * 0,true> { int V __attribute__ ((bitwidth(630 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<630 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<630 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(630 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<630 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<631 + 1024 * 0,true> { int V __attribute__ ((bitwidth(631 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<631 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<631 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(631 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<631 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<632 + 1024 * 0,true> { int V __attribute__ ((bitwidth(632 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<632 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<632 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(632 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<632 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<633 + 1024 * 0,true> { int V __attribute__ ((bitwidth(633 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<633 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<633 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(633 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<633 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<634 + 1024 * 0,true> { int V __attribute__ ((bitwidth(634 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<634 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<634 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(634 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<634 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<635 + 1024 * 0,true> { int V __attribute__ ((bitwidth(635 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<635 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<635 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(635 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<635 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<636 + 1024 * 0,true> { int V __attribute__ ((bitwidth(636 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<636 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<636 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(636 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<636 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<637 + 1024 * 0,true> { int V __attribute__ ((bitwidth(637 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<637 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<637 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(637 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<637 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<638 + 1024 * 0,true> { int V __attribute__ ((bitwidth(638 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<638 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<638 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(638 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<638 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<639 + 1024 * 0,true> { int V __attribute__ ((bitwidth(639 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<639 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<639 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(639 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<639 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<640 + 1024 * 0,true> { int V __attribute__ ((bitwidth(640 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<640 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<640 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(640 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<640 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<641 + 1024 * 0,true> { int V __attribute__ ((bitwidth(641 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<641 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<641 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(641 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<641 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<642 + 1024 * 0,true> { int V __attribute__ ((bitwidth(642 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<642 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<642 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(642 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<642 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<643 + 1024 * 0,true> { int V __attribute__ ((bitwidth(643 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<643 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<643 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(643 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<643 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<644 + 1024 * 0,true> { int V __attribute__ ((bitwidth(644 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<644 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<644 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(644 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<644 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<645 + 1024 * 0,true> { int V __attribute__ ((bitwidth(645 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<645 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<645 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(645 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<645 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<646 + 1024 * 0,true> { int V __attribute__ ((bitwidth(646 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<646 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<646 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(646 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<646 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<647 + 1024 * 0,true> { int V __attribute__ ((bitwidth(647 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<647 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<647 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(647 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<647 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<648 + 1024 * 0,true> { int V __attribute__ ((bitwidth(648 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<648 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<648 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(648 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<648 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<649 + 1024 * 0,true> { int V __attribute__ ((bitwidth(649 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<649 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<649 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(649 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<649 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<650 + 1024 * 0,true> { int V __attribute__ ((bitwidth(650 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<650 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<650 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(650 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<650 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<651 + 1024 * 0,true> { int V __attribute__ ((bitwidth(651 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<651 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<651 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(651 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<651 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<652 + 1024 * 0,true> { int V __attribute__ ((bitwidth(652 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<652 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<652 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(652 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<652 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<653 + 1024 * 0,true> { int V __attribute__ ((bitwidth(653 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<653 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<653 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(653 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<653 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<654 + 1024 * 0,true> { int V __attribute__ ((bitwidth(654 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<654 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<654 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(654 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<654 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<655 + 1024 * 0,true> { int V __attribute__ ((bitwidth(655 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<655 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<655 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(655 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<655 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<656 + 1024 * 0,true> { int V __attribute__ ((bitwidth(656 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<656 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<656 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(656 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<656 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<657 + 1024 * 0,true> { int V __attribute__ ((bitwidth(657 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<657 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<657 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(657 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<657 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<658 + 1024 * 0,true> { int V __attribute__ ((bitwidth(658 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<658 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<658 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(658 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<658 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<659 + 1024 * 0,true> { int V __attribute__ ((bitwidth(659 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<659 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<659 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(659 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<659 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<660 + 1024 * 0,true> { int V __attribute__ ((bitwidth(660 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<660 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<660 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(660 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<660 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<661 + 1024 * 0,true> { int V __attribute__ ((bitwidth(661 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<661 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<661 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(661 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<661 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<662 + 1024 * 0,true> { int V __attribute__ ((bitwidth(662 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<662 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<662 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(662 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<662 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<663 + 1024 * 0,true> { int V __attribute__ ((bitwidth(663 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<663 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<663 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(663 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<663 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<664 + 1024 * 0,true> { int V __attribute__ ((bitwidth(664 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<664 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<664 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(664 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<664 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<665 + 1024 * 0,true> { int V __attribute__ ((bitwidth(665 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<665 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<665 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(665 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<665 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<666 + 1024 * 0,true> { int V __attribute__ ((bitwidth(666 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<666 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<666 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(666 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<666 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<667 + 1024 * 0,true> { int V __attribute__ ((bitwidth(667 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<667 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<667 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(667 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<667 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<668 + 1024 * 0,true> { int V __attribute__ ((bitwidth(668 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<668 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<668 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(668 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<668 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<669 + 1024 * 0,true> { int V __attribute__ ((bitwidth(669 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<669 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<669 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(669 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<669 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<670 + 1024 * 0,true> { int V __attribute__ ((bitwidth(670 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<670 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<670 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(670 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<670 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<671 + 1024 * 0,true> { int V __attribute__ ((bitwidth(671 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<671 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<671 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(671 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<671 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<672 + 1024 * 0,true> { int V __attribute__ ((bitwidth(672 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<672 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<672 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(672 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<672 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<673 + 1024 * 0,true> { int V __attribute__ ((bitwidth(673 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<673 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<673 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(673 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<673 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<674 + 1024 * 0,true> { int V __attribute__ ((bitwidth(674 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<674 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<674 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(674 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<674 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<675 + 1024 * 0,true> { int V __attribute__ ((bitwidth(675 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<675 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<675 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(675 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<675 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<676 + 1024 * 0,true> { int V __attribute__ ((bitwidth(676 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<676 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<676 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(676 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<676 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<677 + 1024 * 0,true> { int V __attribute__ ((bitwidth(677 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<677 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<677 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(677 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<677 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<678 + 1024 * 0,true> { int V __attribute__ ((bitwidth(678 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<678 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<678 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(678 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<678 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<679 + 1024 * 0,true> { int V __attribute__ ((bitwidth(679 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<679 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<679 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(679 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<679 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<680 + 1024 * 0,true> { int V __attribute__ ((bitwidth(680 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<680 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<680 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(680 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<680 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<681 + 1024 * 0,true> { int V __attribute__ ((bitwidth(681 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<681 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<681 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(681 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<681 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<682 + 1024 * 0,true> { int V __attribute__ ((bitwidth(682 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<682 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<682 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(682 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<682 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<683 + 1024 * 0,true> { int V __attribute__ ((bitwidth(683 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<683 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<683 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(683 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<683 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<684 + 1024 * 0,true> { int V __attribute__ ((bitwidth(684 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<684 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<684 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(684 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<684 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<685 + 1024 * 0,true> { int V __attribute__ ((bitwidth(685 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<685 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<685 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(685 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<685 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<686 + 1024 * 0,true> { int V __attribute__ ((bitwidth(686 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<686 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<686 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(686 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<686 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<687 + 1024 * 0,true> { int V __attribute__ ((bitwidth(687 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<687 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<687 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(687 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<687 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<688 + 1024 * 0,true> { int V __attribute__ ((bitwidth(688 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<688 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<688 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(688 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<688 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<689 + 1024 * 0,true> { int V __attribute__ ((bitwidth(689 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<689 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<689 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(689 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<689 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<690 + 1024 * 0,true> { int V __attribute__ ((bitwidth(690 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<690 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<690 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(690 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<690 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<691 + 1024 * 0,true> { int V __attribute__ ((bitwidth(691 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<691 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<691 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(691 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<691 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<692 + 1024 * 0,true> { int V __attribute__ ((bitwidth(692 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<692 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<692 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(692 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<692 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<693 + 1024 * 0,true> { int V __attribute__ ((bitwidth(693 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<693 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<693 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(693 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<693 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<694 + 1024 * 0,true> { int V __attribute__ ((bitwidth(694 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<694 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<694 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(694 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<694 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<695 + 1024 * 0,true> { int V __attribute__ ((bitwidth(695 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<695 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<695 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(695 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<695 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<696 + 1024 * 0,true> { int V __attribute__ ((bitwidth(696 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<696 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<696 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(696 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<696 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<697 + 1024 * 0,true> { int V __attribute__ ((bitwidth(697 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<697 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<697 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(697 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<697 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<698 + 1024 * 0,true> { int V __attribute__ ((bitwidth(698 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<698 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<698 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(698 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<698 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<699 + 1024 * 0,true> { int V __attribute__ ((bitwidth(699 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<699 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<699 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(699 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<699 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<700 + 1024 * 0,true> { int V __attribute__ ((bitwidth(700 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<700 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<700 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(700 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<700 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<701 + 1024 * 0,true> { int V __attribute__ ((bitwidth(701 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<701 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<701 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(701 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<701 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<702 + 1024 * 0,true> { int V __attribute__ ((bitwidth(702 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<702 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<702 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(702 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<702 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<703 + 1024 * 0,true> { int V __attribute__ ((bitwidth(703 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<703 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<703 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(703 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<703 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<704 + 1024 * 0,true> { int V __attribute__ ((bitwidth(704 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<704 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<704 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(704 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<704 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<705 + 1024 * 0,true> { int V __attribute__ ((bitwidth(705 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<705 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<705 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(705 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<705 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<706 + 1024 * 0,true> { int V __attribute__ ((bitwidth(706 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<706 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<706 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(706 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<706 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<707 + 1024 * 0,true> { int V __attribute__ ((bitwidth(707 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<707 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<707 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(707 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<707 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<708 + 1024 * 0,true> { int V __attribute__ ((bitwidth(708 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<708 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<708 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(708 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<708 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<709 + 1024 * 0,true> { int V __attribute__ ((bitwidth(709 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<709 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<709 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(709 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<709 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<710 + 1024 * 0,true> { int V __attribute__ ((bitwidth(710 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<710 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<710 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(710 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<710 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<711 + 1024 * 0,true> { int V __attribute__ ((bitwidth(711 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<711 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<711 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(711 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<711 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<712 + 1024 * 0,true> { int V __attribute__ ((bitwidth(712 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<712 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<712 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(712 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<712 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<713 + 1024 * 0,true> { int V __attribute__ ((bitwidth(713 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<713 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<713 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(713 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<713 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<714 + 1024 * 0,true> { int V __attribute__ ((bitwidth(714 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<714 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<714 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(714 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<714 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<715 + 1024 * 0,true> { int V __attribute__ ((bitwidth(715 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<715 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<715 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(715 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<715 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<716 + 1024 * 0,true> { int V __attribute__ ((bitwidth(716 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<716 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<716 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(716 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<716 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<717 + 1024 * 0,true> { int V __attribute__ ((bitwidth(717 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<717 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<717 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(717 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<717 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<718 + 1024 * 0,true> { int V __attribute__ ((bitwidth(718 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<718 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<718 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(718 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<718 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<719 + 1024 * 0,true> { int V __attribute__ ((bitwidth(719 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<719 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<719 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(719 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<719 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<720 + 1024 * 0,true> { int V __attribute__ ((bitwidth(720 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<720 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<720 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(720 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<720 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<721 + 1024 * 0,true> { int V __attribute__ ((bitwidth(721 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<721 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<721 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(721 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<721 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<722 + 1024 * 0,true> { int V __attribute__ ((bitwidth(722 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<722 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<722 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(722 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<722 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<723 + 1024 * 0,true> { int V __attribute__ ((bitwidth(723 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<723 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<723 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(723 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<723 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<724 + 1024 * 0,true> { int V __attribute__ ((bitwidth(724 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<724 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<724 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(724 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<724 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<725 + 1024 * 0,true> { int V __attribute__ ((bitwidth(725 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<725 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<725 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(725 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<725 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<726 + 1024 * 0,true> { int V __attribute__ ((bitwidth(726 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<726 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<726 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(726 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<726 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<727 + 1024 * 0,true> { int V __attribute__ ((bitwidth(727 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<727 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<727 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(727 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<727 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<728 + 1024 * 0,true> { int V __attribute__ ((bitwidth(728 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<728 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<728 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(728 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<728 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<729 + 1024 * 0,true> { int V __attribute__ ((bitwidth(729 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<729 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<729 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(729 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<729 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<730 + 1024 * 0,true> { int V __attribute__ ((bitwidth(730 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<730 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<730 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(730 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<730 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<731 + 1024 * 0,true> { int V __attribute__ ((bitwidth(731 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<731 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<731 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(731 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<731 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<732 + 1024 * 0,true> { int V __attribute__ ((bitwidth(732 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<732 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<732 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(732 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<732 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<733 + 1024 * 0,true> { int V __attribute__ ((bitwidth(733 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<733 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<733 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(733 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<733 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<734 + 1024 * 0,true> { int V __attribute__ ((bitwidth(734 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<734 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<734 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(734 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<734 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<735 + 1024 * 0,true> { int V __attribute__ ((bitwidth(735 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<735 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<735 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(735 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<735 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<736 + 1024 * 0,true> { int V __attribute__ ((bitwidth(736 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<736 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<736 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(736 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<736 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<737 + 1024 * 0,true> { int V __attribute__ ((bitwidth(737 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<737 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<737 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(737 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<737 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<738 + 1024 * 0,true> { int V __attribute__ ((bitwidth(738 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<738 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<738 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(738 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<738 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<739 + 1024 * 0,true> { int V __attribute__ ((bitwidth(739 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<739 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<739 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(739 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<739 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<740 + 1024 * 0,true> { int V __attribute__ ((bitwidth(740 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<740 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<740 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(740 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<740 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<741 + 1024 * 0,true> { int V __attribute__ ((bitwidth(741 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<741 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<741 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(741 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<741 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<742 + 1024 * 0,true> { int V __attribute__ ((bitwidth(742 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<742 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<742 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(742 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<742 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<743 + 1024 * 0,true> { int V __attribute__ ((bitwidth(743 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<743 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<743 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(743 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<743 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<744 + 1024 * 0,true> { int V __attribute__ ((bitwidth(744 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<744 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<744 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(744 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<744 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<745 + 1024 * 0,true> { int V __attribute__ ((bitwidth(745 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<745 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<745 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(745 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<745 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<746 + 1024 * 0,true> { int V __attribute__ ((bitwidth(746 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<746 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<746 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(746 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<746 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<747 + 1024 * 0,true> { int V __attribute__ ((bitwidth(747 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<747 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<747 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(747 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<747 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<748 + 1024 * 0,true> { int V __attribute__ ((bitwidth(748 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<748 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<748 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(748 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<748 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<749 + 1024 * 0,true> { int V __attribute__ ((bitwidth(749 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<749 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<749 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(749 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<749 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<750 + 1024 * 0,true> { int V __attribute__ ((bitwidth(750 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<750 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<750 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(750 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<750 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<751 + 1024 * 0,true> { int V __attribute__ ((bitwidth(751 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<751 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<751 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(751 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<751 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<752 + 1024 * 0,true> { int V __attribute__ ((bitwidth(752 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<752 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<752 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(752 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<752 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<753 + 1024 * 0,true> { int V __attribute__ ((bitwidth(753 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<753 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<753 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(753 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<753 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<754 + 1024 * 0,true> { int V __attribute__ ((bitwidth(754 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<754 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<754 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(754 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<754 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<755 + 1024 * 0,true> { int V __attribute__ ((bitwidth(755 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<755 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<755 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(755 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<755 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<756 + 1024 * 0,true> { int V __attribute__ ((bitwidth(756 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<756 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<756 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(756 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<756 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<757 + 1024 * 0,true> { int V __attribute__ ((bitwidth(757 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<757 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<757 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(757 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<757 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<758 + 1024 * 0,true> { int V __attribute__ ((bitwidth(758 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<758 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<758 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(758 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<758 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<759 + 1024 * 0,true> { int V __attribute__ ((bitwidth(759 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<759 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<759 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(759 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<759 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<760 + 1024 * 0,true> { int V __attribute__ ((bitwidth(760 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<760 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<760 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(760 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<760 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<761 + 1024 * 0,true> { int V __attribute__ ((bitwidth(761 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<761 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<761 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(761 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<761 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<762 + 1024 * 0,true> { int V __attribute__ ((bitwidth(762 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<762 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<762 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(762 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<762 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<763 + 1024 * 0,true> { int V __attribute__ ((bitwidth(763 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<763 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<763 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(763 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<763 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<764 + 1024 * 0,true> { int V __attribute__ ((bitwidth(764 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<764 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<764 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(764 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<764 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<765 + 1024 * 0,true> { int V __attribute__ ((bitwidth(765 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<765 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<765 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(765 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<765 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<766 + 1024 * 0,true> { int V __attribute__ ((bitwidth(766 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<766 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<766 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(766 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<766 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<767 + 1024 * 0,true> { int V __attribute__ ((bitwidth(767 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<767 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<767 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(767 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<767 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<768 + 1024 * 0,true> { int V __attribute__ ((bitwidth(768 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<768 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<768 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(768 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<768 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<769 + 1024 * 0,true> { int V __attribute__ ((bitwidth(769 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<769 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<769 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(769 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<769 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<770 + 1024 * 0,true> { int V __attribute__ ((bitwidth(770 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<770 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<770 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(770 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<770 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<771 + 1024 * 0,true> { int V __attribute__ ((bitwidth(771 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<771 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<771 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(771 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<771 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<772 + 1024 * 0,true> { int V __attribute__ ((bitwidth(772 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<772 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<772 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(772 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<772 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<773 + 1024 * 0,true> { int V __attribute__ ((bitwidth(773 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<773 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<773 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(773 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<773 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<774 + 1024 * 0,true> { int V __attribute__ ((bitwidth(774 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<774 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<774 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(774 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<774 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<775 + 1024 * 0,true> { int V __attribute__ ((bitwidth(775 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<775 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<775 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(775 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<775 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<776 + 1024 * 0,true> { int V __attribute__ ((bitwidth(776 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<776 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<776 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(776 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<776 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<777 + 1024 * 0,true> { int V __attribute__ ((bitwidth(777 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<777 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<777 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(777 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<777 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<778 + 1024 * 0,true> { int V __attribute__ ((bitwidth(778 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<778 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<778 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(778 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<778 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<779 + 1024 * 0,true> { int V __attribute__ ((bitwidth(779 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<779 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<779 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(779 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<779 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<780 + 1024 * 0,true> { int V __attribute__ ((bitwidth(780 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<780 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<780 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(780 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<780 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<781 + 1024 * 0,true> { int V __attribute__ ((bitwidth(781 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<781 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<781 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(781 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<781 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<782 + 1024 * 0,true> { int V __attribute__ ((bitwidth(782 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<782 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<782 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(782 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<782 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<783 + 1024 * 0,true> { int V __attribute__ ((bitwidth(783 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<783 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<783 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(783 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<783 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<784 + 1024 * 0,true> { int V __attribute__ ((bitwidth(784 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<784 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<784 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(784 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<784 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<785 + 1024 * 0,true> { int V __attribute__ ((bitwidth(785 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<785 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<785 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(785 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<785 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<786 + 1024 * 0,true> { int V __attribute__ ((bitwidth(786 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<786 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<786 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(786 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<786 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<787 + 1024 * 0,true> { int V __attribute__ ((bitwidth(787 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<787 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<787 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(787 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<787 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<788 + 1024 * 0,true> { int V __attribute__ ((bitwidth(788 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<788 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<788 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(788 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<788 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<789 + 1024 * 0,true> { int V __attribute__ ((bitwidth(789 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<789 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<789 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(789 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<789 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<790 + 1024 * 0,true> { int V __attribute__ ((bitwidth(790 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<790 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<790 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(790 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<790 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<791 + 1024 * 0,true> { int V __attribute__ ((bitwidth(791 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<791 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<791 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(791 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<791 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<792 + 1024 * 0,true> { int V __attribute__ ((bitwidth(792 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<792 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<792 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(792 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<792 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<793 + 1024 * 0,true> { int V __attribute__ ((bitwidth(793 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<793 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<793 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(793 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<793 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<794 + 1024 * 0,true> { int V __attribute__ ((bitwidth(794 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<794 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<794 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(794 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<794 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<795 + 1024 * 0,true> { int V __attribute__ ((bitwidth(795 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<795 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<795 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(795 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<795 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<796 + 1024 * 0,true> { int V __attribute__ ((bitwidth(796 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<796 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<796 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(796 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<796 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<797 + 1024 * 0,true> { int V __attribute__ ((bitwidth(797 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<797 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<797 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(797 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<797 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<798 + 1024 * 0,true> { int V __attribute__ ((bitwidth(798 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<798 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<798 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(798 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<798 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<799 + 1024 * 0,true> { int V __attribute__ ((bitwidth(799 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<799 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<799 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(799 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<799 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<800 + 1024 * 0,true> { int V __attribute__ ((bitwidth(800 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<800 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<800 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(800 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<800 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<801 + 1024 * 0,true> { int V __attribute__ ((bitwidth(801 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<801 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<801 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(801 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<801 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<802 + 1024 * 0,true> { int V __attribute__ ((bitwidth(802 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<802 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<802 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(802 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<802 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<803 + 1024 * 0,true> { int V __attribute__ ((bitwidth(803 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<803 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<803 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(803 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<803 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<804 + 1024 * 0,true> { int V __attribute__ ((bitwidth(804 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<804 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<804 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(804 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<804 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<805 + 1024 * 0,true> { int V __attribute__ ((bitwidth(805 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<805 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<805 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(805 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<805 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<806 + 1024 * 0,true> { int V __attribute__ ((bitwidth(806 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<806 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<806 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(806 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<806 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<807 + 1024 * 0,true> { int V __attribute__ ((bitwidth(807 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<807 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<807 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(807 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<807 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<808 + 1024 * 0,true> { int V __attribute__ ((bitwidth(808 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<808 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<808 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(808 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<808 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<809 + 1024 * 0,true> { int V __attribute__ ((bitwidth(809 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<809 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<809 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(809 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<809 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<810 + 1024 * 0,true> { int V __attribute__ ((bitwidth(810 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<810 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<810 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(810 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<810 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<811 + 1024 * 0,true> { int V __attribute__ ((bitwidth(811 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<811 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<811 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(811 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<811 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<812 + 1024 * 0,true> { int V __attribute__ ((bitwidth(812 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<812 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<812 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(812 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<812 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<813 + 1024 * 0,true> { int V __attribute__ ((bitwidth(813 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<813 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<813 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(813 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<813 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<814 + 1024 * 0,true> { int V __attribute__ ((bitwidth(814 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<814 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<814 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(814 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<814 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<815 + 1024 * 0,true> { int V __attribute__ ((bitwidth(815 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<815 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<815 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(815 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<815 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<816 + 1024 * 0,true> { int V __attribute__ ((bitwidth(816 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<816 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<816 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(816 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<816 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<817 + 1024 * 0,true> { int V __attribute__ ((bitwidth(817 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<817 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<817 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(817 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<817 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<818 + 1024 * 0,true> { int V __attribute__ ((bitwidth(818 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<818 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<818 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(818 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<818 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<819 + 1024 * 0,true> { int V __attribute__ ((bitwidth(819 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<819 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<819 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(819 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<819 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<820 + 1024 * 0,true> { int V __attribute__ ((bitwidth(820 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<820 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<820 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(820 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<820 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<821 + 1024 * 0,true> { int V __attribute__ ((bitwidth(821 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<821 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<821 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(821 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<821 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<822 + 1024 * 0,true> { int V __attribute__ ((bitwidth(822 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<822 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<822 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(822 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<822 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<823 + 1024 * 0,true> { int V __attribute__ ((bitwidth(823 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<823 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<823 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(823 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<823 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<824 + 1024 * 0,true> { int V __attribute__ ((bitwidth(824 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<824 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<824 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(824 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<824 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<825 + 1024 * 0,true> { int V __attribute__ ((bitwidth(825 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<825 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<825 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(825 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<825 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<826 + 1024 * 0,true> { int V __attribute__ ((bitwidth(826 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<826 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<826 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(826 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<826 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<827 + 1024 * 0,true> { int V __attribute__ ((bitwidth(827 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<827 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<827 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(827 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<827 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<828 + 1024 * 0,true> { int V __attribute__ ((bitwidth(828 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<828 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<828 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(828 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<828 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<829 + 1024 * 0,true> { int V __attribute__ ((bitwidth(829 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<829 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<829 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(829 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<829 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<830 + 1024 * 0,true> { int V __attribute__ ((bitwidth(830 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<830 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<830 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(830 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<830 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<831 + 1024 * 0,true> { int V __attribute__ ((bitwidth(831 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<831 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<831 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(831 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<831 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<832 + 1024 * 0,true> { int V __attribute__ ((bitwidth(832 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<832 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<832 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(832 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<832 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<833 + 1024 * 0,true> { int V __attribute__ ((bitwidth(833 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<833 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<833 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(833 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<833 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<834 + 1024 * 0,true> { int V __attribute__ ((bitwidth(834 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<834 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<834 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(834 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<834 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<835 + 1024 * 0,true> { int V __attribute__ ((bitwidth(835 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<835 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<835 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(835 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<835 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<836 + 1024 * 0,true> { int V __attribute__ ((bitwidth(836 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<836 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<836 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(836 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<836 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<837 + 1024 * 0,true> { int V __attribute__ ((bitwidth(837 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<837 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<837 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(837 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<837 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<838 + 1024 * 0,true> { int V __attribute__ ((bitwidth(838 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<838 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<838 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(838 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<838 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<839 + 1024 * 0,true> { int V __attribute__ ((bitwidth(839 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<839 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<839 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(839 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<839 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<840 + 1024 * 0,true> { int V __attribute__ ((bitwidth(840 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<840 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<840 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(840 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<840 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<841 + 1024 * 0,true> { int V __attribute__ ((bitwidth(841 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<841 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<841 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(841 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<841 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<842 + 1024 * 0,true> { int V __attribute__ ((bitwidth(842 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<842 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<842 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(842 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<842 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<843 + 1024 * 0,true> { int V __attribute__ ((bitwidth(843 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<843 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<843 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(843 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<843 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<844 + 1024 * 0,true> { int V __attribute__ ((bitwidth(844 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<844 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<844 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(844 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<844 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<845 + 1024 * 0,true> { int V __attribute__ ((bitwidth(845 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<845 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<845 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(845 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<845 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<846 + 1024 * 0,true> { int V __attribute__ ((bitwidth(846 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<846 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<846 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(846 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<846 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<847 + 1024 * 0,true> { int V __attribute__ ((bitwidth(847 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<847 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<847 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(847 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<847 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<848 + 1024 * 0,true> { int V __attribute__ ((bitwidth(848 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<848 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<848 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(848 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<848 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<849 + 1024 * 0,true> { int V __attribute__ ((bitwidth(849 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<849 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<849 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(849 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<849 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<850 + 1024 * 0,true> { int V __attribute__ ((bitwidth(850 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<850 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<850 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(850 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<850 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<851 + 1024 * 0,true> { int V __attribute__ ((bitwidth(851 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<851 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<851 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(851 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<851 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<852 + 1024 * 0,true> { int V __attribute__ ((bitwidth(852 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<852 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<852 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(852 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<852 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<853 + 1024 * 0,true> { int V __attribute__ ((bitwidth(853 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<853 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<853 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(853 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<853 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<854 + 1024 * 0,true> { int V __attribute__ ((bitwidth(854 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<854 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<854 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(854 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<854 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<855 + 1024 * 0,true> { int V __attribute__ ((bitwidth(855 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<855 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<855 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(855 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<855 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<856 + 1024 * 0,true> { int V __attribute__ ((bitwidth(856 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<856 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<856 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(856 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<856 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<857 + 1024 * 0,true> { int V __attribute__ ((bitwidth(857 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<857 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<857 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(857 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<857 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<858 + 1024 * 0,true> { int V __attribute__ ((bitwidth(858 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<858 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<858 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(858 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<858 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<859 + 1024 * 0,true> { int V __attribute__ ((bitwidth(859 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<859 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<859 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(859 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<859 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<860 + 1024 * 0,true> { int V __attribute__ ((bitwidth(860 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<860 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<860 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(860 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<860 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<861 + 1024 * 0,true> { int V __attribute__ ((bitwidth(861 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<861 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<861 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(861 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<861 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<862 + 1024 * 0,true> { int V __attribute__ ((bitwidth(862 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<862 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<862 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(862 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<862 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<863 + 1024 * 0,true> { int V __attribute__ ((bitwidth(863 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<863 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<863 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(863 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<863 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<864 + 1024 * 0,true> { int V __attribute__ ((bitwidth(864 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<864 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<864 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(864 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<864 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<865 + 1024 * 0,true> { int V __attribute__ ((bitwidth(865 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<865 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<865 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(865 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<865 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<866 + 1024 * 0,true> { int V __attribute__ ((bitwidth(866 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<866 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<866 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(866 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<866 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<867 + 1024 * 0,true> { int V __attribute__ ((bitwidth(867 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<867 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<867 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(867 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<867 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<868 + 1024 * 0,true> { int V __attribute__ ((bitwidth(868 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<868 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<868 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(868 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<868 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<869 + 1024 * 0,true> { int V __attribute__ ((bitwidth(869 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<869 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<869 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(869 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<869 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<870 + 1024 * 0,true> { int V __attribute__ ((bitwidth(870 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<870 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<870 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(870 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<870 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<871 + 1024 * 0,true> { int V __attribute__ ((bitwidth(871 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<871 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<871 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(871 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<871 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<872 + 1024 * 0,true> { int V __attribute__ ((bitwidth(872 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<872 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<872 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(872 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<872 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<873 + 1024 * 0,true> { int V __attribute__ ((bitwidth(873 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<873 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<873 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(873 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<873 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<874 + 1024 * 0,true> { int V __attribute__ ((bitwidth(874 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<874 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<874 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(874 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<874 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<875 + 1024 * 0,true> { int V __attribute__ ((bitwidth(875 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<875 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<875 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(875 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<875 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<876 + 1024 * 0,true> { int V __attribute__ ((bitwidth(876 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<876 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<876 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(876 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<876 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<877 + 1024 * 0,true> { int V __attribute__ ((bitwidth(877 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<877 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<877 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(877 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<877 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<878 + 1024 * 0,true> { int V __attribute__ ((bitwidth(878 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<878 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<878 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(878 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<878 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<879 + 1024 * 0,true> { int V __attribute__ ((bitwidth(879 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<879 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<879 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(879 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<879 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<880 + 1024 * 0,true> { int V __attribute__ ((bitwidth(880 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<880 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<880 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(880 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<880 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<881 + 1024 * 0,true> { int V __attribute__ ((bitwidth(881 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<881 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<881 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(881 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<881 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<882 + 1024 * 0,true> { int V __attribute__ ((bitwidth(882 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<882 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<882 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(882 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<882 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<883 + 1024 * 0,true> { int V __attribute__ ((bitwidth(883 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<883 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<883 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(883 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<883 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<884 + 1024 * 0,true> { int V __attribute__ ((bitwidth(884 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<884 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<884 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(884 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<884 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<885 + 1024 * 0,true> { int V __attribute__ ((bitwidth(885 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<885 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<885 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(885 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<885 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<886 + 1024 * 0,true> { int V __attribute__ ((bitwidth(886 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<886 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<886 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(886 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<886 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<887 + 1024 * 0,true> { int V __attribute__ ((bitwidth(887 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<887 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<887 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(887 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<887 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<888 + 1024 * 0,true> { int V __attribute__ ((bitwidth(888 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<888 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<888 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(888 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<888 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<889 + 1024 * 0,true> { int V __attribute__ ((bitwidth(889 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<889 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<889 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(889 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<889 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<890 + 1024 * 0,true> { int V __attribute__ ((bitwidth(890 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<890 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<890 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(890 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<890 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<891 + 1024 * 0,true> { int V __attribute__ ((bitwidth(891 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<891 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<891 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(891 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<891 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<892 + 1024 * 0,true> { int V __attribute__ ((bitwidth(892 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<892 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<892 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(892 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<892 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<893 + 1024 * 0,true> { int V __attribute__ ((bitwidth(893 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<893 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<893 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(893 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<893 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<894 + 1024 * 0,true> { int V __attribute__ ((bitwidth(894 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<894 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<894 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(894 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<894 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<895 + 1024 * 0,true> { int V __attribute__ ((bitwidth(895 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<895 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<895 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(895 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<895 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<896 + 1024 * 0,true> { int V __attribute__ ((bitwidth(896 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<896 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<896 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(896 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<896 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<897 + 1024 * 0,true> { int V __attribute__ ((bitwidth(897 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<897 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<897 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(897 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<897 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<898 + 1024 * 0,true> { int V __attribute__ ((bitwidth(898 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<898 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<898 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(898 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<898 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<899 + 1024 * 0,true> { int V __attribute__ ((bitwidth(899 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<899 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<899 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(899 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<899 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<900 + 1024 * 0,true> { int V __attribute__ ((bitwidth(900 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<900 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<900 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(900 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<900 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<901 + 1024 * 0,true> { int V __attribute__ ((bitwidth(901 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<901 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<901 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(901 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<901 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<902 + 1024 * 0,true> { int V __attribute__ ((bitwidth(902 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<902 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<902 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(902 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<902 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<903 + 1024 * 0,true> { int V __attribute__ ((bitwidth(903 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<903 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<903 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(903 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<903 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<904 + 1024 * 0,true> { int V __attribute__ ((bitwidth(904 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<904 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<904 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(904 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<904 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<905 + 1024 * 0,true> { int V __attribute__ ((bitwidth(905 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<905 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<905 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(905 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<905 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<906 + 1024 * 0,true> { int V __attribute__ ((bitwidth(906 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<906 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<906 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(906 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<906 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<907 + 1024 * 0,true> { int V __attribute__ ((bitwidth(907 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<907 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<907 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(907 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<907 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<908 + 1024 * 0,true> { int V __attribute__ ((bitwidth(908 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<908 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<908 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(908 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<908 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<909 + 1024 * 0,true> { int V __attribute__ ((bitwidth(909 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<909 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<909 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(909 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<909 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<910 + 1024 * 0,true> { int V __attribute__ ((bitwidth(910 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<910 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<910 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(910 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<910 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<911 + 1024 * 0,true> { int V __attribute__ ((bitwidth(911 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<911 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<911 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(911 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<911 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<912 + 1024 * 0,true> { int V __attribute__ ((bitwidth(912 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<912 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<912 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(912 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<912 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<913 + 1024 * 0,true> { int V __attribute__ ((bitwidth(913 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<913 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<913 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(913 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<913 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<914 + 1024 * 0,true> { int V __attribute__ ((bitwidth(914 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<914 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<914 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(914 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<914 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<915 + 1024 * 0,true> { int V __attribute__ ((bitwidth(915 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<915 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<915 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(915 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<915 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<916 + 1024 * 0,true> { int V __attribute__ ((bitwidth(916 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<916 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<916 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(916 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<916 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<917 + 1024 * 0,true> { int V __attribute__ ((bitwidth(917 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<917 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<917 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(917 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<917 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<918 + 1024 * 0,true> { int V __attribute__ ((bitwidth(918 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<918 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<918 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(918 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<918 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<919 + 1024 * 0,true> { int V __attribute__ ((bitwidth(919 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<919 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<919 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(919 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<919 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<920 + 1024 * 0,true> { int V __attribute__ ((bitwidth(920 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<920 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<920 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(920 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<920 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<921 + 1024 * 0,true> { int V __attribute__ ((bitwidth(921 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<921 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<921 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(921 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<921 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<922 + 1024 * 0,true> { int V __attribute__ ((bitwidth(922 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<922 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<922 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(922 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<922 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<923 + 1024 * 0,true> { int V __attribute__ ((bitwidth(923 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<923 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<923 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(923 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<923 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<924 + 1024 * 0,true> { int V __attribute__ ((bitwidth(924 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<924 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<924 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(924 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<924 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<925 + 1024 * 0,true> { int V __attribute__ ((bitwidth(925 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<925 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<925 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(925 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<925 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<926 + 1024 * 0,true> { int V __attribute__ ((bitwidth(926 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<926 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<926 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(926 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<926 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<927 + 1024 * 0,true> { int V __attribute__ ((bitwidth(927 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<927 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<927 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(927 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<927 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<928 + 1024 * 0,true> { int V __attribute__ ((bitwidth(928 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<928 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<928 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(928 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<928 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<929 + 1024 * 0,true> { int V __attribute__ ((bitwidth(929 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<929 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<929 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(929 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<929 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<930 + 1024 * 0,true> { int V __attribute__ ((bitwidth(930 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<930 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<930 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(930 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<930 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<931 + 1024 * 0,true> { int V __attribute__ ((bitwidth(931 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<931 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<931 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(931 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<931 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<932 + 1024 * 0,true> { int V __attribute__ ((bitwidth(932 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<932 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<932 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(932 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<932 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<933 + 1024 * 0,true> { int V __attribute__ ((bitwidth(933 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<933 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<933 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(933 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<933 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<934 + 1024 * 0,true> { int V __attribute__ ((bitwidth(934 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<934 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<934 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(934 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<934 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<935 + 1024 * 0,true> { int V __attribute__ ((bitwidth(935 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<935 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<935 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(935 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<935 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<936 + 1024 * 0,true> { int V __attribute__ ((bitwidth(936 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<936 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<936 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(936 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<936 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<937 + 1024 * 0,true> { int V __attribute__ ((bitwidth(937 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<937 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<937 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(937 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<937 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<938 + 1024 * 0,true> { int V __attribute__ ((bitwidth(938 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<938 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<938 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(938 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<938 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<939 + 1024 * 0,true> { int V __attribute__ ((bitwidth(939 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<939 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<939 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(939 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<939 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<940 + 1024 * 0,true> { int V __attribute__ ((bitwidth(940 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<940 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<940 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(940 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<940 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<941 + 1024 * 0,true> { int V __attribute__ ((bitwidth(941 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<941 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<941 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(941 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<941 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<942 + 1024 * 0,true> { int V __attribute__ ((bitwidth(942 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<942 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<942 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(942 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<942 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<943 + 1024 * 0,true> { int V __attribute__ ((bitwidth(943 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<943 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<943 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(943 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<943 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<944 + 1024 * 0,true> { int V __attribute__ ((bitwidth(944 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<944 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<944 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(944 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<944 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<945 + 1024 * 0,true> { int V __attribute__ ((bitwidth(945 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<945 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<945 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(945 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<945 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<946 + 1024 * 0,true> { int V __attribute__ ((bitwidth(946 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<946 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<946 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(946 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<946 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<947 + 1024 * 0,true> { int V __attribute__ ((bitwidth(947 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<947 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<947 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(947 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<947 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<948 + 1024 * 0,true> { int V __attribute__ ((bitwidth(948 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<948 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<948 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(948 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<948 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<949 + 1024 * 0,true> { int V __attribute__ ((bitwidth(949 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<949 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<949 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(949 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<949 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<950 + 1024 * 0,true> { int V __attribute__ ((bitwidth(950 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<950 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<950 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(950 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<950 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<951 + 1024 * 0,true> { int V __attribute__ ((bitwidth(951 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<951 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<951 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(951 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<951 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<952 + 1024 * 0,true> { int V __attribute__ ((bitwidth(952 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<952 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<952 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(952 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<952 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<953 + 1024 * 0,true> { int V __attribute__ ((bitwidth(953 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<953 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<953 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(953 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<953 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<954 + 1024 * 0,true> { int V __attribute__ ((bitwidth(954 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<954 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<954 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(954 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<954 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<955 + 1024 * 0,true> { int V __attribute__ ((bitwidth(955 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<955 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<955 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(955 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<955 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<956 + 1024 * 0,true> { int V __attribute__ ((bitwidth(956 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<956 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<956 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(956 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<956 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<957 + 1024 * 0,true> { int V __attribute__ ((bitwidth(957 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<957 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<957 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(957 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<957 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<958 + 1024 * 0,true> { int V __attribute__ ((bitwidth(958 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<958 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<958 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(958 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<958 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<959 + 1024 * 0,true> { int V __attribute__ ((bitwidth(959 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<959 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<959 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(959 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<959 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<960 + 1024 * 0,true> { int V __attribute__ ((bitwidth(960 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<960 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<960 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(960 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<960 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<961 + 1024 * 0,true> { int V __attribute__ ((bitwidth(961 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<961 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<961 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(961 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<961 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<962 + 1024 * 0,true> { int V __attribute__ ((bitwidth(962 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<962 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<962 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(962 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<962 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<963 + 1024 * 0,true> { int V __attribute__ ((bitwidth(963 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<963 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<963 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(963 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<963 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<964 + 1024 * 0,true> { int V __attribute__ ((bitwidth(964 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<964 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<964 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(964 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<964 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<965 + 1024 * 0,true> { int V __attribute__ ((bitwidth(965 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<965 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<965 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(965 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<965 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<966 + 1024 * 0,true> { int V __attribute__ ((bitwidth(966 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<966 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<966 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(966 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<966 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<967 + 1024 * 0,true> { int V __attribute__ ((bitwidth(967 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<967 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<967 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(967 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<967 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<968 + 1024 * 0,true> { int V __attribute__ ((bitwidth(968 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<968 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<968 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(968 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<968 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<969 + 1024 * 0,true> { int V __attribute__ ((bitwidth(969 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<969 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<969 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(969 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<969 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<970 + 1024 * 0,true> { int V __attribute__ ((bitwidth(970 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<970 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<970 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(970 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<970 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<971 + 1024 * 0,true> { int V __attribute__ ((bitwidth(971 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<971 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<971 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(971 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<971 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<972 + 1024 * 0,true> { int V __attribute__ ((bitwidth(972 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<972 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<972 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(972 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<972 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<973 + 1024 * 0,true> { int V __attribute__ ((bitwidth(973 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<973 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<973 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(973 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<973 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<974 + 1024 * 0,true> { int V __attribute__ ((bitwidth(974 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<974 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<974 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(974 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<974 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<975 + 1024 * 0,true> { int V __attribute__ ((bitwidth(975 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<975 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<975 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(975 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<975 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<976 + 1024 * 0,true> { int V __attribute__ ((bitwidth(976 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<976 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<976 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(976 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<976 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<977 + 1024 * 0,true> { int V __attribute__ ((bitwidth(977 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<977 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<977 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(977 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<977 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<978 + 1024 * 0,true> { int V __attribute__ ((bitwidth(978 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<978 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<978 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(978 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<978 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<979 + 1024 * 0,true> { int V __attribute__ ((bitwidth(979 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<979 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<979 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(979 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<979 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<980 + 1024 * 0,true> { int V __attribute__ ((bitwidth(980 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<980 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<980 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(980 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<980 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<981 + 1024 * 0,true> { int V __attribute__ ((bitwidth(981 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<981 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<981 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(981 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<981 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<982 + 1024 * 0,true> { int V __attribute__ ((bitwidth(982 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<982 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<982 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(982 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<982 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<983 + 1024 * 0,true> { int V __attribute__ ((bitwidth(983 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<983 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<983 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(983 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<983 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<984 + 1024 * 0,true> { int V __attribute__ ((bitwidth(984 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<984 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<984 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(984 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<984 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<985 + 1024 * 0,true> { int V __attribute__ ((bitwidth(985 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<985 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<985 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(985 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<985 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<986 + 1024 * 0,true> { int V __attribute__ ((bitwidth(986 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<986 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<986 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(986 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<986 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<987 + 1024 * 0,true> { int V __attribute__ ((bitwidth(987 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<987 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<987 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(987 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<987 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<988 + 1024 * 0,true> { int V __attribute__ ((bitwidth(988 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<988 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<988 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(988 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<988 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<989 + 1024 * 0,true> { int V __attribute__ ((bitwidth(989 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<989 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<989 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(989 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<989 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<990 + 1024 * 0,true> { int V __attribute__ ((bitwidth(990 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<990 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<990 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(990 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<990 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<991 + 1024 * 0,true> { int V __attribute__ ((bitwidth(991 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<991 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<991 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(991 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<991 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<992 + 1024 * 0,true> { int V __attribute__ ((bitwidth(992 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<992 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<992 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(992 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<992 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<993 + 1024 * 0,true> { int V __attribute__ ((bitwidth(993 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<993 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<993 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(993 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<993 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<994 + 1024 * 0,true> { int V __attribute__ ((bitwidth(994 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<994 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<994 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(994 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<994 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<995 + 1024 * 0,true> { int V __attribute__ ((bitwidth(995 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<995 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<995 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(995 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<995 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<996 + 1024 * 0,true> { int V __attribute__ ((bitwidth(996 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<996 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<996 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(996 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<996 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<997 + 1024 * 0,true> { int V __attribute__ ((bitwidth(997 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<997 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<997 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(997 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<997 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<998 + 1024 * 0,true> { int V __attribute__ ((bitwidth(998 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<998 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<998 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(998 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<998 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<999 + 1024 * 0,true> { int V __attribute__ ((bitwidth(999 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<999 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<999 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(999 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<999 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1000 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1000 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1000 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1000 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1000 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1000 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1001 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1001 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1001 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1001 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1001 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1001 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1002 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1002 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1002 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1002 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1002 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1002 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1003 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1003 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1003 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1003 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1003 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1003 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1004 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1004 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1004 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1004 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1004 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1004 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1005 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1005 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1005 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1005 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1005 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1005 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1006 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1006 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1006 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1006 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1006 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1006 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1007 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1007 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1007 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1007 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1007 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1007 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1008 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1008 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1008 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1008 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1008 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1008 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1009 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1009 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1009 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1009 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1009 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1009 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1010 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1010 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1010 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1010 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1010 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1010 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1011 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1011 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1011 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1011 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1011 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1011 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1012 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1012 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1012 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1012 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1012 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1012 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1013 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1013 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1013 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1013 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1013 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1013 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1014 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1014 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1014 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1014 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1014 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1014 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1015 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1015 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1015 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1015 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1015 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1015 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1016 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1016 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1016 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1016 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1016 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1016 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1017 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1017 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1017 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1017 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1017 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1017 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1018 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1018 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1018 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1018 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1018 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1018 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1019 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1019 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1019 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1019 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1019 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1019 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1020 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1020 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1020 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1020 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1020 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1020 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1021 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1021 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1021 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1021 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1021 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1021 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1022 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1022 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1022 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1022 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1022 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1022 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1023 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1023 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1023 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1023 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1023 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1023 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1024 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1024 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1024 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1024 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1024 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1024 + 1024 * 0 , false>() { }; };
#pragma line 184 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_int_syn.h" 2
#pragma line 602 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_int_syn.h"
enum BaseMode { SC_BIN=2, SC_OCT=8, SC_DEC=10, SC_HEX=16 };
#pragma line 645 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_int_syn.h"
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/etc/autopilot_ssdm_bits.h" 1
/* autopilot_ssdm_bits.h */
/*
#- (c) Copyright 2011-2016 Xilinx, Inc. All rights reserved.
#-
#- This file contains confidential and proprietary information
#- of Xilinx, Inc. and is protected under U.S. and
#- international copyright and other intellectual property
#- laws.
#-
#- DISCLAIMER
#- This disclaimer is not a license and does not grant any
#- rights to the materials distributed herewith. Except as
#- otherwise provided in a valid license issued to you by
#- Xilinx, and to the maximum extent permitted by applicable
#- law: (1) THESE MATERIALS ARE MADE AVAILABLE "AS IS" AND
#- WITH ALL FAULTS, AND XILINX HEREBY DISCLAIMS ALL WARRANTIES
#- AND CONDITIONS, EXPRESS, IMPLIED, OR STATUTORY, INCLUDING
#- BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, NON-
#- INFRINGEMENT, OR FITNESS FOR ANY PARTICULAR PURPOSE; and
#- (2) Xilinx shall not be liable (whether in contract or tort,
#- including negligence, or under any other theory of
#- liability) for any loss or damage of any kind or nature
#- related to, arising under or in connection with these
#- materials, including for any direct, or any indirect,
#- special, incidental, or consequential loss or damage
#- (including loss of data, profits, goodwill, or any type of
#- loss or damage suffered as a result of any action brought
#- by a third party) even if such damage or loss was
#- reasonably foreseeable or Xilinx had been advised of the
#- possibility of the same.
#-
#- CRITICAL APPLICATIONS
#- Xilinx products are not designed or intended to be fail-
#- safe, or for use in any application requiring fail-safe
#- performance, such as life-support or safety devices or
#- systems, Class III medical devices, nuclear facilities,
#- applications related to the deployment of airbags, or any
#- other applications that could lead to death, personal
#- injury, or severe property or environmental damage
#- (individually and collectively, "Critical
#- Applications"). Customer assumes the sole risk and
#- liability of any use of Xilinx products in Critical
#- Applications, subject only to applicable laws and
#- regulations governing limitations on product liability.
#-
#- THIS COPYRIGHT NOTICE AND DISCLAIMER MUST BE RETAINED AS
#- PART OF THIS FILE AT ALL TIMES.
#- ************************************************************************
#pragma empty_line
*
* $Id$
*/
#pragma line 98 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/etc/autopilot_ssdm_bits.h"
/* -- Concatination ----------------*/
#pragma line 108 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/etc/autopilot_ssdm_bits.h"
/* -- Bit get/set ----------------*/
#pragma line 129 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/etc/autopilot_ssdm_bits.h"
/* -- Part get/set ----------------*/
#pragma empty_line
/* GetRange: Notice that the order of the range indices comply with SystemC
standards. */
#pragma line 143 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/etc/autopilot_ssdm_bits.h"
/* SetRange: Notice that the order of the range indices comply with SystemC
standards. */
#pragma line 156 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/etc/autopilot_ssdm_bits.h"
/* -- Reduce operations ----------------*/
#pragma line 192 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/etc/autopilot_ssdm_bits.h"
/* -- String-Integer conversions ----------------*/
#pragma line 358 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/etc/autopilot_ssdm_bits.h"
// XSIP watermark, do not delete 67d7842dbbe25473c3c32b93c0da8047785f30d78e8a024de1b57352245f9689
#pragma line 646 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_int_syn.h" 2
#pragma empty_line
#pragma empty_line
/* Forward declaration.*/
template<int _AP_W, bool _AP_S, bool _AP_C = (_AP_W <= 64)>
struct ap_int_base;
template<int _AP_W, bool _AP_S> struct ap_range_ref;
template<int _AP_W, bool _AP_S> struct ap_bit_ref;
template<int _AP_W> struct ap_uint;
template<int _AP_W1, typename _AP_T1, int _AP_W2, typename _AP_T2> struct ap_concat_ref;
#pragma empty_line
enum ap_q_mode {
SC_RND, // rounding to plus infinity
SC_RND_ZERO, // rounding to zero
SC_RND_MIN_INF, // rounding to minus infinity
SC_RND_INF, // rounding to infinity
SC_RND_CONV, // convergent rounding
SC_TRN, // truncation
SC_TRN_ZERO // truncation to zero
#pragma empty_line
};
enum ap_o_mode {
SC_SAT, // saturation
SC_SAT_ZERO, // saturation to zero
SC_SAT_SYM, // symmetrical saturation
SC_WRAP, // wrap-around (*)
SC_WRAP_SM // sign magnitude wrap-around (*)
};
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;
template<int _AP_W, int _AP_I, bool _AP_S,
ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> struct af_range_ref;
template<int _AP_W, int _AP_I, bool _AP_S,
ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> struct af_bit_ref;
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Concatination reference.
----------------------------------------------------------------
*/
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 __attribute__((always_inline)) ap_concat_ref(const ap_concat_ref<_AP_W1, _AP_T1,
_AP_W2, _AP_T2>& ref):
mbv1(ref.mbv1), mbv2(ref.mbv2) {}
#pragma empty_line
inline __attribute__((always_inline)) ap_concat_ref( _AP_T1& bv1, _AP_T2& bv2) : mbv1(bv1), mbv2(bv2) { }
#pragma empty_line
#pragma empty_line
template <int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_concat_ref& operator = (const ap_int_base<_AP_W3, _AP_S3>& val) {
ap_int_base<_AP_W1+_AP_W2, false> vval(val);
int W_ref1 = mbv1.length();
int W_ref2 = mbv2.length();
ap_int_base<_AP_W1,false> Part1;
Part1.V = ({ typeof(vval.V) __Result__ = 0; typeof(vval.V) __Val2__ = vval.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), W_ref2, W_ref1+W_ref2-1); __Result__; });
mbv1.set(Part1);
ap_int_base<_AP_W2,false> Part2;
Part2.V = ({ typeof(vval.V) __Result__ = 0; typeof(vval.V) __Val2__ = vval.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 0, W_ref2-1); __Result__; });
mbv2.set(Part2);
return *this;
}
#pragma empty_line
inline __attribute__((always_inline)) ap_concat_ref& operator = (unsigned long long val) {
ap_int_base<_AP_W1+_AP_W2, false> tmpVal(val);
return operator = (tmpVal);
}
#pragma empty_line
/*template<typename _AP_T3>
INLINE ap_concat_ref& operator = ( const _AP_T3& val) {
ap_int_base<_AP_W1+_AP_W2, false> tmpVal(val);
return operator=<_AP_W1+_AP_W2,false>(tmpVal);
}*/
template<int _AP_W3, typename _AP_T3, int _AP_W4, typename _AP_T4>
inline __attribute__((always_inline)) ap_concat_ref& operator = (const ap_concat_ref<_AP_W3,_AP_T3,_AP_W4,_AP_T4>& val) {
ap_int_base<_AP_W1+_AP_W2, false> tmpVal(val);
return operator = (tmpVal);
}
#pragma empty_line
inline __attribute__((always_inline)) ap_concat_ref& operator = (const ap_concat_ref<_AP_W1,_AP_T1,_AP_W2,_AP_T2>& val) {
ap_int_base<_AP_W1+_AP_W2, false> tmpVal(val);
return operator = (tmpVal);
}
template<int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_concat_ref& operator = (const ap_bit_ref<_AP_W3, _AP_S3>& val) {
ap_int_base<_AP_W1+_AP_W2, false> tmpVal(val);
return operator = (tmpVal);
}
template<int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_concat_ref& operator = (const ap_range_ref<_AP_W3, _AP_S3>& val) {
ap_int_base<_AP_W1+_AP_W2, false> tmpVal(val);
return operator = (tmpVal);
}
#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 __attribute__((always_inline)) ap_concat_ref& operator= (const af_range_ref<_AP_W3, _AP_I3, _AP_S3,
_AP_Q3, _AP_O3, _AP_N3>& val) {
return operator = ((const ap_int_base<_AP_W3, false>)(val));
}
#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 __attribute__((always_inline)) ap_concat_ref& operator= (const ap_fixed_base<_AP_W3, _AP_I3, _AP_S3,
_AP_Q3, _AP_O3, _AP_N3>& val) {
return operator = (val.to_ap_int_base());
}
#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 __attribute__((always_inline)) ap_concat_ref& operator= (const af_bit_ref<_AP_W3, _AP_I3, _AP_S3,
_AP_Q3, _AP_O3, _AP_N3>& val) {
return operator=((unsigned long long)(bool)(val));
}
inline __attribute__((always_inline)) operator ap_int_base<_AP_WR, false> () const {
return get();
}
#pragma empty_line
inline __attribute__((always_inline)) operator unsigned long long () const {
return get().to_uint64();
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_concat_ref<_AP_WR, ap_concat_ref, _AP_W3, ap_range_ref<_AP_W3, _AP_S3> >
operator, (const ap_range_ref<_AP_W3, _AP_S3>& a2) {
return ap_concat_ref<_AP_WR, ap_concat_ref,
_AP_W3, ap_range_ref<_AP_W3, _AP_S3> >(*this,
const_cast<ap_range_ref<_AP_W3, _AP_S3>& >(a2));
}
#pragma empty_line
template<int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_concat_ref<_AP_WR, ap_concat_ref, _AP_W3, ap_int_base<_AP_W3, _AP_S3> >
operator, (ap_int_base<_AP_W3, _AP_S3>& a2) {
return ap_concat_ref<_AP_WR, ap_concat_ref,
_AP_W3, ap_int_base<_AP_W3, _AP_S3> >(*this, a2);
}
#pragma empty_line
template<int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_concat_ref<_AP_WR, ap_concat_ref, _AP_W3, ap_int_base<_AP_W3, _AP_S3> >
operator, (volatile ap_int_base<_AP_W3, _AP_S3>& a2) {
return ap_concat_ref<_AP_WR, ap_concat_ref,
_AP_W3, ap_int_base<_AP_W3, _AP_S3> >(*this,
const_cast<ap_int_base<_AP_W3, _AP_S3>& >(a2));
}
#pragma empty_line
template<int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_concat_ref<_AP_WR, ap_concat_ref, _AP_W3, ap_int_base<_AP_W3, _AP_S3> >
operator, (const ap_int_base<_AP_W3, _AP_S3>& a2) {
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 __attribute__((always_inline)) ap_concat_ref<_AP_WR, ap_concat_ref, _AP_W3, ap_int_base<_AP_W3, _AP_S3> >
operator, (const volatile ap_int_base<_AP_W3, _AP_S3>& a2) {
ap_int_base<_AP_W3,_AP_S3> op(a2);
return ap_concat_ref<_AP_WR, ap_concat_ref,
_AP_W3, ap_int_base<_AP_W3, _AP_S3> >(*this,
const_cast<ap_int_base<_AP_W3, _AP_S3>& >(op));
}
template<int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_concat_ref<_AP_WR, ap_concat_ref, 1, ap_bit_ref<_AP_W3, _AP_S3> >
operator, (const ap_bit_ref<_AP_W3, _AP_S3>& a2) {
return ap_concat_ref<_AP_WR, ap_concat_ref,
1, ap_bit_ref<_AP_W3, _AP_S3> >(*this,
const_cast<ap_bit_ref<_AP_W3, _AP_S3>& >(a2));
}
#pragma empty_line
template<int _AP_W3, typename _AP_T3, int _AP_W4, typename _AP_T4>
inline __attribute__((always_inline)) ap_concat_ref<_AP_WR, ap_concat_ref, _AP_W3+_AP_W4,
ap_concat_ref<_AP_W3,_AP_T3,_AP_W4,_AP_T4> >
operator, (const ap_concat_ref<_AP_W3,_AP_T3,_AP_W4,_AP_T4>& a2) {
return ap_concat_ref<_AP_WR, ap_concat_ref,
_AP_W3+_AP_W4, ap_concat_ref<_AP_W3,_AP_T3,_AP_W4,_AP_T4> >(
*this, const_cast<ap_concat_ref<_AP_W3,_AP_T3,
_AP_W4,_AP_T4>& >(a2));
}
#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 __attribute__((always_inline))
ap_concat_ref<_AP_WR, ap_concat_ref, _AP_W3, af_range_ref<_AP_W3, _AP_I3, _AP_S3, _AP_Q3, _AP_O3, _AP_N3> >
operator, (const af_range_ref<_AP_W3, _AP_I3, _AP_S3, _AP_Q3,
_AP_O3, _AP_N3> &a2) {
return ap_concat_ref<_AP_WR, ap_concat_ref, _AP_W3, af_range_ref<_AP_W3,
_AP_I3, _AP_S3, _AP_Q3, _AP_O3, _AP_N3> >(*this,
const_cast<af_range_ref< _AP_W3, _AP_I3, _AP_S3, _AP_Q3,
_AP_O3, _AP_N3>& >(a2));
}
#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 __attribute__((always_inline))
ap_concat_ref<_AP_WR, ap_concat_ref, 1, af_bit_ref<_AP_W3, _AP_I3, _AP_S3, _AP_Q3, _AP_O3, _AP_N3> >
operator, (const af_bit_ref<_AP_W3, _AP_I3, _AP_S3, _AP_Q3,
_AP_O3, _AP_N3> &a2) {
return ap_concat_ref<_AP_WR, ap_concat_ref, 1, af_bit_ref<_AP_W3,
_AP_I3, _AP_S3, _AP_Q3, _AP_O3, _AP_N3> >(*this,
const_cast<af_bit_ref<_AP_W3, _AP_I3, _AP_S3, _AP_Q3,
_AP_O3, _AP_N3>& >(a2));
}
#pragma empty_line
template<int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_int_base<((_AP_WR) > (_AP_W3) ? (_AP_WR) : (_AP_W3)), _AP_S3>
operator & (const ap_int_base<_AP_W3,_AP_S3>& a2) {
return get() & a2;
}
#pragma empty_line
template<int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_int_base<((_AP_WR) > (_AP_W3) ? (_AP_WR) : (_AP_W3)), _AP_S3>
operator | (const ap_int_base<_AP_W3,_AP_S3>& a2) {
return get() | a2;
}
#pragma empty_line
template<int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_int_base<((_AP_WR) > (_AP_W3) ? (_AP_WR) : (_AP_W3)), _AP_S3>
operator ^ (const ap_int_base<_AP_W3,_AP_S3>& a2) {
return get() ^ a2;
}
#pragma line 880 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_int_syn.h"
inline __attribute__((always_inline)) ap_int_base<_AP_WR,false> get() const {
ap_int_base<_AP_WR,false> tmpVal(0);
int W_ref1 = mbv1.length();
int W_ref2 = mbv2.length();
tmpVal.V = ({ typeof(tmpVal.V) __Result__ = 0; typeof(tmpVal.V) __Val2__ = tmpVal.V; typeof((ap_int_base<_AP_W2,false>(mbv2)).V) __Repl2__ = (ap_int_base<_AP_W2,false>(mbv2)).V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), 0, W_ref2-1); __Result__; });
#pragma empty_line
tmpVal.V = ({ typeof(tmpVal.V) __Result__ = 0; typeof(tmpVal.V) __Val2__ = tmpVal.V; typeof((ap_int_base<_AP_W1,false>(mbv1)).V) __Repl2__ = (ap_int_base<_AP_W1,false>(mbv1)).V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), W_ref2, W_ref1+W_ref2-1); __Result__; });
#pragma empty_line
return tmpVal;
}
#pragma empty_line
template <int _AP_W3>
inline __attribute__((always_inline)) void set(const ap_int_base<_AP_W3, false>& val) {
ap_int_base<_AP_W1+_AP_W2, false> vval(val);
int W_ref1 = mbv1.length();
int W_ref2 = mbv2.length();
ap_int_base<_AP_W1,false> tmpVal1;
tmpVal1.V = ({ typeof(vval.V) __Result__ = 0; typeof(vval.V) __Val2__ = vval.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), W_ref2, W_ref1+W_ref2-1); __Result__; });
mbv1.set(tmpVal1);
ap_int_base<_AP_W2, false> tmpVal2;
tmpVal2.V=({ typeof(vval.V) __Result__ = 0; typeof(vval.V) __Val2__ = vval.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 0, W_ref2-1); __Result__; });
mbv2.set(tmpVal2);
}
#pragma empty_line
inline __attribute__((always_inline)) int length() const {
return mbv1.length() + mbv2.length();
}
};
#pragma line 919 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_int_syn.h"
/* Range (slice) reference.
----------------------------------------------------------------
*/
template<int _AP_W, bool _AP_S>
struct ap_range_ref {
ap_int_base<_AP_W,_AP_S> &d_bv;
int l_index;
int h_index;
#pragma empty_line
public:
inline __attribute__((always_inline)) ap_range_ref(const ap_range_ref<_AP_W, _AP_S>& ref):
d_bv(ref.d_bv), l_index(ref.l_index), h_index(ref.h_index) {}
#pragma empty_line
inline __attribute__((always_inline)) ap_range_ref(ap_int_base<_AP_W,_AP_S>* bv, int h, int l) :
d_bv(*bv), l_index(l), h_index(h) {
/*AP_ASSERT(h >= l, "Range must be (High, Low)");*/
}
#pragma empty_line
inline __attribute__((always_inline)) operator ap_int_base<_AP_W, false> () const {
ap_int_base<_AP_W,false> ret;
ret.V = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; });
return ret;
}
#pragma empty_line
inline __attribute__((always_inline)) operator unsigned long long () const {
return to_uint64();
}
#pragma empty_line
inline __attribute__((always_inline)) ap_range_ref& operator = (unsigned long long val) {
ap_int_base<_AP_W, false> loc(val);
d_bv.V = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(loc.V) __Repl2__ = loc.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; });
return *this;
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_range_ref& operator = (const ap_int_base<_AP_W2,_AP_S2>& val) {
ap_int_base<_AP_W, false> loc(val);
d_bv.V = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(loc.V) __Repl2__ = loc.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; });
return *this;
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_range_ref& operator= (const ap_range_ref<_AP_W2,_AP_S2>& val) {
return operator=((const ap_int_base<_AP_W2, false>)val);
}
#pragma empty_line
inline __attribute__((always_inline)) ap_range_ref& operator= (const ap_range_ref<_AP_W, _AP_S>& val) {
return operator=((const ap_int_base<_AP_W, 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 __attribute__((always_inline)) ap_range_ref& operator= (const af_range_ref<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2>& val) {
return operator=((const ap_int_base<_AP_W2, false>)(val));
}
#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 __attribute__((always_inline)) ap_range_ref& operator= (const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2>& val) {
return operator=(val.to_ap_int_base());
}
#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 __attribute__((always_inline)) ap_range_ref& operator= (const af_bit_ref<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2>& val) {
return operator=((unsigned long long)(bool)(val));
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_range_ref& operator= (const ap_bit_ref<_AP_W2, _AP_S2>& val) {
return operator=((unsigned long long)(bool)(val));
}
#pragma empty_line
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_range_ref& operator= (const ap_concat_ref<_AP_W2, _AP_T3, _AP_W3, _AP_T3>& val) {
return operator=((const ap_int_base<_AP_W2 + _AP_W3, false>)(val));
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W,ap_range_ref,_AP_W2,ap_range_ref<_AP_W2,_AP_S2> >
operator, (const ap_range_ref<_AP_W2,_AP_S2> &a2) {
return
ap_concat_ref<_AP_W, ap_range_ref, _AP_W2,
ap_range_ref<_AP_W2,_AP_S2> >(*this,
const_cast<ap_range_ref<_AP_W2, _AP_S2>& >(a2));
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W,ap_range_ref,_AP_W2,ap_int_base<_AP_W2,_AP_S2> >
operator, (ap_int_base<_AP_W2,_AP_S2> &a2) {
return
ap_concat_ref<_AP_W, ap_range_ref, _AP_W2, ap_int_base<_AP_W2,_AP_S2> >(*this, a2);
}
#pragma empty_line
inline __attribute__((always_inline))
ap_concat_ref<_AP_W,ap_range_ref,_AP_W,ap_int_base<_AP_W,_AP_S> >
operator, (ap_int_base<_AP_W,_AP_S> &a2) {
return
ap_concat_ref<_AP_W, ap_range_ref, _AP_W, ap_int_base<_AP_W,_AP_S> >(*this, a2);
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W,ap_range_ref,_AP_W2,ap_int_base<_AP_W2,_AP_S2> >
operator, (volatile ap_int_base<_AP_W2,_AP_S2>& a2) {
return
ap_concat_ref<_AP_W, ap_range_ref, _AP_W2, ap_int_base<_AP_W2,_AP_S2> >(*this,
const_cast<ap_int_base<_AP_W2, _AP_S2>& >(a2));
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W,ap_range_ref,_AP_W2,ap_int_base<_AP_W2,_AP_S2> >
operator, (const ap_int_base<_AP_W2,_AP_S2>& a2) {
return
ap_concat_ref<_AP_W, ap_range_ref, _AP_W2, ap_int_base<_AP_W2,_AP_S2> >(*this,
const_cast<ap_int_base<_AP_W2, _AP_S2>& >(a2));
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W,ap_range_ref,_AP_W2,ap_int_base<_AP_W2,_AP_S2> >
operator, (const volatile ap_int_base<_AP_W2,_AP_S2>& a2) {
return
ap_concat_ref<_AP_W, ap_range_ref, _AP_W2,
ap_int_base<_AP_W2,_AP_S2> >(*this,
const_cast<ap_int_base<_AP_W2, _AP_S2>& >(a2));
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W,ap_range_ref,1,ap_bit_ref<_AP_W2,_AP_S2> >
operator, (const ap_bit_ref<_AP_W2,_AP_S2> &a2) {
return
ap_concat_ref<_AP_W, ap_range_ref, 1, ap_bit_ref<_AP_W2,_AP_S2> >(*this,
const_cast<ap_bit_ref<_AP_W2, _AP_S2>& >(a2));
}
#pragma empty_line
template <int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_range_ref, _AP_W2+_AP_W3, ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >
operator, (const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> &a2) {
return ap_concat_ref<_AP_W, ap_range_ref, _AP_W2+_AP_W3,
ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >(*this,
const_cast<ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& >(a2));
}
#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 __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_range_ref, _AP_W2, af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> a2) {
return ap_concat_ref<_AP_W, ap_range_ref, _AP_W2, af_range_ref<_AP_W2,
_AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(*this,
const_cast<af_range_ref<_AP_W2,_AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2>& >(a2));
}
#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 __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_range_ref, 1, af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &a2) {
return ap_concat_ref<_AP_W, ap_range_ref, 1, af_bit_ref<_AP_W2,
_AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(*this,
const_cast<af_bit_ref<_AP_W2,_AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2>& >(a2));
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator == (const ap_range_ref<_AP_W2, _AP_S2>& op2) {
ap_int_base<_AP_W, false> lop(*this);
ap_int_base<_AP_W2, false> hop(op2);
return lop == hop;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator != (const ap_range_ref<_AP_W2, _AP_S2>& op2) {
return !(operator == (op2));
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator < (const ap_range_ref<_AP_W2, _AP_S2>& op2) {
ap_int_base<_AP_W, false> lop (*this);
#pragma empty_line
ap_int_base<_AP_W2, false> hop (op2);
return lop < hop;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator <= (const ap_range_ref<_AP_W2, _AP_S2>& op2) {
ap_int_base<_AP_W, false> lop (*this);
#pragma empty_line
ap_int_base<_AP_W2, false> hop (op2);
return lop <= hop;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator > (const ap_range_ref<_AP_W2, _AP_S2>& op2) {
return !(operator <= (op2));
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator >= (const ap_range_ref<_AP_W2, _AP_S2>& op2) {
return !(operator < (op2));
}
#pragma empty_line
template <int _AP_W3>
inline __attribute__((always_inline)) void set(const ap_int_base<_AP_W3, false>& val) {
d_bv.V = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(val.V) __Repl2__ = val.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; });
}
#pragma empty_line
inline __attribute__((always_inline)) int length() const {
return h_index >= l_index ? h_index - l_index + 1 : l_index - h_index + 1;
}
#pragma empty_line
inline __attribute__((always_inline)) int to_int() const {
return (int)(({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; }));
}
inline __attribute__((always_inline)) unsigned to_uint() const {
return (unsigned)(({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; }));
}
inline __attribute__((always_inline)) long to_long() const {
return (long)(({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; }));
}
inline __attribute__((always_inline)) unsigned long to_ulong() const {
return (unsigned long)(({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; }));
}
inline __attribute__((always_inline)) ap_slong to_int64() const {
return (ap_slong)(({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; }));
}
inline __attribute__((always_inline)) ap_ulong to_uint64() const {
return (ap_ulong)(({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; }));
}
inline __attribute__((always_inline)) bool and_reduce() const {
bool ret = true;
bool reverse = l_index > h_index;
unsigned low = reverse ? h_index : l_index;
unsigned high = reverse ? l_index : h_index;
for (unsigned i = low; i != high; ++i) {
_ssdm_Unroll(0,0,0, "");
ret &= (bool)(({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), i, i); __Result__; }));
}
return ret;
}
inline __attribute__((always_inline)) bool or_reduce() const {
bool ret = false;
bool reverse = l_index > h_index;
unsigned low = reverse ? h_index : l_index;
unsigned high = reverse ? l_index : h_index;
for (unsigned i = low; i != high; ++i) {
_ssdm_Unroll(0,0,0, "");
ret |= (bool)(({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), i, i); __Result__; }));
}
return ret;
}
inline __attribute__((always_inline)) bool xor_reduce() const {
bool ret = false;
bool reverse = l_index > h_index;
unsigned low = reverse ? h_index : l_index;
unsigned high = reverse ? l_index : h_index;
for (unsigned i = low; i != high; ++i) {
_ssdm_Unroll(0,0,0, "");
ret ^= (bool)(({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), i, i); __Result__; }));
}
return ret;
}
};
#pragma empty_line
#pragma empty_line
/* Bit reference.
----------------------------------------------------------------
*/
template<int _AP_W, bool _AP_S>
struct ap_bit_ref {
ap_int_base<_AP_W, _AP_S>& d_bv;
int d_index;
#pragma empty_line
public:
inline __attribute__((always_inline)) ap_bit_ref(const ap_bit_ref<_AP_W, _AP_S>& ref):
d_bv(ref.d_bv), d_index(ref.d_index) {}
#pragma empty_line
inline __attribute__((always_inline)) ap_bit_ref(ap_int_base<_AP_W,_AP_S>* bv, int index=0) :
d_bv(*bv), d_index(index) { }
inline __attribute__((always_inline)) operator bool () const { return ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), d_index, d_index); (bool)(__Result__ & 1); }); }
inline __attribute__((always_inline)) bool to_bool() const { return ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), d_index, d_index); (bool)(__Result__ & 1); }); }
#pragma empty_line
inline __attribute__((always_inline)) ap_bit_ref& operator = ( unsigned long long val ) {
d_bv.V = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(val) __Repl2__ = !!val; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), d_index, d_index); __Result__; });
return *this;
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_bit_ref& operator = ( const ap_int_base<_AP_W2,_AP_S2> &val ) {
return operator =((unsigned long long)(val.V != 0));
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_bit_ref& operator = ( const ap_range_ref<_AP_W2,_AP_S2> &val ) {
return operator =(val.operator ap_int_base<_AP_W2, false>());
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_bit_ref& operator = (const ap_bit_ref<_AP_W2,_AP_S2>& val) {
return operator =((unsigned long long) (bool) val);
}
#pragma empty_line
inline __attribute__((always_inline)) ap_bit_ref& operator = (const ap_bit_ref<_AP_W,_AP_S>& val) {
return operator =((unsigned long long) (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 __attribute__((always_inline)) ap_bit_ref& operator= (const af_range_ref<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2>& val) {
return operator=((const ap_int_base<_AP_W2, false>)(val));
}
#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 __attribute__((always_inline)) ap_bit_ref& operator= (const af_bit_ref<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2>& val) {
return operator=((unsigned long long)(bool)(val));
}
#pragma empty_line
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_bit_ref& operator= (const ap_concat_ref<_AP_W2, _AP_T3, _AP_W3, _AP_T3>& val) {
return operator=((const ap_int_base<_AP_W2 + _AP_W3, false>)(val));
}
#pragma empty_line
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<1, ap_bit_ref, _AP_W2, ap_int_base<_AP_W2,_AP_S2> >
operator, (ap_int_base<_AP_W2, _AP_S2>& a2) {
return ap_concat_ref<1, ap_bit_ref, _AP_W2, ap_int_base<_AP_W2,_AP_S2> >(*this, a2);
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<1, ap_bit_ref, _AP_W2, ap_int_base<_AP_W2,_AP_S2> >
operator, (volatile ap_int_base<_AP_W2, _AP_S2>& a2) {
return ap_concat_ref<1, ap_bit_ref, _AP_W2, ap_int_base<_AP_W2,_AP_S2>
>(*this, const_cast<ap_int_base<_AP_W2, _AP_S2>& >(a2));
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<1, ap_bit_ref, _AP_W2, ap_int_base<_AP_W2,_AP_S2> >
operator, (const ap_int_base<_AP_W2, _AP_S2>& a2) {
ap_int_base<_AP_W2,_AP_S2> op(a2);
return ap_concat_ref<1,ap_bit_ref,_AP_W2,ap_int_base<_AP_W2,
_AP_S2> >(*this, const_cast<ap_int_base<_AP_W2, _AP_S2>& >(op));
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<1, ap_bit_ref, _AP_W2, ap_int_base<_AP_W2,_AP_S2> >
operator, (const volatile ap_int_base<_AP_W2, _AP_S2>& a2) {
ap_int_base<_AP_W2,_AP_S2> op(a2);
return ap_concat_ref<1,ap_bit_ref,_AP_W2, ap_int_base<_AP_W2,_AP_S2>
>(*this, const_cast< ap_int_base<_AP_W2, _AP_S2>& >(op));
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<1, ap_bit_ref, _AP_W2, ap_range_ref<_AP_W2,_AP_S2> >
operator, (const ap_range_ref<_AP_W2, _AP_S2> &a2) {
return
ap_concat_ref<1, ap_bit_ref, _AP_W2, ap_range_ref<_AP_W2,
_AP_S2> >(*this, const_cast<ap_range_ref<_AP_W2, _AP_S2> &>(a2));
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<1, ap_bit_ref, 1, ap_bit_ref<_AP_W2,_AP_S2> >
operator, (const ap_bit_ref<_AP_W2, _AP_S2> &a2) {
return ap_concat_ref<1, ap_bit_ref, 1, ap_bit_ref<_AP_W2,_AP_S2> >(*this,
const_cast<ap_bit_ref<_AP_W2,_AP_S2>& >(a2));
}
#pragma empty_line
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_concat_ref<1, ap_bit_ref, _AP_W2+_AP_W3, ap_concat_ref<_AP_W2,_AP_T2,_AP_W3,_AP_T3> >
operator, (const ap_concat_ref<_AP_W2,_AP_T2,_AP_W3,_AP_T3> &a2) {
return ap_concat_ref<1,ap_bit_ref,_AP_W2+_AP_W3,ap_concat_ref<_AP_W2,
_AP_T2,_AP_W3,_AP_T3> >(*this,
const_cast<ap_concat_ref<_AP_W2,_AP_T2,_AP_W3,_AP_T3> &>(a2));
}
#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 __attribute__((always_inline))
ap_concat_ref<1, ap_bit_ref, _AP_W2, af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &a2) {
return ap_concat_ref<1, ap_bit_ref, _AP_W2, af_range_ref<_AP_W2,
_AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(*this,
const_cast<af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2>& >(a2));
}
#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 __attribute__((always_inline))
ap_concat_ref<1, ap_bit_ref, 1, af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &a2) {
return ap_concat_ref<1, ap_bit_ref, 1, af_bit_ref<_AP_W2,
_AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(*this,
const_cast<af_bit_ref<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2>& >(a2));
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator == (const ap_bit_ref<_AP_W2, _AP_S2>& op) {
return get() == op.get();
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator != (const ap_bit_ref<_AP_W2, _AP_S2>& op) {
return get() != op.get();
}
#pragma empty_line
inline __attribute__((always_inline)) bool get() const {
return ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), d_index, d_index); (bool)(__Result__ & 1); });
}
#pragma empty_line
inline __attribute__((always_inline)) bool get() {
return ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), d_index, d_index); (bool)(__Result__ & 1); });
}
#pragma empty_line
template <int _AP_W3>
inline __attribute__((always_inline)) void set(const ap_int_base<_AP_W3, false>& val) {
operator = (val);
}
#pragma empty_line
inline __attribute__((always_inline)) bool operator ~() const {
bool bit = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), d_index, d_index); (bool)(__Result__ & 1); });
return bit ? false : true;
}
#pragma empty_line
inline __attribute__((always_inline)) int length() const { return 1; }
};
#pragma empty_line
template <int _AP_N, bool _AP_S> struct retval;
#pragma empty_line
template <int _AP_N>
struct retval<_AP_N, true> {
typedef ap_slong Type;
};
template <int _AP_N>
struct retval<_AP_N, false> {
typedef ap_ulong Type;
};
#pragma empty_line
template<> struct retval<1, true> {
typedef signed char Type;
};
template<> struct retval<1, false> {
typedef unsigned char Type;
};
template<> struct retval<2, true> {
typedef short Type;
};
template<> struct retval<2, false> {
typedef unsigned short Type;
};
template<> struct retval<3, true> {
typedef int Type;
};
template<> struct retval<3, false> {
typedef unsigned int Type;
};
template<> struct retval<4, true> {
typedef int Type;
};
template<> struct retval<4, false> {
typedef unsigned int Type;
};
#pragma empty_line
/* ----------------------------------------------------------------
ap_int_base: AutoPilot integer/Arbitrary precision integer.
----------------------------------------------------------------
*/
#pragma empty_line
template<int _AP_W, bool _AP_S>
struct ap_int_base <_AP_W, _AP_S, true>: public ssdm_int<_AP_W,_AP_S> {
#pragma empty_line
public:
typedef ssdm_int<_AP_W, _AP_S> Base;
#pragma empty_line
typedef typename retval< (_AP_W + 7)/8, _AP_S>::Type RetType;
#pragma empty_line
static const int width = _AP_W;
#pragma empty_line
#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
};
#pragma empty_line
typedef ap_int_base<mult_w, mult_s> mult;
typedef ap_int_base<plus_w, plus_s> plus;
typedef ap_int_base<minus_w, minus_s> minus;
typedef ap_int_base<logic_w, logic_s> logic;
typedef ap_int_base<div_w, div_s> div;
typedef ap_int_base<mod_w, mod_s> mod;
typedef ap_int_base<_AP_W, _AP_S> arg1;
typedef bool reduce;
};
#pragma empty_line
/* Constructors.
----------------------------------------------------------------
*/
inline __attribute__((always_inline)) ap_int_base() {
/*
#ifdef __SC_COMPATIBLE__
Base::V = 0;
#endif
*/
}
#pragma empty_line
//INLINE ap_int_base(const ap_int_base& op) { Base::V = op.V; }
//INLINE ap_int_base(const volatile ap_int_base& op) { Base::V = op.V; }
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base(const ap_int_base<_AP_W2,_AP_S2> &op) { Base::V = op.V; }
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base(const volatile ap_int_base<_AP_W2,_AP_S2> &op) { Base::V = op.V; }
#pragma empty_line
/* For C++ basic data types.*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline __attribute__((always_inline)) explicit ap_int_base(bool op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(signed char op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(unsigned char op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(short op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(unsigned short op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(int op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(unsigned int op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(long op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(unsigned long op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(ap_slong op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(ap_ulong op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(float op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(double op) { Base::V = 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 __attribute__((always_inline)) ap_int_base(const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>& op) {
Base::V = op.to_ap_int_base().V;
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base(const ap_range_ref<_AP_W2,_AP_S2>& ref) {
Base::V = ref.operator ap_int_base<_AP_W2, false>().V;
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base(const ap_bit_ref<_AP_W2,_AP_S2>& ref) {
Base::V = ref.operator bool();
}
#pragma empty_line
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_int_base(const ap_concat_ref<_AP_W2,_AP_T2,_AP_W3,_AP_T3>& ref) {
const ap_int_base<ap_concat_ref<_AP_W2,_AP_T2,_AP_W3,_AP_T3>::_AP_WR,false> tmp = ref.get();
Base::V = tmp.V;
}
#pragma empty_line
/* This constructor is not usable yet, because the second parameter of
__builtin_bit_from_string(...)
is required to be a constant C string.
*/
inline __attribute__((always_inline)) ap_int_base(const char* str) {
typeof(Base::V) Result;
_ssdm_string2bits((void*)(&Result), (const char*)(str), 10,
_AP_W, _AP_S, SC_TRN, SC_WRAP, 0, true);
Base::V = Result;
}
#pragma empty_line
inline __attribute__((always_inline)) ap_int_base(const char* str, signed char radix) {
typeof(Base::V) Result;
_ssdm_string2bits((void*)(&Result), (const char*)(str), radix,
_AP_W, _AP_S, SC_TRN, SC_WRAP, 0, true);
Base::V = Result;
}
#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 __attribute__((always_inline)) ap_int_base(const af_range_ref<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2> &val) {
Base::V = (val.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 __attribute__((always_inline)) ap_int_base(const af_bit_ref<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2> &val) {
Base::V = val.operator bool ();
}
#pragma empty_line
inline __attribute__((always_inline)) ap_int_base read() volatile {
;
ap_int_base ret;
ret.V = Base::V;
return ret;
}
inline __attribute__((always_inline)) void write(const ap_int_base<_AP_W, _AP_S>& op2) volatile {
;
Base::V = op2.V;
}
#pragma empty_line
/* Another form of "write".*/
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) void operator = (const volatile ap_int_base<_AP_W2,_AP_S2>& op2) volatile {
Base::V = op2.V;
}
#pragma empty_line
inline __attribute__((always_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 __attribute__((always_inline)) void operator = (const ap_int_base<_AP_W2,_AP_S2>& op2) volatile {
Base::V = op2.V;
}
#pragma empty_line
inline __attribute__((always_inline)) void operator = (const ap_int_base<_AP_W, _AP_S>& op2) volatile {
Base::V = op2.V;
}
#pragma line 1565 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_int_syn.h"
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base& operator = (const volatile ap_int_base<_AP_W2,_AP_S2>& op2) {
Base::V = op2.V;
return *this;
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base& operator = (const ap_int_base<_AP_W2,_AP_S2>& op2) {
Base::V = op2.V;
return *this;
}
#pragma empty_line
inline __attribute__((always_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 __attribute__((always_inline)) ap_int_base& operator = (const ap_int_base<_AP_W,_AP_S>& op2) {
Base::V = op2.V;
return *this;
}
inline __attribute__((always_inline)) ap_int_base& operator = (const char* str) {
typeof(Base::V) Result;
_ssdm_string2bits((void*)(&Result), (const char*)(str),
10, _AP_W, _AP_S, SC_TRN, SC_WRAP, 0,true);
Base::V = Result;
return *this;
}
#pragma empty_line
inline __attribute__((always_inline)) ap_int_base& set(const char* str, signed char radix) {
typeof(Base::V) Result;
_ssdm_string2bits((void*)(&Result), (const char*)(str), radix,
_AP_W, _AP_S, SC_TRN, SC_WRAP, 0, true);
Base::V = Result;
return *this;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline __attribute__((always_inline)) ap_int_base& operator = (signed char op) { Base::V = op; return *this; }
inline __attribute__((always_inline)) ap_int_base& operator = (unsigned char op) { Base::V = op; return *this; }
inline __attribute__((always_inline)) ap_int_base& operator = (short op) { Base::V = op; return *this; }
inline __attribute__((always_inline)) ap_int_base& operator = (unsigned short op) { Base::V = op; return *this; }
inline __attribute__((always_inline)) ap_int_base& operator = (int op) { Base::V = op; return *this; }
inline __attribute__((always_inline)) ap_int_base& operator = (unsigned int op) { Base::V = op; return *this; }
inline __attribute__((always_inline)) ap_int_base& operator = (ap_slong op) { Base::V = op; return *this; }
inline __attribute__((always_inline)) ap_int_base& operator = (ap_ulong op) { Base::V = op; return *this; }
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base& operator = (const ap_bit_ref<_AP_W2, _AP_S2>& op2) {
Base::V = (bool) op2;
return *this;
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base& operator = (const ap_range_ref<_AP_W2, _AP_S2>& op2) {
Base::V = (ap_int_base<_AP_W2, false>(op2)).V;
return *this;
}
#pragma empty_line
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_int_base& operator = (const ap_concat_ref<_AP_W2,_AP_T2,_AP_W3,_AP_T3>& op2) {
Base::V = op2.get().V;
return *this;
}
#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 __attribute__((always_inline)) ap_int_base& operator = (const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
Base::V = op.to_ap_int_base().V;
return *this;
}
#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 __attribute__((always_inline)) ap_int_base& operator = (const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
Base::V = (bool) op;
return *this;
}
#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 __attribute__((always_inline)) ap_int_base& operator = (const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
Base::V = ((const ap_int_base<_AP_W2, false>)(op)).V;
return *this;
}
#pragma empty_line
inline __attribute__((always_inline)) operator RetType() const { return (RetType)(Base::V); }
#pragma empty_line
#pragma empty_line
/* Explicit conversions to C interger types.
----------------------------------------------------------------
*/
inline __attribute__((always_inline)) bool to_bool() const {return (bool)(Base::V);}
inline __attribute__((always_inline)) unsigned char to_uchar() const {return (unsigned char)(Base::V);}
inline __attribute__((always_inline)) signed char to_char() const {return (signed char)(Base::V);}
inline __attribute__((always_inline)) unsigned short to_ushort() const {return (unsigned short)(Base::V);}
inline __attribute__((always_inline)) short to_short() const {return (short)(Base::V);}
inline __attribute__((always_inline)) int to_int() const { return (int)(Base::V); }
inline __attribute__((always_inline)) unsigned to_uint() const { return (unsigned)(Base::V); }
inline __attribute__((always_inline)) long to_long() const { return (long)(Base::V); }
inline __attribute__((always_inline)) unsigned long to_ulong() const { return (unsigned long)(Base::V); }
inline __attribute__((always_inline)) ap_slong to_int64() const { return (ap_slong)(Base::V); }
inline __attribute__((always_inline)) ap_ulong to_uint64() const { return (ap_ulong)(Base::V); }
inline __attribute__((always_inline)) double to_double() const { return (double)(Base::V); }
#pragma line 1684 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_int_syn.h"
inline __attribute__((always_inline)) int length() const { return _AP_W; }
inline __attribute__((always_inline)) int length() const volatile { return _AP_W; }
#pragma empty_line
/*INLINE operator ap_ulong () { return (ap_ulong)(Base::V); }*/
#pragma empty_line
/*Reverse the contents of ap_int_base instance. I.e. LSB becomes MSB and vise versa*/
inline __attribute__((always_inline)) ap_int_base& reverse () {
Base::V = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W - 1, 0); __Result__; });
return *this;
}
#pragma empty_line
/*Return true if the value of ap_int_base instance is zero*/
inline __attribute__((always_inline)) bool iszero () const {
return Base::V == 0 ;
}
#pragma empty_line
/*Return true if the value of ap_int_base instance is zero*/
inline __attribute__((always_inline)) bool is_zero () const {
return Base::V == 0 ;
}
#pragma empty_line
/* x < 0 */
inline __attribute__((always_inline)) bool sign () const {
if (_AP_S && ({ typeof(const_cast<ap_int_base*>(this)->V) __Result__ = 0; typeof(const_cast<ap_int_base*>(this)->V) __Val2__ = const_cast<ap_int_base*>(this)->V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W - 1, _AP_W - 1); (bool)(__Result__ & 1); }))
return true;
else
return false;
}
#pragma empty_line
/* x[i] = 0 */
inline __attribute__((always_inline)) void clear(int i) {
;
Base::V = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(0) __Repl2__ = !!0; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), i, i); __Result__; });
}
#pragma empty_line
/* x[i] = !x[i]*/
inline __attribute__((always_inline)) void invert(int i) {
;
bool val = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), i, i); (bool)(__Result__ & 1); });
if (val) Base::V = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(0) __Repl2__ = !!0; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), i, i); __Result__; });
else Base::V = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(1) __Repl2__ = !!1; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), i, i); __Result__; });
}
#pragma empty_line
#pragma empty_line
inline __attribute__((always_inline)) bool test (int i) const {
;
return ({ typeof(const_cast<ap_int_base*>(this)->V) __Result__ = 0; typeof(const_cast<ap_int_base*>(this)->V) __Val2__ = const_cast<ap_int_base*>(this)->V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), i, i); (bool)(__Result__ & 1); });
}
#pragma empty_line
//Set the ith bit into 1
inline __attribute__((always_inline)) void set (int i) {
;
Base::V = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(1) __Repl2__ = !!1; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), i, i); __Result__; });
}
#pragma empty_line
//Set the ith bit into v
inline __attribute__((always_inline)) void set (int i, bool v) {
;
Base::V = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(v) __Repl2__ = !!v; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), i, i); __Result__; });
}
#pragma empty_line
//This is used for sc_lv and sc_bv, which is implemented by sc_uint
//Rotate an ap_int_base object n places to the left
inline __attribute__((always_inline)) void lrotate(int n) {
;
typeof(Base::V) l_p = Base::V << n;
typeof(Base::V) r_p = Base::V >> (_AP_W - n);
Base::V = l_p | r_p;
}
#pragma empty_line
//This is used for sc_lv and sc_bv, which is implemented by sc_uint
//Rotate an ap_int_base object n places to the right
inline __attribute__((always_inline)) void rrotate(int n) {
;
typeof(Base::V) l_p = Base::V << (_AP_W - n);
typeof(Base::V) r_p = Base::V >> n;
Base::V = l_p | r_p;
}
#pragma empty_line
//Set the ith bit into v
inline __attribute__((always_inline)) void set_bit (int i, bool v) {
Base::V = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(v) __Repl2__ = !!v; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), i, i); __Result__; });
}
#pragma empty_line
//Get the value of ith bit
inline __attribute__((always_inline)) bool get_bit (int i) const {
return (bool)({ typeof(const_cast<ap_int_base*>(this)->V) __Result__ = 0; typeof(const_cast<ap_int_base*>(this)->V) __Val2__ = const_cast<ap_int_base*>(this)->V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), i, i); (bool)(__Result__ & 1); });
}
#pragma empty_line
//complements every bit
inline __attribute__((always_inline)) void b_not() {
Base::V = ~Base::V;
}
#pragma empty_line
// Count the number of zeros from the most significant bit
// to the first one bit. Note this is only for ap_fixed_base whose
// _AP_W <= 64, otherwise will incur assertion.
inline __attribute__((always_inline)) int countLeadingZeros() {
if (_AP_W <= 32) {
ap_int_base<32, false> t(-1ULL);
t.range(_AP_W-1, 0) = this->range(0, _AP_W-1);
return __builtin_ctz(t.V);
} else if (_AP_W <= 64) {
ap_int_base<64, false> t(-1ULL);
t.range(_AP_W-1, 0) = this->range(0, _AP_W-1);
return __builtin_ctzll(t.V);
} else {
enum { __N = (_AP_W+63)/64 };
int NZeros = 0;
int i = 0;
bool hitNonZero = false;
for (i=0; i<__N-1; ++i) {
ap_int_base<64, false> t;
t.range(0, 63) = this->range(_AP_W - i*64 - 64, _AP_W - i*64 - 1);
NZeros += hitNonZero?0:__builtin_clzll(t.V);
hitNonZero |= (t.to_uint64() != 0);
}
if (!hitNonZero) {
ap_int_base<64, false> t(-1ULL);
t.range(63-(_AP_W-1)%64, 63) = this->range(0, (_AP_W-1)%64);
NZeros += __builtin_clzll(t.V);
}
return NZeros;
}
}
#pragma line 1818 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_int_syn.h"
/* Arithmetic assign.
----------------------------------------------------------------
*/
template<int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator *= ( const ap_int_base<_AP_W2,_AP_S2> &op2) { ; Base::V *= op2.V; return *this; }
template<int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator += ( const ap_int_base<_AP_W2,_AP_S2> &op2) { ; Base::V += op2.V; return *this; }
template<int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator -= ( const ap_int_base<_AP_W2,_AP_S2> &op2) { ; Base::V -= op2.V; return *this; }
template<int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator /= ( const ap_int_base<_AP_W2,_AP_S2> &op2) { ; Base::V /= op2.V; return *this; }
template<int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator %= ( const ap_int_base<_AP_W2,_AP_S2> &op2) { ; Base::V %= op2.V; return *this; }
#pragma empty_line
/* Bitwise assign: and, or, xor.
----------------------------------------------------------------
*/
template<int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator &= ( const ap_int_base<_AP_W2,_AP_S2> &op2) { ; Base::V &= op2.V; return *this; }
template<int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator |= ( const ap_int_base<_AP_W2,_AP_S2> &op2) { ; Base::V |= op2.V; return *this; }
template<int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator ^= ( const ap_int_base<_AP_W2,_AP_S2> &op2) { ; Base::V ^= op2.V; return *this; }
#pragma empty_line
#pragma empty_line
/* Prefix increment, decrement.
----------------------------------------------------------------
*/
inline __attribute__((always_inline)) ap_int_base& operator ++() {
operator+=((ap_int_base<1,false>) 1);
return *this;
}
inline __attribute__((always_inline)) ap_int_base& operator --() {
operator-=((ap_int_base<1,false>) 1);
return *this;
}
#pragma empty_line
/* Postfix increment, decrement
----------------------------------------------------------------
*/
inline __attribute__((always_inline)) const ap_int_base operator ++(int) {
ap_int_base t = *this;
operator+=((ap_int_base<1,false>) 1);
return t;
}
inline __attribute__((always_inline)) const ap_int_base operator --(int) {
ap_int_base t = *this;
operator-=((ap_int_base<1,false>) 1);
return t;
}
#pragma empty_line
/* Unary arithmetic.
----------------------------------------------------------------
*/
inline __attribute__((always_inline)) ap_int_base operator +() const {
return *this;
}
/* Not (!)
----------------------------------------------------------------
*/
inline __attribute__((always_inline)) bool operator ! () const {
return Base::V == 0;
}
#pragma empty_line
inline __attribute__((always_inline)) ap_int_base<((64) < (_AP_W + 1) ? (64) : (_AP_W + 1)), true>
operator -() const {
return ((ap_int_base<1,false>) 0) - *this;
}
#pragma empty_line
/* Shift (result constrained by left operand).
----------------------------------------------------------------
*/
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) ap_int_base operator << ( const ap_int_base<_AP_W2,true> &op2 ) const {
bool isNeg = op2[_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 __attribute__((always_inline)) ap_int_base 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
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) ap_int_base operator >> ( const ap_int_base<_AP_W2,true> &op2 ) const {
bool isNeg = op2[_AP_W2 - 1];
ap_int_base<_AP_W2, false> sh = op2;
if (isNeg) {
sh = -op2;
return operator << (sh);
}
return operator >> (sh);
}
template<int _AP_W2>
inline __attribute__((always_inline)) ap_int_base 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, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base operator << ( const ap_range_ref<_AP_W2,_AP_S2>& op2 ) const {
return *this << (op2.operator ap_int_base<_AP_W2, false>());
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base operator >> ( const ap_range_ref<_AP_W2,_AP_S2>& op2 ) const {
return *this >> (op2.operator ap_int_base<_AP_W2, false>());
}
#pragma empty_line
#pragma empty_line
/* Shift assign
----------------------------------------------------------------
*/
template<int _AP_W2>
inline __attribute__((always_inline)) ap_int_base& operator <<= ( const ap_int_base<_AP_W2,true> &op2 ) {
bool isNeg = op2[_AP_W2 - 1];
ap_int_base<_AP_W2, false> sh = op2;
if (isNeg) {
sh = -op2;
return operator >>= (sh);
} else
return operator <<= (sh);
}
template<int _AP_W2>
inline __attribute__((always_inline)) ap_int_base& operator <<= ( const ap_int_base<_AP_W2,false> &op2 ) {
Base::V <<= op2.to_uint();
return *this;
}
template<int _AP_W2>
inline __attribute__((always_inline)) ap_int_base& operator >>= ( const ap_int_base<_AP_W2,true> &op2 ) {
bool isNeg = op2[_AP_W2 - 1];
ap_int_base<_AP_W2, false> sh = op2;
if (isNeg) {
sh = -op2;
return operator <<= (sh);
}
return operator >>= (sh);
}
template<int _AP_W2>
inline __attribute__((always_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, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base& operator <<= ( const ap_range_ref<_AP_W2,_AP_S2>& op2 ) {
return *this <<= (op2.operator ap_int_base<_AP_W2, false>());
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base& operator >>= ( const ap_range_ref<_AP_W2,_AP_S2>& op2 ) {
return *this >>= (op2.operator ap_int_base<_AP_W2, false>());
}
#pragma empty_line
/* Comparisons.
----------------------------------------------------------------
*/
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator == ( const ap_int_base<_AP_W2,_AP_S2> &op2) const {
return Base::V == op2.V;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator != ( const ap_int_base<_AP_W2,_AP_S2> &op2) const {
return !(Base::V == op2.V);
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator < ( const ap_int_base<_AP_W2,_AP_S2> &op2) const {
return Base::V < op2.V;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator >= ( const ap_int_base<_AP_W2,_AP_S2> &op2) const {
return Base::V >= op2.V;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator > ( const ap_int_base<_AP_W2,_AP_S2> &op2) const {
return Base::V > op2.V;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator <= ( const ap_int_base<_AP_W2,_AP_S2> &op2) const {
return Base::V <= op2.V;
}
#pragma empty_line
#pragma empty_line
/* Bit and Part Select
----------------------------------------------------------------
*/
inline __attribute__((always_inline)) ap_range_ref<_AP_W,_AP_S>
range (int Hi, int Lo) {
;
return ap_range_ref<_AP_W,_AP_S>(this, Hi, Lo);
}
#pragma empty_line
inline __attribute__((always_inline)) ap_range_ref<_AP_W,_AP_S>
operator () (int Hi, int Lo) {
;
return ap_range_ref<_AP_W,_AP_S>(this, Hi, Lo);
}
#pragma empty_line
inline __attribute__((always_inline)) ap_range_ref<_AP_W,_AP_S>
range (int Hi, int Lo) const {
;
return ap_range_ref<_AP_W,_AP_S>(const_cast<ap_int_base*>(this), Hi, Lo);
}
#pragma empty_line
inline __attribute__((always_inline)) ap_range_ref<_AP_W,_AP_S>
operator () (int Hi, int Lo) const {
return this->range(Hi, Lo);
}
#pragma line 2042 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_int_syn.h"
inline __attribute__((always_inline)) ap_bit_ref<_AP_W,_AP_S> operator [] (int index) {
;
;
ap_bit_ref<_AP_W,_AP_S> bvh( this, index );
return bvh;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_bit_ref<_AP_W,_AP_S> operator [] (const ap_int_base<_AP_W2,_AP_S2> &index) {
;
;
ap_bit_ref<_AP_W,_AP_S> bvh( this, index.to_int() );
return bvh;
}
#pragma empty_line
inline __attribute__((always_inline)) bool operator [] (int index) const {
;
;
ap_bit_ref<_AP_W,_AP_S> br(const_cast<ap_int_base*>(this), index);
return br.to_bool();
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator [] (const ap_int_base<_AP_W2,_AP_S2>& index) const {
;
ap_bit_ref<_AP_W,_AP_S> br(const_cast<ap_int_base*>(this),
index.to_int());
return br.to_bool();
}
#pragma empty_line
inline __attribute__((always_inline)) ap_bit_ref<_AP_W,_AP_S> bit (int index) {
;
;
ap_bit_ref<_AP_W,_AP_S> bvh( this, index );
return bvh;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_bit_ref<_AP_W,_AP_S> bit (const ap_int_base<_AP_W2,_AP_S2> &index) {
;
;
ap_bit_ref<_AP_W,_AP_S> bvh( this, index.to_int() );
return bvh;
}
#pragma empty_line
inline __attribute__((always_inline)) bool bit (int index) const {
;
;
ap_bit_ref<_AP_W,_AP_S> br(const_cast<ap_int_base*>(this), index);
return br.to_bool();
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool bit (const ap_int_base<_AP_W2,_AP_S2>& index) const {
;
ap_bit_ref<_AP_W,_AP_S> br = bit(index);
return br.to_bool();
}
#pragma line 2105 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_int_syn.h"
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<_AP_W,ap_int_base,_AP_W2,ap_int_base<_AP_W2,_AP_S2> > concat(const ap_int_base<_AP_W2,_AP_S2>& a2) const {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2,_AP_S2> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this),
const_cast<ap_int_base<_AP_W2, _AP_S2>& >(a2));
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<_AP_W,ap_int_base,_AP_W2,ap_int_base<_AP_W2,_AP_S2> > concat(ap_int_base<_AP_W2,_AP_S2>& a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2,_AP_S2> >(*this, a2);
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_range_ref<_AP_W2, _AP_S2> >
operator, (const ap_range_ref<_AP_W2, _AP_S2> &a2) const {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2,
ap_range_ref<_AP_W2, _AP_S2> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this),
const_cast< ap_range_ref<_AP_W2, _AP_S2>& >(a2));
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_range_ref<_AP_W2, _AP_S2> >
operator, (ap_range_ref<_AP_W2, _AP_S2> &a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2,
ap_range_ref<_AP_W2, _AP_S2> >(*this, a2);
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator, (const ap_int_base<_AP_W2, _AP_S2>& a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2,
_AP_S2> >(*this,
const_cast<ap_int_base<_AP_W2, _AP_S2>& >(a2));
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator, (ap_int_base<_AP_W2, _AP_S2>& a2) const {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2,
_AP_S2> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this),
a2);
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator, (const ap_int_base<_AP_W2, _AP_S2>& a2) const {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2,
_AP_S2> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this),
const_cast<ap_int_base<_AP_W2, _AP_S2>& >(a2));
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator, (ap_int_base<_AP_W2, _AP_S2>& a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >(*this, a2);
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, 1, ap_bit_ref<_AP_W2, _AP_S2> >
operator, (const ap_bit_ref<_AP_W2, _AP_S2> &a2) const {
return ap_concat_ref<_AP_W, ap_int_base, 1, ap_bit_ref<_AP_W2,
_AP_S2> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this), const_cast<ap_bit_ref<_AP_W2, _AP_S2>& >(a2));
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, 1, ap_bit_ref<_AP_W2, _AP_S2> >
operator, (ap_bit_ref<_AP_W2, _AP_S2> &a2) {
return ap_concat_ref<_AP_W, ap_int_base, 1, ap_bit_ref<_AP_W2,
_AP_S2> >(*this, a2);
}
#pragma empty_line
template <int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2+_AP_W3, ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >
operator, (const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> &a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2+_AP_W3,
ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this),
const_cast<ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& >(a2));
}
#pragma empty_line
template <int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2+_AP_W3, ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >
operator, (ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> &a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2+_AP_W3,
ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >(*this, a2);
}
#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 __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &a2) const {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, af_range_ref<_AP_W2,
_AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this),
const_cast<af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& >(a2));
}
#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 __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, af_range_ref<_AP_W2,
_AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(*this, a2);
}
#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 __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, 1, af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &a2) const {
return ap_concat_ref<_AP_W, ap_int_base, 1, af_bit_ref<_AP_W2,
_AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this),
const_cast<af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& >(a2));
}
#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 __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, 1, af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &a2) {
return ap_concat_ref<_AP_W, ap_int_base, 1, af_bit_ref<_AP_W2,
_AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(*this, a2);
}
#pragma empty_line
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_int_base<((_AP_W2+_AP_W3) > (_AP_W) ? (_AP_W2+_AP_W3) : (_AP_W)), _AP_S>
operator & (const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& a2) {
return *this & a2.get();
}
#pragma empty_line
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_int_base<((_AP_W2+_AP_W3) > (_AP_W) ? (_AP_W2+_AP_W3) : (_AP_W)), _AP_S>
operator | (const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& a2) {
return *this | a2.get();
}
#pragma empty_line
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_int_base<((_AP_W2+_AP_W3) > (_AP_W) ? (_AP_W2+_AP_W3) : (_AP_W)), _AP_S>
operator ^ (const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& a2) {
return *this ^ a2.get();
}
#pragma empty_line
template <int _AP_W3>
inline __attribute__((always_inline)) void set(const ap_int_base<_AP_W3, false>& val) {
Base::V = val.V;
}
#pragma empty_line
/* Reduce operations.
----------------------------------------------------------------
*/
inline __attribute__((always_inline)) bool and_reduce() {
return ({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_and_reduce((void*)(&__what2__)); });
}
inline __attribute__((always_inline)) bool nand_reduce() {
return ({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_nand_reduce((void*)(&__what2__)); });
}
inline __attribute__((always_inline)) bool or_reduce() {
return ({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_or_reduce((void*)(&__what2__)); });
}
inline __attribute__((always_inline)) bool nor_reduce() {
return !(({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_or_reduce((void*)(&__what2__)); }));
}
inline __attribute__((always_inline)) bool xor_reduce() {
return ({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_xor_reduce((void*)(&__what2__)); });
}
inline __attribute__((always_inline)) bool xnor_reduce() {
return !(({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_xor_reduce((void*)(&__what2__)); }));
}
#pragma empty_line
inline __attribute__((always_inline)) bool and_reduce() const {
return ({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_and_reduce((void*)(&__what2__)); });
}
inline __attribute__((always_inline)) bool nand_reduce() const {
return ({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_nand_reduce((void*)(&__what2__)); });
}
inline __attribute__((always_inline)) bool or_reduce() const {
return ({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_or_reduce((void*)(&__what2__)); });
}
inline __attribute__((always_inline)) bool nor_reduce() const {
return !(({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_or_reduce((void*)(&__what2__)); }));
}
inline __attribute__((always_inline)) bool xor_reduce() const {
return ({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_xor_reduce((void*)(&__what2__)); });
}
inline __attribute__((always_inline)) bool xnor_reduce() const {
return !(({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_xor_reduce((void*)(&__what2__)); }));
}
#pragma empty_line
/* Output as a string.
----------------------------------------------------------------
*/
void to_string(char* str, int len, BaseMode mode, bool sign = false) const {
for (int i = 0; i <= len; ++i) str[i] = '\0';
if (mode == SC_BIN) {
int size = ((_AP_W) < (len) ? (_AP_W) : (len));
for (int bit = size; bit > 0; --bit) {
if (({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), bit-1, bit-1); (bool)(__Result__ & 1); })) str[size-bit] = '1';
else str[size-bit] = '0';
}
} /*else if (mode == AP_HEX) {
typeof(Base::V) tmpV = Base::V;
int idx = 0;
int size = AP_MIN((_AP_W+3)/4, len);
while (idx < size) {
char hexb = tmpV & 0xF;
if (hexb > 9) hexb = hexb - 10 + 'a';
else hexb += '0';
str[size-1-idx] = hexb;
tmpV >> 4;
idx ++;
}
} */ else if (mode == SC_OCT || mode == SC_DEC) {
;
} else {
;
}
}
#pragma empty_line
inline __attribute__((always_inline)) char* to_string(BaseMode mode, bool sign=false) const {
return 0;
}
#pragma empty_line
inline __attribute__((always_inline)) char* to_string(signed char mode, bool sign=false) const {
return to_string(BaseMode(mode), sign);
}
};
template<int _AP_W, bool _AP_S>
struct ap_int_base<_AP_W, _AP_S, false> : public ssdm_int<_AP_W,_AP_S> {
#pragma empty_line
public:
typedef ssdm_int<_AP_W, _AP_S> Base;
typedef typename retval<8, _AP_S>::Type RetType;
static const int width = _AP_W;
#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
};
#pragma empty_line
typedef ap_int_base<mult_w, mult_s> mult;
typedef ap_int_base<plus_w, plus_s> plus;
typedef ap_int_base<minus_w, minus_s> minus;
typedef ap_int_base<logic_w, logic_s> logic;
typedef ap_int_base<div_w, div_s> div;
typedef ap_int_base<mod_w, mod_s> mod;
typedef ap_int_base<_AP_W, _AP_S> arg1;
typedef bool reduce;
};
#pragma empty_line
/* Constructors.
----------------------------------------------------------------
*/
inline __attribute__((always_inline)) ap_int_base() {
/*
#ifdef __SC_COMPATIBLE__
Base::V = 0;
#endif
*/
}
#pragma empty_line
//INLINE ap_int_base(const ap_int_base& op) { Base::V = op.V; }
//INLINE ap_int_base(const volatile ap_int_base& op) { Base::V = op.V; }
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base(const ap_int_base<_AP_W2,_AP_S2> &op) { Base::V = op.V; }
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base(const volatile ap_int_base<_AP_W2,_AP_S2> &op) { Base::V = op.V; }
#pragma empty_line
/* For C++ basic data types.*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline __attribute__((always_inline)) explicit ap_int_base(bool op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(signed char op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(unsigned char op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(short op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(unsigned short op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(int op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(unsigned int op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(long op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(unsigned long op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(ap_slong op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(ap_ulong op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(float op) { Base::V = op; }
inline __attribute__((always_inline)) explicit ap_int_base(double op) { Base::V = 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 __attribute__((always_inline)) ap_int_base(const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>& op) {
Base::V = op.to_ap_int_base().V;
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base(const ap_range_ref<_AP_W2,_AP_S2>& ref) {
Base::V = ref.operator ap_int_base<_AP_W2, false>().V;
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base(const ap_bit_ref<_AP_W2,_AP_S2>& ref) {
Base::V = ref.operator bool();
}
#pragma empty_line
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_int_base(const ap_concat_ref<_AP_W2,_AP_T2,_AP_W3,_AP_T3>& ref) {
const ap_int_base<ap_concat_ref<_AP_W2,_AP_T2,_AP_W3,_AP_T3>::_AP_WR,false> tmp = ref.get();
Base::V = tmp.V;
}
#pragma empty_line
/* This constructor is not usable yet, because the second parameter of
__builtin_bit_from_string(...)
is required to be a constant C string.
*/
inline __attribute__((always_inline)) ap_int_base(const char* str) {
typeof(Base::V) Result;
_ssdm_string2bits((void*)(&Result), (const char*)(str), 10,
_AP_W, _AP_S, SC_TRN, SC_WRAP, 0, true);
Base::V = Result;
}
#pragma empty_line
inline __attribute__((always_inline)) ap_int_base(const char* str, signed char radix) {
typeof(Base::V) Result;
_ssdm_string2bits((void*)(&Result), (const char*)(str), radix,
_AP_W, _AP_S, SC_TRN, SC_WRAP, 0, true);
Base::V = Result;
}
#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 __attribute__((always_inline)) ap_int_base(const af_range_ref<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2> &val) {
Base::V = (val.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 __attribute__((always_inline)) ap_int_base(const af_bit_ref<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2> &val) {
Base::V = val.operator bool ();
}
#pragma empty_line
inline __attribute__((always_inline)) ap_int_base read() volatile {
;
ap_int_base ret;
ret.V = Base::V;
return ret;
}
inline __attribute__((always_inline)) void write(const ap_int_base<_AP_W, _AP_S>& op2) volatile {
;
Base::V = op2.V;
}
#pragma empty_line
/* Another form of "write".*/
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) void operator = (const volatile ap_int_base<_AP_W2,_AP_S2>& op2) volatile {
Base::V = op2.V;
}
#pragma empty_line
inline __attribute__((always_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 __attribute__((always_inline)) void operator = (const ap_int_base<_AP_W2,_AP_S2>& op2) volatile {
Base::V = op2.V;
}
#pragma empty_line
inline __attribute__((always_inline)) void operator = (const ap_int_base<_AP_W, _AP_S>& op2) volatile {
Base::V = op2.V;
}
#pragma line 2506 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_int_syn.h"
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base& operator = (const volatile ap_int_base<_AP_W2,_AP_S2>& op2) {
Base::V = op2.V;
return *this;
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base& operator = (const ap_int_base<_AP_W2,_AP_S2>& op2) {
Base::V = op2.V;
return *this;
}
#pragma empty_line
inline __attribute__((always_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 __attribute__((always_inline)) ap_int_base& operator = (const ap_int_base<_AP_W,_AP_S>& op2) {
Base::V = op2.V;
return *this;
}
inline __attribute__((always_inline)) ap_int_base& operator = (const char* str) {
typeof(Base::V) Result;
_ssdm_string2bits((void*)(&Result), (const char*)(str), 10,
_AP_W, _AP_S, SC_TRN, SC_WRAP, 0, true);
Base::V = Result;
return *this;
}
#pragma empty_line
inline __attribute__((always_inline)) ap_int_base& set(const char* str, signed char radix) {
typeof(Base::V) Result;
_ssdm_string2bits((void*)(&Result), (const char*)(str), radix,
_AP_W, _AP_S, SC_TRN, SC_WRAP, 0, true);
Base::V = Result;
return *this;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline __attribute__((always_inline)) ap_int_base& operator = (char op) { Base::V = op; return *this; }
inline __attribute__((always_inline)) ap_int_base& operator = (unsigned char op) { Base::V = op; return *this; }
inline __attribute__((always_inline)) ap_int_base& operator = (short op) { Base::V = op; return *this; }
inline __attribute__((always_inline)) ap_int_base& operator = (unsigned short op) { Base::V = op; return *this; }
inline __attribute__((always_inline)) ap_int_base& operator = (int op) { Base::V = op; return *this; }
inline __attribute__((always_inline)) ap_int_base& operator = (unsigned int op) { Base::V = op; return *this; }
inline __attribute__((always_inline)) ap_int_base& operator = (ap_slong op) { Base::V = op; return *this; }
inline __attribute__((always_inline)) ap_int_base& operator = (ap_ulong op) { Base::V = op; return *this; }
#pragma empty_line
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base& operator = (const ap_bit_ref<_AP_W2, _AP_S2>& op2) {
Base::V = (bool) op2;
return *this;
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base& operator = (const ap_range_ref<_AP_W2, _AP_S2>& op2) {
Base::V = (ap_int_base<_AP_W2, false>(op2)).V;
return *this;
}
#pragma empty_line
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_int_base& operator = (const ap_concat_ref<_AP_W2,_AP_T2,_AP_W3,_AP_T3>& op2) {
Base::V = op2.get().V;
return *this;
}
#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 __attribute__((always_inline)) ap_int_base& operator = (const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
Base::V = op.to_ap_int_base().V;
return *this;
}
#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 __attribute__((always_inline)) ap_int_base& operator = (const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
Base::V = (bool) op;
return *this;
}
#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 __attribute__((always_inline)) ap_int_base& operator = (const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
Base::V = ((const ap_int_base<_AP_W2, false>)(op)).V;
return *this;
}
#pragma empty_line
inline __attribute__((always_inline)) operator RetType() const { return (RetType)(Base::V); }
#pragma empty_line
#pragma empty_line
/* Explicit conversions to C interger types.
----------------------------------------------------------------
*/
inline __attribute__((always_inline)) bool to_bool() const {return (bool)(Base::V);}
inline __attribute__((always_inline)) bool to_uchar() const {return (unsigned char)(Base::V);}
inline __attribute__((always_inline)) bool to_char() const {return (char)(Base::V);}
inline __attribute__((always_inline)) bool to_ushort() const {return (unsigned short)(Base::V);}
inline __attribute__((always_inline)) bool to_short() const {return (short)(Base::V);}
inline __attribute__((always_inline)) int to_int() const { return (int)(Base::V); }
inline __attribute__((always_inline)) unsigned to_uint() const { return (unsigned)(Base::V); }
inline __attribute__((always_inline)) long to_long() const { return (long)(Base::V); }
inline __attribute__((always_inline)) unsigned long to_ulong() const { return (unsigned long)(Base::V); }
inline __attribute__((always_inline)) ap_slong to_int64() const { return (ap_slong)(Base::V); }
inline __attribute__((always_inline)) ap_ulong to_uint64() const { return (ap_ulong)(Base::V); }
inline __attribute__((always_inline)) double to_double() const { return (double)(Base::V); }
#pragma line 2625 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_int_syn.h"
inline __attribute__((always_inline)) int length() const { return _AP_W; }
inline __attribute__((always_inline)) int length() const volatile { return _AP_W; }
#pragma empty_line
/*INLINE operator ap_ulong () { return (ap_ulong)(Base::V); }*/
#pragma empty_line
/*Reverse the contents of ap_int_base instance. I.e. LSB becomes MSB and vise versa*/
inline __attribute__((always_inline)) ap_int_base& reverse () {
Base::V = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W - 1, 0); __Result__; });
return *this;
}
#pragma empty_line
/*Return true if the value of ap_int_base instance is zero*/
inline __attribute__((always_inline)) bool iszero () const {
return Base::V == 0 ;
}
#pragma empty_line
/*Return true if the value of ap_int_base instance is zero*/
inline __attribute__((always_inline)) bool is_zero () const {
return Base::V == 0 ;
}
#pragma empty_line
/* x < 0 */
inline __attribute__((always_inline)) bool sign () const {
if (_AP_S && ({ typeof(const_cast<ap_int_base*>(this)->V) __Result__ = 0; typeof(const_cast<ap_int_base*>(this)->V) __Val2__ = const_cast<ap_int_base*>(this)->V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W - 1, _AP_W - 1); (bool)(__Result__ & 1); }))
return true;
else
return false;
}
#pragma empty_line
/* x[i] = 0 */
inline __attribute__((always_inline)) void clear(int i) {
;
Base::V = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(0) __Repl2__ = !!0; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), i, i); __Result__; });
}
#pragma empty_line
/* x[i] = !x[i]*/
inline __attribute__((always_inline)) void invert(int i) {
;
bool val = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), i, i); (bool)(__Result__ & 1); });
if (val) Base::V = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(0) __Repl2__ = !!0; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), i, i); __Result__; });
else Base::V = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(1) __Repl2__ = !!1; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), i, i); __Result__; });
}
#pragma empty_line
#pragma empty_line
inline __attribute__((always_inline)) bool test (int i) const {
;
return ({ typeof(const_cast<ap_int_base*>(this)->V) __Result__ = 0; typeof(const_cast<ap_int_base*>(this)->V) __Val2__ = const_cast<ap_int_base*>(this)->V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), i, i); (bool)(__Result__ & 1); });
}
#pragma empty_line
//Set the ith bit into 1
inline __attribute__((always_inline)) void set (int i) {
;
Base::V = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(1) __Repl2__ = !!1; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), i, i); __Result__; });
}
#pragma empty_line
//Set the ith bit into v
inline __attribute__((always_inline)) void set (int i, bool v) {
;
Base::V = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(v) __Repl2__ = !!v; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), i, i); __Result__; });
}
#pragma empty_line
//This is used for sc_lv and sc_bv, which is implemented by sc_uint
//Rotate an ap_int_base object n places to the left
inline __attribute__((always_inline)) void lrotate(int n) {
;
typeof(Base::V) l_p = Base::V << n;
typeof(Base::V) r_p = Base::V >> (_AP_W - n);
Base::V = l_p | r_p;
}
#pragma empty_line
//This is used for sc_lv and sc_bv, which is implemented by sc_uint
//Rotate an ap_int_base object n places to the right
inline __attribute__((always_inline)) void rrotate(int n) {
;
typeof(Base::V) l_p = Base::V << (_AP_W - n);
typeof(Base::V) r_p = Base::V >> n;
Base::V = l_p | r_p;
}
#pragma empty_line
//Set the ith bit into v
inline __attribute__((always_inline)) void set_bit (int i, bool v) {
Base::V = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(v) __Repl2__ = !!v; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), i, i); __Result__; });
}
#pragma empty_line
//Get the value of ith bit
inline __attribute__((always_inline)) bool get_bit (int i) const {
return (bool)({ typeof(const_cast<ap_int_base*>(this)->V) __Result__ = 0; typeof(const_cast<ap_int_base*>(this)->V) __Val2__ = const_cast<ap_int_base*>(this)->V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), i, i); (bool)(__Result__ & 1); });
}
#pragma empty_line
//complements every bit
inline __attribute__((always_inline)) void b_not() {
Base::V = ~Base::V;
}
#pragma empty_line
// Count the number of zeros from the most significant bit
// to the first one bit. Note this is only for ap_fixed_base whose
// _AP_W <= 64, otherwise will incur assertion.
inline __attribute__((always_inline)) int countLeadingZeros() {
if (_AP_W <= 32) {
ap_int_base<32, false> t(-1ULL);
t.range(_AP_W-1, 0) = this->range(0, _AP_W-1);
return __builtin_ctz(t.V);
} else if (_AP_W <= 64) {
ap_int_base<64, false> t(-1ULL);
t.range(_AP_W-1, 0) = this->range(0, _AP_W-1);
return __builtin_ctzll(t.V);
} else {
enum { __N = (_AP_W+63)/64 };
int NZeros = 0;
unsigned i = 0;
bool hitNonZero = false;
for (i=0; i<__N-1; ++i) {
ap_int_base<64, false> t;
t.range(0, 63) = this->range(_AP_W - i*64 - 64, _AP_W - i*64 - 1);
NZeros += hitNonZero?0:__builtin_clzll(t.V);
hitNonZero |= (t.to_uint64() != 0);
}
if (!hitNonZero) {
ap_int_base<64, false> t(-1ULL);
t.range(63-(_AP_W-1)%64, 63) = this->range(0, (_AP_W-1)%64);
NZeros += __builtin_clzll(t.V);
}
return NZeros;
}
}
#pragma line 2759 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_int_syn.h"
/* Arithmetic assign.
----------------------------------------------------------------
*/
template<int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator *= ( const ap_int_base<_AP_W2,_AP_S2> &op2) { ; Base::V *= op2.V; return *this; }
template<int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator += ( const ap_int_base<_AP_W2,_AP_S2> &op2) { ; Base::V += op2.V; return *this; }
template<int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator -= ( const ap_int_base<_AP_W2,_AP_S2> &op2) { ; Base::V -= op2.V; return *this; }
template<int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator /= ( const ap_int_base<_AP_W2,_AP_S2> &op2) { ; Base::V /= op2.V; return *this; }
template<int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator %= ( const ap_int_base<_AP_W2,_AP_S2> &op2) { ; Base::V %= op2.V; return *this; }
#pragma empty_line
/* Bitwise assign: and, or, xor.
----------------------------------------------------------------
*/
template<int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator &= ( const ap_int_base<_AP_W2,_AP_S2> &op2) { ; Base::V &= op2.V; return *this; }
template<int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator |= ( const ap_int_base<_AP_W2,_AP_S2> &op2) { ; Base::V |= op2.V; return *this; }
template<int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator ^= ( const ap_int_base<_AP_W2,_AP_S2> &op2) { ; Base::V ^= op2.V; return *this; }
#pragma empty_line
#pragma empty_line
/* Prefix increment, decrement.
----------------------------------------------------------------
*/
inline __attribute__((always_inline)) ap_int_base& operator ++() {
operator+=((ap_int_base<1,false>) 1);
return *this;
}
inline __attribute__((always_inline)) ap_int_base& operator --() {
operator-=((ap_int_base<1,false>) 1);
return *this;
}
#pragma empty_line
/* Postfix increment, decrement
----------------------------------------------------------------
*/
inline __attribute__((always_inline)) const ap_int_base operator ++(int) {
ap_int_base t = *this;
operator+=((ap_int_base<1,false>) 1);
return t;
}
inline __attribute__((always_inline)) const ap_int_base operator --(int) {
ap_int_base t = *this;
operator-=((ap_int_base<1,false>) 1);
return t;
}
#pragma empty_line
/* Unary arithmetic.
----------------------------------------------------------------
*/
inline __attribute__((always_inline)) ap_int_base operator +() const{
return *this;
}
#pragma empty_line
inline __attribute__((always_inline)) typename RType<1,false>::minus operator -() const {
return ((ap_int_base<1,false>) 0) - *this;
}
#pragma empty_line
/* Not (!)
----------------------------------------------------------------
*/
inline __attribute__((always_inline)) bool operator ! () const {
return Base::V == 0;
}
#pragma empty_line
/* Bitwise (arithmetic) unary: complement
----------------------------------------------------------------
*/
inline __attribute__((always_inline)) ap_int_base<_AP_W+!_AP_S, true> operator ~() const {
ap_int_base<_AP_W+!_AP_S, true> r;
r.V = ~Base::V;
return r;
}
#pragma empty_line
/* Shift (result constrained by left operand).
----------------------------------------------------------------
*/
template<int _AP_W2>
inline __attribute__((always_inline)) ap_int_base operator << ( const ap_int_base<_AP_W2,true> &op2 ) const {
bool isNeg = op2[_AP_W2 - 1];
ap_int_base<_AP_W2, false> sh = op2;
if (isNeg) {
sh = -op2;
return operator >> (sh);
} else
return operator << (sh);
}
template<int _AP_W2>
inline __attribute__((always_inline)) ap_int_base operator << ( const ap_int_base<_AP_W2,false> &op2 ) const {
ap_int_base r ;
r.V = Base::V << op2.to_uint();
return r;
}
template<int _AP_W2>
inline __attribute__((always_inline)) ap_int_base operator >> ( const ap_int_base<_AP_W2,true> &op2 ) const {
bool isNeg = op2[_AP_W2 - 1];
ap_int_base<_AP_W2, false> sh = op2;
if (isNeg) {
sh = -op2;
return operator << (sh);
}
return operator >> (sh);
}
template<int _AP_W2>
inline __attribute__((always_inline)) ap_int_base 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, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base operator << ( const ap_range_ref<_AP_W2,_AP_S2>& op2 ) const {
return *this << (op2.operator ap_int_base<_AP_W2, false>());
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base operator >> ( const ap_range_ref<_AP_W2,_AP_S2>& op2 ) const {
return *this >> (op2.operator ap_int_base<_AP_W2, false>());
}
#pragma empty_line
/* Shift assign
----------------------------------------------------------------
*/
template<int _AP_W2>
inline __attribute__((always_inline)) ap_int_base& operator <<= ( const ap_int_base<_AP_W2,true> &op2 ) {
bool isNeg = op2[_AP_W2 - 1];
ap_int_base<_AP_W2, false> sh = op2;
if (isNeg) {
sh = -op2;
return operator >>= (sh);
} else
return operator <<= (sh);
}
template<int _AP_W2>
inline __attribute__((always_inline)) ap_int_base& operator <<= ( const ap_int_base<_AP_W2,false> &op2 ) {
Base::V <<= op2.to_uint();
return *this;
}
template<int _AP_W2>
inline __attribute__((always_inline)) ap_int_base& operator >>= ( const ap_int_base<_AP_W2,true> &op2 ) {
bool isNeg = op2[_AP_W2 - 1];
ap_int_base<_AP_W2, false> sh = op2;
if (isNeg) {
sh = -op2;
operator <<= (sh);
}
return operator >>= (sh);
}
template<int _AP_W2>
inline __attribute__((always_inline)) ap_int_base& operator >>= ( const ap_int_base<_AP_W2,false> &op2 ) {
Base::V >>= op2.to_uint();
return *this;
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base& operator <<= ( const ap_range_ref<_AP_W2,_AP_S2>& op2 ) {
return *this <<= (op2.operator ap_int_base<_AP_W2, false>());
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base& operator >>= ( const ap_range_ref<_AP_W2,_AP_S2>& op2 ) {
return *this >>= (op2.operator ap_int_base<_AP_W2, false>());
}
#pragma empty_line
/* Comparisons.
----------------------------------------------------------------
*/
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator == ( const ap_int_base<_AP_W2,_AP_S2> &op2) const {
return Base::V == op2.V;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator != ( const ap_int_base<_AP_W2,_AP_S2> &op2) const {
return !(Base::V == op2.V);
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator < ( const ap_int_base<_AP_W2,_AP_S2> &op2) const {
return Base::V < op2.V;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator >= ( const ap_int_base<_AP_W2,_AP_S2> &op2) const {
return Base::V >= op2.V;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator > ( const ap_int_base<_AP_W2,_AP_S2> &op2) const {
return Base::V > op2.V;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator <= ( const ap_int_base<_AP_W2,_AP_S2> &op2) const {
return Base::V <= op2.V;
}
#pragma empty_line
#pragma empty_line
/* Bit and Part Select
----------------------------------------------------------------
*/
inline __attribute__((always_inline)) ap_range_ref<_AP_W,_AP_S>
range (int Hi, int Lo) {
;
return ap_range_ref<_AP_W,_AP_S>(this, Hi, Lo);
}
#pragma empty_line
inline __attribute__((always_inline)) ap_range_ref<_AP_W,_AP_S>
operator () (int Hi, int Lo) {
;
return ap_range_ref<_AP_W,_AP_S>(this, Hi, Lo);
}
#pragma empty_line
inline __attribute__((always_inline)) ap_range_ref<_AP_W,_AP_S>
range (int Hi, int Lo) const {
;
return ap_range_ref<_AP_W,_AP_S>(const_cast<ap_int_base*>(this), Hi, Lo);
}
#pragma empty_line
inline __attribute__((always_inline)) ap_range_ref<_AP_W,_AP_S>
operator () (int Hi, int Lo) const {
return this->range(Hi, Lo);
}
#pragma line 2988 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_int_syn.h"
inline __attribute__((always_inline)) ap_bit_ref<_AP_W,_AP_S> operator [] (int index) {
;
;
ap_bit_ref<_AP_W,_AP_S> bvh( this, index );
return bvh;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_bit_ref<_AP_W,_AP_S> operator [] (const ap_int_base<_AP_W2,_AP_S2> &index) {
;
;
ap_bit_ref<_AP_W,_AP_S> bvh( this, index.to_int() );
return bvh;
}
#pragma empty_line
inline __attribute__((always_inline)) bool operator [] (int index) const {
;
;
ap_bit_ref<_AP_W,_AP_S> br(const_cast<ap_int_base*>(this), index);
return br.to_bool();
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator [] (const ap_int_base<_AP_W2,_AP_S2>& index) const {
;
ap_bit_ref<_AP_W,_AP_S> br(const_cast<ap_int_base*>(this),
index.to_int());
return br.to_bool();
}
#pragma empty_line
inline __attribute__((always_inline)) ap_bit_ref<_AP_W,_AP_S> bit (int index) {
;
;
ap_bit_ref<_AP_W,_AP_S> bvh( this, index );
return bvh;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_bit_ref<_AP_W,_AP_S> bit (const ap_int_base<_AP_W2,_AP_S2> &index) {
;
;
ap_bit_ref<_AP_W,_AP_S> bvh( this, index.to_int() );
return bvh;
}
#pragma empty_line
inline __attribute__((always_inline)) bool bit (int index) const {
;
;
ap_bit_ref<_AP_W,_AP_S> br(const_cast<ap_int_base*>(this), index);
return br.to_bool();
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool bit (const ap_int_base<_AP_W2,_AP_S2>& index) const {
;
ap_bit_ref<_AP_W,_AP_S> br = bit(index);
return br.to_bool();
}
#pragma line 3051 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_int_syn.h"
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<_AP_W,ap_int_base,_AP_W2,ap_int_base<_AP_W2,_AP_S2> > concat(const ap_int_base<_AP_W2,_AP_S2>& a2) const {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2,_AP_S2> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this),
const_cast<ap_int_base<_AP_W2, _AP_S2>& >(a2));
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<_AP_W,ap_int_base,_AP_W2,ap_int_base<_AP_W2,_AP_S2> > concat(ap_int_base<_AP_W2,_AP_S2>& a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2,_AP_S2> >(*this, a2);
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_range_ref<_AP_W2, _AP_S2> >
operator, (const ap_range_ref<_AP_W2, _AP_S2> &a2) const {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2,
ap_range_ref<_AP_W2, _AP_S2> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this),
const_cast< ap_range_ref<_AP_W2, _AP_S2>& >(a2));
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_range_ref<_AP_W2, _AP_S2> >
operator, (ap_range_ref<_AP_W2, _AP_S2> &a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2,
ap_range_ref<_AP_W2, _AP_S2> >(*this, a2);
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator, (const ap_int_base<_AP_W2, _AP_S2>& a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2,
_AP_S2> >(*this,
const_cast<ap_int_base<_AP_W2, _AP_S2>& >(a2));
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator, (ap_int_base<_AP_W2, _AP_S2>& a2) const {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2,
_AP_S2> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this),
a2);
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator, (const ap_int_base<_AP_W2, _AP_S2>& a2) const {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2,
_AP_S2> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this),
const_cast<ap_int_base<_AP_W2, _AP_S2>& >(a2));
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator, (ap_int_base<_AP_W2, _AP_S2>& a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >(*this, a2);
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, 1, ap_bit_ref<_AP_W2, _AP_S2> >
operator, (const ap_bit_ref<_AP_W2, _AP_S2> &a2) const {
return ap_concat_ref<_AP_W, ap_int_base, 1, ap_bit_ref<_AP_W2,
_AP_S2> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this), const_cast<ap_bit_ref<_AP_W2, _AP_S2>& >(a2));
}
#pragma empty_line
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, 1, ap_bit_ref<_AP_W2, _AP_S2> >
operator, (ap_bit_ref<_AP_W2, _AP_S2> &a2) {
return ap_concat_ref<_AP_W, ap_int_base, 1, ap_bit_ref<_AP_W2,
_AP_S2> >(*this, a2);
}
#pragma empty_line
template <int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2+_AP_W3, ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >
operator, (const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> &a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2+_AP_W3,
ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this),
const_cast<ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& >(a2));
}
#pragma empty_line
template <int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2+_AP_W3, ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >
operator, (ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> &a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2+_AP_W3,
ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >(*this, a2);
}
#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 __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &a2) const {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, af_range_ref<_AP_W2,
_AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this),
const_cast<af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& >(a2));
}
#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 __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, af_range_ref<_AP_W2,
_AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(*this, a2);
}
#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 __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, 1, af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &a2) const {
return ap_concat_ref<_AP_W, ap_int_base, 1, af_bit_ref<_AP_W2,
_AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this),
const_cast<af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& >(a2));
}
#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 __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, 1, af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &a2) {
return ap_concat_ref<_AP_W, ap_int_base, 1, af_bit_ref<_AP_W2,
_AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(*this, a2);
}
#pragma empty_line
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_int_base<((_AP_W2+_AP_W3) > (_AP_W) ? (_AP_W2+_AP_W3) : (_AP_W)), _AP_S>
operator & (const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& a2) {
return *this & a2.get();
}
#pragma empty_line
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_int_base<((_AP_W2+_AP_W3) > (_AP_W) ? (_AP_W2+_AP_W3) : (_AP_W)), _AP_S>
operator | (const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& a2) {
return *this | a2.get();
}
#pragma empty_line
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_int_base<((_AP_W2+_AP_W3) > (_AP_W) ? (_AP_W2+_AP_W3) : (_AP_W)), _AP_S>
operator ^ (const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& a2) {
return *this ^ a2.get();
}
#pragma empty_line
template <int _AP_W3>
inline __attribute__((always_inline)) void set(const ap_int_base<_AP_W3, false>& val) {
Base::V = val.V;
}
#pragma empty_line
/* Reduce operations.
----------------------------------------------------------------
*/
inline __attribute__((always_inline)) bool and_reduce() {
return ({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_and_reduce((void*)(&__what2__)); });
}
inline __attribute__((always_inline)) bool nand_reduce() {
return ({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_nand_reduce((void*)(&__what2__)); });
}
inline __attribute__((always_inline)) bool or_reduce() {
return ({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_or_reduce((void*)(&__what2__)); });
}
inline __attribute__((always_inline)) bool nor_reduce() {
return !(({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_or_reduce((void*)(&__what2__)); }));
}
inline __attribute__((always_inline)) bool xor_reduce() {
return ({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_xor_reduce((void*)(&__what2__)); });
}
inline __attribute__((always_inline)) bool xnor_reduce() {
return !(({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_xor_reduce((void*)(&__what2__)); }));
}
#pragma empty_line
inline __attribute__((always_inline)) bool and_reduce() const {
return ({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_and_reduce((void*)(&__what2__)); });
}
inline __attribute__((always_inline)) bool nand_reduce() const {
return ({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_nand_reduce((void*)(&__what2__)); });
}
inline __attribute__((always_inline)) bool or_reduce() const {
return ({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_or_reduce((void*)(&__what2__)); });
}
inline __attribute__((always_inline)) bool nor_reduce() const {
return !(({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_or_reduce((void*)(&__what2__)); }));
}
inline __attribute__((always_inline)) bool xor_reduce() const {
return ({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_xor_reduce((void*)(&__what2__)); });
}
inline __attribute__((always_inline)) bool xnor_reduce() const {
return !(({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_xor_reduce((void*)(&__what2__)); }));
}
#pragma empty_line
/* Output as a string.
----------------------------------------------------------------
*/
void to_string(char* str, int len, BaseMode mode, bool sign = false) const {
for (int i = 0; i <= len; ++i) str[i] = '\0';
if (mode == SC_BIN) {
int size = ((_AP_W) < (len) ? (_AP_W) : (len));
for (int bit = size; bit > 0; --bit) {
if (({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), bit-1, bit-1); (bool)(__Result__ & 1); })) str[size-bit] = '1';
else str[size-bit] = '0';
}
} /*else if (mode == AP_HEX) {
typeof(Base::V) tmpV = Base::V;
int idx = 0;
int size = AP_MIN((_AP_W+3)/4, len);
while (idx < size) {
char hexb = tmpV & 0xF;
if (hexb > 9) hexb = hexb - 10 + 'a';
else hexb += '0';
str[size-1-idx] = hexb;
tmpV >> 4;
idx ++;
}
} */ else if (mode == SC_OCT || mode == SC_DEC) {
;
} else {
;
}
}
#pragma empty_line
inline __attribute__((always_inline)) char* to_string(BaseMode mode, bool sign=false) const {
return 0;
}
#pragma empty_line
inline __attribute__((always_inline)) char* to_string(signed char mode, bool sign=false) const {
return to_string(BaseMode(mode), sign);
}
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Output streaming.
----------------------------------------------------------------
*/
#pragma empty_line
#pragma empty_line
template<int _AP_W, bool _AP_S>
inline __attribute__((always_inline)) std::ostream& operator << (std::ostream &os, const ap_int_base<_AP_W,_AP_S> &x) {
//os << x.to_string(AP_DEC);
return os;
}
#pragma empty_line
/* Input streaming.
......................................................
*/
template<int _AP_W, bool _AP_S>
inline __attribute__((always_inline)) std::istream& operator >> (std::istream& in, ap_int_base<_AP_W,_AP_S> &op) {
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
return in;
}
#pragma empty_line
template<int _AP_W, bool _AP_S>
inline __attribute__((always_inline)) std::ostream& operator << (std::ostream &os, const ap_range_ref<_AP_W,_AP_S> &x) {
//os << x.to_string(AP_DEC);
return os;
}
#pragma empty_line
/* Input streaming.
......................................................
*/
template<int _AP_W, bool _AP_S>
inline __attribute__((always_inline)) std::istream& operator >> (std::istream& in, ap_range_ref<_AP_W,_AP_S> &op) {
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
return in;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
/*Binary Arithmetic.
----------------------------------------------------------------
*/
#pragma line 3365 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_int_syn.h"
template<int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::mult operator * (const ap_int_base<_AP_W,_AP_S> &op, const ap_int_base<_AP_W2,_AP_S2> &op2) { ; typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::mult lhs(op); typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::mult rhs(op2); typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::mult r ; r.V = lhs.V * rhs.V; return r; }
template<int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::plus operator + (const ap_int_base<_AP_W,_AP_S> &op, const ap_int_base<_AP_W2,_AP_S2> &op2) { ; typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::plus lhs(op); typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::plus rhs(op2); typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::plus r ; r.V = lhs.V + rhs.V; return r; }
template<int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::minus operator - (const ap_int_base<_AP_W,_AP_S> &op, const ap_int_base<_AP_W2,_AP_S2> &op2) { ; typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::minus lhs(op); typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::minus rhs(op2); typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::minus r ; r.V = lhs.V - rhs.V; return r; }
template<int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::div operator / ( const ap_int_base<_AP_W,_AP_S> &op, const ap_int_base<_AP_W2,_AP_S2> &op2) { ; typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::div r ; r.V = op.V / op2.V; return r; }
template<int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::mod operator % ( const ap_int_base<_AP_W,_AP_S> &op, const ap_int_base<_AP_W2,_AP_S2> &op2) { ; typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::mod r ; r.V = op.V % op2.V; return r; }
#pragma empty_line
/* Bitwise and, or, xor.
----------------------------------------------------------------
*/
template<int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::logic operator & (const ap_int_base<_AP_W,_AP_S> &op, const ap_int_base<_AP_W2,_AP_S2> &op2) { ; typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::logic lhs(op); typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::logic rhs(op2); typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::logic r ; r.V = lhs.V & rhs.V; return r; }
template<int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::logic operator | (const ap_int_base<_AP_W,_AP_S> &op, const ap_int_base<_AP_W2,_AP_S2> &op2) { ; typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::logic lhs(op); typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::logic rhs(op2); typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::logic r ; r.V = lhs.V | rhs.V; return r; }
template<int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::logic operator ^ (const ap_int_base<_AP_W,_AP_S> &op, const ap_int_base<_AP_W2,_AP_S2> &op2) { ; typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::logic lhs(op); typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::logic rhs(op2); typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2,_AP_S2>::logic r ; r.V = lhs.V ^ rhs.V; return r; }
#pragma empty_line
#pragma empty_line
//FIXME
#pragma empty_line
//char a[100];
//char* ptr = a;
//ap_int<2> n = 3;
//char* ptr2 = ptr + n*2;
//avoid ambiguous errors
#pragma line 3400 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_int_syn.h"
template<typename PTR_TYPE, int _AP_W, bool _AP_S> inline __attribute__((always_inline)) PTR_TYPE* operator + (PTR_TYPE* i_op, const ap_int_base<_AP_W,_AP_S> &op) { typename ap_int_base<_AP_W,_AP_S>::RetType op2 = op; return i_op + op2; } template<typename PTR_TYPE, int _AP_W, bool _AP_S> inline __attribute__((always_inline)) PTR_TYPE* operator + (const ap_int_base<_AP_W,_AP_S> &op, PTR_TYPE* i_op) { typename ap_int_base<_AP_W,_AP_S>::RetType op2 = op; return op2 + i_op; }
template<typename PTR_TYPE, int _AP_W, bool _AP_S> inline __attribute__((always_inline)) PTR_TYPE* operator - (PTR_TYPE* i_op, const ap_int_base<_AP_W,_AP_S> &op) { typename ap_int_base<_AP_W,_AP_S>::RetType op2 = op; return i_op - op2; } template<typename PTR_TYPE, int _AP_W, bool _AP_S> inline __attribute__((always_inline)) PTR_TYPE* operator - (const ap_int_base<_AP_W,_AP_S> &op, PTR_TYPE* i_op) { typename ap_int_base<_AP_W,_AP_S>::RetType op2 = op; return op2 - i_op; }
#pragma empty_line
//float OP ap_int
//when ap_int<wa>'s width > 64, then trunc ap_int<w> to ap_int<64>
#pragma line 3425 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_int_syn.h"
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) float operator * (float i_op, const ap_int_base<_AP_W,_AP_S> &op) { typename ap_int_base<_AP_W,_AP_S>::RetType op2 = op; return i_op * op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) float operator * (const ap_int_base<_AP_W,_AP_S> &op, float i_op) { typename ap_int_base<_AP_W,_AP_S>::RetType op2 = op; return i_op * op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) float operator / (float i_op, const ap_int_base<_AP_W,_AP_S> &op) { typename ap_int_base<_AP_W,_AP_S>::RetType op2 = op; return i_op / op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) float operator / (const ap_int_base<_AP_W,_AP_S> &op, float i_op) { typename ap_int_base<_AP_W,_AP_S>::RetType op2 = op; return i_op / op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) float operator + (float i_op, const ap_int_base<_AP_W,_AP_S> &op) { typename ap_int_base<_AP_W,_AP_S>::RetType op2 = op; return i_op + op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) float operator + (const ap_int_base<_AP_W,_AP_S> &op, float i_op) { typename ap_int_base<_AP_W,_AP_S>::RetType op2 = op; return i_op + op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) float operator - (float i_op, const ap_int_base<_AP_W,_AP_S> &op) { typename ap_int_base<_AP_W,_AP_S>::RetType op2 = op; return i_op - op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) float operator - (const ap_int_base<_AP_W,_AP_S> &op, float i_op) { typename ap_int_base<_AP_W,_AP_S>::RetType op2 = op; return i_op - op2; }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) double operator * (double i_op, const ap_int_base<_AP_W,_AP_S> &op) { typename ap_int_base<_AP_W,_AP_S>::RetType op2 = op; return i_op * op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) double operator * (const ap_int_base<_AP_W,_AP_S> &op, double i_op) { typename ap_int_base<_AP_W,_AP_S>::RetType op2 = op; return i_op * op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) double operator / (double i_op, const ap_int_base<_AP_W,_AP_S> &op) { typename ap_int_base<_AP_W,_AP_S>::RetType op2 = op; return i_op / op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) double operator / (const ap_int_base<_AP_W,_AP_S> &op, double i_op) { typename ap_int_base<_AP_W,_AP_S>::RetType op2 = op; return i_op / op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) double operator + (double i_op, const ap_int_base<_AP_W,_AP_S> &op) { typename ap_int_base<_AP_W,_AP_S>::RetType op2 = op; return i_op + op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) double operator + (const ap_int_base<_AP_W,_AP_S> &op, double i_op) { typename ap_int_base<_AP_W,_AP_S>::RetType op2 = op; return i_op + op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) double operator - (double i_op, const ap_int_base<_AP_W,_AP_S> &op) { typename ap_int_base<_AP_W,_AP_S>::RetType op2 = op; return i_op - op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) double operator - (const ap_int_base<_AP_W,_AP_S> &op, double i_op) { typename ap_int_base<_AP_W,_AP_S>::RetType op2 = op; return i_op - op2; }
#pragma empty_line
/* Operators mixing Integers with AP_Int
----------------------------------------------------------------
*/
// partially specialize template argument _AP_C in order that:
// for _AP_W > 64, we will explicitly convert operand with native data type
// into corresponding ap_private
// for _AP_W <= 64, we will implicitly convert operand with ap_private into
// (unsigned) long long
#pragma line 3519 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_int_syn.h"
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<1,false>::mult operator * (bool i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<1,false>(i_op) * (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<1,false>::mult operator * ( const ap_int_base<_AP_W,_AP_S> &op, bool i_op) { return op * ap_int_base<1,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<1,false>::plus operator + (bool i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<1,false>(i_op) + (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<1,false>::plus operator + ( const ap_int_base<_AP_W,_AP_S> &op, bool i_op) { return op + ap_int_base<1,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<1,false>::minus operator - (bool i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<1,false>(i_op) - (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<1,false>::minus operator - ( const ap_int_base<_AP_W,_AP_S> &op, bool i_op) { return op - ap_int_base<1,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<1,false>::div operator / (bool i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<1,false>(i_op) / (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<1,false>::div operator / ( const ap_int_base<_AP_W,_AP_S> &op, bool i_op) { return op / ap_int_base<1,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<1,false>::mod operator % (bool i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<1,false>(i_op) % (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<1,false>::mod operator % ( const ap_int_base<_AP_W,_AP_S> &op, bool i_op) { return op % ap_int_base<1,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<1,false>::logic operator & (bool i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<1,false>(i_op) & (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<1,false>::logic operator & ( const ap_int_base<_AP_W,_AP_S> &op, bool i_op) { return op & ap_int_base<1,false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator << (const ap_int_base<_AP_W, _AP_S>& op, bool op2) { ap_int_base<_AP_W, _AP_S> r; if (false) r.V = op2 >= 0 ? (op.V << op2) : (op.V >> (-op2)); else r.V = op.V << op2; return r; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator >> (const ap_int_base<_AP_W, _AP_S>& op, bool op2) { ap_int_base<_AP_W, _AP_S> r; if (false) r.V = op2 >= 0 ? (op.V >> op2) : (op.V << (-op2)); else r.V = op.V >> op2; return r; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<1,false>::logic operator | (bool i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<1,false>(i_op) | (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<1,false>::logic operator | ( const ap_int_base<_AP_W,_AP_S> &op, bool i_op) { return op | ap_int_base<1,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<1,false>::logic operator ^ (bool i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<1,false>(i_op) ^ (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<1,false>::logic operator ^ ( const ap_int_base<_AP_W,_AP_S> &op, bool i_op) { return op ^ ap_int_base<1,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( bool i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<1,false>(i_op).operator == (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_int_base<_AP_W,_AP_S> &op, bool op2) { return op.operator == (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( bool i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<1,false>(i_op).operator != (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_int_base<_AP_W,_AP_S> &op, bool op2) { return op.operator != (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( bool i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<1,false>(i_op).operator > (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_int_base<_AP_W,_AP_S> &op, bool op2) { return op.operator > (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( bool i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<1,false>(i_op).operator >= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_int_base<_AP_W,_AP_S> &op, bool op2) { return op.operator >= (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( bool i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<1,false>(i_op).operator < (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_int_base<_AP_W,_AP_S> &op, bool op2) { return op.operator < (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( bool i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<1,false>(i_op).operator <= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_int_base<_AP_W,_AP_S> &op, bool op2) { return op.operator <= (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator += ( ap_int_base<_AP_W,_AP_S> &op, bool op2) { return op.operator += (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator -= ( ap_int_base<_AP_W,_AP_S> &op, bool op2) { return op.operator -= (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator *= ( ap_int_base<_AP_W,_AP_S> &op, bool op2) { return op.operator *= (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator /= ( ap_int_base<_AP_W,_AP_S> &op, bool op2) { return op.operator /= (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator %= ( ap_int_base<_AP_W,_AP_S> &op, bool op2) { return op.operator %= (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator >>= ( ap_int_base<_AP_W,_AP_S> &op, bool op2) { return op.operator >>= (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator <<= ( ap_int_base<_AP_W,_AP_S> &op, bool op2) { return op.operator <<= (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator &= ( ap_int_base<_AP_W,_AP_S> &op, bool op2) { return op.operator &= (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator |= ( ap_int_base<_AP_W,_AP_S> &op, bool op2) { return op.operator |= (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator ^= ( ap_int_base<_AP_W,_AP_S> &op, bool op2) { return op.operator ^= (ap_int_base<1,false>(op2)); }
#pragma empty_line
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::mult operator * (char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(i_op) * (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::mult operator * ( const ap_int_base<_AP_W,_AP_S> &op, char i_op) { return op * ap_int_base<8,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::plus operator + (char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(i_op) + (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::plus operator + ( const ap_int_base<_AP_W,_AP_S> &op, char i_op) { return op + ap_int_base<8,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::minus operator - (char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(i_op) - (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::minus operator - ( const ap_int_base<_AP_W,_AP_S> &op, char i_op) { return op - ap_int_base<8,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::div operator / (char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(i_op) / (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::div operator / ( const ap_int_base<_AP_W,_AP_S> &op, char i_op) { return op / ap_int_base<8,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::mod operator % (char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(i_op) % (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::mod operator % ( const ap_int_base<_AP_W,_AP_S> &op, char i_op) { return op % ap_int_base<8,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::logic operator & (char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(i_op) & (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::logic operator & ( const ap_int_base<_AP_W,_AP_S> &op, char i_op) { return op & ap_int_base<8,true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator << (const ap_int_base<_AP_W, _AP_S>& op, char op2) { ap_int_base<_AP_W, _AP_S> r; if (true) r.V = op2 >= 0 ? (op.V << op2) : (op.V >> (-op2)); else r.V = op.V << op2; return r; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator >> (const ap_int_base<_AP_W, _AP_S>& op, char op2) { ap_int_base<_AP_W, _AP_S> r; if (true) r.V = op2 >= 0 ? (op.V >> op2) : (op.V << (-op2)); else r.V = op.V >> op2; return r; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::logic operator | (char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(i_op) | (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::logic operator | ( const ap_int_base<_AP_W,_AP_S> &op, char i_op) { return op | ap_int_base<8,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::logic operator ^ (char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(i_op) ^ (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::logic operator ^ ( const ap_int_base<_AP_W,_AP_S> &op, char i_op) { return op ^ ap_int_base<8,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( char i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<8,true>(i_op).operator == (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_int_base<_AP_W,_AP_S> &op, char op2) { return op.operator == (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( char i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<8,true>(i_op).operator != (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_int_base<_AP_W,_AP_S> &op, char op2) { return op.operator != (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( char i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<8,true>(i_op).operator > (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_int_base<_AP_W,_AP_S> &op, char op2) { return op.operator > (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( char i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<8,true>(i_op).operator >= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_int_base<_AP_W,_AP_S> &op, char op2) { return op.operator >= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( char i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<8,true>(i_op).operator < (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_int_base<_AP_W,_AP_S> &op, char op2) { return op.operator < (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( char i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<8,true>(i_op).operator <= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_int_base<_AP_W,_AP_S> &op, char op2) { return op.operator <= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator += ( ap_int_base<_AP_W,_AP_S> &op, char op2) { return op.operator += (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator -= ( ap_int_base<_AP_W,_AP_S> &op, char op2) { return op.operator -= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator *= ( ap_int_base<_AP_W,_AP_S> &op, char op2) { return op.operator *= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator /= ( ap_int_base<_AP_W,_AP_S> &op, char op2) { return op.operator /= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator %= ( ap_int_base<_AP_W,_AP_S> &op, char op2) { return op.operator %= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator >>= ( ap_int_base<_AP_W,_AP_S> &op, char op2) { return op.operator >>= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator <<= ( ap_int_base<_AP_W,_AP_S> &op, char op2) { return op.operator <<= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator &= ( ap_int_base<_AP_W,_AP_S> &op, char op2) { return op.operator &= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator |= ( ap_int_base<_AP_W,_AP_S> &op, char op2) { return op.operator |= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator ^= ( ap_int_base<_AP_W,_AP_S> &op, char op2) { return op.operator ^= (ap_int_base<8,true>(op2)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::mult operator * (signed char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(i_op) * (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::mult operator * ( const ap_int_base<_AP_W,_AP_S> &op, signed char i_op) { return op * ap_int_base<8,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::plus operator + (signed char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(i_op) + (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::plus operator + ( const ap_int_base<_AP_W,_AP_S> &op, signed char i_op) { return op + ap_int_base<8,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::minus operator - (signed char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(i_op) - (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::minus operator - ( const ap_int_base<_AP_W,_AP_S> &op, signed char i_op) { return op - ap_int_base<8,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::div operator / (signed char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(i_op) / (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::div operator / ( const ap_int_base<_AP_W,_AP_S> &op, signed char i_op) { return op / ap_int_base<8,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::mod operator % (signed char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(i_op) % (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::mod operator % ( const ap_int_base<_AP_W,_AP_S> &op, signed char i_op) { return op % ap_int_base<8,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::logic operator & (signed char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(i_op) & (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::logic operator & ( const ap_int_base<_AP_W,_AP_S> &op, signed char i_op) { return op & ap_int_base<8,true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator << (const ap_int_base<_AP_W, _AP_S>& op, signed char op2) { ap_int_base<_AP_W, _AP_S> r; if (true) r.V = op2 >= 0 ? (op.V << op2) : (op.V >> (-op2)); else r.V = op.V << op2; return r; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator >> (const ap_int_base<_AP_W, _AP_S>& op, signed char op2) { ap_int_base<_AP_W, _AP_S> r; if (true) r.V = op2 >= 0 ? (op.V >> op2) : (op.V << (-op2)); else r.V = op.V >> op2; return r; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::logic operator | (signed char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(i_op) | (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::logic operator | ( const ap_int_base<_AP_W,_AP_S> &op, signed char i_op) { return op | ap_int_base<8,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::logic operator ^ (signed char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(i_op) ^ (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::logic operator ^ ( const ap_int_base<_AP_W,_AP_S> &op, signed char i_op) { return op ^ ap_int_base<8,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( signed char i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<8,true>(i_op).operator == (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_int_base<_AP_W,_AP_S> &op, signed char op2) { return op.operator == (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( signed char i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<8,true>(i_op).operator != (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_int_base<_AP_W,_AP_S> &op, signed char op2) { return op.operator != (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( signed char i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<8,true>(i_op).operator > (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_int_base<_AP_W,_AP_S> &op, signed char op2) { return op.operator > (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( signed char i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<8,true>(i_op).operator >= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_int_base<_AP_W,_AP_S> &op, signed char op2) { return op.operator >= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( signed char i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<8,true>(i_op).operator < (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_int_base<_AP_W,_AP_S> &op, signed char op2) { return op.operator < (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( signed char i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<8,true>(i_op).operator <= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_int_base<_AP_W,_AP_S> &op, signed char op2) { return op.operator <= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator += ( ap_int_base<_AP_W,_AP_S> &op, signed char op2) { return op.operator += (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator -= ( ap_int_base<_AP_W,_AP_S> &op, signed char op2) { return op.operator -= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator *= ( ap_int_base<_AP_W,_AP_S> &op, signed char op2) { return op.operator *= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator /= ( ap_int_base<_AP_W,_AP_S> &op, signed char op2) { return op.operator /= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator %= ( ap_int_base<_AP_W,_AP_S> &op, signed char op2) { return op.operator %= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator >>= ( ap_int_base<_AP_W,_AP_S> &op, signed char op2) { return op.operator >>= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator <<= ( ap_int_base<_AP_W,_AP_S> &op, signed char op2) { return op.operator <<= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator &= ( ap_int_base<_AP_W,_AP_S> &op, signed char op2) { return op.operator &= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator |= ( ap_int_base<_AP_W,_AP_S> &op, signed char op2) { return op.operator |= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator ^= ( ap_int_base<_AP_W,_AP_S> &op, signed char op2) { return op.operator ^= (ap_int_base<8,true>(op2)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::mult operator * (unsigned char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(i_op) * (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::mult operator * ( const ap_int_base<_AP_W,_AP_S> &op, unsigned char i_op) { return op * ap_int_base<8,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::plus operator + (unsigned char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(i_op) + (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::plus operator + ( const ap_int_base<_AP_W,_AP_S> &op, unsigned char i_op) { return op + ap_int_base<8,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::minus operator - (unsigned char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(i_op) - (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::minus operator - ( const ap_int_base<_AP_W,_AP_S> &op, unsigned char i_op) { return op - ap_int_base<8,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::div operator / (unsigned char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(i_op) / (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::div operator / ( const ap_int_base<_AP_W,_AP_S> &op, unsigned char i_op) { return op / ap_int_base<8,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::mod operator % (unsigned char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(i_op) % (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::mod operator % ( const ap_int_base<_AP_W,_AP_S> &op, unsigned char i_op) { return op % ap_int_base<8,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::logic operator & (unsigned char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(i_op) & (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::logic operator & ( const ap_int_base<_AP_W,_AP_S> &op, unsigned char i_op) { return op & ap_int_base<8,false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator << (const ap_int_base<_AP_W, _AP_S>& op, unsigned char op2) { ap_int_base<_AP_W, _AP_S> r; if (false) r.V = op2 >= 0 ? (op.V << op2) : (op.V >> (-op2)); else r.V = op.V << op2; return r; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator >> (const ap_int_base<_AP_W, _AP_S>& op, unsigned char op2) { ap_int_base<_AP_W, _AP_S> r; if (false) r.V = op2 >= 0 ? (op.V >> op2) : (op.V << (-op2)); else r.V = op.V >> op2; return r; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::logic operator | (unsigned char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(i_op) | (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::logic operator | ( const ap_int_base<_AP_W,_AP_S> &op, unsigned char i_op) { return op | ap_int_base<8,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::logic operator ^ (unsigned char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(i_op) ^ (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::logic operator ^ ( const ap_int_base<_AP_W,_AP_S> &op, unsigned char i_op) { return op ^ ap_int_base<8,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( unsigned char i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<8,false>(i_op).operator == (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_int_base<_AP_W,_AP_S> &op, unsigned char op2) { return op.operator == (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( unsigned char i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<8,false>(i_op).operator != (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_int_base<_AP_W,_AP_S> &op, unsigned char op2) { return op.operator != (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( unsigned char i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<8,false>(i_op).operator > (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_int_base<_AP_W,_AP_S> &op, unsigned char op2) { return op.operator > (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( unsigned char i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<8,false>(i_op).operator >= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_int_base<_AP_W,_AP_S> &op, unsigned char op2) { return op.operator >= (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( unsigned char i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<8,false>(i_op).operator < (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_int_base<_AP_W,_AP_S> &op, unsigned char op2) { return op.operator < (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( unsigned char i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<8,false>(i_op).operator <= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_int_base<_AP_W,_AP_S> &op, unsigned char op2) { return op.operator <= (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator += ( ap_int_base<_AP_W,_AP_S> &op, unsigned char op2) { return op.operator += (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator -= ( ap_int_base<_AP_W,_AP_S> &op, unsigned char op2) { return op.operator -= (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator *= ( ap_int_base<_AP_W,_AP_S> &op, unsigned char op2) { return op.operator *= (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator /= ( ap_int_base<_AP_W,_AP_S> &op, unsigned char op2) { return op.operator /= (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator %= ( ap_int_base<_AP_W,_AP_S> &op, unsigned char op2) { return op.operator %= (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator >>= ( ap_int_base<_AP_W,_AP_S> &op, unsigned char op2) { return op.operator >>= (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator <<= ( ap_int_base<_AP_W,_AP_S> &op, unsigned char op2) { return op.operator <<= (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator &= ( ap_int_base<_AP_W,_AP_S> &op, unsigned char op2) { return op.operator &= (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator |= ( ap_int_base<_AP_W,_AP_S> &op, unsigned char op2) { return op.operator |= (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator ^= ( ap_int_base<_AP_W,_AP_S> &op, unsigned char op2) { return op.operator ^= (ap_int_base<8,false>(op2)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,true>::mult operator * (short i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<16,true>(i_op) * (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,true>::mult operator * ( const ap_int_base<_AP_W,_AP_S> &op, short i_op) { return op * ap_int_base<16,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,true>::plus operator + (short i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<16,true>(i_op) + (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,true>::plus operator + ( const ap_int_base<_AP_W,_AP_S> &op, short i_op) { return op + ap_int_base<16,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,true>::minus operator - (short i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<16,true>(i_op) - (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,true>::minus operator - ( const ap_int_base<_AP_W,_AP_S> &op, short i_op) { return op - ap_int_base<16,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,true>::div operator / (short i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<16,true>(i_op) / (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,true>::div operator / ( const ap_int_base<_AP_W,_AP_S> &op, short i_op) { return op / ap_int_base<16,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,true>::mod operator % (short i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<16,true>(i_op) % (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,true>::mod operator % ( const ap_int_base<_AP_W,_AP_S> &op, short i_op) { return op % ap_int_base<16,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,true>::logic operator & (short i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<16,true>(i_op) & (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,true>::logic operator & ( const ap_int_base<_AP_W,_AP_S> &op, short i_op) { return op & ap_int_base<16,true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator << (const ap_int_base<_AP_W, _AP_S>& op, short op2) { ap_int_base<_AP_W, _AP_S> r; if (true) r.V = op2 >= 0 ? (op.V << op2) : (op.V >> (-op2)); else r.V = op.V << op2; return r; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator >> (const ap_int_base<_AP_W, _AP_S>& op, short op2) { ap_int_base<_AP_W, _AP_S> r; if (true) r.V = op2 >= 0 ? (op.V >> op2) : (op.V << (-op2)); else r.V = op.V >> op2; return r; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,true>::logic operator | (short i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<16,true>(i_op) | (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,true>::logic operator | ( const ap_int_base<_AP_W,_AP_S> &op, short i_op) { return op | ap_int_base<16,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,true>::logic operator ^ (short i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<16,true>(i_op) ^ (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,true>::logic operator ^ ( const ap_int_base<_AP_W,_AP_S> &op, short i_op) { return op ^ ap_int_base<16,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( short i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<16,true>(i_op).operator == (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_int_base<_AP_W,_AP_S> &op, short op2) { return op.operator == (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( short i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<16,true>(i_op).operator != (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_int_base<_AP_W,_AP_S> &op, short op2) { return op.operator != (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( short i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<16,true>(i_op).operator > (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_int_base<_AP_W,_AP_S> &op, short op2) { return op.operator > (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( short i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<16,true>(i_op).operator >= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_int_base<_AP_W,_AP_S> &op, short op2) { return op.operator >= (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( short i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<16,true>(i_op).operator < (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_int_base<_AP_W,_AP_S> &op, short op2) { return op.operator < (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( short i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<16,true>(i_op).operator <= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_int_base<_AP_W,_AP_S> &op, short op2) { return op.operator <= (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator += ( ap_int_base<_AP_W,_AP_S> &op, short op2) { return op.operator += (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator -= ( ap_int_base<_AP_W,_AP_S> &op, short op2) { return op.operator -= (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator *= ( ap_int_base<_AP_W,_AP_S> &op, short op2) { return op.operator *= (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator /= ( ap_int_base<_AP_W,_AP_S> &op, short op2) { return op.operator /= (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator %= ( ap_int_base<_AP_W,_AP_S> &op, short op2) { return op.operator %= (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator >>= ( ap_int_base<_AP_W,_AP_S> &op, short op2) { return op.operator >>= (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator <<= ( ap_int_base<_AP_W,_AP_S> &op, short op2) { return op.operator <<= (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator &= ( ap_int_base<_AP_W,_AP_S> &op, short op2) { return op.operator &= (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator |= ( ap_int_base<_AP_W,_AP_S> &op, short op2) { return op.operator |= (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator ^= ( ap_int_base<_AP_W,_AP_S> &op, short op2) { return op.operator ^= (ap_int_base<16,true>(op2)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,false>::mult operator * (unsigned short i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<16,false>(i_op) * (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,false>::mult operator * ( const ap_int_base<_AP_W,_AP_S> &op, unsigned short i_op) { return op * ap_int_base<16,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,false>::plus operator + (unsigned short i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<16,false>(i_op) + (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,false>::plus operator + ( const ap_int_base<_AP_W,_AP_S> &op, unsigned short i_op) { return op + ap_int_base<16,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,false>::minus operator - (unsigned short i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<16,false>(i_op) - (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,false>::minus operator - ( const ap_int_base<_AP_W,_AP_S> &op, unsigned short i_op) { return op - ap_int_base<16,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,false>::div operator / (unsigned short i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<16,false>(i_op) / (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,false>::div operator / ( const ap_int_base<_AP_W,_AP_S> &op, unsigned short i_op) { return op / ap_int_base<16,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,false>::mod operator % (unsigned short i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<16,false>(i_op) % (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,false>::mod operator % ( const ap_int_base<_AP_W,_AP_S> &op, unsigned short i_op) { return op % ap_int_base<16,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,false>::logic operator & (unsigned short i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<16,false>(i_op) & (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,false>::logic operator & ( const ap_int_base<_AP_W,_AP_S> &op, unsigned short i_op) { return op & ap_int_base<16,false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator << (const ap_int_base<_AP_W, _AP_S>& op, unsigned short op2) { ap_int_base<_AP_W, _AP_S> r; if (false) r.V = op2 >= 0 ? (op.V << op2) : (op.V >> (-op2)); else r.V = op.V << op2; return r; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator >> (const ap_int_base<_AP_W, _AP_S>& op, unsigned short op2) { ap_int_base<_AP_W, _AP_S> r; if (false) r.V = op2 >= 0 ? (op.V >> op2) : (op.V << (-op2)); else r.V = op.V >> op2; return r; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,false>::logic operator | (unsigned short i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<16,false>(i_op) | (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,false>::logic operator | ( const ap_int_base<_AP_W,_AP_S> &op, unsigned short i_op) { return op | ap_int_base<16,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,false>::logic operator ^ (unsigned short i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<16,false>(i_op) ^ (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<16,false>::logic operator ^ ( const ap_int_base<_AP_W,_AP_S> &op, unsigned short i_op) { return op ^ ap_int_base<16,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( unsigned short i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<16,false>(i_op).operator == (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_int_base<_AP_W,_AP_S> &op, unsigned short op2) { return op.operator == (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( unsigned short i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<16,false>(i_op).operator != (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_int_base<_AP_W,_AP_S> &op, unsigned short op2) { return op.operator != (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( unsigned short i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<16,false>(i_op).operator > (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_int_base<_AP_W,_AP_S> &op, unsigned short op2) { return op.operator > (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( unsigned short i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<16,false>(i_op).operator >= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_int_base<_AP_W,_AP_S> &op, unsigned short op2) { return op.operator >= (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( unsigned short i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<16,false>(i_op).operator < (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_int_base<_AP_W,_AP_S> &op, unsigned short op2) { return op.operator < (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( unsigned short i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<16,false>(i_op).operator <= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_int_base<_AP_W,_AP_S> &op, unsigned short op2) { return op.operator <= (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator += ( ap_int_base<_AP_W,_AP_S> &op, unsigned short op2) { return op.operator += (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator -= ( ap_int_base<_AP_W,_AP_S> &op, unsigned short op2) { return op.operator -= (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator *= ( ap_int_base<_AP_W,_AP_S> &op, unsigned short op2) { return op.operator *= (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator /= ( ap_int_base<_AP_W,_AP_S> &op, unsigned short op2) { return op.operator /= (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator %= ( ap_int_base<_AP_W,_AP_S> &op, unsigned short op2) { return op.operator %= (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator >>= ( ap_int_base<_AP_W,_AP_S> &op, unsigned short op2) { return op.operator >>= (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator <<= ( ap_int_base<_AP_W,_AP_S> &op, unsigned short op2) { return op.operator <<= (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator &= ( ap_int_base<_AP_W,_AP_S> &op, unsigned short op2) { return op.operator &= (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator |= ( ap_int_base<_AP_W,_AP_S> &op, unsigned short op2) { return op.operator |= (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator ^= ( ap_int_base<_AP_W,_AP_S> &op, unsigned short op2) { return op.operator ^= (ap_int_base<16,false>(op2)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,true>::mult operator * (int i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<32,true>(i_op) * (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,true>::mult operator * ( const ap_int_base<_AP_W,_AP_S> &op, int i_op) { return op * ap_int_base<32,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,true>::plus operator + (int i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<32,true>(i_op) + (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,true>::plus operator + ( const ap_int_base<_AP_W,_AP_S> &op, int i_op) { return op + ap_int_base<32,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,true>::minus operator - (int i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<32,true>(i_op) - (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,true>::minus operator - ( const ap_int_base<_AP_W,_AP_S> &op, int i_op) { return op - ap_int_base<32,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,true>::div operator / (int i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<32,true>(i_op) / (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,true>::div operator / ( const ap_int_base<_AP_W,_AP_S> &op, int i_op) { return op / ap_int_base<32,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,true>::mod operator % (int i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<32,true>(i_op) % (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,true>::mod operator % ( const ap_int_base<_AP_W,_AP_S> &op, int i_op) { return op % ap_int_base<32,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,true>::logic operator & (int i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<32,true>(i_op) & (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,true>::logic operator & ( const ap_int_base<_AP_W,_AP_S> &op, int i_op) { return op & ap_int_base<32,true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator << (const ap_int_base<_AP_W, _AP_S>& op, int op2) { ap_int_base<_AP_W, _AP_S> r; if (true) r.V = op2 >= 0 ? (op.V << op2) : (op.V >> (-op2)); else r.V = op.V << op2; return r; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator >> (const ap_int_base<_AP_W, _AP_S>& op, int op2) { ap_int_base<_AP_W, _AP_S> r; if (true) r.V = op2 >= 0 ? (op.V >> op2) : (op.V << (-op2)); else r.V = op.V >> op2; return r; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,true>::logic operator | (int i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<32,true>(i_op) | (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,true>::logic operator | ( const ap_int_base<_AP_W,_AP_S> &op, int i_op) { return op | ap_int_base<32,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,true>::logic operator ^ (int i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<32,true>(i_op) ^ (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,true>::logic operator ^ ( const ap_int_base<_AP_W,_AP_S> &op, int i_op) { return op ^ ap_int_base<32,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( int i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<32,true>(i_op).operator == (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_int_base<_AP_W,_AP_S> &op, int op2) { return op.operator == (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( int i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<32,true>(i_op).operator != (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_int_base<_AP_W,_AP_S> &op, int op2) { return op.operator != (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( int i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<32,true>(i_op).operator > (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_int_base<_AP_W,_AP_S> &op, int op2) { return op.operator > (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( int i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<32,true>(i_op).operator >= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_int_base<_AP_W,_AP_S> &op, int op2) { return op.operator >= (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( int i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<32,true>(i_op).operator < (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_int_base<_AP_W,_AP_S> &op, int op2) { return op.operator < (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( int i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<32,true>(i_op).operator <= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_int_base<_AP_W,_AP_S> &op, int op2) { return op.operator <= (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator += ( ap_int_base<_AP_W,_AP_S> &op, int op2) { return op.operator += (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator -= ( ap_int_base<_AP_W,_AP_S> &op, int op2) { return op.operator -= (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator *= ( ap_int_base<_AP_W,_AP_S> &op, int op2) { return op.operator *= (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator /= ( ap_int_base<_AP_W,_AP_S> &op, int op2) { return op.operator /= (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator %= ( ap_int_base<_AP_W,_AP_S> &op, int op2) { return op.operator %= (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator >>= ( ap_int_base<_AP_W,_AP_S> &op, int op2) { return op.operator >>= (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator <<= ( ap_int_base<_AP_W,_AP_S> &op, int op2) { return op.operator <<= (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator &= ( ap_int_base<_AP_W,_AP_S> &op, int op2) { return op.operator &= (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator |= ( ap_int_base<_AP_W,_AP_S> &op, int op2) { return op.operator |= (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator ^= ( ap_int_base<_AP_W,_AP_S> &op, int op2) { return op.operator ^= (ap_int_base<32,true>(op2)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,false>::mult operator * (unsigned int i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<32,false>(i_op) * (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,false>::mult operator * ( const ap_int_base<_AP_W,_AP_S> &op, unsigned int i_op) { return op * ap_int_base<32,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,false>::plus operator + (unsigned int i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<32,false>(i_op) + (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,false>::plus operator + ( const ap_int_base<_AP_W,_AP_S> &op, unsigned int i_op) { return op + ap_int_base<32,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,false>::minus operator - (unsigned int i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<32,false>(i_op) - (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,false>::minus operator - ( const ap_int_base<_AP_W,_AP_S> &op, unsigned int i_op) { return op - ap_int_base<32,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,false>::div operator / (unsigned int i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<32,false>(i_op) / (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,false>::div operator / ( const ap_int_base<_AP_W,_AP_S> &op, unsigned int i_op) { return op / ap_int_base<32,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,false>::mod operator % (unsigned int i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<32,false>(i_op) % (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,false>::mod operator % ( const ap_int_base<_AP_W,_AP_S> &op, unsigned int i_op) { return op % ap_int_base<32,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,false>::logic operator & (unsigned int i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<32,false>(i_op) & (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,false>::logic operator & ( const ap_int_base<_AP_W,_AP_S> &op, unsigned int i_op) { return op & ap_int_base<32,false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator << (const ap_int_base<_AP_W, _AP_S>& op, unsigned int op2) { ap_int_base<_AP_W, _AP_S> r; if (false) r.V = op2 >= 0 ? (op.V << op2) : (op.V >> (-op2)); else r.V = op.V << op2; return r; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator >> (const ap_int_base<_AP_W, _AP_S>& op, unsigned int op2) { ap_int_base<_AP_W, _AP_S> r; if (false) r.V = op2 >= 0 ? (op.V >> op2) : (op.V << (-op2)); else r.V = op.V >> op2; return r; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,false>::logic operator | (unsigned int i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<32,false>(i_op) | (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,false>::logic operator | ( const ap_int_base<_AP_W,_AP_S> &op, unsigned int i_op) { return op | ap_int_base<32,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,false>::logic operator ^ (unsigned int i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<32,false>(i_op) ^ (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<32,false>::logic operator ^ ( const ap_int_base<_AP_W,_AP_S> &op, unsigned int i_op) { return op ^ ap_int_base<32,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( unsigned int i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<32,false>(i_op).operator == (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_int_base<_AP_W,_AP_S> &op, unsigned int op2) { return op.operator == (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( unsigned int i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<32,false>(i_op).operator != (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_int_base<_AP_W,_AP_S> &op, unsigned int op2) { return op.operator != (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( unsigned int i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<32,false>(i_op).operator > (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_int_base<_AP_W,_AP_S> &op, unsigned int op2) { return op.operator > (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( unsigned int i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<32,false>(i_op).operator >= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_int_base<_AP_W,_AP_S> &op, unsigned int op2) { return op.operator >= (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( unsigned int i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<32,false>(i_op).operator < (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_int_base<_AP_W,_AP_S> &op, unsigned int op2) { return op.operator < (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( unsigned int i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<32,false>(i_op).operator <= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_int_base<_AP_W,_AP_S> &op, unsigned int op2) { return op.operator <= (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator += ( ap_int_base<_AP_W,_AP_S> &op, unsigned int op2) { return op.operator += (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator -= ( ap_int_base<_AP_W,_AP_S> &op, unsigned int op2) { return op.operator -= (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator *= ( ap_int_base<_AP_W,_AP_S> &op, unsigned int op2) { return op.operator *= (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator /= ( ap_int_base<_AP_W,_AP_S> &op, unsigned int op2) { return op.operator /= (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator %= ( ap_int_base<_AP_W,_AP_S> &op, unsigned int op2) { return op.operator %= (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator >>= ( ap_int_base<_AP_W,_AP_S> &op, unsigned int op2) { return op.operator >>= (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator <<= ( ap_int_base<_AP_W,_AP_S> &op, unsigned int op2) { return op.operator <<= (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator &= ( ap_int_base<_AP_W,_AP_S> &op, unsigned int op2) { return op.operator &= (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator |= ( ap_int_base<_AP_W,_AP_S> &op, unsigned int op2) { return op.operator |= (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator ^= ( ap_int_base<_AP_W,_AP_S> &op, unsigned int op2) { return op.operator ^= (ap_int_base<32,false>(op2)); }
#pragma empty_line
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::mult operator * (long i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(i_op) * (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::mult operator * ( const ap_int_base<_AP_W,_AP_S> &op, long i_op) { return op * ap_int_base<64,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::plus operator + (long i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(i_op) + (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::plus operator + ( const ap_int_base<_AP_W,_AP_S> &op, long i_op) { return op + ap_int_base<64,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::minus operator - (long i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(i_op) - (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::minus operator - ( const ap_int_base<_AP_W,_AP_S> &op, long i_op) { return op - ap_int_base<64,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::div operator / (long i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(i_op) / (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::div operator / ( const ap_int_base<_AP_W,_AP_S> &op, long i_op) { return op / ap_int_base<64,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::mod operator % (long i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(i_op) % (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::mod operator % ( const ap_int_base<_AP_W,_AP_S> &op, long i_op) { return op % ap_int_base<64,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::logic operator & (long i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(i_op) & (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::logic operator & ( const ap_int_base<_AP_W,_AP_S> &op, long i_op) { return op & ap_int_base<64,true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator << (const ap_int_base<_AP_W, _AP_S>& op, long op2) { ap_int_base<_AP_W, _AP_S> r; if (true) r.V = op2 >= 0 ? (op.V << op2) : (op.V >> (-op2)); else r.V = op.V << op2; return r; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator >> (const ap_int_base<_AP_W, _AP_S>& op, long op2) { ap_int_base<_AP_W, _AP_S> r; if (true) r.V = op2 >= 0 ? (op.V >> op2) : (op.V << (-op2)); else r.V = op.V >> op2; return r; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::logic operator | (long i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(i_op) | (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::logic operator | ( const ap_int_base<_AP_W,_AP_S> &op, long i_op) { return op | ap_int_base<64,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::logic operator ^ (long i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(i_op) ^ (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::logic operator ^ ( const ap_int_base<_AP_W,_AP_S> &op, long i_op) { return op ^ ap_int_base<64,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( long i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<64,true>(i_op).operator == (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_int_base<_AP_W,_AP_S> &op, long op2) { return op.operator == (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( long i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<64,true>(i_op).operator != (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_int_base<_AP_W,_AP_S> &op, long op2) { return op.operator != (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( long i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<64,true>(i_op).operator > (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_int_base<_AP_W,_AP_S> &op, long op2) { return op.operator > (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( long i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<64,true>(i_op).operator >= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_int_base<_AP_W,_AP_S> &op, long op2) { return op.operator >= (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( long i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<64,true>(i_op).operator < (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_int_base<_AP_W,_AP_S> &op, long op2) { return op.operator < (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( long i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<64,true>(i_op).operator <= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_int_base<_AP_W,_AP_S> &op, long op2) { return op.operator <= (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator += ( ap_int_base<_AP_W,_AP_S> &op, long op2) { return op.operator += (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator -= ( ap_int_base<_AP_W,_AP_S> &op, long op2) { return op.operator -= (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator *= ( ap_int_base<_AP_W,_AP_S> &op, long op2) { return op.operator *= (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator /= ( ap_int_base<_AP_W,_AP_S> &op, long op2) { return op.operator /= (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator %= ( ap_int_base<_AP_W,_AP_S> &op, long op2) { return op.operator %= (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator >>= ( ap_int_base<_AP_W,_AP_S> &op, long op2) { return op.operator >>= (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator <<= ( ap_int_base<_AP_W,_AP_S> &op, long op2) { return op.operator <<= (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator &= ( ap_int_base<_AP_W,_AP_S> &op, long op2) { return op.operator &= (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator |= ( ap_int_base<_AP_W,_AP_S> &op, long op2) { return op.operator |= (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator ^= ( ap_int_base<_AP_W,_AP_S> &op, long op2) { return op.operator ^= (ap_int_base<64,true>(op2)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::mult operator * (unsigned long i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(i_op) * (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::mult operator * ( const ap_int_base<_AP_W,_AP_S> &op, unsigned long i_op) { return op * ap_int_base<64,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::plus operator + (unsigned long i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(i_op) + (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::plus operator + ( const ap_int_base<_AP_W,_AP_S> &op, unsigned long i_op) { return op + ap_int_base<64,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::minus operator - (unsigned long i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(i_op) - (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::minus operator - ( const ap_int_base<_AP_W,_AP_S> &op, unsigned long i_op) { return op - ap_int_base<64,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::div operator / (unsigned long i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(i_op) / (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::div operator / ( const ap_int_base<_AP_W,_AP_S> &op, unsigned long i_op) { return op / ap_int_base<64,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::mod operator % (unsigned long i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(i_op) % (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::mod operator % ( const ap_int_base<_AP_W,_AP_S> &op, unsigned long i_op) { return op % ap_int_base<64,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::logic operator & (unsigned long i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(i_op) & (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::logic operator & ( const ap_int_base<_AP_W,_AP_S> &op, unsigned long i_op) { return op & ap_int_base<64,false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator << (const ap_int_base<_AP_W, _AP_S>& op, unsigned long op2) { ap_int_base<_AP_W, _AP_S> r; if (false) r.V = op2 >= 0 ? (op.V << op2) : (op.V >> (-op2)); else r.V = op.V << op2; return r; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator >> (const ap_int_base<_AP_W, _AP_S>& op, unsigned long op2) { ap_int_base<_AP_W, _AP_S> r; if (false) r.V = op2 >= 0 ? (op.V >> op2) : (op.V << (-op2)); else r.V = op.V >> op2; return r; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::logic operator | (unsigned long i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(i_op) | (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::logic operator | ( const ap_int_base<_AP_W,_AP_S> &op, unsigned long i_op) { return op | ap_int_base<64,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::logic operator ^ (unsigned long i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(i_op) ^ (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::logic operator ^ ( const ap_int_base<_AP_W,_AP_S> &op, unsigned long i_op) { return op ^ ap_int_base<64,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( unsigned long i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<64,false>(i_op).operator == (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_int_base<_AP_W,_AP_S> &op, unsigned long op2) { return op.operator == (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( unsigned long i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<64,false>(i_op).operator != (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_int_base<_AP_W,_AP_S> &op, unsigned long op2) { return op.operator != (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( unsigned long i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<64,false>(i_op).operator > (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_int_base<_AP_W,_AP_S> &op, unsigned long op2) { return op.operator > (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( unsigned long i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<64,false>(i_op).operator >= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_int_base<_AP_W,_AP_S> &op, unsigned long op2) { return op.operator >= (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( unsigned long i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<64,false>(i_op).operator < (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_int_base<_AP_W,_AP_S> &op, unsigned long op2) { return op.operator < (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( unsigned long i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<64,false>(i_op).operator <= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_int_base<_AP_W,_AP_S> &op, unsigned long op2) { return op.operator <= (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator += ( ap_int_base<_AP_W,_AP_S> &op, unsigned long op2) { return op.operator += (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator -= ( ap_int_base<_AP_W,_AP_S> &op, unsigned long op2) { return op.operator -= (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator *= ( ap_int_base<_AP_W,_AP_S> &op, unsigned long op2) { return op.operator *= (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator /= ( ap_int_base<_AP_W,_AP_S> &op, unsigned long op2) { return op.operator /= (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator %= ( ap_int_base<_AP_W,_AP_S> &op, unsigned long op2) { return op.operator %= (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator >>= ( ap_int_base<_AP_W,_AP_S> &op, unsigned long op2) { return op.operator >>= (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator <<= ( ap_int_base<_AP_W,_AP_S> &op, unsigned long op2) { return op.operator <<= (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator &= ( ap_int_base<_AP_W,_AP_S> &op, unsigned long op2) { return op.operator &= (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator |= ( ap_int_base<_AP_W,_AP_S> &op, unsigned long op2) { return op.operator |= (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator ^= ( ap_int_base<_AP_W,_AP_S> &op, unsigned long op2) { return op.operator ^= (ap_int_base<64,false>(op2)); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::mult operator * (ap_slong i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(i_op) * (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::mult operator * ( const ap_int_base<_AP_W,_AP_S> &op, ap_slong i_op) { return op * ap_int_base<64,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::plus operator + (ap_slong i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(i_op) + (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::plus operator + ( const ap_int_base<_AP_W,_AP_S> &op, ap_slong i_op) { return op + ap_int_base<64,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::minus operator - (ap_slong i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(i_op) - (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::minus operator - ( const ap_int_base<_AP_W,_AP_S> &op, ap_slong i_op) { return op - ap_int_base<64,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::div operator / (ap_slong i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(i_op) / (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::div operator / ( const ap_int_base<_AP_W,_AP_S> &op, ap_slong i_op) { return op / ap_int_base<64,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::mod operator % (ap_slong i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(i_op) % (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::mod operator % ( const ap_int_base<_AP_W,_AP_S> &op, ap_slong i_op) { return op % ap_int_base<64,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::logic operator & (ap_slong i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(i_op) & (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::logic operator & ( const ap_int_base<_AP_W,_AP_S> &op, ap_slong i_op) { return op & ap_int_base<64,true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator << (const ap_int_base<_AP_W, _AP_S>& op, ap_slong op2) { ap_int_base<_AP_W, _AP_S> r; if (true) r.V = op2 >= 0 ? (op.V << op2) : (op.V >> (-op2)); else r.V = op.V << op2; return r; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator >> (const ap_int_base<_AP_W, _AP_S>& op, ap_slong op2) { ap_int_base<_AP_W, _AP_S> r; if (true) r.V = op2 >= 0 ? (op.V >> op2) : (op.V << (-op2)); else r.V = op.V >> op2; return r; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::logic operator | (ap_slong i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(i_op) | (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::logic operator | ( const ap_int_base<_AP_W,_AP_S> &op, ap_slong i_op) { return op | ap_int_base<64,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::logic operator ^ (ap_slong i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(i_op) ^ (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,true>::logic operator ^ ( const ap_int_base<_AP_W,_AP_S> &op, ap_slong i_op) { return op ^ ap_int_base<64,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( ap_slong i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<64,true>(i_op).operator == (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_int_base<_AP_W,_AP_S> &op, ap_slong op2) { return op.operator == (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( ap_slong i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<64,true>(i_op).operator != (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_int_base<_AP_W,_AP_S> &op, ap_slong op2) { return op.operator != (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( ap_slong i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<64,true>(i_op).operator > (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_int_base<_AP_W,_AP_S> &op, ap_slong op2) { return op.operator > (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( ap_slong i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<64,true>(i_op).operator >= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_int_base<_AP_W,_AP_S> &op, ap_slong op2) { return op.operator >= (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( ap_slong i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<64,true>(i_op).operator < (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_int_base<_AP_W,_AP_S> &op, ap_slong op2) { return op.operator < (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( ap_slong i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<64,true>(i_op).operator <= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_int_base<_AP_W,_AP_S> &op, ap_slong op2) { return op.operator <= (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator += ( ap_int_base<_AP_W,_AP_S> &op, ap_slong op2) { return op.operator += (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator -= ( ap_int_base<_AP_W,_AP_S> &op, ap_slong op2) { return op.operator -= (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator *= ( ap_int_base<_AP_W,_AP_S> &op, ap_slong op2) { return op.operator *= (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator /= ( ap_int_base<_AP_W,_AP_S> &op, ap_slong op2) { return op.operator /= (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator %= ( ap_int_base<_AP_W,_AP_S> &op, ap_slong op2) { return op.operator %= (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator >>= ( ap_int_base<_AP_W,_AP_S> &op, ap_slong op2) { return op.operator >>= (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator <<= ( ap_int_base<_AP_W,_AP_S> &op, ap_slong op2) { return op.operator <<= (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator &= ( ap_int_base<_AP_W,_AP_S> &op, ap_slong op2) { return op.operator &= (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator |= ( ap_int_base<_AP_W,_AP_S> &op, ap_slong op2) { return op.operator |= (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator ^= ( ap_int_base<_AP_W,_AP_S> &op, ap_slong op2) { return op.operator ^= (ap_int_base<64,true>(op2)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::mult operator * (ap_ulong i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(i_op) * (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::mult operator * ( const ap_int_base<_AP_W,_AP_S> &op, ap_ulong i_op) { return op * ap_int_base<64,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::plus operator + (ap_ulong i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(i_op) + (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::plus operator + ( const ap_int_base<_AP_W,_AP_S> &op, ap_ulong i_op) { return op + ap_int_base<64,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::minus operator - (ap_ulong i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(i_op) - (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::minus operator - ( const ap_int_base<_AP_W,_AP_S> &op, ap_ulong i_op) { return op - ap_int_base<64,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::div operator / (ap_ulong i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(i_op) / (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::div operator / ( const ap_int_base<_AP_W,_AP_S> &op, ap_ulong i_op) { return op / ap_int_base<64,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::mod operator % (ap_ulong i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(i_op) % (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::mod operator % ( const ap_int_base<_AP_W,_AP_S> &op, ap_ulong i_op) { return op % ap_int_base<64,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::logic operator & (ap_ulong i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(i_op) & (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::logic operator & ( const ap_int_base<_AP_W,_AP_S> &op, ap_ulong i_op) { return op & ap_int_base<64,false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator << (const ap_int_base<_AP_W, _AP_S>& op, ap_ulong op2) { ap_int_base<_AP_W, _AP_S> r; if (false) r.V = op2 >= 0 ? (op.V << op2) : (op.V >> (-op2)); else r.V = op.V << op2; return r; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S> operator >> (const ap_int_base<_AP_W, _AP_S>& op, ap_ulong op2) { ap_int_base<_AP_W, _AP_S> r; if (false) r.V = op2 >= 0 ? (op.V >> op2) : (op.V << (-op2)); else r.V = op.V >> op2; return r; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::logic operator | (ap_ulong i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(i_op) | (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::logic operator | ( const ap_int_base<_AP_W,_AP_S> &op, ap_ulong i_op) { return op | ap_int_base<64,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::logic operator ^ (ap_ulong i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(i_op) ^ (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<64,false>::logic operator ^ ( const ap_int_base<_AP_W,_AP_S> &op, ap_ulong i_op) { return op ^ ap_int_base<64,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( ap_ulong i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<64,false>(i_op).operator == (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_int_base<_AP_W,_AP_S> &op, ap_ulong op2) { return op.operator == (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( ap_ulong i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<64,false>(i_op).operator != (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_int_base<_AP_W,_AP_S> &op, ap_ulong op2) { return op.operator != (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( ap_ulong i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<64,false>(i_op).operator > (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_int_base<_AP_W,_AP_S> &op, ap_ulong op2) { return op.operator > (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( ap_ulong i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<64,false>(i_op).operator >= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_int_base<_AP_W,_AP_S> &op, ap_ulong op2) { return op.operator >= (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( ap_ulong i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<64,false>(i_op).operator < (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_int_base<_AP_W,_AP_S> &op, ap_ulong op2) { return op.operator < (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( ap_ulong i_op, const ap_int_base<_AP_W,_AP_S, false> &op) { return ap_int_base<64,false>(i_op).operator <= (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_int_base<_AP_W,_AP_S> &op, ap_ulong op2) { return op.operator <= (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator += ( ap_int_base<_AP_W,_AP_S> &op, ap_ulong op2) { return op.operator += (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator -= ( ap_int_base<_AP_W,_AP_S> &op, ap_ulong op2) { return op.operator -= (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator *= ( ap_int_base<_AP_W,_AP_S> &op, ap_ulong op2) { return op.operator *= (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator /= ( ap_int_base<_AP_W,_AP_S> &op, ap_ulong op2) { return op.operator /= (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator %= ( ap_int_base<_AP_W,_AP_S> &op, ap_ulong op2) { return op.operator %= (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator >>= ( ap_int_base<_AP_W,_AP_S> &op, ap_ulong op2) { return op.operator >>= (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator <<= ( ap_int_base<_AP_W,_AP_S> &op, ap_ulong op2) { return op.operator <<= (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator &= ( ap_int_base<_AP_W,_AP_S> &op, ap_ulong op2) { return op.operator &= (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator |= ( ap_int_base<_AP_W,_AP_S> &op, ap_ulong op2) { return op.operator |= (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator ^= ( ap_int_base<_AP_W,_AP_S> &op, ap_ulong op2) { return op.operator ^= (ap_int_base<64,false>(op2)); }
#pragma line 3578 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_int_syn.h"
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1,_AP_S1>& operator += ( ap_int_base<_AP_W1,_AP_S1>& op1, ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1.operator += (ap_int_base<_AP_W2, false>(op2)); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_range_ref<_AP_W1,_AP_S1>& operator += ( ap_range_ref<_AP_W1,_AP_S1>& op1, ap_int_base<_AP_W2,_AP_S2>& op2) { ap_int_base<_AP_W1, false> tmp(op1); tmp.operator += (op2); op1 = tmp; return op1; }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1,_AP_S1>& operator -= ( ap_int_base<_AP_W1,_AP_S1>& op1, ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1.operator -= (ap_int_base<_AP_W2, false>(op2)); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_range_ref<_AP_W1,_AP_S1>& operator -= ( ap_range_ref<_AP_W1,_AP_S1>& op1, ap_int_base<_AP_W2,_AP_S2>& op2) { ap_int_base<_AP_W1, false> tmp(op1); tmp.operator -= (op2); op1 = tmp; return op1; }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1,_AP_S1>& operator *= ( ap_int_base<_AP_W1,_AP_S1>& op1, ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1.operator *= (ap_int_base<_AP_W2, false>(op2)); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_range_ref<_AP_W1,_AP_S1>& operator *= ( ap_range_ref<_AP_W1,_AP_S1>& op1, ap_int_base<_AP_W2,_AP_S2>& op2) { ap_int_base<_AP_W1, false> tmp(op1); tmp.operator *= (op2); op1 = tmp; return op1; }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1,_AP_S1>& operator /= ( ap_int_base<_AP_W1,_AP_S1>& op1, ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1.operator /= (ap_int_base<_AP_W2, false>(op2)); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_range_ref<_AP_W1,_AP_S1>& operator /= ( ap_range_ref<_AP_W1,_AP_S1>& op1, ap_int_base<_AP_W2,_AP_S2>& op2) { ap_int_base<_AP_W1, false> tmp(op1); tmp.operator /= (op2); op1 = tmp; return op1; }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1,_AP_S1>& operator %= ( ap_int_base<_AP_W1,_AP_S1>& op1, ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1.operator %= (ap_int_base<_AP_W2, false>(op2)); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_range_ref<_AP_W1,_AP_S1>& operator %= ( ap_range_ref<_AP_W1,_AP_S1>& op1, ap_int_base<_AP_W2,_AP_S2>& op2) { ap_int_base<_AP_W1, false> tmp(op1); tmp.operator %= (op2); op1 = tmp; return op1; }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1,_AP_S1>& operator >>= ( ap_int_base<_AP_W1,_AP_S1>& op1, ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1.operator >>= (ap_int_base<_AP_W2, false>(op2)); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_range_ref<_AP_W1,_AP_S1>& operator >>= ( ap_range_ref<_AP_W1,_AP_S1>& op1, ap_int_base<_AP_W2,_AP_S2>& op2) { ap_int_base<_AP_W1, false> tmp(op1); tmp.operator >>= (op2); op1 = tmp; return op1; }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1,_AP_S1>& operator <<= ( ap_int_base<_AP_W1,_AP_S1>& op1, ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1.operator <<= (ap_int_base<_AP_W2, false>(op2)); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_range_ref<_AP_W1,_AP_S1>& operator <<= ( ap_range_ref<_AP_W1,_AP_S1>& op1, ap_int_base<_AP_W2,_AP_S2>& op2) { ap_int_base<_AP_W1, false> tmp(op1); tmp.operator <<= (op2); op1 = tmp; return op1; }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1,_AP_S1>& operator &= ( ap_int_base<_AP_W1,_AP_S1>& op1, ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1.operator &= (ap_int_base<_AP_W2, false>(op2)); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_range_ref<_AP_W1,_AP_S1>& operator &= ( ap_range_ref<_AP_W1,_AP_S1>& op1, ap_int_base<_AP_W2,_AP_S2>& op2) { ap_int_base<_AP_W1, false> tmp(op1); tmp.operator &= (op2); op1 = tmp; return op1; }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1,_AP_S1>& operator |= ( ap_int_base<_AP_W1,_AP_S1>& op1, ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1.operator |= (ap_int_base<_AP_W2, false>(op2)); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_range_ref<_AP_W1,_AP_S1>& operator |= ( ap_range_ref<_AP_W1,_AP_S1>& op1, ap_int_base<_AP_W2,_AP_S2>& op2) { ap_int_base<_AP_W1, false> tmp(op1); tmp.operator |= (op2); op1 = tmp; return op1; }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1,_AP_S1>& operator ^= ( ap_int_base<_AP_W1,_AP_S1>& op1, ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1.operator ^= (ap_int_base<_AP_W2, false>(op2)); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_range_ref<_AP_W1,_AP_S1>& operator ^= ( ap_range_ref<_AP_W1,_AP_S1>& op1, ap_int_base<_AP_W2,_AP_S2>& op2) { ap_int_base<_AP_W1, false> tmp(op1); tmp.operator ^= (op2); op1 = tmp; return op1; }
#pragma empty_line
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator == ( const ap_range_ref<_AP_W1,_AP_S1>& op1, const ap_int_base<_AP_W2,_AP_S2>& op2) { return ap_int_base<_AP_W1,false>(op1).operator == (op2); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator == ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1.operator == (op2.operator ap_int_base<_AP_W2, false>()); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator != ( const ap_range_ref<_AP_W1,_AP_S1>& op1, const ap_int_base<_AP_W2,_AP_S2>& op2) { return ap_int_base<_AP_W1,false>(op1).operator != (op2); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator != ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1.operator != (op2.operator ap_int_base<_AP_W2, false>()); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator > ( const ap_range_ref<_AP_W1,_AP_S1>& op1, const ap_int_base<_AP_W2,_AP_S2>& op2) { return ap_int_base<_AP_W1,false>(op1).operator > (op2); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator > ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1.operator > (op2.operator ap_int_base<_AP_W2, false>()); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator >= ( const ap_range_ref<_AP_W1,_AP_S1>& op1, const ap_int_base<_AP_W2,_AP_S2>& op2) { return ap_int_base<_AP_W1,false>(op1).operator >= (op2); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator >= ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1.operator >= (op2.operator ap_int_base<_AP_W2, false>()); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator < ( const ap_range_ref<_AP_W1,_AP_S1>& op1, const ap_int_base<_AP_W2,_AP_S2>& op2) { return ap_int_base<_AP_W1,false>(op1).operator < (op2); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator < ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1.operator < (op2.operator ap_int_base<_AP_W2, false>()); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator <= ( const ap_range_ref<_AP_W1,_AP_S1>& op1, const ap_int_base<_AP_W2,_AP_S2>& op2) { return ap_int_base<_AP_W1,false>(op1).operator <= (op2); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator <= ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1.operator <= (op2.operator ap_int_base<_AP_W2, false>()); }
#pragma empty_line
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<_AP_W2,_AP_S2>::plus operator + ( const ap_range_ref<_AP_W1,_AP_S1>& op1, const ap_int_base<_AP_W2,_AP_S2>& op2) { return ap_int_base<_AP_W1, false>(op1) + (op2); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<_AP_W2,_AP_S2>::plus operator + ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1 + (ap_int_base<_AP_W2, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<_AP_W2,_AP_S2>::minus operator - ( const ap_range_ref<_AP_W1,_AP_S1>& op1, const ap_int_base<_AP_W2,_AP_S2>& op2) { return ap_int_base<_AP_W1, false>(op1) - (op2); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<_AP_W2,_AP_S2>::minus operator - ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1 - (ap_int_base<_AP_W2, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<_AP_W2,_AP_S2>::mult operator * ( const ap_range_ref<_AP_W1,_AP_S1>& op1, const ap_int_base<_AP_W2,_AP_S2>& op2) { return ap_int_base<_AP_W1, false>(op1) * (op2); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<_AP_W2,_AP_S2>::mult operator * ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1 * (ap_int_base<_AP_W2, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<_AP_W2,_AP_S2>::div operator / ( const ap_range_ref<_AP_W1,_AP_S1>& op1, const ap_int_base<_AP_W2,_AP_S2>& op2) { return ap_int_base<_AP_W1, false>(op1) / (op2); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<_AP_W2,_AP_S2>::div operator / ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1 / (ap_int_base<_AP_W2, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<_AP_W2,_AP_S2>::mod operator % ( const ap_range_ref<_AP_W1,_AP_S1>& op1, const ap_int_base<_AP_W2,_AP_S2>& op2) { return ap_int_base<_AP_W1, false>(op1) % (op2); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<_AP_W2,_AP_S2>::mod operator % ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1 % (ap_int_base<_AP_W2, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<_AP_W2,_AP_S2>::arg1 operator >> ( const ap_range_ref<_AP_W1,_AP_S1>& op1, const ap_int_base<_AP_W2,_AP_S2>& op2) { return ap_int_base<_AP_W1, false>(op1) >> (op2); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<_AP_W2,_AP_S2>::arg1 operator >> ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1 >> (ap_int_base<_AP_W2, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<_AP_W2,_AP_S2>::arg1 operator << ( const ap_range_ref<_AP_W1,_AP_S1>& op1, const ap_int_base<_AP_W2,_AP_S2>& op2) { return ap_int_base<_AP_W1, false>(op1) << (op2); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<_AP_W2,_AP_S2>::arg1 operator << ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1 << (ap_int_base<_AP_W2, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<_AP_W2,_AP_S2>::logic operator & ( const ap_range_ref<_AP_W1,_AP_S1>& op1, const ap_int_base<_AP_W2,_AP_S2>& op2) { return ap_int_base<_AP_W1, false>(op1) & (op2); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<_AP_W2,_AP_S2>::logic operator & ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1 & (ap_int_base<_AP_W2, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<_AP_W2,_AP_S2>::logic operator | ( const ap_range_ref<_AP_W1,_AP_S1>& op1, const ap_int_base<_AP_W2,_AP_S2>& op2) { return ap_int_base<_AP_W1, false>(op1) | (op2); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<_AP_W2,_AP_S2>::logic operator | ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1 | (ap_int_base<_AP_W2, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<_AP_W2,_AP_S2>::logic operator ^ ( const ap_range_ref<_AP_W1,_AP_S1>& op1, const ap_int_base<_AP_W2,_AP_S2>& op2) { return ap_int_base<_AP_W1, false>(op1) ^ (op2); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<_AP_W2,_AP_S2>::logic operator ^ ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_range_ref<_AP_W2,_AP_S2>& op2) { return op1 ^ (ap_int_base<_AP_W2, false>(op2)); }
#pragma line 3634 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_int_syn.h"
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1,_AP_S1>& operator += ( ap_int_base<_AP_W1,_AP_S1>& op1, ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1.operator += (ap_int_base<1, false>(op2)); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_bit_ref<_AP_W1,_AP_S1>& operator += ( ap_bit_ref<_AP_W1,_AP_S1>& op1, ap_int_base<_AP_W2,_AP_S2>& op2) { ap_int_base<1, false> tmp(op1); tmp.operator += (op2); op1 = tmp; return op1; }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1,_AP_S1>& operator -= ( ap_int_base<_AP_W1,_AP_S1>& op1, ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1.operator -= (ap_int_base<1, false>(op2)); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_bit_ref<_AP_W1,_AP_S1>& operator -= ( ap_bit_ref<_AP_W1,_AP_S1>& op1, ap_int_base<_AP_W2,_AP_S2>& op2) { ap_int_base<1, false> tmp(op1); tmp.operator -= (op2); op1 = tmp; return op1; }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1,_AP_S1>& operator *= ( ap_int_base<_AP_W1,_AP_S1>& op1, ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1.operator *= (ap_int_base<1, false>(op2)); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_bit_ref<_AP_W1,_AP_S1>& operator *= ( ap_bit_ref<_AP_W1,_AP_S1>& op1, ap_int_base<_AP_W2,_AP_S2>& op2) { ap_int_base<1, false> tmp(op1); tmp.operator *= (op2); op1 = tmp; return op1; }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1,_AP_S1>& operator /= ( ap_int_base<_AP_W1,_AP_S1>& op1, ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1.operator /= (ap_int_base<1, false>(op2)); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_bit_ref<_AP_W1,_AP_S1>& operator /= ( ap_bit_ref<_AP_W1,_AP_S1>& op1, ap_int_base<_AP_W2,_AP_S2>& op2) { ap_int_base<1, false> tmp(op1); tmp.operator /= (op2); op1 = tmp; return op1; }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1,_AP_S1>& operator %= ( ap_int_base<_AP_W1,_AP_S1>& op1, ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1.operator %= (ap_int_base<1, false>(op2)); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_bit_ref<_AP_W1,_AP_S1>& operator %= ( ap_bit_ref<_AP_W1,_AP_S1>& op1, ap_int_base<_AP_W2,_AP_S2>& op2) { ap_int_base<1, false> tmp(op1); tmp.operator %= (op2); op1 = tmp; return op1; }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1,_AP_S1>& operator >>= ( ap_int_base<_AP_W1,_AP_S1>& op1, ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1.operator >>= (ap_int_base<1, false>(op2)); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_bit_ref<_AP_W1,_AP_S1>& operator >>= ( ap_bit_ref<_AP_W1,_AP_S1>& op1, ap_int_base<_AP_W2,_AP_S2>& op2) { ap_int_base<1, false> tmp(op1); tmp.operator >>= (op2); op1 = tmp; return op1; }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1,_AP_S1>& operator <<= ( ap_int_base<_AP_W1,_AP_S1>& op1, ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1.operator <<= (ap_int_base<1, false>(op2)); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_bit_ref<_AP_W1,_AP_S1>& operator <<= ( ap_bit_ref<_AP_W1,_AP_S1>& op1, ap_int_base<_AP_W2,_AP_S2>& op2) { ap_int_base<1, false> tmp(op1); tmp.operator <<= (op2); op1 = tmp; return op1; }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1,_AP_S1>& operator &= ( ap_int_base<_AP_W1,_AP_S1>& op1, ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1.operator &= (ap_int_base<1, false>(op2)); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_bit_ref<_AP_W1,_AP_S1>& operator &= ( ap_bit_ref<_AP_W1,_AP_S1>& op1, ap_int_base<_AP_W2,_AP_S2>& op2) { ap_int_base<1, false> tmp(op1); tmp.operator &= (op2); op1 = tmp; return op1; }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1,_AP_S1>& operator |= ( ap_int_base<_AP_W1,_AP_S1>& op1, ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1.operator |= (ap_int_base<1, false>(op2)); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_bit_ref<_AP_W1,_AP_S1>& operator |= ( ap_bit_ref<_AP_W1,_AP_S1>& op1, ap_int_base<_AP_W2,_AP_S2>& op2) { ap_int_base<1, false> tmp(op1); tmp.operator |= (op2); op1 = tmp; return op1; }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1,_AP_S1>& operator ^= ( ap_int_base<_AP_W1,_AP_S1>& op1, ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1.operator ^= (ap_int_base<1, false>(op2)); } template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_bit_ref<_AP_W1,_AP_S1>& operator ^= ( ap_bit_ref<_AP_W1,_AP_S1>& op1, ap_int_base<_AP_W2,_AP_S2>& op2) { ap_int_base<1, false> tmp(op1); tmp.operator ^= (op2); op1 = tmp; return op1; }
#pragma empty_line
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator == ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1.operator == (ap_int_base<1, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator != ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1.operator != (ap_int_base<1, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator > ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1.operator > (ap_int_base<1, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator >= ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1.operator >= (ap_int_base<1, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator < ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1.operator < (ap_int_base<1, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator <= ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1.operator <= (ap_int_base<1, false>(op2)); }
#pragma empty_line
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<1,false>::plus operator + ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1 + (ap_int_base<1, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<1,false>::minus operator - ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1 - (ap_int_base<1, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<1,false>::mult operator * ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1 * (ap_int_base<1, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<1,false>::div operator / ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1 / (ap_int_base<1, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<1,false>::mod operator % ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1 % (ap_int_base<1, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<1,false>::arg1 operator >> ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1 >> (ap_int_base<1, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<1,false>::arg1 operator << ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1 << (ap_int_base<1, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<1,false>::logic operator & ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1 & (ap_int_base<1, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1,_AP_S1>::template RType<1,false>::logic operator | ( const ap_int_base<_AP_W1,_AP_S1>& op1, const ap_bit_ref<_AP_W2,_AP_S2>& op2) { return op1 | (ap_int_base<1, false>(op2)); }
template<int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_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)); }
#pragma line 3690 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_int_syn.h"
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_range_ref<_AP_W,_AP_S> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_bit_ref<_AP_W,_AP_S> &op, bool op2) { return (bool(op)) > op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( bool op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 > (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator > ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, bool op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator > (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_range_ref<_AP_W,_AP_S> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_bit_ref<_AP_W,_AP_S> &op, bool op2) { return (bool(op)) < op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( bool op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 < (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator < ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, bool op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator < (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_range_ref<_AP_W,_AP_S> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_bit_ref<_AP_W,_AP_S> &op, bool op2) { return (bool(op)) >= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( bool op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 >= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, bool op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator >= (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_range_ref<_AP_W,_AP_S> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_bit_ref<_AP_W,_AP_S> &op, bool op2) { return (bool(op)) <= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( bool op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 <= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, bool op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator <= (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_range_ref<_AP_W,_AP_S> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_bit_ref<_AP_W,_AP_S> &op, bool op2) { return (bool(op)) == op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( bool op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 == (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator == ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, bool op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator == (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_range_ref<_AP_W,_AP_S> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_bit_ref<_AP_W,_AP_S> &op, bool op2) { return (bool(op)) != op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( bool op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 != (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator != ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, bool op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator != (ap_int_base<1,false>(op2)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_range_ref<_AP_W,_AP_S> &op, char op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<8,(-127 -1) != 0>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_bit_ref<_AP_W,_AP_S> &op, char op2) { return (bool(op)) > op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( char op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 > (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator > ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, char op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator > (ap_int_base<8,(-127 -1) != 0>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_range_ref<_AP_W,_AP_S> &op, char op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<8,(-127 -1) != 0>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_bit_ref<_AP_W,_AP_S> &op, char op2) { return (bool(op)) < op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( char op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 < (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator < ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, char op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator < (ap_int_base<8,(-127 -1) != 0>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_range_ref<_AP_W,_AP_S> &op, char op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<8,(-127 -1) != 0>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_bit_ref<_AP_W,_AP_S> &op, char op2) { return (bool(op)) >= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( char op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 >= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, char op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator >= (ap_int_base<8,(-127 -1) != 0>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_range_ref<_AP_W,_AP_S> &op, char op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<8,(-127 -1) != 0>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_bit_ref<_AP_W,_AP_S> &op, char op2) { return (bool(op)) <= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( char op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 <= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, char op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator <= (ap_int_base<8,(-127 -1) != 0>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_range_ref<_AP_W,_AP_S> &op, char op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<8,(-127 -1) != 0>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_bit_ref<_AP_W,_AP_S> &op, char op2) { return (bool(op)) == op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( char op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 == (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator == ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, char op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator == (ap_int_base<8,(-127 -1) != 0>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_range_ref<_AP_W,_AP_S> &op, char op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<8,(-127 -1) != 0>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_bit_ref<_AP_W,_AP_S> &op, char op2) { return (bool(op)) != op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( char op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 != (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator != ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, char op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator != (ap_int_base<8,(-127 -1) != 0>(op2)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_range_ref<_AP_W,_AP_S> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_bit_ref<_AP_W,_AP_S> &op, signed char op2) { return (bool(op)) > op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( signed char op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 > (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator > ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, signed char op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator > (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_range_ref<_AP_W,_AP_S> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_bit_ref<_AP_W,_AP_S> &op, signed char op2) { return (bool(op)) < op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( signed char op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 < (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator < ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, signed char op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator < (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_range_ref<_AP_W,_AP_S> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_bit_ref<_AP_W,_AP_S> &op, signed char op2) { return (bool(op)) >= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( signed char op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 >= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, signed char op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator >= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_range_ref<_AP_W,_AP_S> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_bit_ref<_AP_W,_AP_S> &op, signed char op2) { return (bool(op)) <= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( signed char op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 <= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, signed char op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator <= (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_range_ref<_AP_W,_AP_S> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_bit_ref<_AP_W,_AP_S> &op, signed char op2) { return (bool(op)) == op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( signed char op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 == (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator == ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, signed char op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator == (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_range_ref<_AP_W,_AP_S> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_bit_ref<_AP_W,_AP_S> &op, signed char op2) { return (bool(op)) != op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( signed char op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 != (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator != ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, signed char op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator != (ap_int_base<8,true>(op2)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_bit_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (bool(op)) > op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( unsigned char op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 > (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator > ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, unsigned char op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator > (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_bit_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (bool(op)) < op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( unsigned char op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 < (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator < ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, unsigned char op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator < (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_bit_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (bool(op)) >= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( unsigned char op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 >= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, unsigned char op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator >= (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_bit_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (bool(op)) <= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( unsigned char op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 <= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, unsigned char op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator <= (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_bit_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (bool(op)) == op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( unsigned char op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 == (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator == ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, unsigned char op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator == (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_bit_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (bool(op)) != op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( unsigned char op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 != (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator != ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, unsigned char op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator != (ap_int_base<8,false>(op2)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_range_ref<_AP_W,_AP_S> &op, short op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_bit_ref<_AP_W,_AP_S> &op, short op2) { return (bool(op)) > op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( short op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 > (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator > ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, short op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator > (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_range_ref<_AP_W,_AP_S> &op, short op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_bit_ref<_AP_W,_AP_S> &op, short op2) { return (bool(op)) < op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( short op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 < (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator < ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, short op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator < (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_range_ref<_AP_W,_AP_S> &op, short op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_bit_ref<_AP_W,_AP_S> &op, short op2) { return (bool(op)) >= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( short op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 >= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, short op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator >= (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_range_ref<_AP_W,_AP_S> &op, short op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_bit_ref<_AP_W,_AP_S> &op, short op2) { return (bool(op)) <= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( short op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 <= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, short op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator <= (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_range_ref<_AP_W,_AP_S> &op, short op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_bit_ref<_AP_W,_AP_S> &op, short op2) { return (bool(op)) == op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( short op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 == (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator == ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, short op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator == (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_range_ref<_AP_W,_AP_S> &op, short op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_bit_ref<_AP_W,_AP_S> &op, short op2) { return (bool(op)) != op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( short op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 != (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator != ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, short op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator != (ap_int_base<16,true>(op2)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned short op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_bit_ref<_AP_W,_AP_S> &op, unsigned short op2) { return (bool(op)) > op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( unsigned short op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 > (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator > ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, unsigned short op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator > (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned short op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_bit_ref<_AP_W,_AP_S> &op, unsigned short op2) { return (bool(op)) < op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( unsigned short op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 < (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator < ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, unsigned short op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator < (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned short op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_bit_ref<_AP_W,_AP_S> &op, unsigned short op2) { return (bool(op)) >= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( unsigned short op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 >= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, unsigned short op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator >= (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned short op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_bit_ref<_AP_W,_AP_S> &op, unsigned short op2) { return (bool(op)) <= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( unsigned short op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 <= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, unsigned short op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator <= (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned short op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_bit_ref<_AP_W,_AP_S> &op, unsigned short op2) { return (bool(op)) == op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( unsigned short op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 == (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator == ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, unsigned short op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator == (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned short op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_bit_ref<_AP_W,_AP_S> &op, unsigned short op2) { return (bool(op)) != op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( unsigned short op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 != (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator != ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, unsigned short op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator != (ap_int_base<16,false>(op2)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_range_ref<_AP_W,_AP_S> &op, int op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_bit_ref<_AP_W,_AP_S> &op, int op2) { return (bool(op)) > op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( int op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 > (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator > ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, int op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator > (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_range_ref<_AP_W,_AP_S> &op, int op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_bit_ref<_AP_W,_AP_S> &op, int op2) { return (bool(op)) < op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( int op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 < (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator < ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, int op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator < (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_range_ref<_AP_W,_AP_S> &op, int op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_bit_ref<_AP_W,_AP_S> &op, int op2) { return (bool(op)) >= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( int op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 >= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, int op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator >= (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_range_ref<_AP_W,_AP_S> &op, int op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_bit_ref<_AP_W,_AP_S> &op, int op2) { return (bool(op)) <= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( int op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 <= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, int op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator <= (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_range_ref<_AP_W,_AP_S> &op, int op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_bit_ref<_AP_W,_AP_S> &op, int op2) { return (bool(op)) == op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( int op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 == (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator == ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, int op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator == (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_range_ref<_AP_W,_AP_S> &op, int op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_bit_ref<_AP_W,_AP_S> &op, int op2) { return (bool(op)) != op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( int op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 != (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator != ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, int op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator != (ap_int_base<32,true>(op2)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned int op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_bit_ref<_AP_W,_AP_S> &op, unsigned int op2) { return (bool(op)) > op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( unsigned int op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 > (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator > ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, unsigned int op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator > (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned int op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_bit_ref<_AP_W,_AP_S> &op, unsigned int op2) { return (bool(op)) < op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( unsigned int op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 < (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator < ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, unsigned int op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator < (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned int op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_bit_ref<_AP_W,_AP_S> &op, unsigned int op2) { return (bool(op)) >= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( unsigned int op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 >= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, unsigned int op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator >= (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned int op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_bit_ref<_AP_W,_AP_S> &op, unsigned int op2) { return (bool(op)) <= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( unsigned int op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 <= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, unsigned int op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator <= (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned int op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_bit_ref<_AP_W,_AP_S> &op, unsigned int op2) { return (bool(op)) == op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( unsigned int op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 == (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator == ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, unsigned int op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator == (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned int op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_bit_ref<_AP_W,_AP_S> &op, unsigned int op2) { return (bool(op)) != op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( unsigned int op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 != (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator != ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, unsigned int op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator != (ap_int_base<32,false>(op2)); }
#pragma empty_line
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_range_ref<_AP_W,_AP_S> &op, long op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_bit_ref<_AP_W,_AP_S> &op, long op2) { return (bool(op)) > op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( long op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 > (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator > ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, long op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator > (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_range_ref<_AP_W,_AP_S> &op, long op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_bit_ref<_AP_W,_AP_S> &op, long op2) { return (bool(op)) < op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( long op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 < (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator < ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, long op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator < (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_range_ref<_AP_W,_AP_S> &op, long op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_bit_ref<_AP_W,_AP_S> &op, long op2) { return (bool(op)) >= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( long op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 >= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, long op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator >= (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_range_ref<_AP_W,_AP_S> &op, long op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_bit_ref<_AP_W,_AP_S> &op, long op2) { return (bool(op)) <= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( long op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 <= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, long op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator <= (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_range_ref<_AP_W,_AP_S> &op, long op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_bit_ref<_AP_W,_AP_S> &op, long op2) { return (bool(op)) == op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( long op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 == (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator == ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, long op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator == (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_range_ref<_AP_W,_AP_S> &op, long op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_bit_ref<_AP_W,_AP_S> &op, long op2) { return (bool(op)) != op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( long op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 != (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator != ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, long op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator != (ap_int_base<64,true>(op2)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned long op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_bit_ref<_AP_W,_AP_S> &op, unsigned long op2) { return (bool(op)) > op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( unsigned long op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 > (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator > ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, unsigned long op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator > (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned long op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_bit_ref<_AP_W,_AP_S> &op, unsigned long op2) { return (bool(op)) < op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( unsigned long op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 < (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator < ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, unsigned long op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator < (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned long op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_bit_ref<_AP_W,_AP_S> &op, unsigned long op2) { return (bool(op)) >= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( unsigned long op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 >= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, unsigned long op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator >= (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned long op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_bit_ref<_AP_W,_AP_S> &op, unsigned long op2) { return (bool(op)) <= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( unsigned long op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 <= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, unsigned long op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator <= (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned long op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_bit_ref<_AP_W,_AP_S> &op, unsigned long op2) { return (bool(op)) == op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( unsigned long op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 == (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator == ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, unsigned long op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator == (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned long op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_bit_ref<_AP_W,_AP_S> &op, unsigned long op2) { return (bool(op)) != op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( unsigned long op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 != (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator != ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, unsigned long op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator != (ap_int_base<64,false>(op2)); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_range_ref<_AP_W,_AP_S> &op, ap_slong op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_bit_ref<_AP_W,_AP_S> &op, ap_slong op2) { return (bool(op)) > op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( ap_slong op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 > (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator > ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, ap_slong op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator > (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_range_ref<_AP_W,_AP_S> &op, ap_slong op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_bit_ref<_AP_W,_AP_S> &op, ap_slong op2) { return (bool(op)) < op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( ap_slong op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 < (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator < ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, ap_slong op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator < (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_range_ref<_AP_W,_AP_S> &op, ap_slong op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_bit_ref<_AP_W,_AP_S> &op, ap_slong op2) { return (bool(op)) >= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( ap_slong op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 >= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, ap_slong op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator >= (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_range_ref<_AP_W,_AP_S> &op, ap_slong op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_bit_ref<_AP_W,_AP_S> &op, ap_slong op2) { return (bool(op)) <= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( ap_slong op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 <= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, ap_slong op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator <= (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_range_ref<_AP_W,_AP_S> &op, ap_slong op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_bit_ref<_AP_W,_AP_S> &op, ap_slong op2) { return (bool(op)) == op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( ap_slong op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 == (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator == ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, ap_slong op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator == (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_range_ref<_AP_W,_AP_S> &op, ap_slong op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_bit_ref<_AP_W,_AP_S> &op, ap_slong op2) { return (bool(op)) != op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( ap_slong op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 != (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator != ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, ap_slong op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator != (ap_int_base<64,true>(op2)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_range_ref<_AP_W,_AP_S> &op, ap_ulong op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( const ap_bit_ref<_AP_W,_AP_S> &op, ap_ulong op2) { return (bool(op)) > op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator > ( ap_ulong op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 > (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator > ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, ap_ulong op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator > (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_range_ref<_AP_W,_AP_S> &op, ap_ulong op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( const ap_bit_ref<_AP_W,_AP_S> &op, ap_ulong op2) { return (bool(op)) < op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator < ( ap_ulong op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 < (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator < ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, ap_ulong op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator < (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_range_ref<_AP_W,_AP_S> &op, ap_ulong op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( const ap_bit_ref<_AP_W,_AP_S> &op, ap_ulong op2) { return (bool(op)) >= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >= ( ap_ulong op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 >= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, ap_ulong op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator >= (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_range_ref<_AP_W,_AP_S> &op, ap_ulong op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( const ap_bit_ref<_AP_W,_AP_S> &op, ap_ulong op2) { return (bool(op)) <= op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <= ( ap_ulong op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 <= (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <= ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, ap_ulong op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator <= (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_range_ref<_AP_W,_AP_S> &op, ap_ulong op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( const ap_bit_ref<_AP_W,_AP_S> &op, ap_ulong op2) { return (bool(op)) == op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( ap_ulong op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 == (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator == ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, ap_ulong op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator == (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_range_ref<_AP_W,_AP_S> &op, ap_ulong op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( const ap_bit_ref<_AP_W,_AP_S> &op, ap_ulong op2) { return (bool(op)) != op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator != ( ap_ulong op2, const ap_bit_ref<_AP_W,_AP_S> &op) { return op2 != (bool(op)); } template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator != ( const ap_concat_ref<_AP_W,_AP_T, _AP_W1, _AP_T1> &op, ap_ulong op2) { return (ap_int_base<_AP_W + _AP_W1, false>(op)).operator != (ap_int_base<64,false>(op2)); }
#pragma line 3732 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_int_syn.h"
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<1,false>::plus operator + ( const ap_range_ref<_AP_W,_AP_S> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)) + (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<1,false>::template RType<_AP_W,false>::plus operator + ( bool op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<1,false>(op2) + (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<1,false>::minus operator - ( const ap_range_ref<_AP_W,_AP_S> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)) - (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<1,false>::template RType<_AP_W,false>::minus operator - ( bool op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<1,false>(op2) - (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<1,false>::mult operator * ( const ap_range_ref<_AP_W,_AP_S> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)) * (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<1,false>::template RType<_AP_W,false>::mult operator * ( bool op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<1,false>(op2) * (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<1,false>::div operator / ( const ap_range_ref<_AP_W,_AP_S> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)) / (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<1,false>::template RType<_AP_W,false>::div operator / ( bool op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<1,false>(op2) / (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<1,false>::mod operator % ( const ap_range_ref<_AP_W,_AP_S> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)) % (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<1,false>::template RType<_AP_W,false>::mod operator % ( bool op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<1,false>(op2) % (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<1,false>::arg1 operator >> ( const ap_range_ref<_AP_W,_AP_S> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)) >> (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<1,false>::template RType<_AP_W,false>::arg1 operator >> ( bool op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<1,false>(op2) >> (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<1,false>::arg1 operator << ( const ap_range_ref<_AP_W,_AP_S> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)) << (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<1,false>::template RType<_AP_W,false>::arg1 operator << ( bool op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<1,false>(op2) << (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<1,false>::logic operator & ( const ap_range_ref<_AP_W,_AP_S> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)) & (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<1,false>::template RType<_AP_W,false>::logic operator & ( bool op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<1,false>(op2) & (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<1,false>::logic operator | ( const ap_range_ref<_AP_W,_AP_S> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)) | (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<1,false>::template RType<_AP_W,false>::logic operator | ( bool op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<1,false>(op2) | (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<1,false>::logic operator ^ ( const ap_range_ref<_AP_W,_AP_S> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)) ^ (ap_int_base<1,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<1,false>::template RType<_AP_W,false>::logic operator ^ ( bool op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<1,false>(op2) ^ (ap_int_base<_AP_W, false>(op)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,(-127 -1) != 0>::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,(-127 -1) != 0>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,(-127 -1) != 0>::template RType<_AP_W,false>::plus operator + ( char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,(-127 -1) != 0>(op2) + (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,(-127 -1) != 0>::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,(-127 -1) != 0>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,(-127 -1) != 0>::template RType<_AP_W,false>::minus operator - ( char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,(-127 -1) != 0>(op2) - (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,(-127 -1) != 0>::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,(-127 -1) != 0>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,(-127 -1) != 0>::template RType<_AP_W,false>::mult operator * ( char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,(-127 -1) != 0>(op2) * (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,(-127 -1) != 0>::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,(-127 -1) != 0>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,(-127 -1) != 0>::template RType<_AP_W,false>::div operator / ( char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,(-127 -1) != 0>(op2) / (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,(-127 -1) != 0>::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,(-127 -1) != 0>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,(-127 -1) != 0>::template RType<_AP_W,false>::mod operator % ( char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,(-127 -1) != 0>(op2) % (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,(-127 -1) != 0>::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,(-127 -1) != 0>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,(-127 -1) != 0>::template RType<_AP_W,false>::arg1 operator >> ( char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,(-127 -1) != 0>(op2) >> (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,(-127 -1) != 0>::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,(-127 -1) != 0>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,(-127 -1) != 0>::template RType<_AP_W,false>::arg1 operator << ( char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,(-127 -1) != 0>(op2) << (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,(-127 -1) != 0>::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,(-127 -1) != 0>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,(-127 -1) != 0>::template RType<_AP_W,false>::logic operator & ( char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,(-127 -1) != 0>(op2) & (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,(-127 -1) != 0>::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,(-127 -1) != 0>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,(-127 -1) != 0>::template RType<_AP_W,false>::logic operator | ( char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,(-127 -1) != 0>(op2) | (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,(-127 -1) != 0>::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,(-127 -1) != 0>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,(-127 -1) != 0>::template RType<_AP_W,false>::logic operator ^ ( char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,(-127 -1) != 0>(op2) ^ (ap_int_base<_AP_W, false>(op)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,true>::plus operator + ( const ap_range_ref<_AP_W,_AP_S> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)) + (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,true>::template RType<_AP_W,false>::plus operator + ( signed char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(op2) + (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,true>::minus operator - ( const ap_range_ref<_AP_W,_AP_S> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)) - (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,true>::template RType<_AP_W,false>::minus operator - ( signed char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(op2) - (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,true>::mult operator * ( const ap_range_ref<_AP_W,_AP_S> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)) * (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,true>::template RType<_AP_W,false>::mult operator * ( signed char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(op2) * (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,true>::div operator / ( const ap_range_ref<_AP_W,_AP_S> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)) / (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,true>::template RType<_AP_W,false>::div operator / ( signed char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(op2) / (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,true>::mod operator % ( const ap_range_ref<_AP_W,_AP_S> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)) % (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,true>::template RType<_AP_W,false>::mod operator % ( signed char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(op2) % (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,true>::arg1 operator >> ( const ap_range_ref<_AP_W,_AP_S> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)) >> (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,true>::template RType<_AP_W,false>::arg1 operator >> ( signed char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(op2) >> (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,true>::arg1 operator << ( const ap_range_ref<_AP_W,_AP_S> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)) << (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,true>::template RType<_AP_W,false>::arg1 operator << ( signed char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(op2) << (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,true>::logic operator & ( const ap_range_ref<_AP_W,_AP_S> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)) & (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,true>::template RType<_AP_W,false>::logic operator & ( signed char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(op2) & (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,true>::logic operator | ( const ap_range_ref<_AP_W,_AP_S> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)) | (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,true>::template RType<_AP_W,false>::logic operator | ( signed char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(op2) | (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,true>::logic operator ^ ( const ap_range_ref<_AP_W,_AP_S> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)) ^ (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,true>::template RType<_AP_W,false>::logic operator ^ ( signed char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(op2) ^ (ap_int_base<_AP_W, false>(op)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,false>::plus operator + ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)) + (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,false>::template RType<_AP_W,false>::plus operator + ( unsigned char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(op2) + (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,false>::minus operator - ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)) - (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,false>::template RType<_AP_W,false>::minus operator - ( unsigned char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(op2) - (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,false>::mult operator * ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)) * (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,false>::template RType<_AP_W,false>::mult operator * ( unsigned char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(op2) * (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,false>::div operator / ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)) / (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,false>::template RType<_AP_W,false>::div operator / ( unsigned char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(op2) / (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,false>::mod operator % ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)) % (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,false>::template RType<_AP_W,false>::mod operator % ( unsigned char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(op2) % (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,false>::arg1 operator >> ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)) >> (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,false>::template RType<_AP_W,false>::arg1 operator >> ( unsigned char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(op2) >> (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,false>::arg1 operator << ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)) << (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,false>::template RType<_AP_W,false>::arg1 operator << ( unsigned char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(op2) << (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,false>::logic operator & ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)) & (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,false>::template RType<_AP_W,false>::logic operator & ( unsigned char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(op2) & (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,false>::logic operator | ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)) | (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,false>::template RType<_AP_W,false>::logic operator | ( unsigned char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(op2) | (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,false>::logic operator ^ ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)) ^ (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,false>::template RType<_AP_W,false>::logic operator ^ ( unsigned char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(op2) ^ (ap_int_base<_AP_W, false>(op)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<16,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<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<16,true>::template RType<_AP_W,false>::plus operator + ( short op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<16,true>(op2) + (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<16,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<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<16,true>::template RType<_AP_W,false>::minus operator - ( short op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<16,true>(op2) - (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<16,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<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<16,true>::template RType<_AP_W,false>::mult operator * ( short op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<16,true>(op2) * (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<16,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<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<16,true>::template RType<_AP_W,false>::div operator / ( short op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<16,true>(op2) / (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<16,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<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<16,true>::template RType<_AP_W,false>::mod operator % ( short op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<16,true>(op2) % (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<16,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<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<16,true>::template RType<_AP_W,false>::arg1 operator >> ( short op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<16,true>(op2) >> (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<16,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<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<16,true>::template RType<_AP_W,false>::arg1 operator << ( short op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<16,true>(op2) << (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<16,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<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<16,true>::template RType<_AP_W,false>::logic operator & ( short op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<16,true>(op2) & (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<16,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<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<16,true>::template RType<_AP_W,false>::logic operator | ( short op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<16,true>(op2) | (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<16,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<16,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<16,true>::template RType<_AP_W,false>::logic operator ^ ( short op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<16,true>(op2) ^ (ap_int_base<_AP_W, false>(op)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<16,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<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<16,false>::template RType<_AP_W,false>::plus operator + ( unsigned short op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<16,false>(op2) + (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<16,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<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<16,false>::template RType<_AP_W,false>::minus operator - ( unsigned short op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<16,false>(op2) - (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<16,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<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<16,false>::template RType<_AP_W,false>::mult operator * ( unsigned short op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<16,false>(op2) * (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<16,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<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<16,false>::template RType<_AP_W,false>::div operator / ( unsigned short op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<16,false>(op2) / (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<16,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<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<16,false>::template RType<_AP_W,false>::mod operator % ( unsigned short op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<16,false>(op2) % (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<16,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<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<16,false>::template RType<_AP_W,false>::arg1 operator >> ( unsigned short op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<16,false>(op2) >> (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<16,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<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<16,false>::template RType<_AP_W,false>::arg1 operator << ( unsigned short op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<16,false>(op2) << (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<16,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<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<16,false>::template RType<_AP_W,false>::logic operator & ( unsigned short op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<16,false>(op2) & (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<16,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<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<16,false>::template RType<_AP_W,false>::logic operator | ( unsigned short op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<16,false>(op2) | (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<16,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<16,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<16,false>::template RType<_AP_W,false>::logic operator ^ ( unsigned short op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<16,false>(op2) ^ (ap_int_base<_AP_W, false>(op)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<32,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<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<32,true>::template RType<_AP_W,false>::plus operator + ( int op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<32,true>(op2) + (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<32,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<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<32,true>::template RType<_AP_W,false>::minus operator - ( int op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<32,true>(op2) - (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<32,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<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<32,true>::template RType<_AP_W,false>::mult operator * ( int op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<32,true>(op2) * (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<32,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<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<32,true>::template RType<_AP_W,false>::div operator / ( int op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<32,true>(op2) / (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<32,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<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<32,true>::template RType<_AP_W,false>::mod operator % ( int op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<32,true>(op2) % (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<32,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<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<32,true>::template RType<_AP_W,false>::arg1 operator >> ( int op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<32,true>(op2) >> (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<32,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<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<32,true>::template RType<_AP_W,false>::arg1 operator << ( int op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<32,true>(op2) << (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<32,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<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<32,true>::template RType<_AP_W,false>::logic operator & ( int op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<32,true>(op2) & (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<32,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<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<32,true>::template RType<_AP_W,false>::logic operator | ( int op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<32,true>(op2) | (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<32,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<32,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<32,true>::template RType<_AP_W,false>::logic operator ^ ( int op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<32,true>(op2) ^ (ap_int_base<_AP_W, false>(op)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<32,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<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<32,false>::template RType<_AP_W,false>::plus operator + ( unsigned int op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<32,false>(op2) + (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<32,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<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<32,false>::template RType<_AP_W,false>::minus operator - ( unsigned int op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<32,false>(op2) - (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<32,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<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<32,false>::template RType<_AP_W,false>::mult operator * ( unsigned int op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<32,false>(op2) * (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<32,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<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<32,false>::template RType<_AP_W,false>::div operator / ( unsigned int op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<32,false>(op2) / (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<32,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<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<32,false>::template RType<_AP_W,false>::mod operator % ( unsigned int op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<32,false>(op2) % (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<32,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<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<32,false>::template RType<_AP_W,false>::arg1 operator >> ( unsigned int op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<32,false>(op2) >> (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<32,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<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<32,false>::template RType<_AP_W,false>::arg1 operator << ( unsigned int op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<32,false>(op2) << (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<32,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<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<32,false>::template RType<_AP_W,false>::logic operator & ( unsigned int op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<32,false>(op2) & (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<32,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<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<32,false>::template RType<_AP_W,false>::logic operator | ( unsigned int op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<32,false>(op2) | (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<32,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<32,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<32,false>::template RType<_AP_W,false>::logic operator ^ ( unsigned int op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<32,false>(op2) ^ (ap_int_base<_AP_W, false>(op)); }
#pragma empty_line
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,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<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,true>::template RType<_AP_W,false>::plus operator + ( long op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(op2) + (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,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<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,true>::template RType<_AP_W,false>::minus operator - ( long op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(op2) - (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,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<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,true>::template RType<_AP_W,false>::mult operator * ( long op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(op2) * (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,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<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,true>::template RType<_AP_W,false>::div operator / ( long op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(op2) / (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,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<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,true>::template RType<_AP_W,false>::mod operator % ( long op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(op2) % (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,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<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,true>::template RType<_AP_W,false>::arg1 operator >> ( long op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(op2) >> (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,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<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,true>::template RType<_AP_W,false>::arg1 operator << ( long op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(op2) << (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,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<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,true>::template RType<_AP_W,false>::logic operator & ( long op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(op2) & (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,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<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,true>::template RType<_AP_W,false>::logic operator | ( long op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(op2) | (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,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<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,true>::template RType<_AP_W,false>::logic operator ^ ( long op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(op2) ^ (ap_int_base<_AP_W, false>(op)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,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<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,false>::template RType<_AP_W,false>::plus operator + ( unsigned long op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(op2) + (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,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<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,false>::template RType<_AP_W,false>::minus operator - ( unsigned long op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(op2) - (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,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<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,false>::template RType<_AP_W,false>::mult operator * ( unsigned long op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(op2) * (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,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<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,false>::template RType<_AP_W,false>::div operator / ( unsigned long op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(op2) / (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,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<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,false>::template RType<_AP_W,false>::mod operator % ( unsigned long op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(op2) % (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,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<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,false>::template RType<_AP_W,false>::arg1 operator >> ( unsigned long op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(op2) >> (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,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<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,false>::template RType<_AP_W,false>::arg1 operator << ( unsigned long op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(op2) << (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,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<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,false>::template RType<_AP_W,false>::logic operator & ( unsigned long op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(op2) & (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,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<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,false>::template RType<_AP_W,false>::logic operator | ( unsigned long op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(op2) | (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,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<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,false>::template RType<_AP_W,false>::logic operator ^ ( unsigned long op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(op2) ^ (ap_int_base<_AP_W, false>(op)); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,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<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,true>::template RType<_AP_W,false>::plus operator + ( ap_slong op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(op2) + (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,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<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,true>::template RType<_AP_W,false>::minus operator - ( ap_slong op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(op2) - (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,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<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,true>::template RType<_AP_W,false>::mult operator * ( ap_slong op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(op2) * (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,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<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,true>::template RType<_AP_W,false>::div operator / ( ap_slong op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(op2) / (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,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<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,true>::template RType<_AP_W,false>::mod operator % ( ap_slong op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(op2) % (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,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<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,true>::template RType<_AP_W,false>::arg1 operator >> ( ap_slong op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(op2) >> (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,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<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,true>::template RType<_AP_W,false>::arg1 operator << ( ap_slong op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(op2) << (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,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<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,true>::template RType<_AP_W,false>::logic operator & ( ap_slong op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(op2) & (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,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<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,true>::template RType<_AP_W,false>::logic operator | ( ap_slong op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(op2) | (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,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<64,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,true>::template RType<_AP_W,false>::logic operator ^ ( ap_slong op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,true>(op2) ^ (ap_int_base<_AP_W, false>(op)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,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<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,false>::template RType<_AP_W,false>::plus operator + ( ap_ulong op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(op2) + (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,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<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,false>::template RType<_AP_W,false>::minus operator - ( ap_ulong op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(op2) - (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,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<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,false>::template RType<_AP_W,false>::mult operator * ( ap_ulong op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(op2) * (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,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<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,false>::template RType<_AP_W,false>::div operator / ( ap_ulong op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(op2) / (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,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<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,false>::template RType<_AP_W,false>::mod operator % ( ap_ulong op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(op2) % (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,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<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,false>::template RType<_AP_W,false>::arg1 operator >> ( ap_ulong op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(op2) >> (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,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<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,false>::template RType<_AP_W,false>::arg1 operator << ( ap_ulong op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(op2) << (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,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<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,false>::template RType<_AP_W,false>::logic operator & ( ap_ulong op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(op2) & (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,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<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,false>::template RType<_AP_W,false>::logic operator | ( ap_ulong op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(op2) | (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<64,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<64,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<64,false>::template RType<_AP_W,false>::logic operator ^ ( ap_ulong op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<64,false>(op2) ^ (ap_int_base<_AP_W, false>(op)); }
#pragma line 3757 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_int_syn.h"
template<int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<_AP_W2, false>::plus operator + (const ap_range_ref<_AP_W,_AP_S> &lhs, const ap_range_ref<_AP_W2,_AP_S2> &rhs) { return ap_int_base<_AP_W, false>(lhs) + (ap_int_base<_AP_W2, false>(rhs)); }
template<int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<_AP_W2, false>::minus operator - (const ap_range_ref<_AP_W,_AP_S> &lhs, const ap_range_ref<_AP_W2,_AP_S2> &rhs) { return ap_int_base<_AP_W, false>(lhs) - (ap_int_base<_AP_W2, false>(rhs)); }
template<int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<_AP_W2, false>::mult operator * (const ap_range_ref<_AP_W,_AP_S> &lhs, const ap_range_ref<_AP_W2,_AP_S2> &rhs) { return ap_int_base<_AP_W, false>(lhs) * (ap_int_base<_AP_W2, false>(rhs)); }
template<int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<_AP_W2, false>::div operator / (const ap_range_ref<_AP_W,_AP_S> &lhs, const ap_range_ref<_AP_W2,_AP_S2> &rhs) { return ap_int_base<_AP_W, false>(lhs) / (ap_int_base<_AP_W2, false>(rhs)); }
template<int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<_AP_W2, false>::mod operator % (const ap_range_ref<_AP_W,_AP_S> &lhs, const ap_range_ref<_AP_W2,_AP_S2> &rhs) { return ap_int_base<_AP_W, false>(lhs) % (ap_int_base<_AP_W2, false>(rhs)); }
template<int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<_AP_W2, false>::arg1 operator >> (const ap_range_ref<_AP_W,_AP_S> &lhs, const ap_range_ref<_AP_W2,_AP_S2> &rhs) { return ap_int_base<_AP_W, false>(lhs) >> (ap_int_base<_AP_W2, false>(rhs)); }
template<int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<_AP_W2, false>::arg1 operator << (const ap_range_ref<_AP_W,_AP_S> &lhs, const ap_range_ref<_AP_W2,_AP_S2> &rhs) { return ap_int_base<_AP_W, false>(lhs) << (ap_int_base<_AP_W2, false>(rhs)); }
template<int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<_AP_W2, false>::logic operator & (const ap_range_ref<_AP_W,_AP_S> &lhs, const ap_range_ref<_AP_W2,_AP_S2> &rhs) { return ap_int_base<_AP_W, false>(lhs) & (ap_int_base<_AP_W2, false>(rhs)); }
template<int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<_AP_W2, false>::logic operator | (const ap_range_ref<_AP_W,_AP_S> &lhs, const ap_range_ref<_AP_W2,_AP_S2> &rhs) { return ap_int_base<_AP_W, false>(lhs) | (ap_int_base<_AP_W2, false>(rhs)); }
template<int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<_AP_W2, false>::logic operator ^ (const ap_range_ref<_AP_W,_AP_S> &lhs, const ap_range_ref<_AP_W2,_AP_S2> &rhs) { return ap_int_base<_AP_W, false>(lhs) ^ (ap_int_base<_AP_W2, false>(rhs)); }
#pragma line 3909 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_int_syn.h"
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 1, false > operator, (const ap_int_base<_AP_W, _AP_S> &op1, bool op2) { ap_int_base<1 + _AP_W, false> val(op2); ap_int_base<1 + _AP_W, false> ret(op1); ret <<= 1; if (false) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret;} template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 1, false > operator, (bool op1, const ap_int_base<_AP_W, _AP_S>& op2) { ap_int_base<1 + _AP_W, false> val(op1); ap_int_base<1 + _AP_W, false> ret(op2); if (_AP_S) { ret <<= 1; ret >>= 1; } ret |= val << _AP_W; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 1, false > operator, (const ap_range_ref<_AP_W, _AP_S> &op1, bool op2) { ap_int_base<1 + _AP_W, false> val(op2); ap_int_base<1 + _AP_W, false> ret(op1); ret <<= 1; if (false) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 1, false > operator, (bool op1, const ap_range_ref<_AP_W, _AP_S> &op2) { ap_int_base<1 + _AP_W, false> val(op1); ap_int_base<1 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<1 + 1, false > operator, (const ap_bit_ref<_AP_W, _AP_S> &op1, bool op2) { ap_int_base<1 + 1, false> val(op2); val[1] = op1; return val; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<1 + 1, false > operator, (bool op1, const ap_bit_ref<_AP_W, _AP_S> &op2) { ap_int_base<1 + 1, false> val(op1); val <<= 1; val[0] = op2; return val; } template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 1, false > operator, (const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op1, bool op2) { ap_int_base<1 + _AP_W + _AP_W2, false> val(op2); ap_int_base<1 + _AP_W + _AP_W2, false> ret(op1); if (false) { val <<= _AP_W + _AP_W2; val >>= _AP_W + _AP_W2; } ret <<= 1; ret |= val; return ret; }template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 1, false > operator, (bool op1, const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op2) { ap_int_base<1 + _AP_W + _AP_W2, false> val(op1); ap_int_base<1 + _AP_W + _AP_W2, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; }template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 1, false > operator, (const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, bool op2) { ap_int_base<1 + _AP_W, false> val(op2); ap_int_base<1 + _AP_W, false> ret(op1); if (false) { val <<= _AP_W; val >>= _AP_W; } ret <<= 1; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 1, false > operator, (bool op1, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<1 + _AP_W, false> val(op1); ap_int_base<1 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 1, false> operator, (const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, bool op2) { ap_int_base<1 + 1, false> val(op2); val[1] = op1; return val; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 1, false> operator, (bool op1, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<1 + 1, false> val(op1); val <<= 1; val[0] = op2; return val; }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 8, false > operator, (const ap_int_base<_AP_W, _AP_S> &op1, char op2) { ap_int_base<8 + _AP_W, false> val(op2); ap_int_base<8 + _AP_W, false> ret(op1); ret <<= 8; if ((-127 -1) != 0) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret;} template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 8, false > operator, (char op1, const ap_int_base<_AP_W, _AP_S>& op2) { ap_int_base<8 + _AP_W, false> val(op1); ap_int_base<8 + _AP_W, false> ret(op2); if (_AP_S) { ret <<= 8; ret >>= 8; } ret |= val << _AP_W; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 8, false > operator, (const ap_range_ref<_AP_W, _AP_S> &op1, char op2) { ap_int_base<8 + _AP_W, false> val(op2); ap_int_base<8 + _AP_W, false> ret(op1); ret <<= 8; if ((-127 -1) != 0) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 8, false > operator, (char op1, const ap_range_ref<_AP_W, _AP_S> &op2) { ap_int_base<8 + _AP_W, false> val(op1); ap_int_base<8 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<8 + 1, false > operator, (const ap_bit_ref<_AP_W, _AP_S> &op1, char op2) { ap_int_base<8 + 1, false> val(op2); val[8] = op1; return val; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<8 + 1, false > operator, (char op1, const ap_bit_ref<_AP_W, _AP_S> &op2) { ap_int_base<8 + 1, false> val(op1); val <<= 1; val[0] = op2; return val; } template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 8, false > operator, (const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op1, char op2) { ap_int_base<8 + _AP_W + _AP_W2, (-127 -1) != 0> val(op2); ap_int_base<8 + _AP_W + _AP_W2, (-127 -1) != 0> ret(op1); if ((-127 -1) != 0) { val <<= _AP_W + _AP_W2; val >>= _AP_W + _AP_W2; } ret <<= 8; ret |= val; return ret; }template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 8, false > operator, (char op1, const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op2) { ap_int_base<8 + _AP_W + _AP_W2, (-127 -1) != 0> val(op1); ap_int_base<8 + _AP_W + _AP_W2, (-127 -1) != 0> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; }template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 8, false > operator, (const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, char op2) { ap_int_base<8 + _AP_W, false> val(op2); ap_int_base<8 + _AP_W, false> ret(op1); if ((-127 -1) != 0) { val <<= _AP_W; val >>= _AP_W; } ret <<= 8; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 8, false > operator, (char op1, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<8 + _AP_W, false> val(op1); ap_int_base<8 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 8, false> operator, (const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, char op2) { ap_int_base<8 + 1, (-127 -1) != 0> val(op2); val[8] = op1; return val; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 8, false> operator, (char op1, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<8 + 1, (-127 -1) != 0> val(op1); val <<= 1; val[0] = op2; return val; }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 8, false > operator, (const ap_int_base<_AP_W, _AP_S> &op1, signed char op2) { ap_int_base<8 + _AP_W, false> val(op2); ap_int_base<8 + _AP_W, false> ret(op1); ret <<= 8; if (true) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret;} template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 8, false > operator, (signed char op1, const ap_int_base<_AP_W, _AP_S>& op2) { ap_int_base<8 + _AP_W, false> val(op1); ap_int_base<8 + _AP_W, false> ret(op2); if (_AP_S) { ret <<= 8; ret >>= 8; } ret |= val << _AP_W; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 8, false > operator, (const ap_range_ref<_AP_W, _AP_S> &op1, signed char op2) { ap_int_base<8 + _AP_W, false> val(op2); ap_int_base<8 + _AP_W, false> ret(op1); ret <<= 8; if (true) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 8, false > operator, (signed char op1, const ap_range_ref<_AP_W, _AP_S> &op2) { ap_int_base<8 + _AP_W, false> val(op1); ap_int_base<8 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<8 + 1, false > operator, (const ap_bit_ref<_AP_W, _AP_S> &op1, signed char op2) { ap_int_base<8 + 1, false> val(op2); val[8] = op1; return val; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<8 + 1, false > operator, (signed char op1, const ap_bit_ref<_AP_W, _AP_S> &op2) { ap_int_base<8 + 1, false> val(op1); val <<= 1; val[0] = op2; return val; } template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 8, false > operator, (const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op1, signed char op2) { ap_int_base<8 + _AP_W + _AP_W2, true> val(op2); ap_int_base<8 + _AP_W + _AP_W2, true> ret(op1); if (true) { val <<= _AP_W + _AP_W2; val >>= _AP_W + _AP_W2; } ret <<= 8; ret |= val; return ret; }template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 8, false > operator, (signed char op1, const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op2) { ap_int_base<8 + _AP_W + _AP_W2, true> val(op1); ap_int_base<8 + _AP_W + _AP_W2, true> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; }template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 8, false > operator, (const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, signed char op2) { ap_int_base<8 + _AP_W, false> val(op2); ap_int_base<8 + _AP_W, false> ret(op1); if (true) { val <<= _AP_W; val >>= _AP_W; } ret <<= 8; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 8, false > operator, (signed char op1, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<8 + _AP_W, false> val(op1); ap_int_base<8 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 8, false> operator, (const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, signed char op2) { ap_int_base<8 + 1, true> val(op2); val[8] = op1; return val; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 8, false> operator, (signed char op1, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<8 + 1, true> val(op1); val <<= 1; val[0] = op2; return val; }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 8, false > operator, (const ap_int_base<_AP_W, _AP_S> &op1, unsigned char op2) { ap_int_base<8 + _AP_W, false> val(op2); ap_int_base<8 + _AP_W, false> ret(op1); ret <<= 8; if (false) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret;} template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 8, false > operator, (unsigned char op1, const ap_int_base<_AP_W, _AP_S>& op2) { ap_int_base<8 + _AP_W, false> val(op1); ap_int_base<8 + _AP_W, false> ret(op2); if (_AP_S) { ret <<= 8; ret >>= 8; } ret |= val << _AP_W; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 8, false > operator, (const ap_range_ref<_AP_W, _AP_S> &op1, unsigned char op2) { ap_int_base<8 + _AP_W, false> val(op2); ap_int_base<8 + _AP_W, false> ret(op1); ret <<= 8; if (false) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 8, false > operator, (unsigned char op1, const ap_range_ref<_AP_W, _AP_S> &op2) { ap_int_base<8 + _AP_W, false> val(op1); ap_int_base<8 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<8 + 1, false > operator, (const ap_bit_ref<_AP_W, _AP_S> &op1, unsigned char op2) { ap_int_base<8 + 1, false> val(op2); val[8] = op1; return val; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<8 + 1, false > operator, (unsigned char op1, const ap_bit_ref<_AP_W, _AP_S> &op2) { ap_int_base<8 + 1, false> val(op1); val <<= 1; val[0] = op2; return val; } template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 8, false > operator, (const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op1, unsigned char op2) { ap_int_base<8 + _AP_W + _AP_W2, false> val(op2); ap_int_base<8 + _AP_W + _AP_W2, false> ret(op1); if (false) { val <<= _AP_W + _AP_W2; val >>= _AP_W + _AP_W2; } ret <<= 8; ret |= val; return ret; }template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 8, false > operator, (unsigned char op1, const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op2) { ap_int_base<8 + _AP_W + _AP_W2, false> val(op1); ap_int_base<8 + _AP_W + _AP_W2, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; }template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 8, false > operator, (const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, unsigned char op2) { ap_int_base<8 + _AP_W, false> val(op2); ap_int_base<8 + _AP_W, false> ret(op1); if (false) { val <<= _AP_W; val >>= _AP_W; } ret <<= 8; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 8, false > operator, (unsigned char op1, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<8 + _AP_W, false> val(op1); ap_int_base<8 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 8, false> operator, (const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, unsigned char op2) { ap_int_base<8 + 1, false> val(op2); val[8] = op1; return val; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 8, false> operator, (unsigned char op1, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<8 + 1, false> val(op1); val <<= 1; val[0] = op2; return val; }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 16, false > operator, (const ap_int_base<_AP_W, _AP_S> &op1, short op2) { ap_int_base<16 + _AP_W, false> val(op2); ap_int_base<16 + _AP_W, false> ret(op1); ret <<= 16; if (true) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret;} template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 16, false > operator, (short op1, const ap_int_base<_AP_W, _AP_S>& op2) { ap_int_base<16 + _AP_W, false> val(op1); ap_int_base<16 + _AP_W, false> ret(op2); if (_AP_S) { ret <<= 16; ret >>= 16; } ret |= val << _AP_W; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 16, false > operator, (const ap_range_ref<_AP_W, _AP_S> &op1, short op2) { ap_int_base<16 + _AP_W, false> val(op2); ap_int_base<16 + _AP_W, false> ret(op1); ret <<= 16; if (true) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 16, false > operator, (short op1, const ap_range_ref<_AP_W, _AP_S> &op2) { ap_int_base<16 + _AP_W, false> val(op1); ap_int_base<16 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<16 + 1, false > operator, (const ap_bit_ref<_AP_W, _AP_S> &op1, short op2) { ap_int_base<16 + 1, false> val(op2); val[16] = op1; return val; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<16 + 1, false > operator, (short op1, const ap_bit_ref<_AP_W, _AP_S> &op2) { ap_int_base<16 + 1, false> val(op1); val <<= 1; val[0] = op2; return val; } template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 16, false > operator, (const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op1, short op2) { ap_int_base<16 + _AP_W + _AP_W2, true> val(op2); ap_int_base<16 + _AP_W + _AP_W2, true> ret(op1); if (true) { val <<= _AP_W + _AP_W2; val >>= _AP_W + _AP_W2; } ret <<= 16; ret |= val; return ret; }template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 16, false > operator, (short op1, const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op2) { ap_int_base<16 + _AP_W + _AP_W2, true> val(op1); ap_int_base<16 + _AP_W + _AP_W2, true> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; }template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 16, false > operator, (const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, short op2) { ap_int_base<16 + _AP_W, false> val(op2); ap_int_base<16 + _AP_W, false> ret(op1); if (true) { val <<= _AP_W; val >>= _AP_W; } ret <<= 16; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 16, false > operator, (short op1, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<16 + _AP_W, false> val(op1); ap_int_base<16 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 16, false> operator, (const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, short op2) { ap_int_base<16 + 1, true> val(op2); val[16] = op1; return val; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 16, false> operator, (short op1, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<16 + 1, true> val(op1); val <<= 1; val[0] = op2; return val; }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 16, false > operator, (const ap_int_base<_AP_W, _AP_S> &op1, unsigned short op2) { ap_int_base<16 + _AP_W, false> val(op2); ap_int_base<16 + _AP_W, false> ret(op1); ret <<= 16; if (false) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret;} template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 16, false > operator, (unsigned short op1, const ap_int_base<_AP_W, _AP_S>& op2) { ap_int_base<16 + _AP_W, false> val(op1); ap_int_base<16 + _AP_W, false> ret(op2); if (_AP_S) { ret <<= 16; ret >>= 16; } ret |= val << _AP_W; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 16, false > operator, (const ap_range_ref<_AP_W, _AP_S> &op1, unsigned short op2) { ap_int_base<16 + _AP_W, false> val(op2); ap_int_base<16 + _AP_W, false> ret(op1); ret <<= 16; if (false) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 16, false > operator, (unsigned short op1, const ap_range_ref<_AP_W, _AP_S> &op2) { ap_int_base<16 + _AP_W, false> val(op1); ap_int_base<16 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<16 + 1, false > operator, (const ap_bit_ref<_AP_W, _AP_S> &op1, unsigned short op2) { ap_int_base<16 + 1, false> val(op2); val[16] = op1; return val; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<16 + 1, false > operator, (unsigned short op1, const ap_bit_ref<_AP_W, _AP_S> &op2) { ap_int_base<16 + 1, false> val(op1); val <<= 1; val[0] = op2; return val; } template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 16, false > operator, (const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op1, unsigned short op2) { ap_int_base<16 + _AP_W + _AP_W2, false> val(op2); ap_int_base<16 + _AP_W + _AP_W2, false> ret(op1); if (false) { val <<= _AP_W + _AP_W2; val >>= _AP_W + _AP_W2; } ret <<= 16; ret |= val; return ret; }template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 16, false > operator, (unsigned short op1, const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op2) { ap_int_base<16 + _AP_W + _AP_W2, false> val(op1); ap_int_base<16 + _AP_W + _AP_W2, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; }template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 16, 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<16 + _AP_W, false> val(op2); ap_int_base<16 + _AP_W, false> ret(op1); if (false) { val <<= _AP_W; val >>= _AP_W; } ret <<= 16; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 16, 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<16 + _AP_W, false> val(op1); ap_int_base<16 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 16, 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<16 + 1, false> val(op2); val[16] = op1; return val; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 16, 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<16 + 1, false> val(op1); val <<= 1; val[0] = op2; return val; }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 32, false > operator, (const ap_int_base<_AP_W, _AP_S> &op1, int op2) { ap_int_base<32 + _AP_W, false> val(op2); ap_int_base<32 + _AP_W, false> ret(op1); ret <<= 32; if (true) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret;} template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 32, false > operator, (int op1, const ap_int_base<_AP_W, _AP_S>& op2) { ap_int_base<32 + _AP_W, false> val(op1); ap_int_base<32 + _AP_W, false> ret(op2); if (_AP_S) { ret <<= 32; ret >>= 32; } ret |= val << _AP_W; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 32, false > operator, (const ap_range_ref<_AP_W, _AP_S> &op1, int op2) { ap_int_base<32 + _AP_W, false> val(op2); ap_int_base<32 + _AP_W, false> ret(op1); ret <<= 32; if (true) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 32, false > operator, (int op1, const ap_range_ref<_AP_W, _AP_S> &op2) { ap_int_base<32 + _AP_W, false> val(op1); ap_int_base<32 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<32 + 1, false > operator, (const ap_bit_ref<_AP_W, _AP_S> &op1, int op2) { ap_int_base<32 + 1, false> val(op2); val[32] = op1; return val; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<32 + 1, false > operator, (int op1, const ap_bit_ref<_AP_W, _AP_S> &op2) { ap_int_base<32 + 1, false> val(op1); val <<= 1; val[0] = op2; return val; } template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 32, false > operator, (const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op1, int op2) { ap_int_base<32 + _AP_W + _AP_W2, true> val(op2); ap_int_base<32 + _AP_W + _AP_W2, true> ret(op1); if (true) { val <<= _AP_W + _AP_W2; val >>= _AP_W + _AP_W2; } ret <<= 32; ret |= val; return ret; }template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 32, false > operator, (int op1, const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op2) { ap_int_base<32 + _AP_W + _AP_W2, true> val(op1); ap_int_base<32 + _AP_W + _AP_W2, true> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; }template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 32, false > operator, (const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, int op2) { ap_int_base<32 + _AP_W, false> val(op2); ap_int_base<32 + _AP_W, false> ret(op1); if (true) { val <<= _AP_W; val >>= _AP_W; } ret <<= 32; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 32, false > operator, (int op1, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<32 + _AP_W, false> val(op1); ap_int_base<32 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 32, false> operator, (const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, int op2) { ap_int_base<32 + 1, true> val(op2); val[32] = op1; return val; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 32, false> operator, (int op1, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<32 + 1, true> val(op1); val <<= 1; val[0] = op2; return val; }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 32, false > operator, (const ap_int_base<_AP_W, _AP_S> &op1, unsigned int op2) { ap_int_base<32 + _AP_W, false> val(op2); ap_int_base<32 + _AP_W, false> ret(op1); ret <<= 32; if (false) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret;} template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 32, false > operator, (unsigned int op1, const ap_int_base<_AP_W, _AP_S>& op2) { ap_int_base<32 + _AP_W, false> val(op1); ap_int_base<32 + _AP_W, false> ret(op2); if (_AP_S) { ret <<= 32; ret >>= 32; } ret |= val << _AP_W; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 32, false > operator, (const ap_range_ref<_AP_W, _AP_S> &op1, unsigned int op2) { ap_int_base<32 + _AP_W, false> val(op2); ap_int_base<32 + _AP_W, false> ret(op1); ret <<= 32; if (false) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 32, false > operator, (unsigned int op1, const ap_range_ref<_AP_W, _AP_S> &op2) { ap_int_base<32 + _AP_W, false> val(op1); ap_int_base<32 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<32 + 1, false > operator, (const ap_bit_ref<_AP_W, _AP_S> &op1, unsigned int op2) { ap_int_base<32 + 1, false> val(op2); val[32] = op1; return val; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<32 + 1, false > operator, (unsigned int op1, const ap_bit_ref<_AP_W, _AP_S> &op2) { ap_int_base<32 + 1, false> val(op1); val <<= 1; val[0] = op2; return val; } template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 32, false > operator, (const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op1, unsigned int op2) { ap_int_base<32 + _AP_W + _AP_W2, false> val(op2); ap_int_base<32 + _AP_W + _AP_W2, false> ret(op1); if (false) { val <<= _AP_W + _AP_W2; val >>= _AP_W + _AP_W2; } ret <<= 32; ret |= val; return ret; }template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 32, false > operator, (unsigned int op1, const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op2) { ap_int_base<32 + _AP_W + _AP_W2, false> val(op1); ap_int_base<32 + _AP_W + _AP_W2, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; }template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 32, 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<32 + _AP_W, false> val(op2); ap_int_base<32 + _AP_W, false> ret(op1); if (false) { val <<= _AP_W; val >>= _AP_W; } ret <<= 32; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 32, 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<32 + _AP_W, false> val(op1); ap_int_base<32 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 32, 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<32 + 1, false> val(op2); val[32] = op1; return val; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 32, 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<32 + 1, false> val(op1); val <<= 1; val[0] = op2; return val; }
#pragma empty_line
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 64, false > operator, (const ap_int_base<_AP_W, _AP_S> &op1, long op2) { ap_int_base<64 + _AP_W, false> val(op2); ap_int_base<64 + _AP_W, false> ret(op1); ret <<= 64; if (true) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret;} template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 64, false > operator, (long op1, const ap_int_base<_AP_W, _AP_S>& op2) { ap_int_base<64 + _AP_W, false> val(op1); ap_int_base<64 + _AP_W, false> ret(op2); if (_AP_S) { ret <<= 64; ret >>= 64; } ret |= val << _AP_W; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 64, false > operator, (const ap_range_ref<_AP_W, _AP_S> &op1, long op2) { ap_int_base<64 + _AP_W, false> val(op2); ap_int_base<64 + _AP_W, false> ret(op1); ret <<= 64; if (true) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 64, false > operator, (long op1, const ap_range_ref<_AP_W, _AP_S> &op2) { ap_int_base<64 + _AP_W, false> val(op1); ap_int_base<64 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<64 + 1, false > operator, (const ap_bit_ref<_AP_W, _AP_S> &op1, long op2) { ap_int_base<64 + 1, false> val(op2); val[64] = op1; return val; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<64 + 1, false > operator, (long op1, const ap_bit_ref<_AP_W, _AP_S> &op2) { ap_int_base<64 + 1, false> val(op1); val <<= 1; val[0] = op2; return val; } template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 64, false > operator, (const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op1, long op2) { ap_int_base<64 + _AP_W + _AP_W2, true> val(op2); ap_int_base<64 + _AP_W + _AP_W2, true> ret(op1); if (true) { val <<= _AP_W + _AP_W2; val >>= _AP_W + _AP_W2; } ret <<= 64; ret |= val; return ret; }template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 64, false > operator, (long op1, const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op2) { ap_int_base<64 + _AP_W + _AP_W2, true> val(op1); ap_int_base<64 + _AP_W + _AP_W2, true> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; }template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 64, false > operator, (const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, long op2) { ap_int_base<64 + _AP_W, false> val(op2); ap_int_base<64 + _AP_W, false> ret(op1); if (true) { val <<= _AP_W; val >>= _AP_W; } ret <<= 64; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 64, false > operator, (long op1, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<64 + _AP_W, false> val(op1); ap_int_base<64 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 64, false> operator, (const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, long op2) { ap_int_base<64 + 1, true> val(op2); val[64] = op1; return val; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 64, false> operator, (long op1, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<64 + 1, true> val(op1); val <<= 1; val[0] = op2; return val; }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 64, false > operator, (const ap_int_base<_AP_W, _AP_S> &op1, unsigned long op2) { ap_int_base<64 + _AP_W, false> val(op2); ap_int_base<64 + _AP_W, false> ret(op1); ret <<= 64; if (false) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret;} template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 64, false > operator, (unsigned long op1, const ap_int_base<_AP_W, _AP_S>& op2) { ap_int_base<64 + _AP_W, false> val(op1); ap_int_base<64 + _AP_W, false> ret(op2); if (_AP_S) { ret <<= 64; ret >>= 64; } ret |= val << _AP_W; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 64, false > operator, (const ap_range_ref<_AP_W, _AP_S> &op1, unsigned long op2) { ap_int_base<64 + _AP_W, false> val(op2); ap_int_base<64 + _AP_W, false> ret(op1); ret <<= 64; if (false) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 64, false > operator, (unsigned long op1, const ap_range_ref<_AP_W, _AP_S> &op2) { ap_int_base<64 + _AP_W, false> val(op1); ap_int_base<64 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<64 + 1, false > operator, (const ap_bit_ref<_AP_W, _AP_S> &op1, unsigned long op2) { ap_int_base<64 + 1, false> val(op2); val[64] = op1; return val; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<64 + 1, false > operator, (unsigned long op1, const ap_bit_ref<_AP_W, _AP_S> &op2) { ap_int_base<64 + 1, false> val(op1); val <<= 1; val[0] = op2; return val; } template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 64, false > operator, (const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op1, unsigned long op2) { ap_int_base<64 + _AP_W + _AP_W2, false> val(op2); ap_int_base<64 + _AP_W + _AP_W2, false> ret(op1); if (false) { val <<= _AP_W + _AP_W2; val >>= _AP_W + _AP_W2; } ret <<= 64; ret |= val; return ret; }template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 64, false > operator, (unsigned long op1, const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op2) { ap_int_base<64 + _AP_W + _AP_W2, false> val(op1); ap_int_base<64 + _AP_W + _AP_W2, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; }template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 64, 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<64 + _AP_W, false> val(op2); ap_int_base<64 + _AP_W, false> ret(op1); if (false) { val <<= _AP_W; val >>= _AP_W; } ret <<= 64; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 64, 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<64 + _AP_W, false> val(op1); ap_int_base<64 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 64, 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<64 + 1, false> val(op2); val[64] = op1; return val; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 64, 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<64 + 1, false> val(op1); val <<= 1; val[0] = op2; return val; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 64, false > operator, (const ap_int_base<_AP_W, _AP_S> &op1, ap_slong op2) { ap_int_base<64 + _AP_W, false> val(op2); ap_int_base<64 + _AP_W, false> ret(op1); ret <<= 64; if (true) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret;} template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 64, false > operator, (ap_slong op1, const ap_int_base<_AP_W, _AP_S>& op2) { ap_int_base<64 + _AP_W, false> val(op1); ap_int_base<64 + _AP_W, false> ret(op2); if (_AP_S) { ret <<= 64; ret >>= 64; } ret |= val << _AP_W; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 64, false > operator, (const ap_range_ref<_AP_W, _AP_S> &op1, ap_slong op2) { ap_int_base<64 + _AP_W, false> val(op2); ap_int_base<64 + _AP_W, false> ret(op1); ret <<= 64; if (true) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 64, false > operator, (ap_slong op1, const ap_range_ref<_AP_W, _AP_S> &op2) { ap_int_base<64 + _AP_W, false> val(op1); ap_int_base<64 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<64 + 1, false > operator, (const ap_bit_ref<_AP_W, _AP_S> &op1, ap_slong op2) { ap_int_base<64 + 1, false> val(op2); val[64] = op1; return val; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<64 + 1, false > operator, (ap_slong op1, const ap_bit_ref<_AP_W, _AP_S> &op2) { ap_int_base<64 + 1, false> val(op1); val <<= 1; val[0] = op2; return val; } template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 64, false > operator, (const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op1, ap_slong op2) { ap_int_base<64 + _AP_W + _AP_W2, true> val(op2); ap_int_base<64 + _AP_W + _AP_W2, true> ret(op1); if (true) { val <<= _AP_W + _AP_W2; val >>= _AP_W + _AP_W2; } ret <<= 64; ret |= val; return ret; }template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 64, false > operator, (ap_slong op1, const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op2) { ap_int_base<64 + _AP_W + _AP_W2, true> val(op1); ap_int_base<64 + _AP_W + _AP_W2, true> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; }template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 64, 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<64 + _AP_W, false> val(op2); ap_int_base<64 + _AP_W, false> ret(op1); if (true) { val <<= _AP_W; val >>= _AP_W; } ret <<= 64; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 64, 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<64 + _AP_W, false> val(op1); ap_int_base<64 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 64, 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<64 + 1, true> val(op2); val[64] = op1; return val; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 64, 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<64 + 1, true> val(op1); val <<= 1; val[0] = op2; return val; }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 64, false > operator, (const ap_int_base<_AP_W, _AP_S> &op1, ap_ulong op2) { ap_int_base<64 + _AP_W, false> val(op2); ap_int_base<64 + _AP_W, false> ret(op1); ret <<= 64; if (false) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret;} template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 64, false > operator, (ap_ulong op1, const ap_int_base<_AP_W, _AP_S>& op2) { ap_int_base<64 + _AP_W, false> val(op1); ap_int_base<64 + _AP_W, false> ret(op2); if (_AP_S) { ret <<= 64; ret >>= 64; } ret |= val << _AP_W; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 64, false > operator, (const ap_range_ref<_AP_W, _AP_S> &op1, ap_ulong op2) { ap_int_base<64 + _AP_W, false> val(op2); ap_int_base<64 + _AP_W, false> ret(op1); ret <<= 64; if (false) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base< _AP_W + 64, false > operator, (ap_ulong op1, const ap_range_ref<_AP_W, _AP_S> &op2) { ap_int_base<64 + _AP_W, false> val(op1); ap_int_base<64 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<64 + 1, false > operator, (const ap_bit_ref<_AP_W, _AP_S> &op1, ap_ulong op2) { ap_int_base<64 + 1, false> val(op2); val[64] = op1; return val; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<64 + 1, false > operator, (ap_ulong op1, const ap_bit_ref<_AP_W, _AP_S> &op2) { ap_int_base<64 + 1, false> val(op1); val <<= 1; val[0] = op2; return val; } template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 64, false > operator, (const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op1, ap_ulong op2) { ap_int_base<64 + _AP_W + _AP_W2, false> val(op2); ap_int_base<64 + _AP_W + _AP_W2, false> ret(op1); if (false) { val <<= _AP_W + _AP_W2; val >>= _AP_W + _AP_W2; } ret <<= 64; ret |= val; return ret; }template<int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 64, false > operator, (ap_ulong op1, const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op2) { ap_int_base<64 + _AP_W + _AP_W2, false> val(op1); ap_int_base<64 + _AP_W + _AP_W2, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; }template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 64, 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<64 + _AP_W, false> val(op2); ap_int_base<64 + _AP_W, false> ret(op1); if (false) { val <<= _AP_W; val >>= _AP_W; } ret <<= 64; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< _AP_W + 64, 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<64 + _AP_W, false> val(op1); ap_int_base<64 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 64, 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<64 + 1, false> val(op2); val[64] = op1; return val; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N > inline __attribute__((always_inline)) ap_int_base< 1 + 64, 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<64 + 1, false> val(op1); val <<= 1; val[0] = op2; return val; }
#pragma line 3935 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_int_syn.h"
template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) ap_uint<_AP_W+_AP_W1> operator << (const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1> lhs, long rhs) { return ((ap_uint<_AP_W+_AP_W1>)lhs.get()) << ((int)rhs); }
template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) ap_uint<_AP_W+_AP_W1> operator << (const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1> lhs, unsigned long rhs) { return ((ap_uint<_AP_W+_AP_W1>)lhs.get()) << ((int)rhs); }
template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) ap_uint<_AP_W+_AP_W1> operator << (const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1> lhs, unsigned int rhs) { return ((ap_uint<_AP_W+_AP_W1>)lhs.get()) << ((int)rhs); }
template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) ap_uint<_AP_W+_AP_W1> operator << (const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1> lhs, ap_ulong rhs) { return ((ap_uint<_AP_W+_AP_W1>)lhs.get()) << ((int)rhs); }
template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) ap_uint<_AP_W+_AP_W1> operator << (const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1> lhs, ap_slong rhs) { return ((ap_uint<_AP_W+_AP_W1>)lhs.get()) << ((int)rhs); }
template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) ap_uint<_AP_W+_AP_W1> operator >> (const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1> lhs, long rhs) { return ((ap_uint<_AP_W+_AP_W1>)lhs.get()) >> ((int)rhs); }
template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) ap_uint<_AP_W+_AP_W1> operator >> (const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1> lhs, unsigned long rhs) { return ((ap_uint<_AP_W+_AP_W1>)lhs.get()) >> ((int)rhs); }
template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) ap_uint<_AP_W+_AP_W1> operator >> (const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1> lhs, unsigned int rhs) { return ((ap_uint<_AP_W+_AP_W1>)lhs.get()) >> ((int)rhs); }
template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) ap_uint<_AP_W+_AP_W1> operator >> (const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1> lhs, ap_ulong rhs) { return ((ap_uint<_AP_W+_AP_W1>)lhs.get()) >> ((int)rhs); }
template<int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) ap_uint<_AP_W+_AP_W1> operator >> (const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1> lhs, ap_slong rhs) { return ((ap_uint<_AP_W+_AP_W1>)lhs.get()) >> ((int)rhs); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
// XSIP watermark, do not delete 67d7842dbbe25473c3c32b93c0da8047785f30d78e8a024de1b57352245f9689
#pragma line 61 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_int.h" 2
#pragma line 1 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_fixed_syn.h" 1
// -*- c++ -*-
#pragma empty_line
/*
#- (c) Copyright 2011-2016 Xilinx, Inc. All rights reserved.
#-
#- This file contains confidential and proprietary information
#- of Xilinx, Inc. and is protected under U.S. and
#- international copyright and other intellectual property
#- laws.
#-
#- DISCLAIMER
#- This disclaimer is not a license and does not grant any
#- rights to the materials distributed herewith. Except as
#- otherwise provided in a valid license issued to you by
#- Xilinx, and to the maximum extent permitted by applicable
#- law: (1) THESE MATERIALS ARE MADE AVAILABLE "AS IS" AND
#- WITH ALL FAULTS, AND XILINX HEREBY DISCLAIMS ALL WARRANTIES
#- AND CONDITIONS, EXPRESS, IMPLIED, OR STATUTORY, INCLUDING
#- BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, NON-
#- INFRINGEMENT, OR FITNESS FOR ANY PARTICULAR PURPOSE; and
#- (2) Xilinx shall not be liable (whether in contract or tort,
#- including negligence, or under any other theory of
#- liability) for any loss or damage of any kind or nature
#- related to, arising under or in connection with these
#- materials, including for any direct, or any indirect,
#- special, incidental, or consequential loss or damage
#- (including loss of data, profits, goodwill, or any type of
#- loss or damage suffered as a result of any action brought
#- by a third party) even if such damage or loss was
#- reasonably foreseeable or Xilinx had been advised of the
#- possibility of the same.
#-
#- CRITICAL APPLICATIONS
#- Xilinx products are not designed or intended to be fail-
#- safe, or for use in any application requiring fail-safe
#- performance, such as life-support or safety devices or
#- systems, Class III medical devices, nuclear facilities,
#- applications related to the deployment of airbags, or any
#- other applications that could lead to death, personal
#- injury, or severe property or environmental damage
#- (individually and collectively, "Critical
#- Applications"). Customer assumes the sole risk and
#- liability of any use of Xilinx products in Critical
#- Applications, subject only to applicable laws and
#- regulations governing limitations on product liability.
#-
#- THIS COPYRIGHT NOTICE AND DISCLAIMER MUST BE RETAINED AS
#- PART OF THIS FILE AT ALL TIMES.
#- ************************************************************************
#pragma empty_line
*
*/
#pragma line 62 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_fixed_syn.h"
/// ap_fixed_base
// -----------------------------------------------------------------------------
//#include <math.h>
#pragma line 79 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_fixed_syn.h"
//enum ap_q_mode { SC_TRN, SC_RND, SC_TRN_ZERO, SC_RND_ZERO,
// SC_RND_INF, SC_RND_MIN_INF, SC_RND_CONV };
#pragma empty_line
//enum ap_o_mode { SC_WRAP, SC_SAT, SC_SAT_ZERO, SC_SAT_SYM,SC_WRAP_SM };
#pragma empty_line
/// Forward declaration.
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;
#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 {
ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& d_bv;
int d_index;
#pragma empty_line
public:
inline __attribute__((always_inline)) af_bit_ref(const af_bit_ref<_AP_W,_AP_I,_AP_S,
_AP_Q,_AP_O,_AP_N>&ref):
d_bv(ref.d_bv), d_index(ref.d_index) {}
#pragma empty_line
inline __attribute__((always_inline)) af_bit_ref(ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>* bv, int index = 0) :
d_bv(*bv), d_index(index) {}
inline __attribute__((always_inline)) operator bool () const { return ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), d_index, d_index); (bool)(__Result__ & 1); }); }
#pragma empty_line
inline __attribute__((always_inline)) af_bit_ref& operator = (unsigned long long val) {
d_bv.V = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(val) __Repl2__ = !!val; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), d_index, d_index); __Result__; });
return *this;
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) af_bit_ref& operator = (const ap_int_base<_AP_W2,_AP_S2>& val) {
return operator =(val.to_uint64());
}
#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 __attribute__((always_inline)) af_bit_ref& operator = (const af_bit_ref<_AP_W2,_AP_I2,
_AP_S2,_AP_Q2,_AP_O2,_AP_N2>& val) {
return operator =((unsigned long long) (bool) val);
}
#pragma empty_line
inline __attribute__((always_inline)) af_bit_ref& operator = (const af_bit_ref<_AP_W,_AP_I,
_AP_S,_AP_Q,_AP_O,_AP_N>& val) {
return operator =((unsigned long long) (bool) val);
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) af_bit_ref& operator = ( const ap_bit_ref<_AP_W2, _AP_S2> &val) {
return operator =((unsigned long long) (bool) val);
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) af_bit_ref& operator = ( const ap_range_ref<_AP_W2,_AP_S2>& val) {
return operator =((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 __attribute__((always_inline)) af_bit_ref& operator= (const af_range_ref<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2>& val) {
return operator=((const ap_int_base<_AP_W2, false>)(val));
}
#pragma empty_line
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) af_bit_ref& operator= (const ap_concat_ref<_AP_W2, _AP_T3, _AP_W3, _AP_T3>& val) {
return operator=((const ap_int_base<_AP_W2 + _AP_W3, false>)(val));
}
#pragma empty_line
template<int _AP_W2, int _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<1, af_bit_ref, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator, (ap_int_base<_AP_W2, _AP_S2>& op) {
return ap_concat_ref<1, af_bit_ref, _AP_W2,
ap_int_base<_AP_W2, _AP_S2> >(*this, op);
}
#pragma empty_line
template<int _AP_W2, int _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<1, af_bit_ref, 1, ap_bit_ref<_AP_W2, _AP_S2> >
operator, (const ap_bit_ref<_AP_W2, _AP_S2> &op) {
return ap_concat_ref<1, af_bit_ref, 1,
ap_bit_ref<_AP_W2, _AP_S2> >(*this,
const_cast<ap_bit_ref<_AP_W2, _AP_S2>& >(op));
}
#pragma empty_line
template<int _AP_W2, int _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<1, af_bit_ref, _AP_W2, ap_range_ref<_AP_W2, _AP_S2> >
operator, (const ap_range_ref<_AP_W2, _AP_S2> &op) {
return ap_concat_ref<1, af_bit_ref, _AP_W2,
ap_range_ref<_AP_W2, _AP_S2> >(*this,
const_cast< ap_range_ref<_AP_W2, _AP_S2>& >(op));
}
#pragma empty_line
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_concat_ref<1, af_bit_ref, _AP_W2 + _AP_W3,
ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >
operator, (const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> op) {
return ap_concat_ref<1, af_bit_ref, _AP_W2 + _AP_W3,
ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >(*this,
const_cast<ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& > (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 __attribute__((always_inline)) ap_concat_ref<1, af_bit_ref, _AP_W2,
af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &op) {
return ap_concat_ref<1, af_bit_ref, _AP_W2,
af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(*this,
const_cast<af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2>& >(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 __attribute__((always_inline)) ap_concat_ref<1, af_bit_ref, 1,
af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &op) {
return ap_concat_ref<1, af_bit_ref, 1,
af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(*this,
const_cast<af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2>& >(op));
}
#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 __attribute__((always_inline)) bool operator == (const af_bit_ref<_AP_W2, _AP_I2,
_AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
return get() == op.get();
}
#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 __attribute__((always_inline)) bool operator != (const af_bit_ref<_AP_W2, _AP_I2,
_AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
return get() != op.get();
}
#pragma empty_line
inline __attribute__((always_inline)) bool get() const {
return ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), d_index, d_index); (bool)(__Result__ & 1); });
}
#pragma empty_line
inline __attribute__((always_inline)) bool operator ~ () const {
bool bit = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), d_index, d_index); (bool)(__Result__ & 1); });
return bit ? false : true;
}
#pragma empty_line
inline __attribute__((always_inline)) int length() const {
return 1;
}
#pragma empty_line
};
/* Range (slice) reference.
----------------------------------------------------------------
*/
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 {
ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& d_bv;
int l_index;
int h_index;
#pragma empty_line
public:
inline __attribute__((always_inline)) af_range_ref(const af_range_ref<_AP_W,_AP_I,_AP_S,
_AP_Q,_AP_O, _AP_N>&ref):
d_bv(ref.d_bv), l_index(ref.l_index), h_index(ref.h_index) {}
#pragma empty_line
inline __attribute__((always_inline)) af_range_ref(ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>* bv
, int h, int l) :
d_bv(*bv), l_index(l), h_index(h) {
}
#pragma empty_line
inline __attribute__((always_inline)) operator ap_int_base<_AP_W,false> () const {
ap_int_base<_AP_W, false> ret;
ret.V = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; });
return ret;
}
#pragma empty_line
inline __attribute__((always_inline)) operator unsigned long long () const {
ap_int_base<_AP_W, false> ret;
ret.V = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; });
return ret.to_uint64();
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline __attribute__((always_inline)) af_range_ref& operator = (const char val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(loc.V) __Repl2__ = loc.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) af_range_ref& operator = (const signed char val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(loc.V) __Repl2__ = loc.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) af_range_ref& operator = (const short val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(loc.V) __Repl2__ = loc.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) af_range_ref& operator = (const unsigned short val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(loc.V) __Repl2__ = loc.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) af_range_ref& operator = (const int val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(loc.V) __Repl2__ = loc.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) af_range_ref& operator = (const unsigned int val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(loc.V) __Repl2__ = loc.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) af_range_ref& operator = (const long val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(loc.V) __Repl2__ = loc.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) af_range_ref& operator = (const unsigned long val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(loc.V) __Repl2__ = loc.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) af_range_ref& operator = (const long long val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(loc.V) __Repl2__ = loc.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) af_range_ref& operator = (const unsigned long long val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(loc.V) __Repl2__ = loc.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) af_range_ref& operator = (const ap_int_base<_AP_W2,_AP_S2>& val) {
ap_int_base<_AP_W, false> loc(val);
d_bv.V = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(loc.V) __Repl2__ = loc.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; });
return *this;
}
#pragma empty_line
inline __attribute__((always_inline)) af_range_ref& operator = (const char* val) {
ap_int_base<_AP_W, false> loc(val);
d_bv.V = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(loc.V) __Repl2__ = loc.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; });
return *this;
}
#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 __attribute__((always_inline)) af_range_ref& operator= (const af_range_ref<_AP_W2,
_AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& val) {
ap_int_base<_AP_W2, false> tmp(val);
return operator=(tmp);
}
#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 __attribute__((always_inline)) af_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
inline __attribute__((always_inline)) af_range_ref& operator= (const af_range_ref<_AP_W,
_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& val) {
ap_int_base<_AP_W, false> tmp(val);
return operator=(tmp);
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) af_range_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 __attribute__((always_inline)) af_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 empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) af_range_ref& operator= (const ap_bit_ref<_AP_W2, _AP_S2>& val) {
return operator=((unsigned long long)(bool)(val));
}
#pragma empty_line
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) af_range_ref& operator= (const ap_concat_ref<_AP_W2, _AP_T3, _AP_W3, _AP_T3>& val) {
return operator=((const ap_int_base<_AP_W2 + _AP_W3, false>)(val));
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator == (const ap_range_ref<_AP_W2, _AP_S2>& op2) {
ap_int_base<_AP_W, false> lop (*this);
ap_int_base<_AP_W2, false> rop (op2);
return lop == rop;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator != (const ap_range_ref<_AP_W2, _AP_S2>& op2) {
return !(operator == (op2));
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator < (const ap_range_ref<_AP_W2, _AP_S2>& op2) {
ap_int_base<_AP_W, false> lop(*this);
ap_int_base<_AP_W2, false> rop(op2);
return lop < rop;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator <= (const ap_range_ref<_AP_W2, _AP_S2>& op2) {
ap_int_base<_AP_W, false> lop(*this);
ap_int_base<_AP_W2, false> rop(op2);
return lop <= rop;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator > (const ap_range_ref<_AP_W2, _AP_S2>& op2) {
return !(operator <= (op2));
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator >= (const ap_range_ref<_AP_W2, _AP_S2>& op2) {
return !(operator < (op2));
}
#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 __attribute__((always_inline)) bool operator == (const af_range_ref<_AP_W2, _AP_I2,
_AP_S2,_AP_Q2, _AP_O2, _AP_N2>& op2) {
ap_int_base<_AP_W, false> lop (*this);
ap_int_base<_AP_W2, false> rop (op2);
return lop == rop;
}
#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 __attribute__((always_inline)) bool operator != (const af_range_ref<_AP_W2, _AP_I2,
_AP_S2,_AP_Q2, _AP_O2, _AP_N2>& op2) {
return !(operator == (op2));
}
#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 __attribute__((always_inline)) bool operator < (const af_range_ref<_AP_W2, _AP_I2,
_AP_S2,_AP_Q2, _AP_O2, _AP_N2>& op2) {
ap_int_base<_AP_W, false> lop (*this);
ap_int_base<_AP_W2, false> rop (op2);
return lop < rop;
}
#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 __attribute__((always_inline)) bool operator <= (const af_range_ref<_AP_W2, _AP_I2,
_AP_S2,_AP_Q2, _AP_O2, _AP_N2>& op2) {
ap_int_base<_AP_W, false> lop( *this);
ap_int_base<_AP_W2, false> rop (op2);
return lop <= rop;
}
#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 __attribute__((always_inline)) bool operator > (const af_range_ref<_AP_W2, _AP_I2,
_AP_S2,_AP_Q2, _AP_O2, _AP_N2>& op2) {
return !(operator <= (op2));
}
#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 __attribute__((always_inline)) bool operator >= (const af_range_ref<_AP_W2, _AP_I2,
_AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op2) {
return !(operator < (op2));
}
#pragma empty_line
template <int _AP_W3>
inline __attribute__((always_inline)) void set(const ap_int_base<_AP_W3, false>& val) {
d_bv.V = ({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(val.V) __Repl2__ = val.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; });
}
#pragma empty_line
template<int _AP_W2, int _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<_AP_W, af_range_ref, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator, (ap_int_base<_AP_W2, _AP_S2>& op) {
return ap_concat_ref<_AP_W, af_range_ref, _AP_W2,
ap_int_base<_AP_W2, _AP_S2> >(*this, op);
}
#pragma empty_line
template<int _AP_W2, int _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<_AP_W, af_range_ref, 1, ap_bit_ref<_AP_W2, _AP_S2> >
operator, (const ap_bit_ref<_AP_W2, _AP_S2> &op) {
return ap_concat_ref<_AP_W, af_range_ref, 1,
ap_bit_ref<_AP_W2, _AP_S2> >(*this,
const_cast<ap_bit_ref<_AP_W2, _AP_S2>& >(op));
}
#pragma empty_line
template<int _AP_W2, int _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<_AP_W, af_range_ref, _AP_W2, ap_range_ref<_AP_W2, _AP_S2> >
operator, (const ap_range_ref<_AP_W2, _AP_S2> &op) {
return ap_concat_ref<_AP_W, af_range_ref, _AP_W2,
ap_range_ref<_AP_W2, _AP_S2> >(*this,
const_cast<ap_range_ref<_AP_W2, _AP_S2>& >(op));
}
#pragma empty_line
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_concat_ref<_AP_W, af_range_ref, _AP_W2 + _AP_W3,
ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >
operator, (const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& op) {
return ap_concat_ref<_AP_W, af_range_ref, _AP_W2 + _AP_W3,
ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >(*this,
const_cast<ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& >(op));
}
#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 __attribute__((always_inline)) ap_concat_ref<_AP_W, af_range_ref, _AP_W2,
af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &op) {
return ap_concat_ref<_AP_W, af_range_ref, _AP_W2,
af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(*this,
const_cast<af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2>& >(op));
}
#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 __attribute__((always_inline)) ap_concat_ref<_AP_W, af_range_ref, 1,
af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &op) {
return ap_concat_ref<_AP_W, af_range_ref, 1,
af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(*this,
const_cast<af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2>& >(op));
}
#pragma empty_line
#pragma empty_line
inline __attribute__((always_inline)) int length() const {
return h_index >= l_index ? h_index - l_index + 1 : l_index - h_index + 1;
}
#pragma empty_line
inline __attribute__((always_inline)) int to_int() const {
return (int)(({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; }));
}
inline __attribute__((always_inline)) unsigned to_uint() const {
return (unsigned)(({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; }));
}
inline __attribute__((always_inline)) long to_long() const {
return (long)(({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; }));
}
inline __attribute__((always_inline)) unsigned long to_ulong() const {
return (unsigned long)(({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; }));
}
inline __attribute__((always_inline)) ap_slong to_int64() const {
return (ap_slong)(({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; }));
}
inline __attribute__((always_inline)) ap_ulong to_uint64() const {
return (ap_ulong)(({ typeof(d_bv.V) __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; }));
}
};
#pragma empty_line
// -----------------------------------------------------------------------------
/// ap_fixed_base: AutoPilot fixed point.
// -----------------------------------------------------------------------------
template<int _AP_W, int _AP_I, bool _AP_S=true,
ap_q_mode _AP_Q=SC_TRN, ap_o_mode _AP_O=SC_WRAP, int _AP_N=0>
struct ap_fixed_base : ssdm_int<_AP_W, _AP_S> {
#pragma empty_line
public:
typedef ssdm_int<_AP_W, _AP_S> Base;
#pragma empty_line
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
/*__attribute__((weak))*/ void overflow_adjust(bool underflow, bool overflow,bool lD, bool sign) {
#pragma empty_line
_ssdm_InlineSelf(0, "");
#pragma empty_line
#pragma empty_line
if (!underflow && !overflow) return;
if (_AP_O==SC_WRAP) {
if (_AP_N == 0)
return;
if (_AP_S) {
//signed SC_WRAP
//n_bits == 1
Base::V = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(sign) __Repl2__ = !!sign; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), _AP_W - 1, _AP_W - 1); __Result__; });
if (_AP_N > 1) {
//n_bits > 1
ap_int_base<_AP_W, false> mask(-1);
if (sign) mask.V = 0;
Base::V = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(mask.V) __Repl2__ = mask.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), _AP_W - _AP_N, _AP_W - 2); __Result__; });
#pragma empty_line
}
} else {
//unsigned SC_WRAP
ap_int_base<_AP_W, false> mask(-1);
Base::V = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(mask.V) __Repl2__ = mask.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), _AP_W - _AP_N, _AP_W - 1); __Result__; });
#pragma empty_line
}
} else if (_AP_O==SC_SAT_ZERO) {
Base::V = 0;
}
else if (_AP_O == SC_WRAP_SM && _AP_S) {
bool Ro = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W - 1, _AP_W - 1); (bool)(__Result__ & 1); });
if (_AP_N == 0) {
if (lD != Ro) {
Base::V = ~Base::V;
Base::V = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(lD) __Repl2__ = !!lD; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), _AP_W - 1, _AP_W - 1); __Result__; });
}
} else {
if (_AP_N == 1 && sign != Ro) {
Base::V = ~Base::V;
} else if (_AP_N > 1) {
bool lNo = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W - _AP_N, _AP_W - _AP_N); (bool)(__Result__ & 1); });
if (lNo == sign)
Base::V = ~Base::V;
ap_int_base<_AP_W, false> mask(-1);
if (sign) mask.V = 0;
Base::V = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(mask.V) __Repl2__ = mask.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), _AP_W - _AP_N, _AP_W - 2); __Result__; });
#pragma empty_line
}
Base::V = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(sign) __Repl2__ = !!sign; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), _AP_W - 1, _AP_W - 1); __Result__; });
#pragma empty_line
}
} 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==SC_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
/*__attribute__((weak))*/ bool quantization_adjust(bool qb, bool r, bool s) {
#pragma empty_line
_ssdm_InlineSelf(0, "");
#pragma empty_line
bool carry=(bool)({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W-1, _AP_W-1); (bool)(__Result__ & 1); });
if (_AP_Q==SC_TRN)
return false;
if (_AP_Q==SC_RND_ZERO)
qb &= s || r;
else if (_AP_Q==SC_RND_MIN_INF)
qb &= r;
else if (_AP_Q==SC_RND_INF)
qb &= !s || r;
else if (_AP_Q==SC_RND_CONV)
qb &= ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 0, 0); (bool)(__Result__ & 1); }) || r;
else if (_AP_Q==SC_TRN_ZERO)
qb = s && ( qb || r );
Base::V += qb;
//return qb;
return carry&&(!(bool)({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W-1, _AP_W-1); (bool)(__Result__ & 1); }));
}
#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_W + ((_AP_W2 - _AP_I2) > (0) ? (_AP_W2 - _AP_I2) : (0)) + _AP_S2,
#pragma empty_line
#pragma empty_line
#pragma empty_line
div_i = _AP_I + _AP_W2 -_AP_I2 + _AP_S2,
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<mult_w, mult_i, mult_s> mult;
typedef ap_fixed_base<plus_w, plus_i, plus_s> plus;
typedef ap_fixed_base<minus_w, minus_i, minus_s> minus;
typedef ap_fixed_base<logic_w, logic_i, logic_s> logic;
typedef ap_fixed_base<div_w, div_i, div_s> div;
typedef ap_fixed_base<_AP_W, _AP_I, _AP_S> arg1;
};
#pragma empty_line
/// Constructors.
// -------------------------------------------------------------------------
inline __attribute__((always_inline)) ap_fixed_base() {
;
/*
#ifdef __SC_COMPATIBLE__
Base::V = 0;
#endif
*/
}
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
/*__attribute__((weak))*/ ap_fixed_base (const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2> &op) {
#pragma empty_line
_ssdm_InlineSelf(0, "");
#pragma empty_line
enum { N2=_AP_W2, _AP_F=_AP_W-_AP_I, F2=_AP_W2-_AP_I2,
QUAN_INC = F2>_AP_F && !(_AP_Q==SC_TRN || (_AP_Q==SC_TRN_ZERO && !_AP_S2)) };
bool carry = false;
#pragma empty_line
#pragma empty_line
#pragma empty_line
// handle quantization
unsigned sh_amt = (F2 > _AP_F) ? F2 - _AP_F : _AP_F - F2;
bool signbit = ({ typeof((const_cast<ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>*>(&op)->V)) __Result__ = 0; typeof((const_cast<ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>*>(&op)->V)) __Val2__ = (const_cast<ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>*>(&op)->V); __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W2-1, _AP_W2-1); (bool)(__Result__ & 1); });
#pragma empty_line
bool isneg = signbit && _AP_S2;
if (F2 == _AP_F)
Base::V = op.V;
else if (F2 > _AP_F) {
if (sh_amt < _AP_W2)
Base::V = op.V >> sh_amt;
else {
static int AllOnesInt = -1;
if (isneg) Base::V = AllOnesInt;
else Base::V = 0;
}
if (_AP_Q!=SC_TRN && !(_AP_Q==SC_TRN_ZERO && !_AP_S2)) {
bool qbit = ({ typeof((const_cast<ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>*>(&op)->V)) __Result__ = 0; typeof((const_cast<ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>*>(&op)->V)) __Val2__ = (const_cast<ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>*>(&op)->V); __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), F2-_AP_F-1, F2-_AP_F-1); (bool)(__Result__ & 1); });
#pragma empty_line
bool qb = (F2-_AP_F > _AP_W2) ? _AP_S2 && signbit : qbit;
#pragma empty_line
bool r = (F2 > _AP_F+1) ?
({ typeof((const_cast<ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>*>(&op)->V)) __Result__ = 0; typeof((const_cast<ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>*>(&op)->V)) __Val2__ = (const_cast<ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>*>(&op)->V); __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 0, F2-_AP_F-2<_AP_W2?F2-_AP_F-2:_AP_W2-1); __Result__; })!=0 : false;
#pragma empty_line
#pragma empty_line
carry = quantization_adjust(qb, r, _AP_S2 && signbit);
}
}
else { // no quantization
Base::V = op.V;
if (sh_amt < _AP_W)
Base::V = Base::V << sh_amt;
else
Base::V = 0;
}
#pragma empty_line
// handle overflow/underflow
if ((_AP_O != SC_WRAP || _AP_N != 0) && ((!_AP_S && _AP_S2) ||
_AP_I-_AP_S < _AP_I2-_AP_S2+(QUAN_INC ||
(_AP_S2 && _AP_O==SC_SAT_SYM)))) { // saturation
bool deleted_zeros = _AP_S2?true:!carry,
deleted_ones = true;
bool neg_src = isneg;
bool lD = false;
#pragma empty_line
bool newsignbit = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W-1, _AP_W-1); (bool)(__Result__ & 1); });
int pos1 = F2 - _AP_F + _AP_W;
int pos2 = F2 - _AP_F + _AP_W + 1;
if (pos1 < _AP_W2 && pos1 >= 0)
lD = ({ typeof((const_cast<ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>*>(&op)->V)) __Result__ = 0; typeof((const_cast<ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>*>(&op)->V)) __Val2__ = (const_cast<ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>*>(&op)->V); __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), pos1, pos1); (bool)(__Result__ & 1); });
#pragma empty_line
#pragma empty_line
#pragma empty_line
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> Range1(0);
ap_int_base<_AP_W2,false> Range2(0);
ap_int_base<_AP_W2,false> all_ones(-1);
#pragma empty_line
if (pos2 < _AP_W2 && pos2 >= 0) {
Range2.V = ({ typeof((const_cast<ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>*> (&op)->V)) __Result__ = 0; typeof((const_cast<ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>*> (&op)->V)) __Val2__ = (const_cast<ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>*> (&op)->V); __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), pos2, _AP_W2-1); __Result__; });
#pragma empty_line
#pragma empty_line
Range2_all_ones = Range2 == (all_ones >> pos2);
} else if (pos2 < 0)
Range2_all_ones = false;
#pragma empty_line
if (pos1 >= 0 && pos2 < _AP_W2) {
Range1.V = ({ typeof((const_cast<ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>*> (&op)->V)) __Result__ = 0; typeof((const_cast<ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>*> (&op)->V)) __Val2__ = (const_cast<ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>*> (&op)->V); __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), pos1, _AP_W2-1); __Result__; });
#pragma empty_line
#pragma empty_line
#pragma empty_line
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
#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 == SC_SAT_SYM) && _AP_S2 && _AP_S)
underflow |= neg_src && (_AP_W > 1 ?
({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 0, _AP_W - 2); __Result__; }) == 0 : true);
#pragma empty_line
overflow_adjust(underflow, overflow, lD, neg_src);
}
}
#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 __attribute__((always_inline)) ap_fixed_base(const volatile ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> &op) {
*this = const_cast<ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>&>(op);
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_fixed_base (const ap_int_base<_AP_W2,_AP_S2>& op) {
;
ap_fixed_base<_AP_W2,_AP_W2,_AP_S2> f_op;
f_op.V = op.V;
*this = f_op;
}
#pragma empty_line
inline __attribute__((always_inline)) ap_fixed_base( bool b ) { *this = (ap_fixed_base<1, 1, false>) b; }
inline __attribute__((always_inline)) ap_fixed_base( char b ) { *this = (ap_fixed_base<8, 8, true>) b; }
inline __attribute__((always_inline)) ap_fixed_base( signed char b ) { *this = (ap_fixed_base<8, 8, true>) b; }
inline __attribute__((always_inline)) ap_fixed_base( unsigned char b ) { *this = (ap_fixed_base<8, 8, false>) b; }
inline __attribute__((always_inline)) ap_fixed_base( signed short b ) { *this = (ap_fixed_base<16, 16, true>) b; }
inline __attribute__((always_inline)) ap_fixed_base( unsigned short b ) { *this = (ap_fixed_base<16, 16, false>) b; }
inline __attribute__((always_inline)) ap_fixed_base( signed int b ) { *this = (ap_fixed_base<32, 32, true>) b; }
inline __attribute__((always_inline)) ap_fixed_base( unsigned int b ) { *this = (ap_fixed_base<32, 32, false>) b; }
#pragma empty_line
inline __attribute__((always_inline)) ap_fixed_base( signed long b ) { *this = (ap_fixed_base<64, 64, true>) b; }
inline __attribute__((always_inline)) ap_fixed_base( unsigned long b ) { *this = (ap_fixed_base<64, 64, false>) b; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline __attribute__((always_inline)) ap_fixed_base( ap_slong b ) { *this = (ap_fixed_base<64, 64, true>) b; }
inline __attribute__((always_inline)) ap_fixed_base( ap_ulong b ) { *this = (ap_fixed_base<64, 64, false>) b; }
inline __attribute__((always_inline)) ap_fixed_base(const char* str) {
typeof(Base::V) Result;
_ssdm_string2bits((void*)(&Result), (const char*)(str),
10, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N, true);
Base::V = Result;
}
#pragma empty_line
inline __attribute__((always_inline)) ap_fixed_base(const char* str, signed char radix) {
typeof(Base::V) Result;
_ssdm_string2bits((void*)(&Result), (const char*)(str),
radix, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N, true);
Base::V = Result;
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_fixed_base(const ap_bit_ref<_AP_W2, _AP_S2>& op) {
*this = ((bool)op);
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_fixed_base(const ap_range_ref<_AP_W2, _AP_S2>& op) {
*this = (ap_int_base<_AP_W2, false>(op));
}
#pragma empty_line
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_fixed_base(const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& op) {
*this = (ap_int_base<_AP_W2 + _AP_W3, false>(op));
#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 __attribute__((always_inline)) ap_fixed_base(const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
*this = (bool(op));
}
#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 __attribute__((always_inline)) ap_fixed_base(const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
*this = (ap_int_base<_AP_W2, false>(op));
}
#pragma empty_line
// helper function.
inline __attribute__((always_inline)) unsigned long long doubleToRawBits(double pf) const {
union {
unsigned long long __L;
double __D;
} LD;
LD.__D = pf;
return LD.__L;
}
inline __attribute__((always_inline)) unsigned int floatToRawBits(float pf) const {
union {
unsigned int __L;
float __D;
} LD;
LD.__D = pf;
return LD.__L;
}
#pragma empty_line
inline __attribute__((always_inline)) double rawBitsToDouble(unsigned long long pi) const {
union {
unsigned long long __L;
double __D;
} LD;
LD.__L = pi;
return LD.__D;
}
#pragma empty_line
inline __attribute__((always_inline)) float rawBitsToFloat (unsigned int pi) const {
union {
unsigned int __L;
float __D;
} LD;
LD.__L = pi;
return LD.__D;
}
#pragma empty_line
/*__attribute__((weak))*/ ap_fixed_base(double d) {
#pragma empty_line
_ssdm_InlineSelf(0, "");
#pragma empty_line
ap_int_base<64,false> ireg;
ireg.V = doubleToRawBits(d);
bool isneg = ({ typeof(ireg.V) __Result__ = 0; typeof(ireg.V) __Val2__ = ireg.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 63, 63); (bool)(__Result__ & 1); });
#pragma empty_line
ap_int_base<11 + 1, true> exp;
ap_int_base<11, false> exp_tmp;
exp_tmp.V = ({ typeof(ireg.V) __Result__ = 0; typeof(ireg.V) __Val2__ = ireg.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 52, 52 + 11 -1); __Result__; });
#pragma empty_line
exp = exp_tmp - ((1<<(11 -1))-1);
ap_int_base<52 + 2, true> man;
man.V = ({ typeof(ireg.V) __Result__ = 0; typeof(ireg.V) __Val2__ = ireg.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 0, 52 - 1); __Result__; });
//do not support NaN
#pragma empty_line
;
man.V = ({ typeof(man.V) __Result__ = 0; typeof(man.V) __Val2__ = man.V; typeof(1) __Repl2__ = !!1; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), 52, 52); __Result__; });
if(isneg) man = -man;
if ( (ireg.V & 0x7fffffffffffffffLL)==0 ) {
Base::V = 0;
} else {
int _AP_W2=52 +2, _AP_I2=exp.V+2, _AP_F=_AP_W-_AP_I, F2=_AP_W2-_AP_I2;
bool _AP_S2 = true,
QUAN_INC = F2>_AP_F && !(_AP_Q==SC_TRN || (_AP_Q==SC_TRN_ZERO && !_AP_S2));
bool carry = false;
// handle quantization
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 {
static int AllOnesInt = -1;
if (isneg) Base::V = AllOnesInt;
else Base::V = 0;
}
if ((_AP_Q != SC_TRN) && !((_AP_Q == SC_TRN_ZERO) && !_AP_S2)) {
#pragma empty_line
bool qb = (F2-_AP_F > _AP_W2) ?
isneg : (bool) ({ typeof(man.V) __Result__ = 0; typeof(man.V) __Val2__ = man.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), F2 - _AP_F - 1, F2 - _AP_F - 1); (bool)(__Result__ & 1); });
bool r = (F2 > _AP_F + 1) ? ({ typeof(man.V) __Result__ = 0; typeof(man.V) __Val2__ = man.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 0, (F2 - _AP_F - 2 < _AP_W2) ? (F2 - _AP_F - 2): (_AP_W2 - 1)); __Result__; }) !=
#pragma empty_line
0 : false;
carry = quantization_adjust(qb, r, isneg);
}
}
else { // no quantization
Base::V = man.V;
if (sh_amt < _AP_W)
Base::V = Base::V << sh_amt;
else
Base::V = 0;
}
// handle overflow/underflow
if ((_AP_O != SC_WRAP || _AP_N != 0) && ((!_AP_S && _AP_S2)
|| _AP_I - _AP_S < _AP_I2 - _AP_S2 + (QUAN_INC ||
(_AP_S2 && (_AP_O == SC_SAT_SYM)))) ) { // saturation
bool deleted_zeros = _AP_S2?true:!carry,
deleted_ones = true;
bool neg_src = isneg;
bool lD = false;
int pos1 =F2 - _AP_F + _AP_W;
int pos2 =F2 - _AP_F + _AP_W + 1;
bool newsignbit = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W - 1, _AP_W - 1); (bool)(__Result__ & 1); });
if (pos1 < _AP_W2 && pos1 >= 0)
//lD = _ssdm_op_get_bit(man.V, pos1);
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) {
//Range2.V = _ssdm_op_get_range(man.V,
// pos2, _AP_W2 - 1);
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 == SC_SAT_SYM) && _AP_S2 && _AP_S)
underflow |= neg_src && (_AP_W > 1 ?
({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 0, _AP_W - 2); __Result__; }) == 0 : true);
overflow_adjust(underflow, overflow, lD, neg_src);
}
}
}
#pragma empty_line
inline __attribute__((always_inline)) ap_fixed_base& operator=(const ap_fixed_base<_AP_W, _AP_I, _AP_S,
_AP_Q, _AP_O, _AP_N>& op)
{
Base::V = op.V;
return *this;
}
#pragma empty_line
inline __attribute__((always_inline)) ap_fixed_base& operator=(const volatile ap_fixed_base<_AP_W, _AP_I, _AP_S,
_AP_Q, _AP_O, _AP_N>& op)
{
Base::V = op.V;
return *this;
}
#pragma empty_line
inline __attribute__((always_inline)) void operator=(const ap_fixed_base<_AP_W, _AP_I, _AP_S,
_AP_Q, _AP_O, _AP_N>& op) volatile
{
Base::V = op.V;
}
#pragma empty_line
inline __attribute__((always_inline)) void operator=(const volatile ap_fixed_base<_AP_W, _AP_I, _AP_S,
_AP_Q, _AP_O, _AP_N>& op) volatile
{
Base::V = op.V;
}
#pragma empty_line
// Set this ap_fixed_base with a bits string. That means the ssdm_int::V
// inside this ap_fixed_base is assigned by bv.
// Note the input parameter should be a fixed-point formatted bit string.
inline __attribute__((always_inline)) ap_fixed_base& setBits(unsigned long long bv) {
Base::V = bv;
return *this;
}
// Return a ap_fixed_base object whose ssdm_int::V is assigned by bv.
// Note the input parameter should be a fixed-point formatted bit string.
static inline __attribute__((always_inline)) ap_fixed_base bitsToFixed(unsigned long long bv) {
ap_fixed_base Tmp;
Tmp.V = bv;
return Tmp;
}
#pragma empty_line
// Explicit conversion functions to ap_int_base that captures
// all integer bits (bits are truncated)
inline __attribute__((always_inline)) ap_int_base<((_AP_I) > (1) ? (_AP_I) : (1)),_AP_S>
to_ap_int_base(bool Cnative = true) const {
//return ap_int_base<AP_MAX(_AP_I,1),_AP_S>(_AP_I > 1 ?
// _ssdm_op_get_range(const_cast<ap_fixed_base*>(this)->Base::V,_AP_W-_AP_I,_AP_W-1) : 0);
ap_int_base<((_AP_I) > (1) ? (_AP_I) : (1)),_AP_S> ret(0);
if(_AP_I > 0 && _AP_I <= _AP_W)
ret.V = ({ typeof(const_cast< ap_fixed_base*>(this)->Base::V) __Result__ = 0; typeof(const_cast< ap_fixed_base*>(this)->Base::V) __Val2__ = const_cast< ap_fixed_base*>(this)->Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W - _AP_I, _AP_W - 1); __Result__; });
#pragma empty_line
#pragma empty_line
else if (_AP_I > _AP_W)
{
ret.V = ({ typeof(const_cast< ap_fixed_base*>(this)->Base::V) __Result__ = 0; typeof(const_cast< ap_fixed_base*>(this)->Base::V) __Val2__ = const_cast< ap_fixed_base*>(this)->Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 0, _AP_W - 1); __Result__; });
#pragma empty_line
unsigned int shift = _AP_I - _AP_W;
ret.V <<= shift;
}
if (Cnative) {
//Follow C native data type, conversion from double to int
if (_AP_S && ({ typeof(const_cast< ap_fixed_base*>(this)->Base::V) __Result__ = 0; typeof(const_cast< ap_fixed_base*>(this)->Base::V) __Val2__ = const_cast< ap_fixed_base*>(this)->Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W - 1, _AP_W - 1); (bool)(__Result__ & 1); })
#pragma empty_line
&& (_AP_I < _AP_W) && (({ typeof(const_cast<ap_fixed_base*>(this)->Base::V) __Result__ = 0; typeof(const_cast<ap_fixed_base*>(this)->Base::V) __Val2__ = const_cast<ap_fixed_base*>(this)->Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 0, _AP_I >= 0 ? _AP_W - _AP_I - 1: _AP_W - 1); __Result__; }) != 0))
#pragma empty_line
#pragma empty_line
ret.V += 1;
} else {
//Follow OSCI library, conversion from sc_fixed to sc_int
}
return ret;
};
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) operator ap_int_base<_AP_W2,_AP_S2> () const {
return (ap_int_base<_AP_W2,_AP_S2>)to_ap_int_base();
}
#pragma empty_line
// Explicit conversion function to C built-in integral type.
inline __attribute__((always_inline)) int to_int() const {
return to_ap_int_base().to_int();
}
inline __attribute__((always_inline)) unsigned to_uint() const {
return to_ap_int_base().to_uint();
}
inline __attribute__((always_inline)) ap_slong to_int64() const {
return to_ap_int_base().to_int64();
}
inline __attribute__((always_inline)) ap_ulong to_uint64() const {
return to_ap_int_base().to_uint64();
}
/*__attribute__((weak))*/ double to_double() const {
#pragma empty_line
_ssdm_InlineSelf(0, "");
#pragma empty_line
if (_AP_W - _AP_I > 0 && _AP_W <= 64) {
if (!Base::V)
return 0;
double dp = Base::V;
ap_int_base<64,true> res;
res.V = doubleToRawBits(dp);
ap_int_base<11, true> exp;
exp.V = ({ typeof(res.V) __Result__ = 0; typeof(res.V) __Val2__ = res.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 52, 62); __Result__; });
exp -= _AP_W - _AP_I;
res.V = ({ typeof(res.V) __Result__ = 0; typeof(res.V) __Val2__ = res.V; typeof(exp.V) __Repl2__ = exp.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), 52, 62); __Result__; });
dp = rawBitsToDouble(res.to_int64());
return dp;
} else if (_AP_I - _AP_W >= 0 && _AP_I <= 64) {
ap_int_base<((1) > (_AP_I) ? (1) : (_AP_I)), _AP_S> temp;
temp.V = Base::V;
temp <<= _AP_I - _AP_W;
double dp = temp.V;
return dp;
} else {
if (!Base::V)
return 0;
ap_int_base<64,true> res;
res.V = 0;
bool isneg = _AP_S ? ({ typeof(const_cast<ap_fixed_base*>(this)->V) __Result__ = 0; typeof(const_cast<ap_fixed_base*>(this)->V) __Val2__ = const_cast<ap_fixed_base*>(this)->V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W - 1, _AP_W - 1); (bool)(__Result__ & 1); }) : false;
#pragma empty_line
ap_int_base<_AP_W+_AP_S,_AP_S> tmp;
tmp.V = Base::V;
if (isneg) tmp.V = -Base::V;
#pragma empty_line
res.V = ({ typeof(res.V) __Result__ = 0; typeof(res.V) __Val2__ = res.V; typeof(isneg) __Repl2__ = !!isneg; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), 63, 63); __Result__; });
int j = _AP_W+_AP_S-1-tmp.countLeadingZeros();
#pragma empty_line
int exp = _AP_I-(_AP_W-j);
res.V = ({ typeof(res.V) __Result__ = 0; typeof(res.V) __Val2__ = res.V; typeof(exp + ((1<<(11 -1))-1)) __Repl2__ = exp + ((1<<(11 -1))-1); __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), 52, 62); __Result__; });
if (j == 0)
res.V = ({ typeof(res.V) __Result__ = 0; typeof(res.V) __Val2__ = res.V; typeof(0) __Repl2__ = 0; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), 0, 52 - 1); __Result__; });
else {
ap_int_base<52,false> man;
man.V = ({ typeof(tmp.V) __Result__ = 0; typeof(tmp.V) __Val2__ = tmp.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), j > 52 ? j - 52 : 0, j - 1); __Result__; });
#pragma empty_line
man.V <<= 52 > j ? 52 -j : 0;
res.V = ({ typeof(res.V) __Result__ = 0; typeof(res.V) __Val2__ = res.V; typeof(man.V) __Repl2__ = man.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), 0, 52 - 1); __Result__; });
}
double dp = rawBitsToDouble(res.to_int64());
return dp;
}
#pragma empty_line
}
#pragma empty_line
/*__attribute__((weak))*/ float to_float() const {
#pragma empty_line
_ssdm_InlineSelf(0, "");
#pragma empty_line
if (_AP_W - _AP_I > 0 && _AP_W <= 64) {
if (!Base::V)
return 0;
float dp = Base::V;
ap_int_base<32,true> res;
res.V = floatToRawBits(dp);
ap_int_base<8, true> exp;
exp.V = ({ typeof(res.V) __Result__ = 0; typeof(res.V) __Val2__ = res.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 23, 30); __Result__; });
exp -= _AP_W - _AP_I;
res.V = ({ typeof(res.V) __Result__ = 0; typeof(res.V) __Val2__ = res.V; typeof(exp.V) __Repl2__ = exp.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), 23, 30); __Result__; });
dp = rawBitsToFloat(res.to_int());
return dp;
} else if (_AP_I - _AP_W >= 0 && _AP_I <= 64) {
ap_int_base<((1) > (_AP_I) ? (1) : (_AP_I)), _AP_S> temp;
temp.V = Base::V;
temp <<= _AP_I - _AP_W;
float dp = temp.V;
return dp;
} else {
if (!Base::V)
return 0;
ap_int_base<32,true> res;
res.V = 0;
bool isneg = _AP_S ? ({ typeof(const_cast<ap_fixed_base*>(this)->V) __Result__ = 0; typeof(const_cast<ap_fixed_base*>(this)->V) __Val2__ = const_cast<ap_fixed_base*>(this)->V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W - 1, _AP_W - 1); (bool)(__Result__ & 1); }) : false;
#pragma empty_line
ap_int_base<_AP_W+_AP_S,_AP_S> tmp;
tmp.V = Base::V;
if (isneg) tmp.V = -Base::V;
res.V = ({ typeof(res.V) __Result__ = 0; typeof(res.V) __Val2__ = res.V; typeof(isneg) __Repl2__ = !!isneg; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), 31, 31); __Result__; });
int j = _AP_W+_AP_S-1-tmp.countLeadingZeros();
#pragma empty_line
int exp = _AP_I-(_AP_W-j);
res.V = ({ typeof(res.V) __Result__ = 0; typeof(res.V) __Val2__ = res.V; typeof(exp + ((1<<(8 -1))-1)) __Repl2__ = exp + ((1<<(8 -1))-1); __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), 23, 30); __Result__; });
if (j == 0)
res.V = ({ typeof(res.V) __Result__ = 0; typeof(res.V) __Val2__ = res.V; typeof(0) __Repl2__ = 0; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), 0, 23 - 1); __Result__; });
else {
ap_int_base<23,false> man;
man.V = ({ typeof(tmp.V) __Result__ = 0; typeof(tmp.V) __Val2__ = tmp.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), j > 23 ? j - 23 : 0, j - 1); __Result__; });
#pragma empty_line
man.V <<= 23 > j ? 23 -j: 0;
res.V = ({ typeof(res.V) __Result__ = 0; typeof(res.V) __Val2__ = res.V; typeof(man.V) __Repl2__ = man.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), 0, 23 - 1); __Result__; });
}
return rawBitsToFloat(res.to_int());
}
}
#pragma empty_line
#pragma empty_line
inline __attribute__((always_inline)) operator double () const {
return to_double();
}
#pragma empty_line
inline __attribute__((always_inline)) operator float () const {
return to_float();
}
#pragma empty_line
inline __attribute__((always_inline)) operator char () const {
return (char) to_int();
}
#pragma empty_line
inline __attribute__((always_inline)) operator signed char () const {
return (signed char) to_int();
}
#pragma empty_line
inline __attribute__((always_inline)) operator unsigned char () const {
return (unsigned char) to_uint();
}
#pragma empty_line
inline __attribute__((always_inline)) operator short () const {
return (short) to_int();
}
#pragma empty_line
inline __attribute__((always_inline)) operator unsigned short () const {
return (unsigned short) to_uint();
}
#pragma empty_line
#pragma empty_line
inline __attribute__((always_inline)) operator int () const {
return to_int();
}
#pragma empty_line
inline __attribute__((always_inline)) operator unsigned int () const {
return to_uint();
}
#pragma empty_line
#pragma empty_line
inline __attribute__((always_inline)) operator long () const {
return (long)to_int64();
}
#pragma empty_line
inline __attribute__((always_inline)) operator unsigned long () const {
return (unsigned long) to_uint64();
}
#pragma line 1245 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_fixed_syn.h"
inline __attribute__((always_inline)) operator unsigned long long () const {
return to_uint64();
}
#pragma empty_line
inline __attribute__((always_inline)) operator long long () const {
return to_int64();
}
#pragma empty_line
inline __attribute__((always_inline)) int length() const { return _AP_W; };
// Count the number of zeros from the most significant bit
// to the first one bit. Note this is only for ap_fixed_base whose
// _AP_W <= 64, otherwise will incur assertion.
inline __attribute__((always_inline)) int countLeadingZeros() {
if (_AP_W <= 32) {
ap_int_base<32, false> t(-1ULL);
t.range(_AP_W-1, 0) = this->range(0, _AP_W-1);
return __builtin_ctz(t.V);
} else if (_AP_W <= 64) {
ap_int_base<64, false> t(-1ULL);
t.range(_AP_W-1, 0) = this->range(0, _AP_W-1);
return __builtin_ctzll(t.V);
} else {
enum { __N = (_AP_W+63)/64 };
int NZeros = 0;
unsigned i = 0;
bool hitNonZero = false;
for (i=0; i<__N-1; ++i) {
ap_int_base<64, false> t;
t.range(0, 63) = this->range(_AP_W - i*64 - 64, _AP_W - i*64 - 1);
NZeros += hitNonZero?0:__builtin_clzll(t.V);
hitNonZero |= (t != 0);
}
if (!hitNonZero) {
ap_int_base<64, false> t(-1ULL);
t.range(63-(_AP_W-1)%64, 63) = this->range(0, (_AP_W-1)%64);
NZeros += __builtin_clzll(t.V);
}
return NZeros;
}
}
#pragma empty_line
// Arithmetic : Binary
// -------------------------------------------------------------------------
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) typename RType<_AP_W2,_AP_I2,_AP_S2>::mult
operator *(const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>& op2) const {
typename RType<_AP_W2,_AP_I2,_AP_S2>::mult r;
ap_int_base<_AP_W+_AP_W2,_AP_S> OP1;
OP1.V = Base::V;
ap_int_base<_AP_W+_AP_W2,_AP_S2> OP2;
OP2.V = op2.V ;
r.V = OP1.V * OP2.V;
return r;
}
#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 __attribute__((always_inline)) typename RType<_AP_W2,_AP_I2,_AP_S2>::div
operator /(const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>& op2) const {
typename RType<_AP_W2,_AP_I2,_AP_S2>::div r;
#pragma empty_line
ap_fixed_base<_AP_W + ((_AP_W2 - _AP_I2) > (0) ? (_AP_W2 - _AP_I2) : (0)),
_AP_I, _AP_S> t(*this);
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
r.V = t.V / op2.V;
//r = double(to_double() / op2.to_double());
return r;
}
#pragma line 1329 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_fixed_syn.h"
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) typename RType<_AP_W2,_AP_I2,_AP_S2>::plus operator + (const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>& op2) const { ; enum { _AP_F = _AP_W-_AP_I, F2 = _AP_W2-_AP_I2 }; ; typename RType<_AP_W2,_AP_I2,_AP_S2>::plus r, lhs(*this), rhs(op2); ; r.V = lhs.V + rhs.V; return r; }
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) typename RType<_AP_W2,_AP_I2,_AP_S2>::minus 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 }; ; typename RType<_AP_W2,_AP_I2,_AP_S2>::minus r, lhs(*this), rhs(op2); ; r.V = lhs.V - rhs.V; return r; }
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) typename RType<_AP_W2,_AP_I2,_AP_S2>::logic 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 }; ; typename RType<_AP_W2,_AP_I2,_AP_S2>::logic r, lhs(*this), rhs(op2); ; r.V = lhs.V & rhs.V; return r; }
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) typename RType<_AP_W2,_AP_I2,_AP_S2>::logic 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 }; ; typename RType<_AP_W2,_AP_I2,_AP_S2>::logic r, lhs(*this), rhs(op2); ; r.V = lhs.V | rhs.V; return r; }
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) typename RType<_AP_W2,_AP_I2,_AP_S2>::logic 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 }; ; typename RType<_AP_W2,_AP_I2,_AP_S2>::logic r, lhs(*this), rhs(op2); ; r.V = lhs.V ^ rhs.V; return r; }
#pragma empty_line
#pragma empty_line
// Arithmetic : assign
// -------------------------------------------------------------------------
#pragma line 1347 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_fixed_syn.h"
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) ap_fixed_base& operator += (const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2,_AP_N2>& op2) { ; *this = operator + (op2); return *this; }
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) ap_fixed_base& operator -= (const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2,_AP_N2>& op2) { ; *this = operator - (op2); return *this; }
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) ap_fixed_base& operator *= (const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2,_AP_N2>& op2) { ; *this = operator * (op2); return *this; }
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) ap_fixed_base& operator /= (const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2,_AP_N2>& op2) { ; *this = operator / (op2); return *this; }
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) ap_fixed_base& operator &= (const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2,_AP_N2>& op2) { ; *this = operator & (op2); return *this; }
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) ap_fixed_base& operator |= (const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2,_AP_N2>& op2) { ; *this = operator | (op2); return *this; }
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) ap_fixed_base& operator ^= (const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2,_AP_N2>& op2) { ; *this = operator ^ (op2); return *this; }
#pragma empty_line
#pragma empty_line
// Prefix increment, decrement.
// -------------------------------------------------------------------------
inline __attribute__((always_inline)) ap_fixed_base& operator ++() {
operator+=(ap_fixed_base<_AP_W-_AP_I+1,1,false>(1));
return *this;
}
inline __attribute__((always_inline)) ap_fixed_base& operator --() {
operator-=(ap_fixed_base<_AP_W-_AP_I+1,1,false>(1));
return *this;
}
#pragma empty_line
// Postfix increment, decrement
// -------------------------------------------------------------------------
inline __attribute__((always_inline)) const ap_fixed_base
operator ++(int) {
ap_fixed_base t(*this);
operator++();
return t;
}
inline __attribute__((always_inline)) const ap_fixed_base
operator --(int) {
ap_fixed_base t(*this);
operator--();
return t;
}
#pragma empty_line
// Unary arithmetic.
// -------------------------------------------------------------------------
inline __attribute__((always_inline)) ap_fixed_base operator +() {
return *this;
}
#pragma empty_line
inline __attribute__((always_inline)) ap_fixed_base<_AP_W + 1, _AP_I + 1, true> operator -() const {
ap_fixed_base<_AP_W + 1, _AP_I + 1, true> ret(*this);
ret.V = - ret.V;
return ret;
}
#pragma empty_line
inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,true,_AP_Q,_AP_O,_AP_N> getNeg() {
ap_fixed_base<_AP_W,_AP_I,true,_AP_Q,_AP_O,_AP_N> Tmp(*this);
Tmp.V = -Tmp.V;
return Tmp;
}
#pragma empty_line
// Not (!)
// -------------------------------------------------------------------------
inline __attribute__((always_inline)) bool operator !() const {
return Base::V == 0;
}
#pragma empty_line
// Bitwise complement
// -------------------------------------------------------------------------
inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S> operator ~() const {
ap_fixed_base<_AP_W, _AP_I, _AP_S> ret;
ret.V=~Base::V;
return ret;
}
#pragma empty_line
// Shift
// -------------------------------------------------------------------------
template<int _AP_SHIFT>
inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I + _AP_SHIFT, _AP_S> lshift () const {
ap_fixed_base<_AP_W, _AP_I + _AP_SHIFT, _AP_S> r;
r.V = Base::V;
return r;
}
#pragma empty_line
template<int _AP_SHIFT>
inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I - _AP_SHIFT, _AP_S> rshift () const {
ap_fixed_base<_AP_W, _AP_I - _AP_SHIFT, _AP_S> r;
r.V = Base::V;
return r;
}
#pragma empty_line
/*__attribute__((weak))*/ ap_fixed_base
operator << (int sh) const {
#pragma empty_line
_ssdm_InlineSelf(0, "");
#pragma empty_line
ap_fixed_base r;
bool isNeg = sh & 0x80000000;
sh = isNeg ? -sh : sh;
if (isNeg) r.V = Base::V >> sh;
else r.V = Base::V << sh;
#pragma line 1478 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_fixed_syn.h"
return r;
#pragma empty_line
}
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) ap_fixed_base
operator << (const ap_int_base<_AP_W2,true>& op2) const {
int sh = op2.to_int();
return operator << (sh);
}
#pragma empty_line
/*__attribute__((weak))*/ ap_fixed_base
operator << (unsigned int sh) const {
#pragma empty_line
_ssdm_InlineSelf(0, "");
#pragma empty_line
ap_fixed_base r;
r.V = Base::V << sh;
#pragma line 1523 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_fixed_syn.h"
return r;
}
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) ap_fixed_base
operator << (const ap_int_base<_AP_W2,false>& op2) const {
unsigned int sh = op2.to_uint();
return operator << (sh);
}
#pragma empty_line
/*__attribute__((weak))*/ ap_fixed_base
operator >> (int sh) const {
#pragma empty_line
_ssdm_InlineSelf(0, "");
#pragma empty_line
ap_fixed_base r;
bool isNeg = sh & 0x80000000;
sh = isNeg ? -sh : sh;
if (isNeg) r.V = Base::V << sh;
else r.V = Base::V >> sh;
#pragma line 1581 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_fixed_syn.h"
return r;
}
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) ap_fixed_base
operator >> (const ap_int_base<_AP_W2,true>& op2) const {
int sh = op2.to_int();
return operator >> (sh);
}
#pragma empty_line
/*__attribute__((weak))*/ ap_fixed_base
operator >> (unsigned sh) const {
#pragma empty_line
_ssdm_InlineSelf(0, "");
#pragma empty_line
ap_fixed_base r;
r.V = Base::V >> sh;
#pragma line 1613 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_fixed_syn.h"
return r;
}
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) ap_fixed_base
operator >> (const ap_int_base<_AP_W2,false>& op2) const {
unsigned int sh = op2.to_uint();
return operator >> (sh);
}
#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 __attribute__((always_inline)) ap_fixed_base
operator >> (const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2,
_AP_N2>& op2) {
return operator >> (op2.to_ap_int_base());
}
#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 __attribute__((always_inline)) ap_fixed_base
operator << (const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2,
_AP_N2>& op2) {
return operator << (op2.to_ap_int_base());
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
// Shift assign
// -------------------------------------------------------------------------
/*__attribute__((weak))*/ ap_fixed_base&
operator <<= (int sh) {
#pragma empty_line
_ssdm_InlineSelf(0, "");
#pragma empty_line
if (sh == 0) return *this;
bool isNeg = sh & 0x80000000;
sh = isNeg ? -sh : sh;
#pragma line 1682 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_fixed_syn.h"
if (isNeg) Base::V >>= sh;
else Base::V <<= sh;
#pragma line 1696 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_fixed_syn.h"
return *this;
}
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) ap_fixed_base&
operator <<= (const ap_int_base<_AP_W2,true>& op2) {
int sh = op2.to_int();
return operator <<= (sh);
}
#pragma empty_line
/*__attribute__((weak))*/ ap_fixed_base&
operator <<= (unsigned int sh) {
#pragma empty_line
_ssdm_InlineSelf(0, "");
#pragma line 1731 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_fixed_syn.h"
Base::V <<= sh;
#pragma line 1743 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_fixed_syn.h"
return *this;
}
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) ap_fixed_base&
operator <<= (const ap_int_base<_AP_W2,false>& op2) {
unsigned int sh = op2.to_uint();
return operator <<= (sh);
}
#pragma empty_line
/*__attribute__((weak))*/ ap_fixed_base&
operator >>= (int sh) {
#pragma empty_line
_ssdm_InlineSelf(0, "");
#pragma empty_line
if (sh == 0) return *this;
bool isNeg = sh & 0x80000000;
sh = isNeg ? -sh : sh;
#pragma line 1791 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_fixed_syn.h"
if (isNeg) Base::V <<= sh;
else Base::V >>= sh;
#pragma line 1805 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_fixed_syn.h"
return *this;
}
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) ap_fixed_base&
operator >>= (const ap_int_base<_AP_W2,true>& op2) {
int sh = op2.to_int();
return operator >>= (sh);
}
#pragma empty_line
/*__attribute__((weak))*/ ap_fixed_base&
operator >>= (unsigned int sh) {
#pragma empty_line
_ssdm_InlineSelf(0, "");
#pragma line 1835 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_fixed_syn.h"
Base::V >>= sh;
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
return *this;
}
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) ap_fixed_base&
operator >>= (const ap_int_base<_AP_W2,false>& op2) {
unsigned int sh = op2.to_uint();
return operator >>= (sh);
}
#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 __attribute__((always_inline)) ap_fixed_base&
operator >>= (const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2,
_AP_N2>& op2) {
return operator >>= (op2.to_ap_int_base());
}
#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 __attribute__((always_inline)) ap_fixed_base&
operator <<= (const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2,
_AP_N2>& op2) {
return operator <<= (op2.to_ap_int_base());
}
#pragma empty_line
// Comparisons.
// -------------------------------------------------------------------------
#pragma line 1882 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_fixed_syn.h"
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) bool operator == (const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>& op2) const { const int _AP_F = _AP_W-_AP_I, F2 = _AP_W2-_AP_I2 ; if (_AP_F == F2) return Base::V == op2.V; else if (_AP_F > F2) return Base::V == ap_fixed_base<((_AP_W2+_AP_F-F2) > (1) ? (_AP_W2+_AP_F-F2) : (1)),_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>(op2).V; else return ap_fixed_base<((_AP_W+F2-_AP_F+1) > (1) ? (_AP_W+F2-_AP_F+1) : (1)),_AP_I+1,_AP_S,_AP_Q,_AP_O, _AP_N>(*this).V == op2.V; return false; }
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) bool operator != (const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>& op2) const { const int _AP_F = _AP_W-_AP_I, F2 = _AP_W2-_AP_I2 ; if (_AP_F == F2) return Base::V != op2.V; else if (_AP_F > F2) return Base::V != ap_fixed_base<((_AP_W2+_AP_F-F2) > (1) ? (_AP_W2+_AP_F-F2) : (1)),_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>(op2).V; else return ap_fixed_base<((_AP_W+F2-_AP_F+1) > (1) ? (_AP_W+F2-_AP_F+1) : (1)),_AP_I+1,_AP_S,_AP_Q,_AP_O, _AP_N>(*this).V != op2.V; return false; }
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) bool operator > (const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>& op2) const { const int _AP_F = _AP_W-_AP_I, F2 = _AP_W2-_AP_I2 ; if (_AP_F == F2) return Base::V > op2.V; else if (_AP_F > F2) return Base::V > ap_fixed_base<((_AP_W2+_AP_F-F2) > (1) ? (_AP_W2+_AP_F-F2) : (1)),_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>(op2).V; else return ap_fixed_base<((_AP_W+F2-_AP_F+1) > (1) ? (_AP_W+F2-_AP_F+1) : (1)),_AP_I+1,_AP_S,_AP_Q,_AP_O, _AP_N>(*this).V > op2.V; return false; }
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) bool operator >= (const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>& op2) const { const int _AP_F = _AP_W-_AP_I, F2 = _AP_W2-_AP_I2 ; if (_AP_F == F2) return Base::V >= op2.V; else if (_AP_F > F2) return Base::V >= ap_fixed_base<((_AP_W2+_AP_F-F2) > (1) ? (_AP_W2+_AP_F-F2) : (1)),_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>(op2).V; else return ap_fixed_base<((_AP_W+F2-_AP_F+1) > (1) ? (_AP_W+F2-_AP_F+1) : (1)),_AP_I+1,_AP_S,_AP_Q,_AP_O, _AP_N>(*this).V >= op2.V; return false; }
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) bool operator < (const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>& op2) const { const int _AP_F = _AP_W-_AP_I, F2 = _AP_W2-_AP_I2 ; if (_AP_F == F2) return Base::V < op2.V; else if (_AP_F > F2) return Base::V < ap_fixed_base<((_AP_W2+_AP_F-F2) > (1) ? (_AP_W2+_AP_F-F2) : (1)),_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>(op2).V; else return ap_fixed_base<((_AP_W+F2-_AP_F+1) > (1) ? (_AP_W+F2-_AP_F+1) : (1)),_AP_I+1,_AP_S,_AP_Q,_AP_O, _AP_N>(*this).V < op2.V; return false; }
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) bool operator <= (const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>& op2) const { const int _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
#pragma empty_line
inline __attribute__((always_inline)) bool operator == (double d) const { return to_double() == d; }
inline __attribute__((always_inline)) bool operator != (double d) const { return to_double() != d; }
inline __attribute__((always_inline)) bool operator > (double d) const { return to_double() > d; }
inline __attribute__((always_inline)) bool operator >= (double d) const { return to_double() >= d; }
inline __attribute__((always_inline)) bool operator < (double d) const { return to_double() < d; }
inline __attribute__((always_inline)) bool operator <= (double d) const { return to_double() <= d; }
#pragma empty_line
// Bit and Slice Select
inline __attribute__((always_inline)) af_bit_ref<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N> operator[] (unsigned index) {
;
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 __attribute__((always_inline)) af_bit_ref<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N> operator [] (const ap_int_base<_AP_W2,_AP_S2>& index) {
;
;
return af_bit_ref<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>(this, index.to_int());
}
#pragma empty_line
inline __attribute__((always_inline)) bool operator [] (unsigned index) const {
;
return ({ typeof(const_cast<ap_fixed_base*>(this)->V) __Result__ = 0; typeof(const_cast<ap_fixed_base*>(this)->V) __Val2__ = const_cast<ap_fixed_base*>(this)->V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), index, index); (bool)(__Result__ & 1); });
}
#pragma empty_line
inline __attribute__((always_inline)) af_bit_ref<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N> bit(unsigned index) {
;
return af_bit_ref<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>(this, index);
}
#pragma empty_line
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) af_bit_ref<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N> bit (const ap_int_base<_AP_W2,_AP_S2>& index) {
;
;
return af_bit_ref<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>(this, index.to_int());
}
#pragma empty_line
inline __attribute__((always_inline)) bool bit (unsigned index) const {
;
return ({ typeof(const_cast<ap_fixed_base*>(this)->V) __Result__ = 0; typeof(const_cast<ap_fixed_base*>(this)->V) __Val2__ = const_cast<ap_fixed_base*>(this)->V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), index, index); (bool)(__Result__ & 1); });
}
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) af_bit_ref<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N> get_bit (const ap_int_base<_AP_W2, true>& index) {
;
;
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 __attribute__((always_inline)) bool get_bit (int index) const {
;
;
return ({ typeof(const_cast<ap_fixed_base*>(this)->V) __Result__ = 0; typeof(const_cast<ap_fixed_base*>(this)->V) __Val2__ = const_cast<ap_fixed_base*>(this)->V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), index + _AP_W - _AP_I, index + _AP_W - _AP_I); (bool)(__Result__ & 1); });
}
#pragma empty_line
inline __attribute__((always_inline)) af_bit_ref<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N> get_bit (int index) {
;
;
return af_bit_ref<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>(this, index + _AP_W - _AP_I);
}
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) bool get_bit (const ap_int_base<_AP_W2, true>& index) const {
;
;
return ({ typeof(const_cast<ap_fixed_base*>(this)->V) __Result__ = 0; typeof(const_cast<ap_fixed_base*>(this)->V) __Val2__ = const_cast<ap_fixed_base*>(this)->V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), index.to_int() + _AP_W - _AP_I, index.to_int() + _AP_W - _AP_I); (bool)(__Result__ & 1); });
}
#pragma empty_line
#pragma empty_line
inline __attribute__((always_inline)) af_range_ref<_AP_W,_AP_I,_AP_S, _AP_Q, _AP_O, _AP_N>
range(int Hi, int Lo) {
;
return af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>(this, Hi, Lo);
}
#pragma empty_line
inline __attribute__((always_inline)) af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>
operator () (int Hi, int Lo) {
;
return af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>(this, Hi, Lo);
}
#pragma empty_line
inline __attribute__((always_inline)) af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>
range(int Hi, int Lo) const {
;
return af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>(const_cast<
ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>*>(this),
Hi, Lo);
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2, int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) af_range_ref<_AP_W,_AP_I,_AP_S, _AP_Q, _AP_O, _AP_N>
range(const ap_int_base<_AP_W2, _AP_S2> &HiIdx,
const ap_int_base<_AP_W3, _AP_S3> &LoIdx) {
int Hi = HiIdx.to_int();
int Lo = LoIdx.to_int();
;
return af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>(this, Hi, Lo);
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2, int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) af_range_ref<_AP_W,_AP_I,_AP_S, _AP_Q, _AP_O, _AP_N>
operator () (const ap_int_base<_AP_W2, _AP_S2> &HiIdx,
const ap_int_base<_AP_W3, _AP_S3> &LoIdx) {
int Hi = HiIdx.to_int();
int Lo = LoIdx.to_int();
;
return af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>(this, Hi, Lo);
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2, int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) af_range_ref<_AP_W,_AP_I,_AP_S, _AP_Q, _AP_O, _AP_N>
range(const ap_int_base<_AP_W2, _AP_S2> &HiIdx,
const ap_int_base<_AP_W3, _AP_S3> &LoIdx) const {
int Hi = HiIdx.to_int();
int Lo = LoIdx.to_int();
;
return af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>(const_cast<
ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>*>(this),
Hi, Lo);
}
#pragma empty_line
template<int _AP_W2, bool _AP_S2, int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) af_range_ref<_AP_W,_AP_I,_AP_S, _AP_Q, _AP_O, _AP_N>
operator () (const ap_int_base<_AP_W2, _AP_S2> &HiIdx,
const ap_int_base<_AP_W3, _AP_S3> &LoIdx) const {
int Hi = HiIdx.to_int();
int Lo = LoIdx.to_int();
return this->range(Hi, Lo);
}
#pragma empty_line
inline __attribute__((always_inline)) af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>
operator () (int Hi, int Lo) const {
return this->range(Hi, Lo);
}
#pragma empty_line
inline __attribute__((always_inline)) af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>
range() {
return this->range(_AP_W - 1, 0);
}
#pragma empty_line
inline __attribute__((always_inline)) af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>
range() const {
return this->range(_AP_W - 1, 0);
}
#pragma empty_line
inline __attribute__((always_inline)) bool is_zero () const {
return Base::V == 0;
}
#pragma empty_line
inline __attribute__((always_inline)) bool is_neg () const {
if (_AP_S && ({ typeof(const_cast<ap_fixed_base*>(this)->V) __Result__ = 0; typeof(const_cast<ap_fixed_base*>(this)->V) __Val2__ = const_cast<ap_fixed_base*>(this)->V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W - 1, _AP_W - 1); (bool)(__Result__ & 1); }))
return true;
return false;
}
#pragma empty_line
inline __attribute__((always_inline)) int wl () const {
return _AP_W;
}
#pragma empty_line
inline __attribute__((always_inline)) int iwl () const {
return _AP_I;
}
#pragma empty_line
inline __attribute__((always_inline)) ap_q_mode q_mode () const {
return _AP_Q;
}
#pragma empty_line
inline __attribute__((always_inline)) ap_o_mode o_mode () const {
return _AP_O;
}
#pragma empty_line
inline __attribute__((always_inline)) int n_bits () const {
return _AP_N;
}
#pragma empty_line
inline __attribute__((always_inline)) char* to_string(BaseMode mode) {
return 0;
}
#pragma empty_line
inline __attribute__((always_inline)) char* to_string(signed char mode) {
return to_string(BaseMode(mode));
}
};
#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 __attribute__((always_inline)) void b_not(ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& ret,
const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) {
ret.V = ~ op.V;
}
#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 __attribute__((always_inline)) void b_and(ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& ret,
const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op1,
const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op2) {
ret.V = op1.V & op2.V;
}
#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 __attribute__((always_inline)) void b_or(ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& ret,
const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op1,
const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op2) {
ret.V = op1.V | op2.V;
}
#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 __attribute__((always_inline)) void b_xor(ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& ret,
const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op1,
const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op2) {
ret.V = op1.V ^ op2.V;
}
#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 __attribute__((always_inline)) void neg(ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& ret,
const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
ap_fixed_base<_AP_W2+!_AP_S2, _AP_I2+!_AP_S2, true, _AP_Q2, _AP_O2, _AP_N2> Tmp;
Tmp.V = - op.V;
ret = Tmp;
}
#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 __attribute__((always_inline)) void lshift(ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& ret,
const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op,
int i) {
ap_fixed_base<_AP_W2 - _AP_I2 + ((_AP_I) > (_AP_I2) ? (_AP_I) : (_AP_I2)), ((_AP_I) > (_AP_I2) ? (_AP_I) : (_AP_I2)), _AP_S2, _AP_Q2, _AP_O2, _AP_N2> Tmp;
Tmp.V = op.V;
Tmp.V <<= i;
ret = Tmp;
}
#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 __attribute__((always_inline)) void rshift(ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& ret,
const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op,
int i) {
ap_fixed_base<_AP_I2 + ((_AP_W - _AP_I) > (_AP_W2 - _AP_I2) ? (_AP_W - _AP_I) : (_AP_W2 - _AP_I2)), _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> Tmp;
const int val = _AP_W - _AP_I - (_AP_W2 - _AP_I2);
Tmp.V = op.V;
if (val > 0) Tmp.V <<= val;
Tmp.V >>= i;
ret = Tmp;
}
#pragma line 2155 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_fixed_syn.h"
template<> inline __attribute__((always_inline)) ap_fixed_base<1,1,true,SC_TRN,SC_WRAP>::ap_fixed_base(bool i_op) { Base::V = i_op; } template<> inline __attribute__((always_inline)) ap_fixed_base<1,1,false,SC_TRN,SC_WRAP>::ap_fixed_base(bool i_op) { Base::V = i_op; }
template<> inline __attribute__((always_inline)) ap_fixed_base<8,8,true,SC_TRN,SC_WRAP>::ap_fixed_base(char i_op) { Base::V = i_op; } template<> inline __attribute__((always_inline)) ap_fixed_base<8,8,false,SC_TRN,SC_WRAP>::ap_fixed_base(char i_op) { Base::V = i_op; }
template<> inline __attribute__((always_inline)) ap_fixed_base<8,8,true,SC_TRN,SC_WRAP>::ap_fixed_base(signed char i_op) { Base::V = i_op; } template<> inline __attribute__((always_inline)) ap_fixed_base<8,8,false,SC_TRN,SC_WRAP>::ap_fixed_base(signed char i_op) { Base::V = i_op; }
template<> inline __attribute__((always_inline)) ap_fixed_base<8,8,true,SC_TRN,SC_WRAP>::ap_fixed_base(unsigned char i_op) { Base::V = i_op; } template<> inline __attribute__((always_inline)) ap_fixed_base<8,8,false,SC_TRN,SC_WRAP>::ap_fixed_base(unsigned char i_op) { Base::V = i_op; }
template<> inline __attribute__((always_inline)) ap_fixed_base<16,16,true,SC_TRN,SC_WRAP>::ap_fixed_base(signed short i_op) { Base::V = i_op; } template<> inline __attribute__((always_inline)) ap_fixed_base<16,16,false,SC_TRN,SC_WRAP>::ap_fixed_base(signed short i_op) { Base::V = i_op; }
template<> inline __attribute__((always_inline)) ap_fixed_base<16,16,true,SC_TRN,SC_WRAP>::ap_fixed_base(unsigned short i_op) { Base::V = i_op; } template<> inline __attribute__((always_inline)) ap_fixed_base<16,16,false,SC_TRN,SC_WRAP>::ap_fixed_base(unsigned short i_op) { Base::V = i_op; }
template<> inline __attribute__((always_inline)) ap_fixed_base<32,32,true,SC_TRN,SC_WRAP>::ap_fixed_base(signed int i_op) { Base::V = i_op; } template<> inline __attribute__((always_inline)) ap_fixed_base<32,32,false,SC_TRN,SC_WRAP>::ap_fixed_base(signed int i_op) { Base::V = i_op; }
template<> inline __attribute__((always_inline)) ap_fixed_base<32,32,true,SC_TRN,SC_WRAP>::ap_fixed_base(unsigned int i_op) { Base::V = i_op; } template<> inline __attribute__((always_inline)) ap_fixed_base<32,32,false,SC_TRN,SC_WRAP>::ap_fixed_base(unsigned int i_op) { Base::V = i_op; }
#pragma empty_line
template<> inline __attribute__((always_inline)) ap_fixed_base<64,64,true,SC_TRN,SC_WRAP>::ap_fixed_base(long i_op) { Base::V = i_op; } template<> inline __attribute__((always_inline)) ap_fixed_base<64,64,false,SC_TRN,SC_WRAP>::ap_fixed_base(long i_op) { Base::V = i_op; }
template<> inline __attribute__((always_inline)) ap_fixed_base<64,64,true,SC_TRN,SC_WRAP>::ap_fixed_base(unsigned long i_op) { Base::V = i_op; } template<> inline __attribute__((always_inline)) ap_fixed_base<64,64,false,SC_TRN,SC_WRAP>::ap_fixed_base(unsigned long i_op) { Base::V = i_op; }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
template<> inline __attribute__((always_inline)) ap_fixed_base<64,64,true,SC_TRN,SC_WRAP>::ap_fixed_base(ap_slong i_op) { Base::V = i_op; } template<> inline __attribute__((always_inline)) ap_fixed_base<64,64,false,SC_TRN,SC_WRAP>::ap_fixed_base(ap_slong i_op) { Base::V = i_op; }
template<> inline __attribute__((always_inline)) ap_fixed_base<64,64,true,SC_TRN,SC_WRAP>::ap_fixed_base(ap_ulong i_op) { Base::V = i_op; } template<> inline __attribute__((always_inline)) ap_fixed_base<64,64,false,SC_TRN,SC_WRAP>::ap_fixed_base(ap_ulong i_op) { Base::V = i_op; }
#pragma empty_line
#pragma empty_line
/// Output streamimg.
// -----------------------------------------------------------------------------
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q,
ap_o_mode _AP_O, int _AP_N>
inline __attribute__((always_inline)) std::ostream&
operator << (std::ostream& os, const ap_fixed_base<_AP_W,_AP_I,
_AP_S,_AP_Q,_AP_O, _AP_N>& x) {
// os << x.to_double();
return os;
}
#pragma empty_line
/// Input streamimg.
// -----------------------------------------------------------------------------
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q,
ap_o_mode _AP_O, int _AP_N>
inline __attribute__((always_inline)) std::istream&
operator >> (std::istream& in, ap_fixed_base<_AP_W,_AP_I,
_AP_S,_AP_Q,_AP_O, _AP_N>& x) {
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
return in;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
/// Operators mixing Integers with ap_fixed_base
// -----------------------------------------------------------------------------
#pragma line 2273 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_fixed_syn.h"
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<1,1,false>::plus operator + ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, bool i_op) { return op.operator + (ap_fixed_base<1,1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<1,1,false>::plus operator + ( bool i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<1,1,false>(i_op).operator + (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<1,1,false>::minus operator - ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, bool i_op) { return op.operator - (ap_fixed_base<1,1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<1,1,false>::minus operator - ( bool i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<1,1,false>(i_op).operator - (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<1,1,false>::mult operator * ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, bool i_op) { return op.operator * (ap_fixed_base<1,1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<1,1,false>::mult operator * ( bool i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<1,1,false>(i_op).operator * (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<1,1,false>::div operator / ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, bool i_op) { return op.operator / (ap_fixed_base<1,1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<1,1,false>::div operator / ( bool i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<1,1,false>(i_op).operator / (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<1,1,false>::arg1 operator >> ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, bool i_op) { return op.operator >> (ap_int_base<1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<1,1,false>::arg1 operator << ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, bool i_op) { return op.operator << (ap_int_base<1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<1,1,false>::logic operator & ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, bool i_op) { return op.operator & (ap_fixed_base<1,1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<1,1,false>::logic operator & ( bool i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<1,1,false>(i_op).operator & (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<1,1,false>::logic operator | ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, bool i_op) { return op.operator | (ap_fixed_base<1,1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<1,1,false>::logic operator | ( bool i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<1,1,false>(i_op).operator | (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<1,1,false>::logic operator ^ ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, bool i_op) { return op.operator ^ (ap_fixed_base<1,1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<1,1,false>::logic operator ^ ( bool i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<1,1,false>(i_op).operator ^ (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, bool i_op) { return op.operator == (ap_fixed_base<1,1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( bool i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<1,1,false>(i_op).operator == (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, bool i_op) { return op.operator != (ap_fixed_base<1,1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( bool i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<1,1,false>(i_op).operator != (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, bool i_op) { return op.operator > (ap_fixed_base<1,1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( bool i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<1,1,false>(i_op).operator > (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, bool i_op) { return op.operator >= (ap_fixed_base<1,1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( bool i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<1,1,false>(i_op).operator >= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, bool i_op) { return op.operator < (ap_fixed_base<1,1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( bool i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<1,1,false>(i_op).operator < (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, bool i_op) { return op.operator <= (ap_fixed_base<1,1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( bool i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<1,1,false>(i_op).operator <= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator += ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, bool i_op) { return op.operator += (ap_fixed_base<1,1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator -= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, bool i_op) { return op.operator -= (ap_fixed_base<1,1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator *= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, bool i_op) { return op.operator *= (ap_fixed_base<1,1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator /= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, bool i_op) { return op.operator /= (ap_fixed_base<1,1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator >>= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, bool i_op) { return op.operator >>= (ap_int_base<1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator <<= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, bool i_op) { return op.operator <<= (ap_int_base<1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator &= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, bool i_op) { return op.operator &= (ap_fixed_base<1,1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator |= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, bool i_op) { return op.operator |= (ap_fixed_base<1,1,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator ^= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, bool i_op) { return op.operator ^= (ap_fixed_base<1,1,false>(i_op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) 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, char i_op) { return op.operator + (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::plus operator + ( char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator + (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::minus operator - ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, char i_op) { return op.operator - (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::minus operator - ( char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator - (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::mult operator * ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, char i_op) { return op.operator * (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::mult operator * ( char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator * (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::div operator / ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, char i_op) { return op.operator / (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::div operator / ( char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator / (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::arg1 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,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::arg1 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,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::logic operator & ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, char i_op) { return op.operator & (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::logic operator & ( char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator & (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::logic operator | ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, char i_op) { return op.operator | (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::logic operator | ( char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator | (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::logic operator ^ ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, char i_op) { return op.operator ^ (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::logic operator ^ ( char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator ^ (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, char i_op) { return op.operator == (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator == (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, char i_op) { return op.operator != (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator != (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, char i_op) { return op.operator > (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator > (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, char i_op) { return op.operator >= (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator >= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, char i_op) { return op.operator < (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator < (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, char i_op) { return op.operator <= (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator <= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_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,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator -= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, char i_op) { return op.operator -= (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator *= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, char i_op) { return op.operator *= (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator /= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, char i_op) { return op.operator /= (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator >>= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, char i_op) { return op.operator >>= (ap_int_base<8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator <<= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, char i_op) { return op.operator <<= (ap_int_base<8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator &= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, char i_op) { return op.operator &= (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator |= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, char i_op) { return op.operator |= (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator ^= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, char i_op) { return op.operator ^= (ap_fixed_base<8,8,true>(i_op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::plus operator + ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed char i_op) { return op.operator + (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::plus operator + ( signed char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator + (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::minus operator - ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed char i_op) { return op.operator - (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::minus operator - ( signed char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator - (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::mult operator * ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed char i_op) { return op.operator * (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::mult operator * ( signed char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator * (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::div operator / ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed char i_op) { return op.operator / (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::div operator / ( signed char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator / (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::arg1 operator >> ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed char i_op) { return op.operator >> (ap_int_base<8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::arg1 operator << ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed char i_op) { return op.operator << (ap_int_base<8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::logic operator & ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed char i_op) { return op.operator & (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::logic operator & ( signed char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator & (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::logic operator | ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed char i_op) { return op.operator | (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::logic operator | ( signed char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator | (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::logic operator ^ ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed char i_op) { return op.operator ^ (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,true>::logic operator ^ ( signed char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator ^ (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed char i_op) { return op.operator == (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( signed char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator == (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed char i_op) { return op.operator != (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( signed char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator != (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed char i_op) { return op.operator > (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( signed char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator > (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed char i_op) { return op.operator >= (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( signed char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator >= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed char i_op) { return op.operator < (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( signed char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator < (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed char i_op) { return op.operator <= (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( signed char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<8,8,true>(i_op).operator <= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator += ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, signed char i_op) { return op.operator += (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator -= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, signed char i_op) { return op.operator -= (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator *= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, signed char i_op) { return op.operator *= (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator /= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, signed char i_op) { return op.operator /= (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator >>= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed char i_op) { return op.operator >>= (ap_int_base<8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator <<= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed char i_op) { return op.operator <<= (ap_int_base<8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator &= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, signed char i_op) { return op.operator &= (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator |= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, signed char i_op) { return op.operator |= (ap_fixed_base<8,8,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator ^= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, signed char i_op) { return op.operator ^= (ap_fixed_base<8,8,true>(i_op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,false>::plus operator + ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned char i_op) { return op.operator + (ap_fixed_base<8,8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,false>::plus operator + ( unsigned char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<8,8,false>(i_op).operator + (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,false>::minus operator - ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned char i_op) { return op.operator - (ap_fixed_base<8,8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,false>::minus operator - ( unsigned char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<8,8,false>(i_op).operator - (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,false>::mult operator * ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned char i_op) { return op.operator * (ap_fixed_base<8,8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,false>::mult operator * ( unsigned char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<8,8,false>(i_op).operator * (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,false>::div operator / ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned char i_op) { return op.operator / (ap_fixed_base<8,8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,false>::div operator / ( unsigned char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<8,8,false>(i_op).operator / (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,false>::arg1 operator >> ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned char i_op) { return op.operator >> (ap_int_base<8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,false>::arg1 operator << ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned char i_op) { return op.operator << (ap_int_base<8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,false>::logic operator & ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned char i_op) { return op.operator & (ap_fixed_base<8,8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,false>::logic operator & ( unsigned char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<8,8,false>(i_op).operator & (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,false>::logic operator | ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned char i_op) { return op.operator | (ap_fixed_base<8,8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,false>::logic operator | ( unsigned char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<8,8,false>(i_op).operator | (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,false>::logic operator ^ ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned char i_op) { return op.operator ^ (ap_fixed_base<8,8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<8,8,false>::logic operator ^ ( unsigned char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<8,8,false>(i_op).operator ^ (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned char i_op) { return op.operator == (ap_fixed_base<8,8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( unsigned char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<8,8,false>(i_op).operator == (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned char i_op) { return op.operator != (ap_fixed_base<8,8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( unsigned char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<8,8,false>(i_op).operator != (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned char i_op) { return op.operator > (ap_fixed_base<8,8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( unsigned char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<8,8,false>(i_op).operator > (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned char i_op) { return op.operator >= (ap_fixed_base<8,8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( unsigned char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<8,8,false>(i_op).operator >= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned char i_op) { return op.operator < (ap_fixed_base<8,8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( unsigned char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<8,8,false>(i_op).operator < (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned char i_op) { return op.operator <= (ap_fixed_base<8,8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( unsigned char i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<8,8,false>(i_op).operator <= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator += ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned char i_op) { return op.operator += (ap_fixed_base<8,8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator -= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned char i_op) { return op.operator -= (ap_fixed_base<8,8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator *= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned char i_op) { return op.operator *= (ap_fixed_base<8,8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator /= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned char i_op) { return op.operator /= (ap_fixed_base<8,8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator >>= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned char i_op) { return op.operator >>= (ap_int_base<8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator <<= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned char i_op) { return op.operator <<= (ap_int_base<8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator &= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned char i_op) { return op.operator &= (ap_fixed_base<8,8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator |= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned char i_op) { return op.operator |= (ap_fixed_base<8,8,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator ^= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned char i_op) { return op.operator ^= (ap_fixed_base<8,8,false>(i_op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,true>::plus operator + ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed short i_op) { return op.operator + (ap_fixed_base<16,16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,true>::plus operator + ( signed short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<16,16,true>(i_op).operator + (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,true>::minus operator - ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed short i_op) { return op.operator - (ap_fixed_base<16,16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,true>::minus operator - ( signed short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<16,16,true>(i_op).operator - (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,true>::mult operator * ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed short i_op) { return op.operator * (ap_fixed_base<16,16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,true>::mult operator * ( signed short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<16,16,true>(i_op).operator * (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,true>::div operator / ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed short i_op) { return op.operator / (ap_fixed_base<16,16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,true>::div operator / ( signed short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<16,16,true>(i_op).operator / (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,true>::arg1 operator >> ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed short i_op) { return op.operator >> (ap_int_base<16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,true>::arg1 operator << ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed short i_op) { return op.operator << (ap_int_base<16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,true>::logic operator & ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed short i_op) { return op.operator & (ap_fixed_base<16,16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,true>::logic operator & ( signed short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<16,16,true>(i_op).operator & (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,true>::logic operator | ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed short i_op) { return op.operator | (ap_fixed_base<16,16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,true>::logic operator | ( signed short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<16,16,true>(i_op).operator | (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,true>::logic operator ^ ( const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed short i_op) { return op.operator ^ (ap_fixed_base<16,16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,true>::logic operator ^ ( signed short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<16,16,true>(i_op).operator ^ (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed short i_op) { return op.operator == (ap_fixed_base<16,16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( signed short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<16,16,true>(i_op).operator == (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed short i_op) { return op.operator != (ap_fixed_base<16,16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( signed short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<16,16,true>(i_op).operator != (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed short i_op) { return op.operator > (ap_fixed_base<16,16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( signed short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<16,16,true>(i_op).operator > (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed short i_op) { return op.operator >= (ap_fixed_base<16,16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( signed short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<16,16,true>(i_op).operator >= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed short i_op) { return op.operator < (ap_fixed_base<16,16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( signed short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<16,16,true>(i_op).operator < (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed short i_op) { return op.operator <= (ap_fixed_base<16,16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( signed short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<16,16,true>(i_op).operator <= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_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 short i_op) { return op.operator += (ap_fixed_base<16,16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator -= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, signed short i_op) { return op.operator -= (ap_fixed_base<16,16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator *= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, signed short i_op) { return op.operator *= (ap_fixed_base<16,16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator /= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, signed short i_op) { return op.operator /= (ap_fixed_base<16,16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator >>= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed short i_op) { return op.operator >>= (ap_int_base<16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator <<= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, signed short i_op) { return op.operator <<= (ap_int_base<16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator &= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, signed short i_op) { return op.operator &= (ap_fixed_base<16,16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator |= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, signed short i_op) { return op.operator |= (ap_fixed_base<16,16,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator ^= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, signed short i_op) { return op.operator ^= (ap_fixed_base<16,16,true>(i_op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,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<16,16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,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<16,16,false>(i_op).operator + (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,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<16,16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,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<16,16,false>(i_op).operator - (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,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<16,16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,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<16,16,false>(i_op).operator * (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,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<16,16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,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<16,16,false>(i_op).operator / (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,false>::arg1 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<16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,false>::arg1 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<16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,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<16,16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,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<16,16,false>(i_op).operator & (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,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<16,16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,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<16,16,false>(i_op).operator | (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,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<16,16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<16,16,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<16,16,false>(i_op).operator ^ (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned short i_op) { return op.operator == (ap_fixed_base<16,16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( unsigned short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<16,16,false>(i_op).operator == (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned short i_op) { return op.operator != (ap_fixed_base<16,16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( unsigned short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<16,16,false>(i_op).operator != (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned short i_op) { return op.operator > (ap_fixed_base<16,16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( unsigned short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<16,16,false>(i_op).operator > (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned short i_op) { return op.operator >= (ap_fixed_base<16,16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( unsigned short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<16,16,false>(i_op).operator >= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned short i_op) { return op.operator < (ap_fixed_base<16,16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( unsigned short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<16,16,false>(i_op).operator < (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned short i_op) { return op.operator <= (ap_fixed_base<16,16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( unsigned short i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<16,16,false>(i_op).operator <= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_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<16,16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator -= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned short i_op) { return op.operator -= (ap_fixed_base<16,16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator *= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned short i_op) { return op.operator *= (ap_fixed_base<16,16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator /= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned short i_op) { return op.operator /= (ap_fixed_base<16,16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator >>= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned short i_op) { return op.operator >>= (ap_int_base<16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator <<= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned short i_op) { return op.operator <<= (ap_int_base<16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator &= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned short i_op) { return op.operator &= (ap_fixed_base<16,16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator |= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned short i_op) { return op.operator |= (ap_fixed_base<16,16,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator ^= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned short i_op) { return op.operator ^= (ap_fixed_base<16,16,false>(i_op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,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<32,32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,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<32,32,true>(i_op).operator + (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,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<32,32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,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<32,32,true>(i_op).operator - (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,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<32,32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,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<32,32,true>(i_op).operator * (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,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<32,32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,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<32,32,true>(i_op).operator / (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,true>::arg1 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<32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,true>::arg1 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<32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,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<32,32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,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<32,32,true>(i_op).operator & (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,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<32,32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,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<32,32,true>(i_op).operator | (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,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<32,32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,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<32,32,true>(i_op).operator ^ (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, int i_op) { return op.operator == (ap_fixed_base<32,32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( int i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<32,32,true>(i_op).operator == (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, int i_op) { return op.operator != (ap_fixed_base<32,32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( int i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<32,32,true>(i_op).operator != (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, int i_op) { return op.operator > (ap_fixed_base<32,32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( int i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<32,32,true>(i_op).operator > (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, int i_op) { return op.operator >= (ap_fixed_base<32,32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( int i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<32,32,true>(i_op).operator >= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, int i_op) { return op.operator < (ap_fixed_base<32,32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( int i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<32,32,true>(i_op).operator < (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, int i_op) { return op.operator <= (ap_fixed_base<32,32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( int i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<32,32,true>(i_op).operator <= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_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<32,32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator -= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, int i_op) { return op.operator -= (ap_fixed_base<32,32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator *= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, int i_op) { return op.operator *= (ap_fixed_base<32,32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator /= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, int i_op) { return op.operator /= (ap_fixed_base<32,32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator >>= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, int i_op) { return op.operator >>= (ap_int_base<32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator <<= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, int i_op) { return op.operator <<= (ap_int_base<32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator &= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, int i_op) { return op.operator &= (ap_fixed_base<32,32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator |= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, int i_op) { return op.operator |= (ap_fixed_base<32,32,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator ^= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, int i_op) { return op.operator ^= (ap_fixed_base<32,32,true>(i_op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,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<32,32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,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<32,32,false>(i_op).operator + (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,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<32,32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,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<32,32,false>(i_op).operator - (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,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<32,32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,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<32,32,false>(i_op).operator * (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,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<32,32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,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<32,32,false>(i_op).operator / (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,false>::arg1 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<32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,false>::arg1 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<32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,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<32,32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,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<32,32,false>(i_op).operator & (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,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<32,32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,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<32,32,false>(i_op).operator | (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,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<32,32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<32,32,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<32,32,false>(i_op).operator ^ (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned int i_op) { return op.operator == (ap_fixed_base<32,32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( unsigned int i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<32,32,false>(i_op).operator == (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned int i_op) { return op.operator != (ap_fixed_base<32,32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( unsigned int i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<32,32,false>(i_op).operator != (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned int i_op) { return op.operator > (ap_fixed_base<32,32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( unsigned int i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<32,32,false>(i_op).operator > (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned int i_op) { return op.operator >= (ap_fixed_base<32,32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( unsigned int i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<32,32,false>(i_op).operator >= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned int i_op) { return op.operator < (ap_fixed_base<32,32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( unsigned int i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<32,32,false>(i_op).operator < (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned int i_op) { return op.operator <= (ap_fixed_base<32,32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( unsigned int i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<32,32,false>(i_op).operator <= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_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<32,32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator -= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned int i_op) { return op.operator -= (ap_fixed_base<32,32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator *= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned int i_op) { return op.operator *= (ap_fixed_base<32,32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator /= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned int i_op) { return op.operator /= (ap_fixed_base<32,32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator >>= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned int i_op) { return op.operator >>= (ap_int_base<32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator <<= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned int i_op) { return op.operator <<= (ap_int_base<32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator &= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned int i_op) { return op.operator &= (ap_fixed_base<32,32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator |= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned int i_op) { return op.operator |= (ap_fixed_base<32,32,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator ^= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned int i_op) { return op.operator ^= (ap_fixed_base<32,32,false>(i_op)); }
#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 __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,true>(i_op).operator + (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,true>(i_op).operator - (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,true>(i_op).operator * (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,true>(i_op).operator / (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,true>::arg1 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<64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,true>::arg1 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<64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,true>(i_op).operator & (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,true>(i_op).operator | (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,true>(i_op).operator ^ (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, long i_op) { return op.operator == (ap_fixed_base<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( long i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<64,64,true>(i_op).operator == (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, long i_op) { return op.operator != (ap_fixed_base<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( long i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<64,64,true>(i_op).operator != (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, long i_op) { return op.operator > (ap_fixed_base<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( long i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<64,64,true>(i_op).operator > (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, long i_op) { return op.operator >= (ap_fixed_base<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( long i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<64,64,true>(i_op).operator >= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, long i_op) { return op.operator < (ap_fixed_base<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( long i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<64,64,true>(i_op).operator < (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, long i_op) { return op.operator <= (ap_fixed_base<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( long i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<64,64,true>(i_op).operator <= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_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<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator -= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, long i_op) { return op.operator -= (ap_fixed_base<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator *= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, long i_op) { return op.operator *= (ap_fixed_base<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator /= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, long i_op) { return op.operator /= (ap_fixed_base<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator >>= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, long i_op) { return op.operator >>= (ap_int_base<64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator <<= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, long i_op) { return op.operator <<= (ap_int_base<64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator &= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, long i_op) { return op.operator &= (ap_fixed_base<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator |= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, long i_op) { return op.operator |= (ap_fixed_base<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator ^= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, long i_op) { return op.operator ^= (ap_fixed_base<64,64,true>(i_op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,false>(i_op).operator + (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,false>(i_op).operator - (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,false>(i_op).operator * (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,false>(i_op).operator / (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,false>::arg1 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<64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,false>::arg1 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<64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,false>(i_op).operator & (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,false>(i_op).operator | (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,false>(i_op).operator ^ (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned long i_op) { return op.operator == (ap_fixed_base<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( unsigned long i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<64,64,false>(i_op).operator == (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned long i_op) { return op.operator != (ap_fixed_base<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( unsigned long i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<64,64,false>(i_op).operator != (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned long i_op) { return op.operator > (ap_fixed_base<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( unsigned long i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<64,64,false>(i_op).operator > (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned long i_op) { return op.operator >= (ap_fixed_base<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( unsigned long i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<64,64,false>(i_op).operator >= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned long i_op) { return op.operator < (ap_fixed_base<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( unsigned long i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<64,64,false>(i_op).operator < (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned long i_op) { return op.operator <= (ap_fixed_base<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( unsigned long i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<64,64,false>(i_op).operator <= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_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<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator -= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned long i_op) { return op.operator -= (ap_fixed_base<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator *= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned long i_op) { return op.operator *= (ap_fixed_base<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator /= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned long i_op) { return op.operator /= (ap_fixed_base<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator >>= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned long i_op) { return op.operator >>= (ap_int_base<64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator <<= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, unsigned long i_op) { return op.operator <<= (ap_int_base<64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator &= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned long i_op) { return op.operator &= (ap_fixed_base<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator |= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned long i_op) { return op.operator |= (ap_fixed_base<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator ^= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, unsigned long i_op) { return op.operator ^= (ap_fixed_base<64,64,false>(i_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 __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,true>(i_op).operator + (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,true>(i_op).operator - (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,true>(i_op).operator * (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,true>(i_op).operator / (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,true>::arg1 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<64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,true>::arg1 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<64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,true>(i_op).operator & (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,true>(i_op).operator | (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,true>(i_op).operator ^ (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_slong i_op) { return op.operator == (ap_fixed_base<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( ap_slong i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<64,64,true>(i_op).operator == (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_slong i_op) { return op.operator != (ap_fixed_base<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( ap_slong i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<64,64,true>(i_op).operator != (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_slong i_op) { return op.operator > (ap_fixed_base<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( ap_slong i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<64,64,true>(i_op).operator > (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_slong i_op) { return op.operator >= (ap_fixed_base<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( ap_slong i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<64,64,true>(i_op).operator >= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_slong i_op) { return op.operator < (ap_fixed_base<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( ap_slong i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<64,64,true>(i_op).operator < (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_slong i_op) { return op.operator <= (ap_fixed_base<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( ap_slong i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<64,64,true>(i_op).operator <= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_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<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator -= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, ap_slong i_op) { return op.operator -= (ap_fixed_base<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator *= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, ap_slong i_op) { return op.operator *= (ap_fixed_base<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator /= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, ap_slong i_op) { return op.operator /= (ap_fixed_base<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator >>= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_slong i_op) { return op.operator >>= (ap_int_base<64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator <<= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_slong i_op) { return op.operator <<= (ap_int_base<64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator &= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, ap_slong i_op) { return op.operator &= (ap_fixed_base<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator |= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, ap_slong i_op) { return op.operator |= (ap_fixed_base<64,64,true>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator ^= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, ap_slong i_op) { return op.operator ^= (ap_fixed_base<64,64,true>(i_op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,false>(i_op).operator + (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,false>(i_op).operator - (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,false>(i_op).operator * (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,false>(i_op).operator / (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,false>::arg1 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<64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,false>::arg1 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<64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,false>(i_op).operator & (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,false>(i_op).operator | (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W,_AP_I,_AP_S>::template RType<64,64,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<64,64,false>(i_op).operator ^ (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator == (ap_fixed_base<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( ap_ulong i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<64,64,false>(i_op).operator == (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator != (ap_fixed_base<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( ap_ulong i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<64,64,false>(i_op).operator != (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator > (ap_fixed_base<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( ap_ulong i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<64,64,false>(i_op).operator > (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator >= (ap_fixed_base<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( ap_ulong i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<64,64,false>(i_op).operator >= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator < (ap_fixed_base<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( ap_ulong i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<64,64,false>(i_op).operator < (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator <= (ap_fixed_base<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( ap_ulong i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<64,64,false>(i_op).operator <= (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_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<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator -= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator -= (ap_fixed_base<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator *= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator *= (ap_fixed_base<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator /= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator /= (ap_fixed_base<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator >>= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator >>= (ap_int_base<64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& operator <<= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator <<= (ap_int_base<64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator &= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator &= (ap_fixed_base<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator |= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator |= (ap_fixed_base<64,64,false>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& operator ^= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q, _AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator ^= (ap_fixed_base<64,64,false>(i_op)); }
#pragma line 2323 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_fixed_syn.h"
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>::template RType<_AP_W,_AP_I,_AP_S>::plus operator + ( const ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op).operator + (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType<_AP_W2,_AP_W2,_AP_S2>::plus operator + ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator + (ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>::template RType<_AP_W,_AP_I,_AP_S>::minus operator - ( const ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op).operator - (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType<_AP_W2,_AP_W2,_AP_S2>::minus operator - ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator - (ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>::template RType<_AP_W,_AP_I,_AP_S>::mult operator * ( const ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op).operator * (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType<_AP_W2,_AP_W2,_AP_S2>::mult operator * ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator * (ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>::template RType<_AP_W,_AP_I,_AP_S>::div operator / ( const ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op).operator / (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType<_AP_W2,_AP_W2,_AP_S2>::div operator / ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator / (ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>::template RType<_AP_W,_AP_I,_AP_S>::logic operator & ( const ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op).operator & (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType<_AP_W2,_AP_W2,_AP_S2>::logic operator & ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator & (ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>::template RType<_AP_W,_AP_I,_AP_S>::logic operator | ( const ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op).operator | (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType<_AP_W2,_AP_W2,_AP_S2>::logic operator | ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator | (ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>::template RType<_AP_W,_AP_I,_AP_S>::logic operator ^ ( const ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op).operator ^ (op); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType<_AP_W2,_AP_W2,_AP_S2>::logic operator ^ ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator ^ (ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); }
#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 __attribute__((always_inline)) bool operator == ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator == ( ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator == ( const ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op) { return ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op).operator == (op); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator != ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator != ( ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator != ( const ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op) { return ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op).operator != (op); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator > ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator > ( ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator > ( const ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op) { return ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op).operator > (op); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator >= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator >= ( ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator >= ( const ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op) { return ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op).operator >= (op); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator < ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator < ( ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator < ( const ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op) { return ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op).operator < (op); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator <= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator <= ( ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator <= ( const ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op) { return ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op).operator <= (op); }
#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 __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& operator += ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator += (ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W2,_AP_S2>& operator += ( ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return i_op.operator += (op.to_ap_int_base()); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& operator -= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator -= (ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W2,_AP_S2>& operator -= ( ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return i_op.operator -= (op.to_ap_int_base()); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& operator *= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator *= (ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W2,_AP_S2>& operator *= ( ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return i_op.operator *= (op.to_ap_int_base()); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& operator /= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator /= (ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W2,_AP_S2>& operator /= ( ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return i_op.operator /= (op.to_ap_int_base()); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& operator &= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator &= (ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W2,_AP_S2>& operator &= ( ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return i_op.operator &= (op.to_ap_int_base()); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& operator |= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator |= (ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W2,_AP_S2>& operator |= ( ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return i_op.operator |= (op.to_ap_int_base()); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& operator ^= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator ^= (ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W2,_AP_S2>& operator ^= ( ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return i_op.operator ^= (op.to_ap_int_base()); }
#pragma empty_line
// Relational Operators with double
template<int _AP_W, int _AP_I, bool _AP_S,
ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N>
inline __attribute__((always_inline)) bool operator == ( double op1, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op2) {
return op2.operator == (op1);
}
template<int _AP_W, int _AP_I, bool _AP_S,
ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N>
inline __attribute__((always_inline)) bool operator != ( double op1, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op2) {
return op2.operator != (op1);
}
template<int _AP_W, int _AP_I, bool _AP_S,
ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N>
inline __attribute__((always_inline)) bool operator > ( double op1, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op2) {
return op2.operator < (op1);
}
template<int _AP_W, int _AP_I, bool _AP_S,
ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N>
inline __attribute__((always_inline)) bool operator >= ( double op1, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op2) {
return op2.operator <= (op1);
}
template<int _AP_W, int _AP_I, bool _AP_S,
ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N>
inline __attribute__((always_inline)) bool operator < ( double op1, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op2) {
return op2.operator > (op1);
}
template<int _AP_W, int _AP_I, bool _AP_S,
ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N>
inline __attribute__((always_inline)) bool operator <= ( double op1, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op2) {
return op2.operator >= (op1);
}
#pragma line 2408 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_fixed_syn.h"
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<1,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( bool op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<1,false>(op2).operator > (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, bool op2) { return (bool(op)) > op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( bool op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 > (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<1,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( bool op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<1,false>(op2).operator < (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, bool op2) { return (bool(op)) < op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( bool op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 < (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<1,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( bool op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<1,false>(op2).operator >= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, bool op2) { return (bool(op)) >= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( bool op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 >= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<1,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( bool op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<1,false>(op2).operator <= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, bool op2) { return (bool(op)) <= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( bool op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 <= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<1,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( bool op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<1,false>(op2).operator == (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, bool op2) { return (bool(op)) == op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( bool op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 == (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, bool op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<1,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( bool op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<1,false>(op2).operator != (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, bool op2) { return (bool(op)) != op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( bool op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 != (bool(op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, char op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<8,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( 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).operator > (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, char op2) { return (bool(op)) > op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 > (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, char op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<8,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( 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).operator < (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, char op2) { return (bool(op)) < op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 < (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, char op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<8,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( 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).operator >= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, char op2) { return (bool(op)) >= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 >= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, char op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<8,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( 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).operator <= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, char op2) { return (bool(op)) <= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 <= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, char op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<8,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( 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).operator == (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, char op2) { return (bool(op)) == op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 == (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, char op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<8,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( 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).operator != (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, char op2) { return (bool(op)) != op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 != (bool(op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<8,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( signed char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<8,true>(op2).operator > (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, signed char op2) { return (bool(op)) > op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( signed char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 > (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<8,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( signed char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<8,true>(op2).operator < (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, signed char op2) { return (bool(op)) < op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( signed char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 < (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<8,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( signed char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<8,true>(op2).operator >= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, signed char op2) { return (bool(op)) >= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( signed char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 >= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<8,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( signed char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<8,true>(op2).operator <= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, signed char op2) { return (bool(op)) <= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( signed char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 <= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<8,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( signed char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<8,true>(op2).operator == (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, signed char op2) { return (bool(op)) == op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( signed char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 == (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<8,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( signed char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<8,true>(op2).operator != (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, signed char op2) { return (bool(op)) != op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( signed char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 != (bool(op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<8,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( unsigned char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<8,false>(op2).operator > (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned char op2) { return (bool(op)) > op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( unsigned char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 > (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<8,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( unsigned char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<8,false>(op2).operator < (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned char op2) { return (bool(op)) < op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( unsigned char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 < (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<8,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( unsigned char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<8,false>(op2).operator >= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned char op2) { return (bool(op)) >= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( unsigned char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 >= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<8,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( unsigned char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<8,false>(op2).operator <= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned char op2) { return (bool(op)) <= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( unsigned char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 <= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<8,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( unsigned char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<8,false>(op2).operator == (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned char op2) { return (bool(op)) == op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( unsigned char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 == (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<8,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( unsigned char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<8,false>(op2).operator != (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned char op2) { return (bool(op)) != op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( unsigned char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 != (bool(op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, short op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<16,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( short op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<16,true>(op2).operator > (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, short op2) { return (bool(op)) > op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( short op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 > (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, short op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<16,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( short op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<16,true>(op2).operator < (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, short op2) { return (bool(op)) < op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( short op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 < (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, short op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<16,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( short op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<16,true>(op2).operator >= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, short op2) { return (bool(op)) >= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( short op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 >= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, short op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<16,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( short op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<16,true>(op2).operator <= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, short op2) { return (bool(op)) <= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( short op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 <= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, short op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<16,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( short op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<16,true>(op2).operator == (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, short op2) { return (bool(op)) == op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( short op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 == (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, short op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<16,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( short op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<16,true>(op2).operator != (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, short op2) { return (bool(op)) != op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( short op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 != (bool(op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned short op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<16,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( unsigned short op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<16,false>(op2).operator > (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned short op2) { return (bool(op)) > op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( unsigned short op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 > (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned short op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<16,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( unsigned short op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<16,false>(op2).operator < (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned short op2) { return (bool(op)) < op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( unsigned short op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 < (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned short op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<16,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( unsigned short op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<16,false>(op2).operator >= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned short op2) { return (bool(op)) >= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( unsigned short op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 >= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned short op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<16,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( unsigned short op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<16,false>(op2).operator <= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned short op2) { return (bool(op)) <= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( unsigned short op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 <= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned short op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<16,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( unsigned short op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<16,false>(op2).operator == (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned short op2) { return (bool(op)) == op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( unsigned short op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 == (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned short op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<16,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( unsigned short op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<16,false>(op2).operator != (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned short op2) { return (bool(op)) != op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( unsigned short op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 != (bool(op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, int op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<32,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( int op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,true>(op2).operator > (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, int op2) { return (bool(op)) > op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( int op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 > (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, int op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<32,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( int op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,true>(op2).operator < (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, int op2) { return (bool(op)) < op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( int op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 < (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, int op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<32,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( int op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,true>(op2).operator >= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, int op2) { return (bool(op)) >= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( int op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 >= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, int op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<32,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( int op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,true>(op2).operator <= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, int op2) { return (bool(op)) <= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( int op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 <= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, int op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<32,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( int op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,true>(op2).operator == (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, int op2) { return (bool(op)) == op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( int op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 == (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, int op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<32,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( int op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,true>(op2).operator != (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, int op2) { return (bool(op)) != op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( int op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 != (bool(op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned int op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<32,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( unsigned int op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,false>(op2).operator > (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned int op2) { return (bool(op)) > op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( unsigned int op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 > (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned int op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<32,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( unsigned int op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,false>(op2).operator < (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned int op2) { return (bool(op)) < op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( unsigned int op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 < (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned int op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<32,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( unsigned int op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,false>(op2).operator >= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned int op2) { return (bool(op)) >= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( unsigned int op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 >= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned int op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<32,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( unsigned int op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,false>(op2).operator <= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned int op2) { return (bool(op)) <= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( unsigned int op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 <= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned int op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<32,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( unsigned int op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,false>(op2).operator == (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned int op2) { return (bool(op)) == op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( unsigned int op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 == (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned int op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<32,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( unsigned int op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,false>(op2).operator != (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned int op2) { return (bool(op)) != op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( unsigned int op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 != (bool(op)); }
#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 __attribute__((always_inline)) bool operator > ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, long op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<32,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( long op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,true>(op2).operator > (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, long op2) { return (bool(op)) > op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( long op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 > (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, long op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<32,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( long op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,true>(op2).operator < (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, long op2) { return (bool(op)) < op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( long op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 < (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, long op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<32,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( long op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,true>(op2).operator >= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, long op2) { return (bool(op)) >= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( long op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 >= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, long op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<32,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( long op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,true>(op2).operator <= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, long op2) { return (bool(op)) <= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( long op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 <= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, long op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<32,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( long op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,true>(op2).operator == (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, long op2) { return (bool(op)) == op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( long op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 == (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, long op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<32,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( long op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,true>(op2).operator != (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, long op2) { return (bool(op)) != op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( long op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 != (bool(op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned long op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<32,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( unsigned long op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,false>(op2).operator > (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned long op2) { return (bool(op)) > op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( unsigned long op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 > (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned long op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<32,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( unsigned long op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,false>(op2).operator < (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned long op2) { return (bool(op)) < op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( unsigned long op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 < (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned long op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<32,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( unsigned long op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,false>(op2).operator >= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned long op2) { return (bool(op)) >= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( unsigned long op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 >= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned long op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<32,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( unsigned long op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,false>(op2).operator <= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned long op2) { return (bool(op)) <= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( unsigned long op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 <= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned long op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<32,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( unsigned long op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,false>(op2).operator == (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned long op2) { return (bool(op)) == op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( unsigned long op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 == (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned long op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<32,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( unsigned long op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<32,false>(op2).operator != (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, unsigned long op2) { return (bool(op)) != op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( unsigned long op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 != (bool(op)); }
#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 __attribute__((always_inline)) bool operator > ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_slong op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<64,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( ap_slong op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<64,true>(op2).operator > (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_slong op2) { return (bool(op)) > op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( ap_slong op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 > (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_slong op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<64,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( ap_slong op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<64,true>(op2).operator < (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_slong op2) { return (bool(op)) < op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( ap_slong op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 < (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_slong op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<64,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( ap_slong op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<64,true>(op2).operator >= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_slong op2) { return (bool(op)) >= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( ap_slong op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 >= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_slong op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<64,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( ap_slong op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<64,true>(op2).operator <= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_slong op2) { return (bool(op)) <= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( ap_slong op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 <= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_slong op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<64,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( ap_slong op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<64,true>(op2).operator == (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_slong op2) { return (bool(op)) == op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( ap_slong op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 == (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_slong op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<64,true>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( ap_slong op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<64,true>(op2).operator != (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_slong op2) { return (bool(op)) != op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( ap_slong op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 != (bool(op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_ulong op2) { return (ap_int_base<_AP_W, false>(op)).operator > (ap_int_base<64,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( ap_ulong op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<64,false>(op2).operator > (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_ulong op2) { return (bool(op)) > op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator > ( ap_ulong op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 > (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_ulong op2) { return (ap_int_base<_AP_W, false>(op)).operator < (ap_int_base<64,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( ap_ulong op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<64,false>(op2).operator < (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_ulong op2) { return (bool(op)) < op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator < ( ap_ulong op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 < (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_ulong op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (ap_int_base<64,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( ap_ulong op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<64,false>(op2).operator >= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_ulong op2) { return (bool(op)) >= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >= ( ap_ulong op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 >= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_ulong op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (ap_int_base<64,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( ap_ulong op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<64,false>(op2).operator <= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_ulong op2) { return (bool(op)) <= op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <= ( ap_ulong op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 <= (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_ulong op2) { return (ap_int_base<_AP_W, false>(op)).operator == (ap_int_base<64,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( ap_ulong op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<64,false>(op2).operator == (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_ulong op2) { return (bool(op)) == op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator == ( ap_ulong op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 == (bool(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_ulong op2) { return (ap_int_base<_AP_W, false>(op)).operator != (ap_int_base<64,false>(op2)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( ap_ulong op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return ap_int_base<64,false>(op2).operator != (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, ap_ulong op2) { return (bool(op)) != op2; } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator != ( ap_ulong op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2 != (bool(op)); }
#pragma line 2448 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_fixed_syn.h"
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator > ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, const ap_int_base<_AP_W2, _AP_S> &op2) { return (ap_int_base<_AP_W, false>(op)).operator > (op2); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator > (const ap_int_base<_AP_W2, _AP_S2> &op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2.operator > (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator > ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, const ap_int_base<_AP_W2, _AP_S2> &op2) { return (ap_int_base<1, false>(op)).operator > (op2); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator > ( const ap_int_base<_AP_W2, _AP_S2> &op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2.operator > (ap_int_base<1,false>(op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator < ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, const ap_int_base<_AP_W2, _AP_S> &op2) { return (ap_int_base<_AP_W, false>(op)).operator < (op2); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator < (const ap_int_base<_AP_W2, _AP_S2> &op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2.operator < (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator < ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, const ap_int_base<_AP_W2, _AP_S2> &op2) { return (ap_int_base<1, false>(op)).operator < (op2); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator < ( const ap_int_base<_AP_W2, _AP_S2> &op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2.operator < (ap_int_base<1,false>(op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator >= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, const ap_int_base<_AP_W2, _AP_S> &op2) { return (ap_int_base<_AP_W, false>(op)).operator >= (op2); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator >= (const ap_int_base<_AP_W2, _AP_S2> &op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2.operator >= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator >= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, const ap_int_base<_AP_W2, _AP_S2> &op2) { return (ap_int_base<1, false>(op)).operator >= (op2); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator >= ( const ap_int_base<_AP_W2, _AP_S2> &op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2.operator >= (ap_int_base<1,false>(op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator <= ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, const ap_int_base<_AP_W2, _AP_S> &op2) { return (ap_int_base<_AP_W, false>(op)).operator <= (op2); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator <= (const ap_int_base<_AP_W2, _AP_S2> &op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2.operator <= (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator <= ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, const ap_int_base<_AP_W2, _AP_S2> &op2) { return (ap_int_base<1, false>(op)).operator <= (op2); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator <= ( const ap_int_base<_AP_W2, _AP_S2> &op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2.operator <= (ap_int_base<1,false>(op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator == ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, const ap_int_base<_AP_W2, _AP_S> &op2) { return (ap_int_base<_AP_W, false>(op)).operator == (op2); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator == (const ap_int_base<_AP_W2, _AP_S2> &op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2.operator == (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator == ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, const ap_int_base<_AP_W2, _AP_S2> &op2) { return (ap_int_base<1, false>(op)).operator == (op2); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator == ( const ap_int_base<_AP_W2, _AP_S2> &op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2.operator == (ap_int_base<1,false>(op)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator != ( const af_range_ref<_AP_W,_AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, const ap_int_base<_AP_W2, _AP_S> &op2) { return (ap_int_base<_AP_W, false>(op)).operator != (op2); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator != (const ap_int_base<_AP_W2, _AP_S2> &op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2.operator != (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator != ( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op, const ap_int_base<_AP_W2, _AP_S2> &op2) { return (ap_int_base<1, false>(op)).operator != (op2); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator != ( const ap_int_base<_AP_W2, _AP_S2> &op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op) { return op2.operator != (ap_int_base<1,false>(op)); }
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
// XSIP watermark, do not delete 67d7842dbbe25473c3c32b93c0da8047785f30d78e8a024de1b57352245f9689
#pragma line 62 "/opt/Xilinx/Vivado_HLS/2016.4/common/technology/autopilot/ap_int.h" 2
//Forward declaration
template<int _AP_W, int _AP_I, ap_q_mode _AP_Q,
ap_o_mode _AP_O, int _AP_N> struct ap_fixed;
template<int _AP_W, int _AP_I, ap_q_mode _AP_Q,
ap_o_mode _AP_O, int _AP_N> struct ap_ufixed;
template<int _AP_W> struct ap_int;
template<int _AP_W> struct ap_uint;
#pragma empty_line
//AP_INT
//--------------------------------------------------------
template<int _AP_W>
struct ap_int: ap_int_base<_AP_W, true> {
typedef ap_int_base<_AP_W, true> Base;
//Constructor
inline __attribute__((always_inline)) ap_int(): Base() {}
template<int _AP_W2>
inline __attribute__((always_inline)) ap_int(const ap_int<_AP_W2> &op) {Base::V = op.V;}
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) ap_int(const volatile ap_int<_AP_W2> &op) {Base::V = op.V;}
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) ap_int(const ap_uint<_AP_W2> &op) { Base::V = op.V;}
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_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 __attribute__((always_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 __attribute__((always_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 __attribute__((always_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 __attribute__((always_inline)) ap_int(const ap_fixed<_AP_W2, _AP_I2, _AP_Q2, _AP_O2, _AP_N2>& op)
:Base((ap_fixed_base<_AP_W2, _AP_I2, true, _AP_Q2, _AP_O2, _AP_N2>)op) {}
#pragma empty_line
template<int _AP_W2, int _AP_I2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_int(const ap_ufixed<_AP_W2, _AP_I2, _AP_Q2, _AP_O2, _AP_N2>& op)
:Base((ap_fixed_base<_AP_W2, _AP_I2, false, _AP_Q2, _AP_O2, _AP_N2>)op) {}
#pragma empty_line
template<int _AP_W2, int _AP_I2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_int(const volatile ap_fixed<_AP_W2, _AP_I2, _AP_Q2, _AP_O2, _AP_N2>& op)
:Base((ap_fixed_base<_AP_W2, _AP_I2, true, _AP_Q2, _AP_O2, _AP_N2>)op) {}
#pragma empty_line
template<int _AP_W2, int _AP_I2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_int(const volatile ap_ufixed<_AP_W2, _AP_I2, _AP_Q2, _AP_O2, _AP_N2>& op)
:Base((ap_fixed_base<_AP_W2, _AP_I2, false, _AP_Q2, _AP_O2, _AP_N2>)op) {}
#pragma empty_line
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int(const ap_int_base<_AP_W2, _AP_S2>& op){ Base::V = op.V; }
#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 __attribute__((always_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 __attribute__((always_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 __attribute__((always_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 __attribute__((always_inline)) ap_int(bool val) {Base::V = val; }
inline __attribute__((always_inline)) ap_int(signed char val) {Base::V = val; }
inline __attribute__((always_inline)) ap_int(unsigned char val) {Base::V = val; }
inline __attribute__((always_inline)) ap_int(short val) {Base::V = val; }
inline __attribute__((always_inline)) ap_int(unsigned short val) {Base::V = val; }
inline __attribute__((always_inline)) ap_int(int val) {Base::V = val; }
inline __attribute__((always_inline)) ap_int(unsigned int val) {Base::V = val; }
inline __attribute__((always_inline)) ap_int(long val) {Base::V = val; }
inline __attribute__((always_inline)) ap_int(unsigned long val) {Base::V = val; }
inline __attribute__((always_inline)) ap_int(unsigned long long val) {Base::V = val; }
inline __attribute__((always_inline)) ap_int(long long val) {Base::V = val; }
inline __attribute__((always_inline)) ap_int(float val) {Base::V = val; }
inline __attribute__((always_inline)) ap_int(double val) {Base::V = val; }
#pragma empty_line
inline __attribute__((always_inline)) ap_int(const char* str):Base(str) {}
inline __attribute__((always_inline)) ap_int(const char* str, signed char radix):Base(str, radix) {}
//Assignment
//Assignment
//Another form of "write"
inline __attribute__((always_inline)) void operator = (const ap_int<_AP_W>& op2) volatile {
Base::V = op2.V;
}
#pragma empty_line
inline __attribute__((always_inline)) void operator = (const volatile ap_int<_AP_W>& op2) volatile {
Base::V = op2.V;
}
#pragma empty_line
inline __attribute__((always_inline)) ap_int& operator = (const volatile ap_int<_AP_W>& op2) {
Base::V = op2.V;
return *this;
}
#pragma empty_line
inline __attribute__((always_inline)) ap_int& operator = (const ap_int<_AP_W>& op2) {
Base::V = op2.V;
return *this;
}
};
#pragma empty_line
//AP_UINT
//---------------------------------------------------------------
template<int _AP_W>
struct ap_uint: ap_int_base<_AP_W, false> {
typedef ap_int_base<_AP_W, false> Base;
//Constructor
inline __attribute__((always_inline)) ap_uint(): Base() {}
template<int _AP_W2>
inline __attribute__((always_inline)) ap_uint(const ap_uint<_AP_W2> &op) { Base::V = op.V; }
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) ap_uint(const ap_int<_AP_W2> &op) { Base::V = op.V;}
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) ap_uint(const volatile ap_uint<_AP_W2> &op) { Base::V = op.V; }
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_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 __attribute__((always_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 __attribute__((always_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 __attribute__((always_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 __attribute__((always_inline)) ap_uint(const ap_fixed<_AP_W2, _AP_I2, _AP_Q2, _AP_O2, _AP_N2>& op)
:Base((ap_fixed_base<_AP_W2, _AP_I2, true, _AP_Q2, _AP_O2, _AP_N2>)op) {}
#pragma empty_line
template<int _AP_W2, int _AP_I2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_uint(const ap_ufixed<_AP_W2, _AP_I2, _AP_Q2, _AP_O2, _AP_N2>& op)
:Base((ap_fixed_base<_AP_W2, _AP_I2, false, _AP_Q2, _AP_O2, _AP_N2>)op) {}
#pragma empty_line
template<int _AP_W2, int _AP_I2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_uint(const volatile ap_fixed<_AP_W2, _AP_I2, _AP_Q2, _AP_O2, _AP_N2>& op)
:Base((ap_fixed_base<_AP_W2, _AP_I2, true, _AP_Q2, _AP_O2, _AP_N2>)op) {}
#pragma empty_line
template<int _AP_W2, int _AP_I2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_uint(const volatile ap_ufixed<_AP_W2, _AP_I2, _AP_Q2, _AP_O2, _AP_N2>& op)
:Base((ap_fixed_base<_AP_W2, _AP_I2, false, _AP_Q2, _AP_O2, _AP_N2>)op) {}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_uint(const ap_int_base<_AP_W2, _AP_S2>& op){ Base::V = op.V;}
#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 __attribute__((always_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 __attribute__((always_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 __attribute__((always_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 __attribute__((always_inline)) ap_uint(bool val) { Base::V = val; }
inline __attribute__((always_inline)) ap_uint(signed char val) { Base::V = val; }
inline __attribute__((always_inline)) ap_uint(unsigned char val) { Base::V = val; }
inline __attribute__((always_inline)) ap_uint(short val) { Base::V = val; }
inline __attribute__((always_inline)) ap_uint(unsigned short val) { Base::V = val; }
inline __attribute__((always_inline)) ap_uint(int val) { Base::V = val; }
inline __attribute__((always_inline)) ap_uint(unsigned int val) { Base::V = val; }
inline __attribute__((always_inline)) ap_uint(long val) { Base::V = val; }
inline __attribute__((always_inline)) ap_uint(unsigned long val) { Base::V = val; }
inline __attribute__((always_inline)) ap_uint(unsigned long long val) { Base::V = val; }
inline __attribute__((always_inline)) ap_uint(long long val) { Base::V = val; }
inline __attribute__((always_inline)) ap_uint(float val) { Base::V = val; }
inline __attribute__((always_inline)) ap_uint(double val) { Base::V = val; }
#pragma empty_line
inline __attribute__((always_inline)) ap_uint(const char* str):Base(str) {}
inline __attribute__((always_inline)) ap_uint(const char* str, signed char radix):Base(str, radix) {}
//Assignment
//Another form of "write"
inline __attribute__((always_inline)) void operator = (const ap_uint<_AP_W>& op2) volatile {
Base::V = op2.V;
}
#pragma empty_line
inline __attribute__((always_inline)) void operator = (const volatile ap_uint<_AP_W>& op2) volatile {
Base::V = op2.V;
}
#pragma empty_line
inline __attribute__((always_inline)) ap_uint& operator = (const volatile ap_uint<_AP_W>& op2) {
Base::V = op2.V;
return *this;
}
#pragma empty_line
inline __attribute__((always_inline)) ap_uint& operator = (const ap_uint<_AP_W>& op2) {
Base::V = op2.V;
return *this;
}
};
#pragma empty_line
#pragma empty_line
//AP_FIXED
//---------------------------------------------------------------------
template<int _AP_W, int _AP_I, ap_q_mode _AP_Q = SC_TRN,
ap_o_mode _AP_O = SC_WRAP, int _AP_N = 0>
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;
//Constructor
inline __attribute__((always_inline)) ap_fixed():Base() {}
#pragma empty_line
template<int _AP_W2, int _AP_I2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_fixed(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 __attribute__((always_inline)) ap_fixed(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>
inline __attribute__((always_inline)) ap_fixed(const ap_int<_AP_W2>& op):
Base(ap_int_base<_AP_W2, true>(op)) {}
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) ap_fixed(const ap_uint<_AP_W2>& op):
Base(ap_int_base<_AP_W2, false>(op)) {}
template<int _AP_W2, int _AP_I2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_fixed(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 __attribute__((always_inline)) ap_fixed(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>
inline __attribute__((always_inline)) ap_fixed(const volatile ap_int<_AP_W2>& op):
Base(ap_int_base<_AP_W2, true>(op)) {}
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) ap_fixed(const volatile ap_uint<_AP_W2>& op):
Base(ap_int_base<_AP_W2, false>(op)) {}
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_fixed(const 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, bool _AP_S2>
inline __attribute__((always_inline)) ap_fixed(const ap_bit_ref<_AP_W2, _AP_S2>& op):
Base(op) {}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_fixed(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 __attribute__((always_inline)) ap_fixed(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 __attribute__((always_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
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_fixed(const af_range_ref<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2>& op): Base(op) {}
#pragma empty_line
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_fixed(const ap_int_base<_AP_W2, _AP_S2>& op): Base(op) {}
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline __attribute__((always_inline)) ap_fixed(bool v):Base(v) {}
inline __attribute__((always_inline)) ap_fixed(signed char v):Base(v) {}
inline __attribute__((always_inline)) ap_fixed(unsigned char v):Base(v) {}
inline __attribute__((always_inline)) ap_fixed(short v):Base(v) {}
inline __attribute__((always_inline)) ap_fixed(unsigned short v):Base(v) {}
inline __attribute__((always_inline)) ap_fixed(int v):Base(v) {}
inline __attribute__((always_inline)) ap_fixed(unsigned int v):Base(v) {}
inline __attribute__((always_inline)) ap_fixed(long v):Base(v) {}
inline __attribute__((always_inline)) ap_fixed(unsigned long v):Base(v) {}
inline __attribute__((always_inline)) ap_fixed(unsigned long long v):Base(v) {}
inline __attribute__((always_inline)) ap_fixed(long long v):Base(v) {}
inline __attribute__((always_inline)) ap_fixed(float v):Base(v) {}
inline __attribute__((always_inline)) ap_fixed(double v):Base(v) {}
#pragma empty_line
inline __attribute__((always_inline)) ap_fixed(const char* str):Base(str) {}
inline __attribute__((always_inline)) ap_fixed(const char* str, signed char radix):Base(str, radix) {}
#pragma empty_line
//Assignment
inline __attribute__((always_inline)) ap_fixed& operator = (const ap_fixed<_AP_W, _AP_I, _AP_Q, _AP_O,
_AP_N>& op) {
Base::V = op.V;
return *this;
}
#pragma empty_line
inline __attribute__((always_inline)) ap_fixed& operator = (const volatile ap_fixed<_AP_W, _AP_I, _AP_Q, _AP_O, _AP_N>& op) {
Base::V = op.V;
return *this;
}
#pragma empty_line
inline __attribute__((always_inline)) void operator = (const ap_fixed<_AP_W, _AP_I, _AP_Q, _AP_O,
_AP_N>& op) volatile {
Base::V = op.V;
}
#pragma empty_line
inline __attribute__((always_inline)) void operator = (const volatile ap_fixed<_AP_W, _AP_I, _AP_Q, _AP_O, _AP_N>& op) volatile {
Base::V = op.V;
}
#pragma empty_line
#pragma empty_line
#pragma empty_line
};
//AP_UFIXED
//-------------------------------------------------------------------
template<int _AP_W, int _AP_I, ap_q_mode _AP_Q = SC_TRN,
ap_o_mode _AP_O = SC_WRAP, int _AP_N = 0>
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;
//Constructor
inline __attribute__((always_inline)) ap_ufixed():Base() {}
#pragma empty_line
template<int _AP_W2, int _AP_I2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_ufixed(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
#pragma empty_line
template<int _AP_W2, int _AP_I2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_ufixed(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>
inline __attribute__((always_inline)) ap_ufixed(const ap_int<_AP_W2>& op):
Base(ap_int_base<_AP_W2, true>(op)) {}
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) ap_ufixed(const ap_uint<_AP_W2>& op):
Base(ap_int_base<_AP_W2, false>(op)) {}
template<int _AP_W2, int _AP_I2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_ufixed(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
#pragma empty_line
template<int _AP_W2, int _AP_I2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_ufixed(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>
inline __attribute__((always_inline)) ap_ufixed(const volatile ap_int<_AP_W2>& op):
Base(ap_int_base<_AP_W2, true>(op)) {}
#pragma empty_line
template<int _AP_W2>
inline __attribute__((always_inline)) ap_ufixed(const volatile ap_uint<_AP_W2>& op):
Base(ap_int_base<_AP_W2, false>(op)) {}
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_ufixed(const 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, bool _AP_S2>
inline __attribute__((always_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 __attribute__((always_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 __attribute__((always_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 __attribute__((always_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 __attribute__((always_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
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_ufixed(const ap_int_base<_AP_W2, _AP_S2>& op): Base(op) {}
#pragma empty_line
#pragma empty_line
#pragma empty_line
inline __attribute__((always_inline)) ap_ufixed(bool v):Base(v) {}
inline __attribute__((always_inline)) ap_ufixed(signed char v):Base(v) {}
inline __attribute__((always_inline)) ap_ufixed(unsigned char v):Base(v) {}
inline __attribute__((always_inline)) ap_ufixed(short v):Base(v) {}
inline __attribute__((always_inline)) ap_ufixed(unsigned short v):Base(v) {}
inline __attribute__((always_inline)) ap_ufixed(int v):Base(v) {}
inline __attribute__((always_inline)) ap_ufixed(unsigned int v):Base(v) {}
inline __attribute__((always_inline)) ap_ufixed(long v):Base(v) {}
inline __attribute__((always_inline)) ap_ufixed(unsigned long v):Base(v) {}
inline __attribute__((always_inline)) ap_ufixed(unsigned long long v):Base(v) {}
inline __attribute__((always_inline)) ap_ufixed(long long v):Base(v) {}
inline __attribute__((always_inline)) ap_ufixed(float v):Base(v) {}
inline __attribute__((always_inline)) ap_ufixed(double v):Base(v) {}
#pragma empty_line
inline __attribute__((always_inline)) ap_ufixed(const char* str):Base(str) {}
inline __attribute__((always_inline)) ap_ufixed(const char* str, signed char radix):Base(str, radix) {}
#pragma empty_line
//Assignment
inline __attribute__((always_inline)) ap_ufixed& operator = (const ap_ufixed<_AP_W, _AP_I,
_AP_Q, _AP_O, _AP_N>& op) {
Base::V = op.V;
return *this;
}
#pragma empty_line
inline __attribute__((always_inline)) ap_ufixed& operator = (const volatile ap_ufixed<_AP_W, _AP_I,
_AP_Q, _AP_O, _AP_N>& op) {
Base::V = op.V;
return *this;
}
#pragma empty_line
inline __attribute__((always_inline)) void operator = (const ap_ufixed<_AP_W, _AP_I,
_AP_Q, _AP_O, _AP_N>& op) volatile {
Base::V = op.V;
}
#pragma empty_line
inline __attribute__((always_inline)) void operator = (const volatile ap_ufixed<_AP_W, _AP_I,
_AP_Q, _AP_O, _AP_N>& op) volatile {
Base::V = op.V;
}
#pragma empty_line
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
// XSIP watermark, do not delete 67d7842dbbe25473c3c32b93c0da8047785f30d78e8a024de1b57352245f9689
#pragma line 14 "example/udp.h" 2
#pragma empty_line
#pragma empty_line
namespace udp {
struct eth_header {
ap_uint<48> dest;
ap_uint<48> source;
ap_uint<16> proto; /* host endianess */
#pragma empty_line
static const int width = 112;
#pragma empty_line
eth_header(ap_uint<width> d) :
dest(d(111, 64)),
source(d(63, 16)),
proto(d(15, 0))
{}
#pragma empty_line
operator ap_uint<width>()
{
return (dest, source, proto);
}
};
#pragma empty_line
struct ip_header {
ap_uint<4> version;
ap_uint<4> ihl;
ap_uint<8> tos;
ap_uint<16> tot_len;
ap_uint<16> id;
ap_uint<16> frag_off;
ap_uint<8> ttl;
ap_uint<8> protocol;
ap_uint<16> check;
ap_uint<32> saddr;
ap_uint<32> daddr;
#pragma empty_line
static const int width = 160;
#pragma empty_line
ip_header(ap_uint<width> d) :
version (d(159, 156)),
ihl (d(155, 152)),
tos (d(151, 144)),
tot_len (d(143, 128)),
id (d(127, 112)),
frag_off(d(111, 96)),
ttl (d( 95, 88)),
protocol(d( 87, 80)),
check (d( 79, 64)),
saddr (d( 63, 32)),
daddr (d( 31, 0))
{}
#pragma empty_line
operator ap_uint<width>() {
return (version, ihl, tos, tot_len, id, frag_off, ttl, protocol,
check, saddr, daddr);
}
};
#pragma empty_line
struct udp_header {
ap_uint<16> source;
ap_uint<16> dest;
ap_uint<16> length;
ap_uint<16> checksum;
#pragma empty_line
static const int width = 64;
udp_header(ap_uint<width> d) :
source (d(63, 48)),
dest (d(47, 32)),
length (d(31, 16)),
checksum(d(15, 0))
{}
#pragma empty_line
operator ap_uint<width>() {
return (source, dest, length, checksum);
}
#pragma empty_line
bool empty_packet() const { return length <= width / 8; }
};
#pragma empty_line
struct checksum_t {
ap_uint<16> ip_checksum;
ap_uint<16> udp_checksum;
};
#pragma empty_line
struct header_buffer;
#pragma empty_line
struct header_parser {
eth_header eth;
ip_header ip;
udp_header udp;
#pragma empty_line
static const int width = eth_header::width + ip_header::width + udp_header::width;
#pragma empty_line
header_parser(ap_uint<width> d = 0) :
eth(d(width - 1, 160 + 64)),
ip(d(160 + 64 - 1, 64)),
udp(d(63, 0))
{}
#pragma empty_line
header_parser(const header_buffer& buf);
#pragma empty_line
operator ap_uint<width>() {
return (ap_uint<eth_header::width>(eth),
ap_uint<ip_header::width>(ip),
ap_uint<udp_header::width>(udp));
}
#pragma empty_line
operator header_buffer();
#pragma empty_line
#pragma empty_line
};
#pragma empty_line
struct header_buffer {
ap_uint<header_parser::width> hdr;
static const int width = header_parser::width;
bool drop; /* Mark the packet to be dropped */
bool generated; /* Mark generated packets */
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
}
#pragma line 2 "example/udp.cpp" 2
#pragma line 1 "example/hls_helper.h" 1
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
#pragma empty_line
/* Use DO_PRAGMA to be able to have C preprocessor expansion in a pragma */
#pragma empty_line
#pragma empty_line
namespace hls_helpers {
#pragma empty_line
template <typename T>
bool any_full(hls::stream<T>& out1, hls::stream<T>& out2)
{
return out1.full() || out2.full();
}
#pragma empty_line
template <typename T>
void dup(hls::stream<T>& in, hls::stream<T>& out1, hls::stream<T>& out2)
{
#pragma HLS pipeline II=1 enable_flush
if (!in.empty() && !any_full(out1, out2)) {
T word;
in.read(word);
out1.write(word);
out2.write(word);
}
}
#pragma empty_line
template <unsigned num_streams, typename data>
class duplicator
{
public:
typedef hls::stream<data> stream;
void dup_array(stream& in, stream out[num_streams])
{
#pragma HLS pipeline II=1 enable_flush
if (!in.empty() && !any_full(out)) {
data word;
in.read(word);
for (unsigned i = 0; i < num_streams; ++i)
out[i].write(word);
}
}
#pragma empty_line
void dup2(stream& in, stream& out1, stream& out2)
{
#pragma HLS pipeline II=1 enable_flush
if (!in.empty() && !any_full(out1, out2)) {
data word;
in.read(word);
out1.write(word);
out2.write(word);
}
}
#pragma empty_line
void dup3(stream& in, stream& out1, stream& out2, stream& out3)
{
#pragma HLS pipeline II=1 enable_flush
if (!in.empty() && !any_full(out1, out2, out3)) {
data word;
in.read(word);
out1.write(word);
out2.write(word);
out3.write(word);
}
}
#pragma empty_line
void dup4(stream& in, stream& out1, stream& out2, stream& out3, stream& out4)
{
#pragma HLS inline
dup2(in, intermediate1, intermediate2);
dup2(intermediate1, out1, out2);
dup2(intermediate2, out3, out4);
}
private:
#pragma empty_line
bool any_full(stream out[num_streams])
{
for (int i = 0; i < num_streams; ++i)
if (out[i].full())
return true;
return false;
}
#pragma empty_line
bool any_full(stream& out1, stream& out2)
{
return out1.full() || out2.full();
}
#pragma empty_line
bool any_full(stream& out1, stream& out2, stream& out3)
{
return out1.full() || out2.full() || out3.full();
}
#pragma empty_line
stream intermediate1, intermediate2;
};
#pragma empty_line
#pragma empty_line
#pragma empty_line
template <typename Functor>
class binary_stream
{
public:
typedef typename Functor::first_argument_type first_argument_type;
typedef typename Functor::second_argument_type second_argument_type;
typedef typename Functor::result_type result_type;
void step(hls::stream<first_argument_type>& in1, hls::stream<second_argument_type>& in2, hls::stream<result_type>& out)
{
#pragma HLS pipeline enable_flush
if (!in1.empty() && !in2.empty() && !out.full()) {
out.write(f(in1.read(), in2.read()));
}
}
private:
Functor f;
};
#pragma empty_line
#pragma empty_line
static inline ap_uint<16> swap16(const ap_uint<16> d)
{
return (d(7, 0), d(15, 8));
}
#pragma empty_line
/* AXI Stream output cannot check for fullness as it generates code that is not
* allowed in the standard. */
template <typename T1, typename T2>
static inline void link_axi_stream(hls::stream<T1>& in, hls::stream<T2>& out)
{
#pragma HLS pipeline enable_flush ii=1
T1 flit;
if (in.read_nb(flit))
out.write(T2(flit));
}
#pragma empty_line
template <typename T1, typename T2>
static inline void link_fifo(hls::stream<T1>& in, hls::stream<T2>& out)
{
#pragma HLS pipeline enable_flush ii=1
if (in.empty() || out.full())
return;
#pragma empty_line
T1 flit;
in.read_nb(flit);
out.write_nb(T2(flit));
}
#pragma empty_line
template <typename T1, typename T2>
static inline void link_axi_to_fifo(hls::stream<T1>& in, hls::stream<T2>& out)
{
#pragma HLS pipeline enable_flush ii=1
if (in.empty() || out.full())
return;
#pragma empty_line
T1 flit = in.read();
out.write_nb(T2(flit));
}
#pragma empty_line
template <typename T>
void consume(hls::stream<T>& in)
{
if (!in.empty())
in.read();
}
#pragma empty_line
template <typename T>
void consume(hls::stream<T>& in, bool enabled)
{
T tmp;
if (enabled && !in.empty())
/* In simulation build we read a FIFO, but with synthesis it is an AXI4-Stream.
* This causes an error when trying to use read_nb about an interface mismatch:
*
* ERROR: [XFORM 203-801] Interface read on 'in.V.V' has incompatible types.
* Possible cause(s): data pack is only applied on source(port) or
* destination(variable).
* ERROR: [HLS 200-70] Failed building synthesis data model.
*/
#pragma empty_line
#pragma empty_line
#pragma empty_line
in.read(tmp);
#pragma empty_line
}
#pragma empty_line
template <unsigned Width>
unsigned char get_byte(const ap_uint<Width>& vec, const int i) {
#pragma HLS inline
const int bottom = (Width - 1) - ((i + 1) * 8 - 1), top = (Width - 1) - (i * 8);
#pragma empty_line
return vec(top, bottom);
}
#pragma empty_line
template <unsigned Width>
void write_byte(ap_uint<Width>& vec, const int i, const unsigned char val) {
#pragma HLS inline
const int bottom = (Width - 1) - ((i + 1) * 8 - 1), top = (Width - 1) - (i * 8);
#pragma empty_line
vec(top, bottom) = val;
}
#pragma empty_line
template <unsigned Size, typename T>
void memcpy(T *dest, const T *src) {
#pragma HLS inline
for (int i = 0; i < Size; ++i) {
#pragma HLS unroll
dest[i] = src[i];
}
}
#pragma empty_line
template <unsigned Size, int Width, int Width2>
void memcpy(ap_uint<Width>& dest, ap_uint<Width2>& src) {
#pragma HLS inline
for (int i = 0; i < Size; ++i) {
#pragma HLS unroll
write_byte<Width>(dest, i, get_byte<Width2>(src, i));
}
}
#pragma empty_line
template <unsigned Size, int Width>
void ap_uint_to_char(char *dst, ap_uint<Width>& src) {
#pragma HLS inline
for (int i = 0; i < Size; ++i) {
#pragma HLS unroll
dst[i] = get_byte<Width>(src, i);
}
}
#pragma empty_line
template <unsigned Size, typename T>
void memset(T *dest, T value) {
#pragma HLS inline
for (int i = 0; i < Size; ++i) {
#pragma HLS unroll
dest[i] = value;
}
}
#pragma empty_line
inline int bytes_to_int(const unsigned char* bytes, const uint32_t offset) {
#pragma HLS inline
return (bytes[4 * offset]) << 24 |
(bytes[4 * offset + 1] & 0xFF) << 16 |
(bytes[4 * offset + 2] & 0xFF) << 8 |
(bytes[4 * offset + 3] & 0xFF);
}
#pragma empty_line
template <unsigned Width>
inline void int_to_bytes(const int src, ap_uint<Width>& dest, const uint32_t offset) {
#pragma HLS inline
write_byte<Width>(dest, 4 * offset, src >> 24);
write_byte<Width>(dest, 4 * offset + 1, src >> 16);
write_byte<Width>(dest, 4 * offset + 2, src >> 8);
write_byte<Width>(dest, 4 * offset + 3, src);
}
#pragma empty_line
/* Zero out bytes in the data stream that have their keep bit cleared */
template <typename axi>
// TODO instead of 256 get the width from axi::data::width
ap_uint<256> mask_last_word(axi word)
{
const size_t bits = 256;
const size_t bytes = bits / 8;
ap_uint<8> ret[bytes];
#pragma HLS array_partition variable=ret complete
ap_uint<bits> result;
#pragma empty_line
for (unsigned i = 0; i < sizeof(ret); ++i)
ret[i] = word.data((i+1) * 8 - 1, i * 8);
#pragma empty_line
if (word.last) {
for (unsigned i = 0; i < sizeof(ret); ++i)
if (!word.keep(bytes - 1 - i, bytes - 1 - i))
ret[i] = 0;
}
#pragma empty_line
for (unsigned i = 0; i < sizeof(ret); ++i)
result((i+1) * 8 - 1, i * 8) = ret[i];
#pragma empty_line
return result;
}
#pragma empty_line
} // namespace
#pragma line 3 "example/udp.cpp" 2
#pragma line 1 "/usr/include/boost/preprocessor/iteration/local.hpp" 1 3 4
#pragma line 15 "/usr/include/boost/preprocessor/iteration/local.hpp" 3 4
#pragma line 1 "/usr/include/boost/preprocessor/config/config.hpp" 1 3 4
#pragma line 16 "/usr/include/boost/preprocessor/iteration/local.hpp" 2 3 4
#pragma line 1 "/usr/include/boost/preprocessor/slot/slot.hpp" 1 3 4
#pragma line 15 "/usr/include/boost/preprocessor/slot/slot.hpp" 3 4
#pragma line 1 "/usr/include/boost/preprocessor/cat.hpp" 1 3 4
#pragma line 16 "/usr/include/boost/preprocessor/slot/slot.hpp" 2 3 4
#pragma line 1 "/usr/include/boost/preprocessor/slot/detail/def.hpp" 1 3 4
#pragma line 17 "/usr/include/boost/preprocessor/slot/slot.hpp" 2 3 4
#pragma line 17 "/usr/include/boost/preprocessor/iteration/local.hpp" 2 3 4
#pragma line 1 "/usr/include/boost/preprocessor/tuple/elem.hpp" 1 3 4
#pragma line 18 "/usr/include/boost/preprocessor/tuple/elem.hpp" 3 4
#pragma line 1 "/usr/include/boost/preprocessor/cat.hpp" 1 3 4
#pragma line 19 "/usr/include/boost/preprocessor/tuple/elem.hpp" 2 3 4
#pragma line 1 "/usr/include/boost/preprocessor/config/config.hpp" 1 3 4
#pragma line 20 "/usr/include/boost/preprocessor/tuple/elem.hpp" 2 3 4
#pragma line 1 "/usr/include/boost/preprocessor/facilities/expand.hpp" 1 3 4
#pragma line 17 "/usr/include/boost/preprocessor/facilities/expand.hpp" 3 4
#pragma line 1 "/usr/include/boost/preprocessor/config/config.hpp" 1 3 4
#pragma line 18 "/usr/include/boost/preprocessor/facilities/expand.hpp" 2 3 4
#pragma line 21 "/usr/include/boost/preprocessor/tuple/elem.hpp" 2 3 4
#pragma line 1 "/usr/include/boost/preprocessor/facilities/overload.hpp" 1 3 4
#pragma line 16 "/usr/include/boost/preprocessor/facilities/overload.hpp" 3 4
#pragma line 1 "/usr/include/boost/preprocessor/cat.hpp" 1 3 4
#pragma line 17 "/usr/include/boost/preprocessor/facilities/overload.hpp" 2 3 4
#pragma line 1 "/usr/include/boost/preprocessor/variadic/size.hpp" 1 3 4
#pragma line 16 "/usr/include/boost/preprocessor/variadic/size.hpp" 3 4
#pragma line 1 "/usr/include/boost/preprocessor/cat.hpp" 1 3 4
#pragma line 17 "/usr/include/boost/preprocessor/variadic/size.hpp" 2 3 4
#pragma line 1 "/usr/include/boost/preprocessor/config/config.hpp" 1 3 4
#pragma line 18 "/usr/include/boost/preprocessor/variadic/size.hpp" 2 3 4
#pragma line 18 "/usr/include/boost/preprocessor/facilities/overload.hpp" 2 3 4
#pragma line 22 "/usr/include/boost/preprocessor/tuple/elem.hpp" 2 3 4
#pragma line 1 "/usr/include/boost/preprocessor/tuple/rem.hpp" 1 3 4
#pragma line 16 "/usr/include/boost/preprocessor/tuple/rem.hpp" 3 4
#pragma line 1 "/usr/include/boost/preprocessor/cat.hpp" 1 3 4
#pragma line 17 "/usr/include/boost/preprocessor/tuple/rem.hpp" 2 3 4
#pragma line 1 "/usr/include/boost/preprocessor/config/config.hpp" 1 3 4
#pragma line 18 "/usr/include/boost/preprocessor/tuple/rem.hpp" 2 3 4
#pragma line 1 "/usr/include/boost/preprocessor/facilities/expand.hpp" 1 3 4
#pragma line 19 "/usr/include/boost/preprocessor/tuple/rem.hpp" 2 3 4
#pragma line 1 "/usr/include/boost/preprocessor/facilities/overload.hpp" 1 3 4
#pragma line 20 "/usr/include/boost/preprocessor/tuple/rem.hpp" 2 3 4
#pragma line 1 "/usr/include/boost/preprocessor/tuple/detail/is_single_return.hpp" 1 3 4
#pragma line 15 "/usr/include/boost/preprocessor/tuple/detail/is_single_return.hpp" 3 4
#pragma line 1 "/usr/include/boost/preprocessor/config/config.hpp" 1 3 4
#pragma line 16 "/usr/include/boost/preprocessor/tuple/detail/is_single_return.hpp" 2 3 4
#pragma line 21 "/usr/include/boost/preprocessor/tuple/rem.hpp" 2 3 4
#pragma line 36 "/usr/include/boost/preprocessor/tuple/rem.hpp" 3 4
/*
VC++8.0 cannot handle the variadic version of BOOST_PP_TUPLE_REM(size)
*/
#pragma line 23 "/usr/include/boost/preprocessor/tuple/elem.hpp" 2 3 4
#pragma line 1 "/usr/include/boost/preprocessor/variadic/elem.hpp" 1 3 4
#pragma line 16 "/usr/include/boost/preprocessor/variadic/elem.hpp" 3 4
#pragma line 1 "/usr/include/boost/preprocessor/cat.hpp" 1 3 4
#pragma line 17 "/usr/include/boost/preprocessor/variadic/elem.hpp" 2 3 4
#pragma line 1 "/usr/include/boost/preprocessor/config/config.hpp" 1 3 4
#pragma line 18 "/usr/include/boost/preprocessor/variadic/elem.hpp" 2 3 4
#pragma line 24 "/usr/include/boost/preprocessor/tuple/elem.hpp" 2 3 4
#pragma line 1 "/usr/include/boost/preprocessor/tuple/detail/is_single_return.hpp" 1 3 4
#pragma line 25 "/usr/include/boost/preprocessor/tuple/elem.hpp" 2 3 4
#pragma line 18 "/usr/include/boost/preprocessor/iteration/local.hpp" 2 3 4
#pragma line 4 "example/udp.cpp" 2
#pragma empty_line
using namespace hls_helpers;
#pragma empty_line
namespace udp {
#pragma empty_line
/* basic UDP full packet format:
0x00 - eth.dest[5:2]
0x04 - eth.dest[0:1] eth.src[5:4]
0x08 - eth.src[3:0]
0x0c - ethertype[1:0] ip.ihl ip.version ip.tos
0x10 - ip.totlen ip.id
0x14 - ip.frag_off ip.ttl ip.protocol
0x18 - ip.checksum ip.saddr[3:2]
0x1c - ip.saddr[1:0] ip.daddr[3:2]
0x20 - ip.daddr[1:0] udp.source-port
0x24 - udp.dest-port udp.len
0x28 - udp.checksum data[2 bytes] */
#pragma empty_line
header_parser::header_parser(const header_buffer& buf) :
eth(buf.hdr(width - 1, udp_header::width + ip_header::width)),
ip(buf.hdr(udp_header::width + ip_header::width - 1, udp_header::width)),
udp(buf.hdr(udp_header::width - 1, 0))
{std::cout<<"created this"<<std::endl;}
#pragma empty_line
header_parser::operator header_buffer()
{
header_buffer buf; buf.hdr = *this; buf.generated = true;;
return buf;
}
}
| [
"frythelegend@gmail.com"
] | frythelegend@gmail.com |
3031a50b754d2d228260f8d266ae272e118e5947 | b247668a88e0fe282b1cd29da8afaea9c9691d3d | /cantera18/changes/MinGW_Port/Cantera/src/equil/vcs_inest.cpp | f071a044a518659bae4b1ec155d4888cd798c384 | [] | no_license | nashiong/cantera | 1d47be92b1ad321018ac6136ca9bd52e3e5ac3b4 | 45c579993135e5899d851cc0ca66618445b5296e | refs/heads/master | 2021-01-10T07:00:29.059520 | 2015-08-24T17:10:06 | 2015-08-24T17:10:06 | 44,044,045 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 17,531 | cpp | /**
* @file vcs_inest.cpp
* Implementation methods for obtaining a good initial guess
*/
/* $Author$
* $Date$
* $Revision$
*/
/*
* Copywrite (2005) Sandia Corporation. Under the terms of
* Contract DE-AC04-94AL85000 with Sandia Corporation, the
* U.S. Government retains certain rights in this software.
*/
#include "vcs_solve.h"
#include "vcs_internal.h"
#include "vcs_VolPhase.h"
#include "clockWC.h"
#include <cstdio>
#include <cstdlib>
#include <cmath>
namespace VCSnonideal {
static char pprefix[20] = " --- vcs_inest: ";
// Estimate equilibrium compositions
/*
* Estimates equilibrium compositions.
* Algorithm covered in a section of Smith and Missen's Book.
*
* Linear programming module is based on using dbolm.
*
* @param aw aw[i[ Mole fraction work space (ne in length)
* @param sa sa[j] = Gramm-Schmidt orthog work space (ne in length)
* @param sm sm[i+j*ne] = QR matrix work space (ne*ne in length)
* @param ss ss[j] = Gramm-Schmidt orthog work space (ne in length)
* @param test This is a small negative number.
*/
void VCS_SOLVE::vcs_inest(double * const aw, double * const sa, double * const sm,
double * const ss, double test) {
int conv, k, lt, ikl, kspec, iph, irxn;
double s;
double s1 = 0.0;
double xl, par;
int finished;
int nspecies = m_numSpeciesTot;
int nrxn = m_numRxnTot;
vcs_VolPhase *Vphase = 0;
// double *molNum = VCS_DATA_PTR(m_molNumSpecies_old);
double TMolesMultiphase;
double *xtphMax = VCS_DATA_PTR(m_TmpPhase);
double *xtphMin = VCS_DATA_PTR(m_TmpPhase2);
ikl = 0;
lt = 0;
/*
* CALL ROUTINE TO SOLVE MAX(CC*molNum) SUCH THAT AX*molNum = BB
* AND molNum(I) .GE. 0.0
*
* Note, both of these programs do this.
*/
#ifdef ALTLINPROG
vcs_setMolesLinProg();
#else
int j, jj;
std::vector<double> ax(m_numElemConstraints*nspecies, 0.0);
std::vector<double> bb(m_numElemConstraints, 0.0);
std::vector<double> cc(nspecies, 0.0);
int neActive = 0;
jj = 0;
for (j = 0; j < m_numElemConstraints; j++) {
if (m_elementActive[j]) {
neActive++;
bb[jj] = m_elemAbundancesGoal[j];
jj++;
}
}
for (kspec = 0; kspec < nspecies; ++kspec) {
cc[kspec] = -m_SSfeSpecies[kspec];
jj = 0;
for (j = 0; j < m_numElemConstraints; ++j) {
if (m_elementActive[j]) {
ax[jj + kspec * neActive] = m_formulaMatrix[j][kspec];
jj++;
}
}
}
linprogmax(VCS_DATA_PTR(m_molNumSpecies_old), VCS_DATA_PTR(cc), VCS_DATA_PTR(ax),
VCS_DATA_PTR(bb), neActive, nspecies, neActive);
#endif
#ifdef DEBUG_MODE
if (m_debug_print_lvl >= 2) {
plogf("%s Mole Numbers returned from linear programming (vcs_inest initial guess):\n",
pprefix);
plogf("%s SPECIES MOLE_NUMBER -SS_ChemPotential\n", pprefix);
for (kspec = 0; kspec < nspecies; ++kspec) {
plogf("%s ", pprefix); plogf("%-12.12s", m_speciesName[kspec].c_str());
plogf(" %15.5g %12.3g\n", m_molNumSpecies_old[kspec], -m_SSfeSpecies[kspec]);
}
plogf("%s Element Abundance Agreement returned from linear "
"programming (vcs_inest initial guess):",
pprefix);
plogendl();
plogf("%s Element Goal Actual\n", pprefix);
int jj = 0;
for (int j = 0; j < m_numElemConstraints; j++) {
if (m_elementActive[j]) {
double tmp = 0.0;
for (kspec = 0; kspec < nspecies; ++kspec) {
tmp += m_formulaMatrix[j][kspec] * m_molNumSpecies_old[kspec];
}
plogf("%s ", pprefix); plogf(" %-9.9s", (m_elementName[j]).c_str());
plogf(" %12.3g %12.3g\n", m_elemAbundancesGoal[j], tmp);
jj++;
}
}
plogendl();
}
#endif
/*
* Make sure all species have positive definite mole numbers
* Set voltages to zero for now, until we figure out what to do
*/
vcs_dzero(VCS_DATA_PTR(m_deltaMolNumSpecies), nspecies);
for (kspec = 0; kspec < nspecies; ++kspec) {
iph = m_phaseID[kspec];
Vphase = m_VolPhaseList[iph];
if (m_speciesUnknownType[kspec] != VCS_SPECIES_TYPE_INTERFACIALVOLTAGE) {
if (m_molNumSpecies_old[kspec] <= 0.0) {
/*
* HKM Should eventually include logic here for non SS phases
*/
if (!m_SSPhase[kspec]) {
m_molNumSpecies_old[kspec] = 1.0e-30;
}
}
} else {
m_molNumSpecies_old[kspec] = 0.0;
}
}
/*
* Now find the optimized basis that spans the stoichiometric
* coefficient matrix
*/
(void) vcs_basopt(FALSE, aw, sa, sm, ss, test, &conv);
/* ***************************************************************** */
/* **** CALCULATE TOTAL MOLES, ****************** */
/* **** CHEMICAL POTENTIALS OF BASIS ****************** */
/* ***************************************************************** */
/*
* Calculate TMoles and m_tPhaseMoles_old[]
*/
vcs_tmoles();
/*
* m_tPhaseMoles_new[] will consist of just the component moles
*/
for (iph = 0; iph < m_numPhases; iph++) {
m_tPhaseMoles_new[iph] = TPhInertMoles[iph] + 1.0E-20;
}
for (kspec = 0; kspec < m_numComponents; ++kspec) {
if (m_speciesUnknownType[kspec] == VCS_SPECIES_TYPE_MOLNUM) {
m_tPhaseMoles_new[m_phaseID[kspec]] += m_molNumSpecies_old[kspec];
}
}
TMolesMultiphase = 0.0;
for (iph = 0; iph < m_numPhases; iph++) {
if (! m_VolPhaseList[iph]->m_singleSpecies) {
TMolesMultiphase += m_tPhaseMoles_new[iph];
}
}
vcs_dcopy(VCS_DATA_PTR(m_molNumSpecies_new), VCS_DATA_PTR(m_molNumSpecies_old), nspecies);
for (kspec = 0; kspec < m_numComponents; ++kspec) {
if (m_speciesUnknownType[kspec] != VCS_SPECIES_TYPE_MOLNUM) {
m_molNumSpecies_new[kspec] = 0.0;
}
}
vcs_dcopy(VCS_DATA_PTR(m_feSpecies_new), VCS_DATA_PTR(m_SSfeSpecies),
nspecies);
for (kspec = 0; kspec < m_numComponents; ++kspec) {
if (m_speciesUnknownType[kspec] == VCS_SPECIES_TYPE_MOLNUM) {
if (! m_SSPhase[kspec]) {
iph = m_phaseID[kspec];
m_feSpecies_new[kspec] += log(m_molNumSpecies_new[kspec] / m_tPhaseMoles_old[iph]);
}
} else {
m_molNumSpecies_new[kspec] = 0.0;
}
}
vcs_deltag(0, true, VCS_STATECALC_NEW);
#ifdef DEBUG_MODE
if (m_debug_print_lvl >= 2) {
for (kspec = 0; kspec < nspecies; ++kspec) {
plogf("%s", pprefix); plogf("%-12.12s", m_speciesName[kspec].c_str());
if (kspec < m_numComponents)
plogf("fe* = %15.5g ff = %15.5g\n", m_feSpecies_new[kspec],
m_SSfeSpecies[kspec]);
else
plogf("fe* = %15.5g ff = %15.5g dg* = %15.5g\n",
m_feSpecies_new[kspec], m_SSfeSpecies[kspec], m_deltaGRxn_new[kspec-m_numComponents]);
}
}
#endif
/* ********************************************************** */
/* **** ESTIMATE REACTION ADJUSTMENTS *********************** */
/* ********************************************************** */
vcs_dzero(VCS_DATA_PTR(m_deltaPhaseMoles), m_numPhases);
for (iph = 0; iph < m_numPhases; iph++) {
xtphMax[iph] = log(m_tPhaseMoles_new[iph] * 1.0E32);
xtphMin[iph] = log(m_tPhaseMoles_new[iph] * 1.0E-32);
}
for (irxn = 0; irxn < nrxn; ++irxn) {
kspec = m_indexRxnToSpecies[irxn];
/*
* For single species phases, we will not estimate the
* mole numbers. If the phase exists, it stays. If it
* doesn't exist in the estimate, it doesn't come into
* existence here.
*/
if (! m_SSPhase[kspec]) {
iph = m_phaseID[kspec];
if (m_deltaGRxn_new[irxn] > xtphMax[iph]) m_deltaGRxn_new[irxn] = 0.8 * xtphMax[iph];
if (m_deltaGRxn_new[irxn] < xtphMin[iph]) m_deltaGRxn_new[irxn] = 0.8 * xtphMin[iph];
/*
* HKM -> The TMolesMultiphase is a change of mine.
* It more evenly distributes the initial moles amongst
* multiple multispecies phases according to the
* relative values of the standard state free energies.
* There is no change for problems with one multispecies
* phase.
* It cut diamond4.vin iterations down from 62 to 14.
*/
m_deltaMolNumSpecies[kspec] = 0.5 * (m_tPhaseMoles_new[iph] + TMolesMultiphase)
* exp(-m_deltaGRxn_new[irxn]);
for (k = 0; k < m_numComponents; ++k) {
m_deltaMolNumSpecies[k] += m_stoichCoeffRxnMatrix[irxn][k] * m_deltaMolNumSpecies[kspec];
}
for (iph = 0; iph < m_numPhases; iph++) {
m_deltaPhaseMoles[iph] += m_deltaMolNumPhase[irxn][iph] * m_deltaMolNumSpecies[kspec];
}
}
}
#ifdef DEBUG_MODE
if (m_debug_print_lvl >= 2) {
for (kspec = 0; kspec < nspecies; ++kspec) {
if (m_speciesUnknownType[kspec] != VCS_SPECIES_TYPE_INTERFACIALVOLTAGE) {
plogf("%sdirection (", pprefix); plogf("%-12.12s", m_speciesName[kspec].c_str());
plogf(") = %g", m_deltaMolNumSpecies[kspec]);
if (m_SSPhase[kspec]) {
if (m_molNumSpecies_old[kspec] > 0.0) {
plogf(" (ssPhase exists at w = %g moles)", m_molNumSpecies_old[kspec]);
} else {
plogf(" (ssPhase doesn't exist -> stability not checked)");
}
}
plogendl();
}
}
}
#endif
/* *********************************************************** */
/* **** KEEP COMPONENT SPECIES POSITIVE ********************** */
/* *********************************************************** */
par = 0.5;
for (kspec = 0; kspec < m_numComponents; ++kspec) {
if (m_speciesUnknownType[kspec] != VCS_SPECIES_TYPE_INTERFACIALVOLTAGE) {
if (par < -m_deltaMolNumSpecies[kspec] / m_molNumSpecies_new[kspec]) {
par = -m_deltaMolNumSpecies[kspec] / m_molNumSpecies_new[kspec];
}
}
}
par = 1. / par;
if (par <= 1.0 && par > 0.0) {
par *= 0.8;
} else {
par = 1.0;
}
/* ******************************************** */
/* **** CALCULATE NEW MOLE NUMBERS ************ */
/* ******************************************** */
finished = FALSE;
do {
for (kspec = 0; kspec < m_numComponents; ++kspec) {
if (m_speciesUnknownType[kspec] != VCS_SPECIES_TYPE_INTERFACIALVOLTAGE) {
m_molNumSpecies_old[kspec] = m_molNumSpecies_new[kspec] + par * m_deltaMolNumSpecies[kspec];
} else {
m_deltaMolNumSpecies[kspec] = 0.0;
}
}
for (kspec = m_numComponents; kspec < nspecies; ++kspec) {
if (m_speciesUnknownType[kspec] != VCS_SPECIES_TYPE_INTERFACIALVOLTAGE) {
if (m_deltaMolNumSpecies[kspec] != 0.0) {
m_molNumSpecies_old[kspec] = m_deltaMolNumSpecies[kspec] * par;
}
}
}
/*
* We have a new w[] estimate, go get the
* TMoles and m_tPhaseMoles_old[] values
*/
vcs_tmoles();
if (lt > 0) goto finished;
/* ******************************************* */
/* **** CONVERGENCE FORCING SECTION ********** */
/* ******************************************* */
vcs_setFlagsVolPhases(false, VCS_STATECALC_OLD);
vcs_dfe(VCS_STATECALC_OLD, 0, 0, nspecies);
for (kspec = 0, s = 0.0; kspec < nspecies; ++kspec) {
s += m_deltaMolNumSpecies[kspec] * m_feSpecies_old[kspec];
}
if (s == 0.0) {
finished = TRUE; continue;
}
if (s < 0.0) {
if (ikl <= 0) {
finished = TRUE; continue;
}
}
/* ***************************************** */
/* *** TRY HALF STEP SIZE ****************** */
/* ***************************************** */
if (ikl <= 0) {
s1 = s;
par *= 0.5;
ikl = 1;
continue;
}
/* **************************************************** */
/* **** FIT PARABOLA THROUGH HALF AND FULL STEPS ****** */
/* **************************************************** */
xl = (1.0 - s / (s1 - s)) * 0.5;
if (xl < 0.0) {
/* *************************************************** */
/* *** POOR DIRECTION, REDUCE STEP SIZE TO 0.2 ******* */
/* *************************************************** */
par *= 0.2;
} else {
if (xl > 1.0) {
/* *************************************************** */
/* **** TOO BIG A STEP, TAKE ORIGINAL FULL STEP ****** */
/* *************************************************** */
par *= 2.0;
} else {
/* *************************************************** */
/* **** ACCEPT RESULTS OF FORCER ********************* */
/* *************************************************** */
par = par * 2.0 * xl;
}
}
lt = 1;
} while (!finished);
finished:
;
#ifdef DEBUG_MODE
if (m_debug_print_lvl >= 2) {
plogf("%s Final Mole Numbers produced by inest:\n",
pprefix);
plogf("%s SPECIES MOLE_NUMBER\n", pprefix);
for (kspec = 0; kspec < nspecies; ++kspec) {
plogf("%s ", pprefix); plogf("%-12.12s", m_speciesName[kspec].c_str());
plogf(" %g", m_molNumSpecies_old[kspec]);
plogendl();
}
}
#endif
}
/***************************************************************************/
// Create an initial estimate of the solution to the thermodynamic
// equilibrium problem.
/*
* @return Return value indicates success:
* - 0: successful initial guess
* - -1: Unsuccessful initial guess; the elemental abundances aren't
* satisfied.
*/
int VCS_SOLVE::vcs_inest_TP() {
int retn = 0;
double test;
Cantera::clockWC tickTock;
test = -1.0E20;
if (m_doEstimateEquil > 0) {
/*
* Calculate the elemental abundances
*/
vcs_elab();
if (vcs_elabcheck(0)) {
#ifdef DEBUG_MODE
if (m_debug_print_lvl >= 2) {
plogf("%s Initial guess passed element abundances on input\n", pprefix);
plogf("%s m_doEstimateEquil = 1 so will use the input mole "
"numbers as estimates", pprefix);
plogendl();
}
#endif
return retn;
#ifdef DEBUG_MODE
} else {
if (m_debug_print_lvl >= 2) {
plogf("%s Initial guess failed element abundances on input\n", pprefix);
plogf("%s m_doEstimateEquil = 1 so will discard input "
"mole numbers and find our own estimate", pprefix);
plogendl();
}
#endif
}
}
/*
* Malloc temporary space for usage in this routine and in
* subroutines
* sm[ne*ne]
* ss[ne]
* sa[ne]
* aw[m]
*/
std::vector<double> sm(m_numElemConstraints*m_numElemConstraints, 0.0);
std::vector<double> ss(m_numElemConstraints, 0.0);
std::vector<double> sa(m_numElemConstraints, 0.0);
std::vector<double> aw(m_numSpeciesTot+ m_numElemConstraints, 0.0);
/*
* Go get the estimate of the solution
*/
#ifdef DEBUG_MODE
if (m_debug_print_lvl >= 2) {
plogf("%sGo find an initial estimate for the equilibrium problem",
pprefix);
plogendl();
}
#endif
vcs_inest(VCS_DATA_PTR(aw), VCS_DATA_PTR(sa), VCS_DATA_PTR(sm),
VCS_DATA_PTR(ss), test);
/*
* Calculate the elemental abundances
*/
vcs_elab();
/*
* If we still fail to achieve the correct elemental abundances,
* try to fix the problem again by calling the main elemental abundances
* fixer routine, used in the main program. This
* attempts to tweak the mole numbers of the component species to
* satisfy the element abundance constraints.
*
* Note: We won't do this unless we have to since it involves inverting
* a matrix.
*/
int rangeCheck = vcs_elabcheck(1);
if (!vcs_elabcheck(0)) {
#ifdef DEBUG_MODE
if (m_debug_print_lvl >= 2) {
plogf("%sInitial guess failed element abundances\n", pprefix);
plogf("%sCall vcs_elcorr to attempt fix", pprefix);
plogendl();
}
#endif
vcs_elcorr(VCS_DATA_PTR(sm), VCS_DATA_PTR(aw));
rangeCheck = vcs_elabcheck(1);
if (!vcs_elabcheck(0)) {
plogf("%sInitial guess still fails element abundance equations\n",
pprefix);
plogf("%s - Inability to ever satisfy element abundance "
"constraints is probable", pprefix);
plogendl();
retn = -1;
} else {
#ifdef DEBUG_MODE
if (m_debug_print_lvl >= 2) {
if (rangeCheck) {
plogf("%sInitial guess now satisfies element abundances", pprefix);
plogendl();
} else {
plogf("%sElement Abundances RANGE ERROR\n", pprefix);
plogf("%s - Initial guess satisfies NC=%d element abundances, "
"BUT not NE=%d element abundances", pprefix,
m_numComponents, m_numElemConstraints);
plogendl();
}
}
#endif
}
}
else {
#ifdef DEBUG_MODE
if (m_debug_print_lvl >= 2) {
if (rangeCheck) {
plogf("%sInitial guess satisfies element abundances", pprefix);
plogendl();
} else {
plogf("%sElement Abundances RANGE ERROR\n", pprefix);
plogf("%s - Initial guess satisfies NC=%d element abundances, "
"BUT not NE=%d element abundances", pprefix,
m_numComponents, m_numElemConstraints);
plogendl();
}
}
#endif
}
#ifdef DEBUG_MODE
if (m_debug_print_lvl >= 2) {
plogf("%sTotal Dimensionless Gibbs Free Energy = %15.7E", pprefix,
vcs_Total_Gibbs(VCS_DATA_PTR(m_molNumSpecies_old), VCS_DATA_PTR(m_feSpecies_new),
VCS_DATA_PTR(m_tPhaseMoles_old)));
plogendl();
}
#endif
/*
* Record time
*/
double tsecond = tickTock.secondsWC();
m_VCount->T_Time_inest += tsecond;
(m_VCount->T_Calls_Inest)++;
return retn;
}
}
| [
"hkmoffa@02a645c2-efd0-11dd-984d-ab748d24aa7e"
] | hkmoffa@02a645c2-efd0-11dd-984d-ab748d24aa7e |
a84563aaab6e620922731db37941dcc92989874c | 76d4243eb812451c6e248df117f629a752417429 | /Camera.cpp | 9822229b821b072d0e4325c2d3a9724b813b8441 | [] | no_license | sevoniak/SpaceShooter | e41c318e91284f836a544ee7c6ab0a716d37b338 | 70065f5d1dc1cc8f1148bc98c3188779f41948c3 | refs/heads/master | 2021-01-10T04:16:22.426591 | 2016-03-03T21:37:20 | 2016-03-03T21:37:20 | 53,049,252 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,036 | cpp | #include "Camera.h"
Camera::Camera(int width, int height)
{
position = XMFLOAT3(0.0f, 0.0f, -5.0f);
direction = XMFLOAT3(0.0f, 0.0f, 1.0f);
upDirection = XMFLOAT3(0.0f, 1.0f, 0.0f);
XMStoreFloat4(&orientation, XMQuaternionRotationRollPitchYaw(0, 0, 0));
screenWidth = width;
screenHeight = height;
screenAspectRatio = (float)screenWidth / screenHeight;
fieldOfView = NOMINAL_FOV_Y;
}
Camera::~Camera(void)
{
}
void Camera::updateMatrices()
{
// rebuild direction vectors with current camera quaternion
XMStoreFloat3(&direction, XMVector3Normalize(XMVector4Transform(XMVectorSet(0.0f, 0.0f, 1.0f, 0.0f), XMMatrixRotationQuaternion(XMLoadFloat4(&orientation)))));
XMStoreFloat3(&upDirection, XMVector3Normalize(XMVector4Transform(XMVectorSet(0.0f, 1.0f, 0.0f, 0.0f), XMMatrixRotationQuaternion(XMLoadFloat4(&orientation)))));
//Create a view matrix based on direction camera is looking
XMStoreFloat4x4(&m_viewMatrix, XMMatrixLookToLH(XMLoadFloat3(&position), XMLoadFloat3(&direction), XMLoadFloat3(&upDirection)));
//Create the projection matrix for 3D rendering.
XMStoreFloat4x4(&m_projectionMatrix, XMMatrixPerspectiveFovLH(NOMINAL_FOV_Y, screenAspectRatio, 0.01f, 300.0f));//fieldOfView, screenAspectRatio, CAMERA_SCREEN_NEAR, CAMERA_SCREEN_FAR));
}
XMFLOAT4X4 Camera::getViewMatrix() { return m_viewMatrix; }
XMFLOAT4X4 Camera::getProjectionMatrix() { return m_projectionMatrix; }
void Camera::setPosition(float x, float y, float z)
{
position = XMFLOAT3(x, y, z);
}
void Camera::setDirection(float x, float y, float z)
{
XMFLOAT3 newDirection = XMFLOAT3(x, y, z);
XMStoreFloat3(&direction, XMVector3Normalize(XMLoadFloat3(&newDirection)));
}
void Camera::setUpDirection(float x, float y, float z)
{
XMFLOAT3 newUpDirection = XMFLOAT3(x, y, z);
XMStoreFloat3(&upDirection, XMVector3Normalize(XMLoadFloat3(&newUpDirection)));
}
XMFLOAT3 Camera::getPos() { return position; }
XMFLOAT4 Camera::getOri() { return orientation; }
XMFLOAT3 Camera::getFwd() { return direction; }
XMFLOAT3 Camera::getUp() { return upDirection; }
void Camera::moveForward()
{
position.x += direction.x * CAMERA_DOLLY_SPEED;
position.y += direction.y * CAMERA_DOLLY_SPEED;
position.z += direction.z * CAMERA_DOLLY_SPEED;
}
void Camera::moveForward(float delta)
{
position.x += direction.x * delta;
position.y += direction.y * delta;
position.z += direction.z * delta;
}
void Camera::moveBackward()
{
position.x -= direction.x * CAMERA_DOLLY_SPEED;
position.y -= direction.y * CAMERA_DOLLY_SPEED;
position.z -= direction.z * CAMERA_DOLLY_SPEED;
}
void Camera::moveBackward(float delta)
{
position.x -= direction.x * delta;
position.y -= direction.y * delta;
position.z -= direction.z * delta;
}
void Camera::craneUp()
{
position.x += upDirection.x * CAMERA_CRANE_SPEED;
position.y += upDirection.y * CAMERA_CRANE_SPEED;
position.z += upDirection.z * CAMERA_CRANE_SPEED;
}
void Camera::craneDown()
{
position.x -= upDirection.x * CAMERA_CRANE_SPEED;
position.y -= upDirection.y * CAMERA_CRANE_SPEED;
position.z -= upDirection.z * CAMERA_CRANE_SPEED;
}
void Camera::strafeLeft()
{
XMVECTOR sideWaysVector = XMVector3Normalize(XMVector3Cross(XMLoadFloat3(&upDirection), XMLoadFloat3(&direction)));
position.x -= XMVectorGetX(sideWaysVector) * CAMERA_STRAFE_SPEED;
position.y -= XMVectorGetY(sideWaysVector) * CAMERA_STRAFE_SPEED;
position.z -= XMVectorGetZ(sideWaysVector) * CAMERA_STRAFE_SPEED;
}
void Camera::strafeRight()
{
XMVECTOR sideWaysVector = XMVector3Normalize(XMVector3Cross(XMLoadFloat3(&upDirection), XMLoadFloat3(&direction)));
position.x += XMVectorGetX(sideWaysVector) * CAMERA_STRAFE_SPEED;
position.y += XMVectorGetY(sideWaysVector) * CAMERA_STRAFE_SPEED;
position.z += XMVectorGetZ(sideWaysVector) * CAMERA_STRAFE_SPEED;
}
void Camera::tiltDown()
{
XMVECTOR sideWaysVector = XMVector3Normalize(XMVector3Cross(XMLoadFloat3(&upDirection), XMLoadFloat3(&direction)));
XMVECTOR tiltRotationQuaternion = XMQuaternionRotationAxis(sideWaysVector, XM_PIDIV4/100*CAMERA_TILT_SPEED);
XMStoreFloat4(&orientation, XMQuaternionMultiply(XMLoadFloat4(&orientation),tiltRotationQuaternion));
}
void Camera::tiltUp()
{
XMVECTOR sideWaysVector = XMVector3Normalize(XMVector3Cross(XMLoadFloat3(&upDirection), XMLoadFloat3(&direction)));
XMVECTOR tiltRotationQuaternion = XMQuaternionRotationAxis(sideWaysVector, -XM_PIDIV4/100*CAMERA_TILT_SPEED);
XMStoreFloat4(&orientation, XMQuaternionMultiply(XMLoadFloat4(&orientation),tiltRotationQuaternion));
}
void Camera::panLeft()
{
XMVECTOR panRotationQuaternion = XMQuaternionRotationAxis(XMLoadFloat3(&upDirection), -XM_PIDIV4/100*CAMERA_PAN_SPEED);
XMStoreFloat4(&orientation, XMQuaternionMultiply(XMLoadFloat4(&orientation),panRotationQuaternion));
}
void Camera::panRight()
{
XMVECTOR panRotationQuaternion = XMQuaternionRotationAxis(XMLoadFloat3(&upDirection), XM_PIDIV4/100*CAMERA_PAN_SPEED);
XMStoreFloat4(&orientation, XMQuaternionMultiply(XMLoadFloat4(&orientation),panRotationQuaternion));
}
void Camera::rollLeft()
{
XMVECTOR rollRotationQuaternion = XMQuaternionRotationAxis(XMLoadFloat3(&direction), XM_PIDIV4/100*CAMERA_ROLL_SPEED);
XMStoreFloat4(&orientation, XMQuaternionMultiply(XMLoadFloat4(&orientation),rollRotationQuaternion));
}
void Camera::rollRight()
{
XMVECTOR rollRotationQuaternion = XMQuaternionRotationAxis(XMLoadFloat3(&direction), -XM_PIDIV4/100*CAMERA_ROLL_SPEED);
XMStoreFloat4(&orientation, XMQuaternionMultiply(XMLoadFloat4(&orientation),rollRotationQuaternion));
}
void Camera::zoomIn()
{
if(fieldOfView * CAMERA_ZOOM_IN_FACTOR >= MIN_CAMERA_FOV)
fieldOfView = fieldOfView * CAMERA_ZOOM_IN_FACTOR;
}
void Camera::zoomOut()
{
if( fieldOfView * CAMERA_ZOOM_OUT_FACTOR <= MAX_CAMERA_FOV)
fieldOfView = fieldOfView * CAMERA_ZOOM_OUT_FACTOR;
}
void Camera::resetZoom()
{
fieldOfView = NOMINAL_FOV_Y;
}
| [
"sebsplace@gmail.com"
] | sebsplace@gmail.com |
41363d5efeda9fe39e422cf63bca638b5fbf0f25 | 056fcc67222afe34d96fd9cadb35469f6d305907 | /driveronly_mp_rom/frameworks/av/media/libstagefright/include/MPEG2TSExtractor.h | 30b71b5275086ddbb756f79442bc85c679e41cfe | [
"Apache-2.0",
"LicenseRef-scancode-unicode"
] | permissive | datagutt/12055 | a9e98f2972a76d92b7d07eee690cd1300b780efe | 593741d834fff91ad3587c762caea5f00b69ba69 | refs/heads/master | 2020-07-21T13:04:55.731555 | 2013-10-10T06:12:43 | 2013-10-10T06:12:43 | 14,116,459 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 2,449 | h | /*
* Copyright (C) 2010 The Android Open Source Project
*
* 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 MPEG2_TS_EXTRACTOR_H_
#define MPEG2_TS_EXTRACTOR_H_
#include <media/stagefright/foundation/ABase.h>
#include <media/stagefright/MediaExtractor.h>
#include <utils/threads.h>
#include <utils/Vector.h>
namespace android {
struct AMessage;
struct AnotherPacketSource;
struct ATSParser;
struct DataSource;
struct MPEG2TSSource;
struct String8;
struct LiveSession;
struct MPEG2TSExtractor : public MediaExtractor {
MPEG2TSExtractor(const sp<DataSource> &source);
virtual size_t countTracks();
virtual sp<MediaSource> getTrack(size_t index);
virtual sp<MetaData> getTrackMetaData(size_t index, uint32_t flags);
virtual sp<MetaData> getMetaData();
virtual uint32_t flags() const;
void setLiveSession(const sp<LiveSession> &liveSession);
void seekTo(int64_t seekTimeUs);
#ifndef ANDROID_DEFAULT_CODE
bool getSeeking();
void setVideoState(bool state);
bool getVideoState(void);
#endif
private:
friend struct MPEG2TSSource;
#ifndef ANDROID_DEFAULT_CODE
int64_t mDurationUs;
int64_t mSeekTimeUs;
bool mSeeking;
uint64_t mMaxcount;
off64_t mSeekingOffset;
off64_t mFileSize ;
off64_t mMinOffset ;
off64_t mMaxOffset ;
bool mVideoUnSupportedByDecoder;
#endif
mutable Mutex mLock;
sp<DataSource> mDataSource;
sp<LiveSession> mLiveSession;
sp<ATSParser> mParser;
Vector<sp<AnotherPacketSource> > mSourceImpls;
off64_t mOffset;
void init();
status_t feedMore();
#ifndef ANDROID_DEFAULT_CODE
status_t parseMaxPTS();
uint64_t getDurationUs();
bool findPAT();
#endif
DISALLOW_EVIL_CONSTRUCTORS(MPEG2TSExtractor);
};
bool SniffMPEG2TS(
const sp<DataSource> &source, String8 *mimeType, float *confidence,
sp<AMessage> *);
} // namespace android
#endif // MPEG2_TS_EXTRACTOR_H_
| [
"zhangws@gmail.com"
] | zhangws@gmail.com |
a4431e5466324ae36a97d8911e32ca2e14a69993 | 9218e5e38843856242f052a99c04d748c4f644fc | /cf 1374E1(2).cpp | 426a764f3249e05811799d1ba08c0c4c65250395 | [] | no_license | Sajib-006/Compettitive-programming-code | 1ad124165935e1df5a346093d43fcc6ad40dfb64 | 4cf96529c6084951f53fd31fbf7e9f161570a734 | refs/heads/master | 2022-12-02T09:00:58.579188 | 2020-08-16T17:35:12 | 2020-08-16T17:35:12 | 282,496,200 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 612 | cpp |
#include <cstdio>
#include <algorithm>
#define maxn 200010
using namespace std;
int a[maxn],b[maxn],c[maxn],an,bn,cn;
int main(){
int n,k,i,t,x,y,ans=0;
scanf("%d%d",&n,&k);
for(i=1;i<=n;i++){
scanf("%d%d%d",&t,&x,&y);
if(x==1&&y==1)c[++cn]=t;
else if(x==1)a[++an]=t;
else if(y==1)b[++bn]=t;
}
sort(a+1,a+1+an);
sort(b+1,b+1+bn);
n=min(an,bn);
printf("%d :",cn);
for(i=1;i<=n;i++)
c[++cn]=a[i]+b[i];
printf("%d :",cn);
sort(c+1,c+1+cn);
printf("%d :",cn);
if(cn<k) printf("-1\n");
else{
for(i=1;i<=k;i++)ans+=c[i];
printf("%d\n",ans);
}
return 0;}
| [
"noreply@github.com"
] | noreply@github.com |
7756c2a46fff3e6a560505bb07d6249ac2c809a9 | 8567438779e6af0754620a25d379c348e4cd5a5d | /net/http2/decoder/decode_http2_structures_test.cc | 71cd286258f5cc049967f63622d4b85ec1571d41 | [
"BSD-3-Clause"
] | permissive | thngkaiyuan/chromium | c389ac4b50ccba28ee077cbf6115c41b547955ae | dab56a4a71f87f64ecc0044e97b4a8f247787a68 | refs/heads/master | 2022-11-10T02:50:29.326119 | 2017-04-08T12:28:57 | 2017-04-08T12:28:57 | 84,073,924 | 0 | 1 | BSD-3-Clause | 2022-10-25T19:47:15 | 2017-03-06T13:04:15 | null | UTF-8 | C++ | false | false | 13,712 | cc | // Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "net/http2/decoder/decode_http2_structures.h"
// Tests decoding all of the fixed size HTTP/2 structures (i.e. those defined
// in net/http2/http2_structures.h).
#include <stddef.h>
#include <string>
#include "base/logging.h"
#include "base/strings/string_piece.h"
#include "net/http2/decoder/decode_buffer.h"
#include "net/http2/decoder/decode_status.h"
#include "net/http2/http2_constants.h"
#include "net/http2/http2_structures_test_util.h"
#include "net/http2/tools/http2_frame_builder.h"
#include "net/http2/tools/http2_random.h"
#include "testing/gtest/include/gtest/gtest.h"
using ::testing::AssertionFailure;
using ::testing::AssertionResult;
using ::testing::AssertionSuccess;
using base::StringPiece;
using std::string;
namespace net {
namespace test {
namespace {
template <typename T, size_t N>
StringPiece ToStringPiece(T (&data)[N]) {
return StringPiece(reinterpret_cast<const char*>(data), N * sizeof(T));
}
template <class S>
string SerializeStructure(const S& s) {
Http2FrameBuilder fb;
fb.Append(s);
EXPECT_EQ(S::EncodedSize(), fb.size());
return fb.buffer();
}
template <class S>
class StructureDecoderTest : public ::testing::Test {
protected:
typedef S Structure;
StructureDecoderTest() : random_decode_count_(100) {
CHECK_LE(random_decode_count_, 1000u * 1000u) << "That should be plenty!";
}
// Set the fields of |*p| to random values.
void Randomize(S* p) { ::net::test::Randomize(p, &random_); }
// Fully decodes the Structure at the start of data, and confirms it matches
// *expected (if provided).
void DecodeLeadingStructure(const S* expected, StringPiece data) {
ASSERT_LE(S::EncodedSize(), data.size());
DecodeBuffer db(data);
Randomize(&structure_);
DoDecode(&structure_, &db);
EXPECT_EQ(db.Offset(), S::EncodedSize());
if (expected != nullptr) {
EXPECT_EQ(structure_, *expected);
}
}
template <size_t N>
void DecodeLeadingStructure(const char (&data)[N]) {
DecodeLeadingStructure(nullptr, StringPiece(data, N));
}
// Encode the structure |in_s| into bytes, then decode the bytes
// and validate that the decoder produced the same field values.
void EncodeThenDecode(const S& in_s) {
string bytes = SerializeStructure(in_s);
EXPECT_EQ(S::EncodedSize(), bytes.size());
DecodeLeadingStructure(&in_s, bytes);
}
// Generate
void TestDecodingRandomizedStructures(size_t count) {
EXPECT_LT(count, 1000u * 1000u) << "That should be plenty!";
for (size_t i = 0; i < count && !HasFailure(); ++i) {
Structure input;
Randomize(&input);
EncodeThenDecode(input);
}
}
void TestDecodingRandomizedStructures() {
TestDecodingRandomizedStructures(random_decode_count_);
}
Http2Random random_;
const size_t random_decode_count_;
uint32_t decode_offset_ = 0;
S structure_;
size_t fast_decode_count_ = 0;
size_t slow_decode_count_ = 0;
};
class FrameHeaderDecoderTest : public StructureDecoderTest<Http2FrameHeader> {};
TEST_F(FrameHeaderDecoderTest, DecodesLiteral) {
{
// Realistic input.
const char kData[] = {
0x00, 0x00, 0x05, // Payload length: 5
0x01, // Frame type: HEADERS
0x08, // Flags: PADDED
0x00, 0x00, 0x00, 0x01, // Stream ID: 1
0x04, // Padding length: 4
0x00, 0x00, 0x00, 0x00, // Padding bytes
};
DecodeLeadingStructure(kData);
if (!HasFailure()) {
EXPECT_EQ(5u, structure_.payload_length);
EXPECT_EQ(Http2FrameType::HEADERS, structure_.type);
EXPECT_EQ(Http2FrameFlag::FLAG_PADDED, structure_.flags);
EXPECT_EQ(1u, structure_.stream_id);
}
}
{
// Unlikely input.
const char kData[] = {
0xffu, 0xffu, 0xffu, // Payload length: uint24 max
0xffu, // Frame type: Unknown
0xffu, // Flags: Unknown/All
0xffu, 0xffu, 0xffu, 0xffu, // Stream ID: uint31 max, plus R-bit
};
DecodeLeadingStructure(kData);
if (!HasFailure()) {
EXPECT_EQ((1u << 24) - 1, structure_.payload_length);
EXPECT_EQ(static_cast<Http2FrameType>(255), structure_.type);
EXPECT_EQ(255, structure_.flags);
EXPECT_EQ(0x7FFFFFFFu, structure_.stream_id);
}
}
}
TEST_F(FrameHeaderDecoderTest, DecodesRandomized) {
TestDecodingRandomizedStructures();
}
//------------------------------------------------------------------------------
class PriorityFieldsDecoderTest
: public StructureDecoderTest<Http2PriorityFields> {};
TEST_F(PriorityFieldsDecoderTest, DecodesLiteral) {
{
const char kData[] = {
0x80u, 0x00, 0x00, 0x05, // Exclusive (yes) and Dependency (5)
0xffu, // Weight: 256 (after adding 1)
};
DecodeLeadingStructure(kData);
if (!HasFailure()) {
EXPECT_EQ(5u, structure_.stream_dependency);
EXPECT_EQ(256u, structure_.weight);
EXPECT_EQ(true, structure_.is_exclusive);
}
}
{
const char kData[] = {
0x7f, 0xffu,
0xffu, 0xffu, // Exclusive (no) and Dependency (0x7fffffff)
0x00, // Weight: 1 (after adding 1)
};
DecodeLeadingStructure(kData);
if (!HasFailure()) {
EXPECT_EQ(StreamIdMask(), structure_.stream_dependency);
EXPECT_EQ(1u, structure_.weight);
EXPECT_FALSE(structure_.is_exclusive);
}
}
}
TEST_F(PriorityFieldsDecoderTest, DecodesRandomized) {
TestDecodingRandomizedStructures();
}
//------------------------------------------------------------------------------
class RstStreamFieldsDecoderTest
: public StructureDecoderTest<Http2RstStreamFields> {};
TEST_F(RstStreamFieldsDecoderTest, DecodesLiteral) {
{
const char kData[] = {
0x00, 0x00, 0x00, 0x01, // Error: PROTOCOL_ERROR
};
DecodeLeadingStructure(kData);
if (!HasFailure()) {
EXPECT_TRUE(structure_.IsSupportedErrorCode());
EXPECT_EQ(Http2ErrorCode::PROTOCOL_ERROR, structure_.error_code);
}
}
{
const char kData[] = {
0xffu, 0xffu, 0xffu, 0xffu, // Error: max uint32 (Unknown error code)
};
DecodeLeadingStructure(kData);
if (!HasFailure()) {
EXPECT_FALSE(structure_.IsSupportedErrorCode());
EXPECT_EQ(static_cast<Http2ErrorCode>(0xffffffff), structure_.error_code);
}
}
}
TEST_F(RstStreamFieldsDecoderTest, DecodesRandomized) {
TestDecodingRandomizedStructures();
}
//------------------------------------------------------------------------------
class SettingFieldsDecoderTest
: public StructureDecoderTest<Http2SettingFields> {};
TEST_F(SettingFieldsDecoderTest, DecodesLiteral) {
{
const char kData[] = {
0x00, 0x01, // Setting: HEADER_TABLE_SIZE
0x00, 0x00, 0x40, 0x00, // Value: 16K
};
DecodeLeadingStructure(kData);
if (!HasFailure()) {
EXPECT_TRUE(structure_.IsSupportedParameter());
EXPECT_EQ(Http2SettingsParameter::HEADER_TABLE_SIZE,
structure_.parameter);
EXPECT_EQ(1u << 14, structure_.value);
}
}
{
const char kData[] = {
0x00, 0x00, // Setting: Unknown (0)
0xffu, 0xffu, 0xffu, 0xffu, // Value: max uint32
};
DecodeLeadingStructure(kData);
if (!HasFailure()) {
EXPECT_FALSE(structure_.IsSupportedParameter());
EXPECT_EQ(static_cast<Http2SettingsParameter>(0), structure_.parameter);
}
}
}
TEST_F(SettingFieldsDecoderTest, DecodesRandomized) {
TestDecodingRandomizedStructures();
}
//------------------------------------------------------------------------------
class PushPromiseFieldsDecoderTest
: public StructureDecoderTest<Http2PushPromiseFields> {};
TEST_F(PushPromiseFieldsDecoderTest, DecodesLiteral) {
{
const char kData[] = {
0x00, 0x01, 0x8au, 0x92u, // Promised Stream ID: 101010
};
DecodeLeadingStructure(kData);
if (!HasFailure()) {
EXPECT_EQ(101010u, structure_.promised_stream_id);
}
}
{
// Promised stream id has R-bit (reserved for future use) set, which
// should be cleared by the decoder.
const char kData[] = {
0xffu, 0xffu, 0xffu, 0xffu, // Promised Stream ID: max uint31 and R-bit
};
DecodeLeadingStructure(kData);
if (!HasFailure()) {
EXPECT_EQ(StreamIdMask(), structure_.promised_stream_id);
}
}
}
TEST_F(PushPromiseFieldsDecoderTest, DecodesRandomized) {
TestDecodingRandomizedStructures();
}
//------------------------------------------------------------------------------
class PingFieldsDecoderTest : public StructureDecoderTest<Http2PingFields> {};
TEST_F(PingFieldsDecoderTest, DecodesLiteral) {
{
// Each byte is different, so can detect if order changed.
const char kData[] = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
};
DecodeLeadingStructure(kData);
if (!HasFailure()) {
EXPECT_EQ(StringPiece(kData, 8), ToStringPiece(structure_.opaque_data));
}
}
{
// All zeros, detect problems handling NULs.
const char kData[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
DecodeLeadingStructure(kData);
if (!HasFailure()) {
EXPECT_EQ(StringPiece(kData, 8), ToStringPiece(structure_.opaque_data));
}
}
{
const char kData[] = {
0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu,
};
DecodeLeadingStructure(kData);
if (!HasFailure()) {
EXPECT_EQ(StringPiece(kData, 8), ToStringPiece(structure_.opaque_data));
}
}
}
TEST_F(PingFieldsDecoderTest, DecodesRandomized) {
TestDecodingRandomizedStructures();
}
//------------------------------------------------------------------------------
class GoAwayFieldsDecoderTest : public StructureDecoderTest<Http2GoAwayFields> {
};
TEST_F(GoAwayFieldsDecoderTest, DecodesLiteral) {
{
const char kData[] = {
0x00, 0x00, 0x00, 0x00, // Last Stream ID: 0
0x00, 0x00, 0x00, 0x00, // Error: NO_ERROR (0)
};
DecodeLeadingStructure(kData);
if (!HasFailure()) {
EXPECT_EQ(0u, structure_.last_stream_id);
EXPECT_TRUE(structure_.IsSupportedErrorCode());
EXPECT_EQ(Http2ErrorCode::HTTP2_NO_ERROR, structure_.error_code);
}
}
{
const char kData[] = {
0x00, 0x00, 0x00, 0x01, // Last Stream ID: 1
0x00, 0x00, 0x00, 0x0d, // Error: HTTP_1_1_REQUIRED
};
DecodeLeadingStructure(kData);
if (!HasFailure()) {
EXPECT_EQ(1u, structure_.last_stream_id);
EXPECT_TRUE(structure_.IsSupportedErrorCode());
EXPECT_EQ(Http2ErrorCode::HTTP_1_1_REQUIRED, structure_.error_code);
}
}
{
const char kData[] = {
0xffu, 0xffu, 0xffu, 0xffu, // Last Stream ID: max uint31 and R-bit
0xffu, 0xffu, 0xffu, 0xffu, // Error: max uint32 (Unknown error code)
};
DecodeLeadingStructure(kData);
if (!HasFailure()) {
EXPECT_EQ(StreamIdMask(), structure_.last_stream_id); // No high-bit.
EXPECT_FALSE(structure_.IsSupportedErrorCode());
EXPECT_EQ(static_cast<Http2ErrorCode>(0xffffffff), structure_.error_code);
}
}
}
TEST_F(GoAwayFieldsDecoderTest, DecodesRandomized) {
TestDecodingRandomizedStructures();
}
//------------------------------------------------------------------------------
class WindowUpdateFieldsDecoderTest
: public StructureDecoderTest<Http2WindowUpdateFields> {};
TEST_F(WindowUpdateFieldsDecoderTest, DecodesLiteral) {
{
const char kData[] = {
0x00, 0x01, 0x00, 0x00, // Window Size Increment: 2 ^ 16
};
DecodeLeadingStructure(kData);
if (!HasFailure()) {
EXPECT_EQ(1u << 16, structure_.window_size_increment);
}
}
{
// Increment must be non-zero, but we need to be able to decode the invalid
// zero to detect it.
const char kData[] = {
0x00, 0x00, 0x00, 0x00, // Window Size Increment: 0
};
DecodeLeadingStructure(kData);
if (!HasFailure()) {
EXPECT_EQ(0u, structure_.window_size_increment);
}
}
{
// Increment has R-bit (reserved for future use) set, which
// should be cleared by the decoder.
// clang-format off
const char kData[] = {
// Window Size Increment: max uint31 and R-bit
0xffu, 0xffu, 0xffu, 0xffu,
};
// clang-format on
DecodeLeadingStructure(kData);
if (!HasFailure()) {
EXPECT_EQ(StreamIdMask(), structure_.window_size_increment);
}
}
}
TEST_F(WindowUpdateFieldsDecoderTest, DecodesRandomized) {
TestDecodingRandomizedStructures();
}
//------------------------------------------------------------------------------
class AltSvcFieldsDecoderTest : public StructureDecoderTest<Http2AltSvcFields> {
};
TEST_F(AltSvcFieldsDecoderTest, DecodesLiteral) {
{
const char kData[] = {
0x00, 0x00, // Origin Length: 0
};
DecodeLeadingStructure(kData);
if (!HasFailure()) {
EXPECT_EQ(0, structure_.origin_length);
}
}
{
const char kData[] = {
0x00, 0x14, // Origin Length: 20
};
DecodeLeadingStructure(kData);
if (!HasFailure()) {
EXPECT_EQ(20, structure_.origin_length);
}
}
{
const char kData[] = {
0xffu, 0xffu, // Origin Length: uint16 max
};
DecodeLeadingStructure(kData);
if (!HasFailure()) {
EXPECT_EQ(65535, structure_.origin_length);
}
}
}
TEST_F(AltSvcFieldsDecoderTest, DecodesRandomized) {
TestDecodingRandomizedStructures();
}
} // namespace
} // namespace test
} // namespace net
| [
"hedonist.ky@gmail.com"
] | hedonist.ky@gmail.com |
04e1c358bb72e55582e386f8014840c27a9f80d7 | bcb81cd629fd9af3038e8b497c0604f4828c952d | /GdfEdit2/StringTable.cpp | 65de1c47576e4675af6dceb4775811cedf57d7b1 | [
"MIT"
] | permissive | joeriedel/tread2.4f | be2394d4f9fd2820097ecf0bd2efd9ece272479d | e23ac7beb3db6601095334e54b8e3e565f3e520a | refs/heads/master | 2020-06-18T11:12:30.254749 | 2019-07-10T22:42:07 | 2019-07-10T22:42:07 | 196,283,955 | 2 | 1 | null | null | null | null | WINDOWS-1252 | C++ | false | false | 2,332 | cpp | // STRINGTABLE.CPP
// Copyright © 1999 Joe Riedel, Nick Randal.
// Author: Nick Randal.
#include "stdafx.h"
#include "StringTable.h"
#define TABLE_SPAN 20000
CStringTable m_StringTable;
CStringTable* GetStringTable() { return &m_StringTable; }
CStringTable::CStringTable()
{
for(int n = 0; n < 27; n++)
m_nCount[n] = 0;
m_nDuplicate = 0;
}
CStringTable::~CStringTable()
{
for(int n = 0; n < 27; n++)
{
m_nCount[n] = 0;
m_Table[n].DestroyList();
}
}
int CStringTable::AddItem(const CString &sInput)
{
TABLEENTRY* pNode = NULL;
int n;
int k;
if(sInput.IsEmpty())
return -1;
k = sInput.GetAt(0);
if((k > 64) && (k < 91))
k = k - 65;
else if((k > 96) && (k < 123))
k = k - 97;
else
k = 26;
for(n = 0; n < m_nCount[k]; n++)
{
pNode = m_Table[k].GetItem(n);
if(pNode == NULL)
return -1; //failed linked list is corrupt
if(pNode->sEntry == sInput)
{
m_nDuplicate++;
//return n;
break;
}
else
pNode = NULL;
}
//new entry
if(pNode == NULL)
{
pNode = new TABLEENTRY;
if(pNode == NULL)
return -1;
pNode->sEntry = sInput;
m_Table[k].AddItem(pNode, LL_TAIL);
n = m_nCount[k];
m_nCount[k]++;
}
return (k * TABLE_SPAN) + n;
}
bool CStringTable::GetItem(int nRef, CString &sOutput)
{
TABLEENTRY* pNode = m_Table[nRef / TABLE_SPAN].GetItem(nRef % TABLE_SPAN);
if(pNode != NULL)
{
sOutput = pNode->sEntry;
return true;
}
else
return false;
}
int CStringTable::FindItem(const CString &sInput)
{
int n;
int k;
TABLEENTRY* pNode = NULL;
k = sInput.GetAt(0);
if((k > 64) && (k < 91))
k = k - 65;
else if((k > 96) && (k < 123))
k = k - 97;
else
k = 26;
for(n = 0; n < m_nCount[k]; n++)
{
pNode = m_Table[k].GetItem(n);
if(pNode == NULL)
return -1; //failed linked list is corrupt
if(pNode->sEntry == sInput)
return (k * TABLE_SPAN) + n;
}
return -1;
}
void CStringTable::ClearTable()
{
for(int n = 0; n < 27; n++)
{
m_nCount[n] = 0;
m_Table[n].DestroyList();
}
m_nDuplicate = 0;
}
int CStringTable::GetCount()
{
int k = 0;
for(int n = 0; n < 27; n++)
k += m_nCount[n];
return k;
}
int CStringTable::GetDuplicateCount()
{
return m_nDuplicate;
}
bool CStringTable::IsEmpty()
{
int k = 0;
for(int n = 0; n < 27; n++)
k += m_nCount[n];
if(k <= 0)
return true;
else
return false;
}
| [
"joeriedel@hotmail.com"
] | joeriedel@hotmail.com |
686765663b7a038c3d258efdd643e966aa2c9cd4 | 32d7c0ec4148ebf4025dcdd7f56df0cb0a88dcaf | /OKEEGE14.cpp | cfbeea02a2c3689c1b73ff57d085a482073e0041 | [] | no_license | Chukwu12/gh-Java-project-pt2 | 720f927867b1bded4c7d1a085ec4b77128e258ff | c37a37fdda38a08712a211e3d461ddd10d683463 | refs/heads/master | 2022-10-20T20:23:21.280686 | 2020-06-16T14:33:14 | 2020-06-16T14:33:14 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,129 | cpp | #include <iostream>
using namespace std;
int main()
{
char ch;
cout << ("Line 1: Enter a string: ");
cin.get(ch);
cout << endl;
cout << "line 4 : after first cin.get (ch);"
<< "ch = " << ch << endl;
cin.get(ch);
cout << "Line 6 : after second cin.get(ch);"
<< "ch = " << ch << endl;
cin.putback(ch);
cin.get(ch);
cout << "Line 9: After putback and then"
<< "cin.get(ch); ch = " << ch << endl;
ch = cin.peek();
cout << "Line 11 : after cin.peek(); ch = "
<< ch << endl;
cin.get(ch);
cout << "Line 13: after cin.get(ch); ch = "
<< ch << endl;
cin.get(ch);
cout << "line 14: after cin.get(ch); ch = "
<< ch << endl;
cin.get(ch);
cout << "Line 16: after cin.get(ch); ch = "
<< ch << endl;
cin.putback(ch);
cin.get(ch);
cout << " Line 18: after putback and then "
<< "cin.get(ch); ch = " << ch << endl;
ch = cin.peek();
cout << "Line 11: after cin.peek(); ch = "
<< ch << endl;
cin.putback(ch);
cin.get(ch);
cout << "Line 21: after putback and then "
<< "cin.get(ch); ch = " << ch << endl;
system("pause");
return 0;
} | [
"noreply@github.com"
] | noreply@github.com |
b9390fa2b5f5910291e2bc74f605a2c1f04d8fb5 | 91a882547e393d4c4946a6c2c99186b5f72122dd | /Source/XPSP1/NT/admin/snapin/filemgmt/svcprop.h | bf47aae72b3828996cbf0fcfd8700069a3d95ce3 | [] | no_license | IAmAnubhavSaini/cryptoAlgorithm-nt5src | 94f9b46f101b983954ac6e453d0cf8d02aa76fc7 | d9e1cdeec650b9d6d3ce63f9f0abe50dabfaf9e2 | refs/heads/master | 2023-09-02T10:14:14.795579 | 2021-11-20T13:47:06 | 2021-11-20T13:47:06 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,634 | h | // SvcProp.h : header file
//
// Data object used to display service properties.
//
//
#ifndef __SVCPROP_H__
#define __SVCPROP_H__
/////////////////////////////////////////////////////////////////////
// Structure used by the hardware profile listbox. One of these
// structure is allocated per listbox item.
//
// Typically the listbox has very few entries.
//
class CHardwareProfileEntry // hpe
{
public:
CHardwareProfileEntry * m_pNext; // Next item of the linked-list
HWPROFILEINFO m_hpi; // Hardware profile info returned by CM_Get_Hardware_Profile_Info_Ex()
ULONG m_uHwFlags; // Hardware profile flags for the given device instance
CString m_strDeviceName;
CString m_strDeviceNameFriendly;
BOOL m_fReadOnly; // TRUE => Cannot disable this hardware profile entry
BOOL m_fEnabled; // TRUE => Given hardware profile entry is enabled.
public:
CHardwareProfileEntry(
IN CONST HWPROFILEINFO * phpi,
IN ULONG uHwFlags,
TCHAR * pszDeviceName,
CString * pstrDeviceNameFriendly);
~CHardwareProfileEntry();
BOOL FWriteHardwareProfile(HMACHINE hMachine);
}; // CHardwareProfileEntry
#define SERVICE_cchDisplayNameMax 256
#define SERVICE_cchDescriptionMax 2048 // Maximum number of character in the description
#define SERVICE_cbQueryServiceConfigMax 4096 // Maximum number of bytes required by QueryServiceConfig()
#define SERVICE_cchRebootMessageMax 2048 // Longest length of the reboot message
#define cActionsMax 3 // Maximum number of failure/actions supported
// Macros to convert one time unit to another
#define CvtMillisecondsIntoMinutes(dwMilliseconds) ((dwMilliseconds) / (1000 * 60))
#define CvtSecondsIntoDays(dwSeconds) ((dwSeconds) / (60 * 60 * 24))
#define CvtMinutesIntoMilliseconds(dwMinutes) ((dwMinutes) * 60 * 1000)
#define CvtDaysIntoSeconds(dwDays) ((dwDays) * 60 * 60 * 24)
/////////////////////////////////////////////////////////////////////
// class CDlgPropService - Service dialog properties
//
// This object is created only to display the service properties
// of a given service.
//
class CServicePropertyData
{
friend class CServicePageGeneral;
friend class CServicePageHwProfile;
friend class CServicePageRecovery;
friend class CServicePageRecovery2;
friend class CServiceDlgRebootComputer;
protected:
enum _DIRTYFLAGS
{
mskzValidNone = 0x00000000, // None of the fields are valid
mskfValidSS = 0x00000001, // Content of m_SS is valid
mskfValidQSC = 0x00000002, // Content of m_paQSC is valid
mskfValidSFA = 0x00000004, // Content of m_SFA is valid
mskfValidDescr = 0x00000008, // Service description is valid
mskfSystemProcess = 0x00000010, // Service runs in system process
//mskfValidAll = 0x00000080, // All the fields are valid
mskfErrorBAADF00D = 0x00008000, // Workaround for the error code returned by CM_Get_Hardware_Profile_Info_Ex()
// General
#ifdef EDIT_DISPLAY_NAME_373025
mskfDirtyDisplayName = 0x00010000, // Service display name has been modified
mskfDirtyDescription = 0x00020000, // Service description has been modified
#endif // EDIT_DISPLAY_NAME_373025
mskfDirtyStartupType = 0x00040000, // Startup type has been modified
// mskfDirtyStartupParam = 0x00080000, // IGNORED: Startup parameters are not persistent
// Log On
mskfDirtyAccountName = 0x01000000,
mskfDirtyPassword = 0x02000000,
mskfDirtySvcType = 0x04000000,
// Recovery
mskfDirtySFA = 0x10000000, // Content of m_SFA has been modified
mskfDirtyRunFile = 0x20000000, // Command to run a file has been modified
mskfDirtyRebootMessage = 0x40000000, // Reboot message has been modified
mskfDirtyActionType = 0x80000000, // Only the action type has been changed
mskmDirtyAll = 0xFFFF0000, // Mask to check if one of the field has been modified
} DIRTYFLAGS;
protected:
IDataObjectPtr m_spDataObject; // Used for MMCPropertyChangeNotify
LONG_PTR m_lNotifyHandle; // Handle used to notify SnapIn parent when properties are modified
HMACHINE m_hMachine; // Handle of computer for Configuration Manager.
SC_HANDLE m_hScManager; // Handle to service control manager database
CString m_strMachineName; // Name of the computer. Empty for 'local machine'.
CString m_strUiMachineName; // Name of the computer in a friendly way (should not be used with the APIs)
CString m_strServiceName; // Name of the service
CONST TCHAR * m_pszServiceName; // Pointer to service name (pointing to m_strServiceName)
CString m_strServiceDisplayName; // Display name of the service
BOOL m_fQueryServiceConfig2; // TRUE => Machine support QueryServiceConfig2() API
UINT m_uFlags; // Flags about which fields are dirty
//
// General Dialog
//
// JonN 4/21/01 348163
// Note that this structure may not be initialized, or only the
// SERVICE_STATUS field may be initialized
SERVICE_STATUS_PROCESS m_SS; // Service Status structure
QUERY_SERVICE_CONFIG * m_paQSC; // Pointer to allocated QSC structure
CString m_strDescription; // Description of service
//
// Logon As Dialog
//
CString m_strLogOnAccountName;
CString m_strPassword;
//
// Hardware profile
//
CHardwareProfileEntry * m_paHardwareProfileEntryList; // Pointer to linked list of entries
BOOL m_fShowHwProfileInstances; // TRUE => Show the device instances
INT m_iSubItemHwProfileStatus; // Always 1 or 2 (computed from 1 + m_fShowHwProfileInstance)
//
// Recovery Dialog
//
SERVICE_FAILURE_ACTIONS * m_paSFA; // Pointer to allocated SFA structure
SERVICE_FAILURE_ACTIONS m_SFA; // Output SFA structure
SC_ACTION m_rgSA[cActionsMax]; // Array to hold first, second and subsequent failures
BOOL m_fAllSfaTakeNoAction; // TRUE => All SFA recovery attemps do take no actions
// JonN 3/28/00 28975
// IIS 5.0 Reliability : SCM Snap-in :
// The snap-in is changing the failure action delay value
//
// We remember the initial value and what we initially displayed.
// if the user does not change the value of DelayAbendCount,
// DelayRestartService, or DelayRebootComputer.
UINT m_secOriginalAbendCount;
UINT m_daysOriginalAbendCount;
UINT m_daysDisplayAbendCount;
UINT m_msecOriginalRestartService;
UINT m_minOriginalRestartService;
UINT m_minDisplayRestartService;
UINT m_msecOriginalRebootComputer;
UINT m_minOriginalRebootComputer;
UINT m_minDisplayRebootComputer;
CString m_strRunFileCommand; // Command line with arguments and abend number (if any)
CString m_strRebootMessage; // Reboot message
HWND m_hwndPropertySheet; // Handle of the property sheet
CServicePageGeneral * m_pPageGeneral;
CServicePageHwProfile * m_pPageHwProfile;
CServicePageRecovery * m_pPageRecovery;
CServicePageRecovery2 * m_pPageRecovery2; // JonN 4/20/01 348163
public:
CServicePropertyData();
~CServicePropertyData();
BOOL FInit(
LPDATAOBJECT lpDataObject,
CONST TCHAR pszMachineName[],
CONST TCHAR pszServiceName[],
CONST TCHAR pszServiceDisplayName[],
LONG_PTR lNotifyHandle);
BOOL CreatePropertyPages(LPPROPERTYSHEETCALLBACK pCallback);
BOOL FOpenScManager();
BOOL FQueryServiceInfo();
BOOL FUpdateServiceInfo();
void FCheckLSAAccount();
BOOL FOnApply();
void NotifySnapInParent();
void UpdateCaption();
void FlushHardwareProfileEntries();
BOOL FQueryHardwareProfileEntries();
BOOL FChangeHardwareProfileEntries();
void SetDirty(enum CServicePropertyData::_DIRTYFLAGS uDirtyFlag)
{
Assert((uDirtyFlag & ~mskmDirtyAll) == 0);
m_uFlags |= uDirtyFlag;
}
UINT GetDelayForActionType(SC_ACTION_TYPE actionType, BOOL * pfDelayFound);
void SetDelayForActionType(SC_ACTION_TYPE actionType, UINT uDelay);
UINT QueryUsesActionType(SC_ACTION_TYPE actionType);
BOOL FAllSfaTakeNoAction();
}; // CServicePropertyData
/*
These functions all through to the appropriate ADVAPI32 calls
and set the last parameter to FALSE
*/
BOOL MyChangeServiceConfig2(
BOOL* pfDllPresentLocally, // will set to FALSE if new ADVAPI32 not present
SC_HANDLE hService, // handle to service
DWORD dwInfoLevel, // which configuration information to change
LPVOID lpInfo // pointer to configuration information
);
BOOL MyQueryServiceConfig2(
BOOL* pfDllPresentLocally, // will set to FALSE if new ADVAPI32 not present
SC_HANDLE hService, // handle of service
DWORD dwInfoLevel, // which configuration data is requested
LPBYTE lpBuffer, // pointer to service configuration buffer
DWORD cbBufSize, // size of service configuration buffer
LPDWORD pcbBytesNeeded // address of variable for bytes needed
);
#endif // ~__SVCPROP_H__
| [
"support@cryptoalgo.cf"
] | support@cryptoalgo.cf |
d1fca9dcff54f7b8586a0c1c585deaf8fc964f34 | b22588340d7925b614a735bbbde1b351ad657ffc | /athena/Trigger/TrigT1/TrigT1RPChardware/TrigT1RPChardware/CMROCompare.h | 739844f601cee21727acb4da1657ddff0b0420b6 | [] | no_license | rushioda/PIXELVALID_athena | 90befe12042c1249cbb3655dde1428bb9b9a42ce | 22df23187ef85e9c3120122c8375ea0e7d8ea440 | refs/heads/master | 2020-12-14T22:01:15.365949 | 2020-01-19T03:59:35 | 2020-01-19T03:59:35 | 234,836,993 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 598 | h | /*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
#ifndef CMROCompare_H
#define CMROCompare_H
#include "TrigT1RPChardware/Lvl1Def.h"
#include "TrigT1RPChardware/MatrixReadOut.h"
#include "MuonCablingTools/BaseObject.h"
class CMROCompare : public BaseObject {
public:
CMROCompare(MatrixReadOut *h, MatrixReadOut *s);
~CMROCompare();
void compare();
void compareHead();
void compareSubh();
void compareBody();
void compareFoot();
CMAword diffOut(){return diffOutput;};
private:
MatrixReadOut *hardware;
MatrixReadOut *simulation;
CMAword diffOutput;
};
#endif
| [
"rushioda@lxplus754.cern.ch"
] | rushioda@lxplus754.cern.ch |
ddbf7f56625ba55aab5750a9b7145ae86c219477 | b6bf42ba6650ff16e8ca32b0b996b14d7397a25d | /lw5/Garanin Timofey/lab/BatcherAlgoritm.cpp | 83f44862a6a8788ea2b31949377f63624e0b29c2 | [] | no_license | onethousandsuns/pp | 3132e9fc96b6a3979267192ab4a4a4e090ce3cce | b52943f096d2122cb50e005f5693d02a9228461a | refs/heads/master | 2021-01-18T13:12:45.156628 | 2017-04-04T06:15:59 | 2017-04-04T06:15:59 | 80,737,749 | 0 | 0 | null | 2017-02-02T15:20:26 | 2017-02-02T15:20:26 | null | UTF-8 | C++ | false | false | 2,729 | cpp | #include "stdafx.h"
#include "BatcherAlgoritm.h"
#include <iterator>
#include <omp.h>
#include <chrono>
CBatcherAlgoritm::CBatcherAlgoritm(Vector const & listValues)
:m_listValues(listValues)
{
}
Vector CBatcherAlgoritm::GetSortedList() const
{
return m_listValues;
}
bool CBatcherAlgoritm::SortList()
{
auto copyList = m_listValues;
while (!IsUnit(copyList))
{
for (size_t i = 0; i != copyList.size(); ++i)
{
if (copyList.at(i).size() != 1)
{
Pair pair = BreakList(copyList.at(i));
copyList.erase(copyList.begin() + i);
copyList.insert(copyList.begin() + i, pair.first);
copyList.insert(copyList.begin() + i + 1, pair.second);
}
}
}
MergeSort(copyList);
m_listValues = copyList;
return true;
}
void CBatcherAlgoritm::MergeSort(Vector & vec)
{
Vector copyVec = vec;
auto startParallel = std::chrono::system_clock::now();
while (copyVec.size() != 1)
{
Vector resultVec;
#pragma omp parallel for
for (int k = 0; k < copyVec.size(); k += 2)
{
std::vector<int> interResult;
auto vecFirst = copyVec.at(k);
if (k + 1 >= copyVec.size())
{
interResult.resize(vecFirst.size());
std::copy(vecFirst.begin(), vecFirst.end(), interResult.begin());
}
else
{
int j = 0;
for (int i = 0; i != vecFirst.size(); ++i)
{
auto vecSecond = copyVec.at(k + 1);
for (; j != vecSecond.size(); ++j)
{
auto headFirst = vecFirst.at(i);
auto headSecond = vecSecond.at(j);
if (headFirst <= headSecond)
{
interResult.push_back(headFirst);
break;
}
else
interResult.push_back(headSecond);
}
if (i + 1 == vecFirst.size())
std::copy(vecSecond.begin() + j, vecSecond.end(), std::back_inserter(interResult));
if (j + 1 > vecSecond.size())
{
std::copy(vecFirst.begin() + i, vecFirst.end(), std::back_inserter(interResult));
break;
}
}
}
#pragma omp critical
{
resultVec.push_back(interResult);
}
}
copyVec = resultVec;
}
vec = copyVec;
auto endParallel = std::chrono::system_clock::now();
std::chrono::duration<double> diff = endParallel - startParallel;
std::cout << "Time: " << diff.count() << std::endl;
}
Pair CBatcherAlgoritm::BreakList(std::vector<int> const &list)
{
size_t sizeHalf = list.size() / 2;
std::vector<int> firstHalf(sizeHalf);
std::vector<int> secondHalf(list.size() - sizeHalf);
std::copy(list.begin(), list.begin() + sizeHalf, firstHalf.begin());
std::copy(list.begin() + sizeHalf, list.end(), secondHalf.begin());
return { firstHalf, secondHalf };
}
bool CBatcherAlgoritm::IsUnit(Vector const &vec)
{
for (auto el : vec)
{
if (el.size() > 1)
return false;
}
return true;
}
| [
"wrager@users.noreply.github.com"
] | wrager@users.noreply.github.com |
c253f251cd70f68ebe4451c9d20e6fbe183903e9 | b257bd5ea374c8fb296dbc14590db56cb7e741d8 | /Extras/DevExpress VCL/Library/RS17/cxExtEditRepositoryItems.hpp | 908d3b5406d3c771e4d31f70692192ecce313b07 | [] | no_license | kitesoft/Roomer-PMS-1 | 3d362069e3093f2a49570fc1677fe5682de3eabd | c2f4ac76b4974e4a174a08bebdb02536a00791fd | refs/heads/master | 2021-09-14T07:13:32.387737 | 2018-05-04T12:56:58 | 2018-05-04T12:56:58 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 10,101 | hpp | // CodeGear C++Builder
// Copyright (c) 1995, 2012 by Embarcadero Technologies, Inc.
// All rights reserved
// (DO NOT EDIT: machine generated header) 'cxExtEditRepositoryItems.pas' rev: 24.00 (Win32)
#ifndef CxexteditrepositoryitemsHPP
#define CxexteditrepositoryitemsHPP
#pragma delphiheader begin
#pragma option push
#pragma option -w- // All warnings off
#pragma option -Vx // Zero-length empty class member
#pragma pack(push,8)
#include <System.hpp> // Pascal unit
#include <SysInit.hpp> // Pascal unit
#include <Winapi.Windows.hpp> // Pascal unit
#include <System.Classes.hpp> // Pascal unit
#include <Vcl.ComCtrls.hpp> // Pascal unit
#include <Vcl.Controls.hpp> // Pascal unit
#include <Vcl.Forms.hpp> // Pascal unit
#include <Vcl.Graphics.hpp> // Pascal unit
#include <Winapi.Messages.hpp> // Pascal unit
#include <Vcl.StdCtrls.hpp> // Pascal unit
#include <System.SysUtils.hpp> // Pascal unit
#include <cxCheckComboBox.hpp> // Pascal unit
#include <cxCheckGroup.hpp> // Pascal unit
#include <cxClasses.hpp> // Pascal unit
#include <cxColorComboBox.hpp> // Pascal unit
#include <cxEdit.hpp> // Pascal unit
#include <cxFontNameComboBox.hpp> // Pascal unit
#include <cxLabel.hpp> // Pascal unit
#include <cxProgressBar.hpp> // Pascal unit
#include <cxRichEdit.hpp> // Pascal unit
#include <cxSpinButton.hpp> // Pascal unit
#include <cxTextEdit.hpp> // Pascal unit
#include <cxTrackBar.hpp> // Pascal unit
#include <dxColorEdit.hpp> // Pascal unit
//-- user supplied -----------------------------------------------------------
namespace Cxexteditrepositoryitems
{
//-- type declarations -------------------------------------------------------
class DELPHICLASS TcxEditRepositoryLabel;
class PASCALIMPLEMENTATION TcxEditRepositoryLabel : public Cxedit::TcxEditRepositoryItem
{
typedef Cxedit::TcxEditRepositoryItem inherited;
private:
Cxlabel::TcxLabelProperties* __fastcall GetProperties(void);
HIDESBASE void __fastcall SetProperties(Cxlabel::TcxLabelProperties* Value);
public:
__classmethod virtual Cxedit::TcxCustomEditPropertiesClass __fastcall GetEditPropertiesClass();
__published:
__property Cxlabel::TcxLabelProperties* Properties = {read=GetProperties, write=SetProperties};
public:
/* TcxEditRepositoryItem.Create */ inline __fastcall virtual TcxEditRepositoryLabel(System::Classes::TComponent* AOwner) : Cxedit::TcxEditRepositoryItem(AOwner) { }
/* TcxEditRepositoryItem.Destroy */ inline __fastcall virtual ~TcxEditRepositoryLabel(void) { }
};
class DELPHICLASS TcxEditRepositoryProgressBar;
class PASCALIMPLEMENTATION TcxEditRepositoryProgressBar : public Cxedit::TcxEditRepositoryItem
{
typedef Cxedit::TcxEditRepositoryItem inherited;
private:
Cxprogressbar::TcxProgressBarProperties* __fastcall GetProperties(void);
HIDESBASE void __fastcall SetProperties(Cxprogressbar::TcxProgressBarProperties* Value);
public:
__classmethod virtual Cxedit::TcxCustomEditPropertiesClass __fastcall GetEditPropertiesClass();
__published:
__property Cxprogressbar::TcxProgressBarProperties* Properties = {read=GetProperties, write=SetProperties};
public:
/* TcxEditRepositoryItem.Create */ inline __fastcall virtual TcxEditRepositoryProgressBar(System::Classes::TComponent* AOwner) : Cxedit::TcxEditRepositoryItem(AOwner) { }
/* TcxEditRepositoryItem.Destroy */ inline __fastcall virtual ~TcxEditRepositoryProgressBar(void) { }
};
class DELPHICLASS TcxEditRepositoryFontNameComboBox;
class PASCALIMPLEMENTATION TcxEditRepositoryFontNameComboBox : public Cxedit::TcxEditRepositoryItem
{
typedef Cxedit::TcxEditRepositoryItem inherited;
private:
Cxfontnamecombobox::TcxFontNameComboBoxProperties* __fastcall GetProperties(void);
HIDESBASE void __fastcall SetProperties(Cxfontnamecombobox::TcxFontNameComboBoxProperties* Value);
public:
__classmethod virtual Cxedit::TcxCustomEditPropertiesClass __fastcall GetEditPropertiesClass();
__published:
__property Cxfontnamecombobox::TcxFontNameComboBoxProperties* Properties = {read=GetProperties, write=SetProperties};
public:
/* TcxEditRepositoryItem.Create */ inline __fastcall virtual TcxEditRepositoryFontNameComboBox(System::Classes::TComponent* AOwner) : Cxedit::TcxEditRepositoryItem(AOwner) { }
/* TcxEditRepositoryItem.Destroy */ inline __fastcall virtual ~TcxEditRepositoryFontNameComboBox(void) { }
};
class DELPHICLASS TcxEditRepositoryColorComboBox;
class PASCALIMPLEMENTATION TcxEditRepositoryColorComboBox : public Cxedit::TcxEditRepositoryItem
{
typedef Cxedit::TcxEditRepositoryItem inherited;
private:
Cxcolorcombobox::TcxColorComboBoxProperties* __fastcall GetProperties(void);
HIDESBASE void __fastcall SetProperties(Cxcolorcombobox::TcxColorComboBoxProperties* Value);
public:
__classmethod virtual Cxedit::TcxCustomEditPropertiesClass __fastcall GetEditPropertiesClass();
__published:
__property Cxcolorcombobox::TcxColorComboBoxProperties* Properties = {read=GetProperties, write=SetProperties};
public:
/* TcxEditRepositoryItem.Create */ inline __fastcall virtual TcxEditRepositoryColorComboBox(System::Classes::TComponent* AOwner) : Cxedit::TcxEditRepositoryItem(AOwner) { }
/* TcxEditRepositoryItem.Destroy */ inline __fastcall virtual ~TcxEditRepositoryColorComboBox(void) { }
};
class DELPHICLASS TcxEditRepositoryColorEdit;
class PASCALIMPLEMENTATION TcxEditRepositoryColorEdit : public Cxedit::TcxEditRepositoryItem
{
typedef Cxedit::TcxEditRepositoryItem inherited;
private:
Dxcoloredit::TdxColorEditProperties* __fastcall GetProperties(void);
HIDESBASE void __fastcall SetProperties(Dxcoloredit::TdxColorEditProperties* Value);
public:
__classmethod virtual Cxedit::TcxCustomEditPropertiesClass __fastcall GetEditPropertiesClass();
__published:
__property Dxcoloredit::TdxColorEditProperties* Properties = {read=GetProperties, write=SetProperties};
public:
/* TcxEditRepositoryItem.Create */ inline __fastcall virtual TcxEditRepositoryColorEdit(System::Classes::TComponent* AOwner) : Cxedit::TcxEditRepositoryItem(AOwner) { }
/* TcxEditRepositoryItem.Destroy */ inline __fastcall virtual ~TcxEditRepositoryColorEdit(void) { }
};
class DELPHICLASS TcxEditRepositoryTrackBar;
class PASCALIMPLEMENTATION TcxEditRepositoryTrackBar : public Cxedit::TcxEditRepositoryItem
{
typedef Cxedit::TcxEditRepositoryItem inherited;
private:
Cxtrackbar::TcxTrackBarProperties* __fastcall GetProperties(void);
HIDESBASE void __fastcall SetProperties(Cxtrackbar::TcxTrackBarProperties* Value);
public:
__classmethod virtual Cxedit::TcxCustomEditPropertiesClass __fastcall GetEditPropertiesClass();
__published:
__property Cxtrackbar::TcxTrackBarProperties* Properties = {read=GetProperties, write=SetProperties};
public:
/* TcxEditRepositoryItem.Create */ inline __fastcall virtual TcxEditRepositoryTrackBar(System::Classes::TComponent* AOwner) : Cxedit::TcxEditRepositoryItem(AOwner) { }
/* TcxEditRepositoryItem.Destroy */ inline __fastcall virtual ~TcxEditRepositoryTrackBar(void) { }
};
class DELPHICLASS TcxEditRepositoryCheckComboBox;
class PASCALIMPLEMENTATION TcxEditRepositoryCheckComboBox : public Cxedit::TcxEditRepositoryItem
{
typedef Cxedit::TcxEditRepositoryItem inherited;
private:
Cxcheckcombobox::TcxCheckComboBoxProperties* __fastcall GetProperties(void);
HIDESBASE void __fastcall SetProperties(Cxcheckcombobox::TcxCheckComboBoxProperties* Value);
public:
__classmethod virtual Cxedit::TcxCustomEditPropertiesClass __fastcall GetEditPropertiesClass();
__published:
__property Cxcheckcombobox::TcxCheckComboBoxProperties* Properties = {read=GetProperties, write=SetProperties};
public:
/* TcxEditRepositoryItem.Create */ inline __fastcall virtual TcxEditRepositoryCheckComboBox(System::Classes::TComponent* AOwner) : Cxedit::TcxEditRepositoryItem(AOwner) { }
/* TcxEditRepositoryItem.Destroy */ inline __fastcall virtual ~TcxEditRepositoryCheckComboBox(void) { }
};
class DELPHICLASS TcxEditRepositoryCheckGroupItem;
class PASCALIMPLEMENTATION TcxEditRepositoryCheckGroupItem : public Cxedit::TcxEditRepositoryItem
{
typedef Cxedit::TcxEditRepositoryItem inherited;
private:
Cxcheckgroup::TcxCheckGroupProperties* __fastcall GetProperties(void);
HIDESBASE void __fastcall SetProperties(Cxcheckgroup::TcxCheckGroupProperties* Value);
public:
__classmethod virtual Cxedit::TcxCustomEditPropertiesClass __fastcall GetEditPropertiesClass();
__published:
__property Cxcheckgroup::TcxCheckGroupProperties* Properties = {read=GetProperties, write=SetProperties};
public:
/* TcxEditRepositoryItem.Create */ inline __fastcall virtual TcxEditRepositoryCheckGroupItem(System::Classes::TComponent* AOwner) : Cxedit::TcxEditRepositoryItem(AOwner) { }
/* TcxEditRepositoryItem.Destroy */ inline __fastcall virtual ~TcxEditRepositoryCheckGroupItem(void) { }
};
class DELPHICLASS TcxEditRepositoryRichItem;
class PASCALIMPLEMENTATION TcxEditRepositoryRichItem : public Cxedit::TcxEditRepositoryItem
{
typedef Cxedit::TcxEditRepositoryItem inherited;
private:
Cxrichedit::TcxRichEditProperties* __fastcall GetProperties(void);
HIDESBASE void __fastcall SetProperties(Cxrichedit::TcxRichEditProperties* Value);
public:
__classmethod virtual Cxedit::TcxCustomEditPropertiesClass __fastcall GetEditPropertiesClass();
__published:
__property Cxrichedit::TcxRichEditProperties* Properties = {read=GetProperties, write=SetProperties};
public:
/* TcxEditRepositoryItem.Create */ inline __fastcall virtual TcxEditRepositoryRichItem(System::Classes::TComponent* AOwner) : Cxedit::TcxEditRepositoryItem(AOwner) { }
/* TcxEditRepositoryItem.Destroy */ inline __fastcall virtual ~TcxEditRepositoryRichItem(void) { }
};
//-- var, const, procedure ---------------------------------------------------
} /* namespace Cxexteditrepositoryitems */
#if !defined(DELPHIHEADER_NO_IMPLICIT_NAMESPACE_USE) && !defined(NO_USING_NAMESPACE_CXEXTEDITREPOSITORYITEMS)
using namespace Cxexteditrepositoryitems;
#endif
#pragma pack(pop)
#pragma option pop
#pragma delphiheader end.
//-- end unit ----------------------------------------------------------------
#endif // CxexteditrepositoryitemsHPP
| [
"bas@roomerpms.com"
] | bas@roomerpms.com |
308506c0785412ed06b03c0319c72f1f4b6759c0 | b46e6e8fabe537f25d57713b2caf6171161d8a85 | /C++/PAT_basic/1016. 部分A+B (15)/key.cpp | 8e0c2837d8f3aee8400ecb255966ab3ad38bc311 | [] | no_license | liuzeyan/MyLearning | 655d9ef09195029fc321496593521807f790ac7a | 83f8a182b461d3f9a98c0455cb48fe8939c28440 | refs/heads/master | 2021-09-04T11:42:35.052385 | 2018-01-18T11:21:56 | 2018-01-18T11:21:56 | 104,704,551 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 424 | cpp | #include<iostream>
#include<string>
using namespace std;
int main()
{
string str1,str2;
char ch1,ch2;
int sum1=0,sum2=0;
int c1 = 1,c2 =1;
cin>>str1>>ch1>>str2>>ch2;
for(int i=0;i<str1.length();i++)
{
if(str1[i]==ch1)
{
sum1= sum1+c1*(ch1-48);
c1=c1*10;
}
}
for(int i=0;i<str2.length();i++)
{
if(str2[i]==ch2)
{
sum2= sum2+c2*(ch2-48);
c2=c2*10;
}
}
cout<<sum1+sum2<<endl;
return 0;
}
| [
"liuzeyan3148@qq.com"
] | liuzeyan3148@qq.com |
04e5e4b64b5d1f83040c0c88fbd5491dbcf21a84 | 1a66e809db3cd8f8b2a925a2a51f46de29bea6f7 | /testCGAL/overlapping/tests/r3d_unit_tests.cpp | 1bcb6e2140d0be9ea36cb27f892b9dc52e784fc6 | [] | no_license | tlchoque/overlapping_2D | 47c089b94985b4a6cbc6584edfe2f9a30f431c93 | becc8df67c849faf016bb76050e3fa401234c084 | refs/heads/master | 2020-12-02T22:38:43.857592 | 2017-07-05T02:03:20 | 2017-07-05T02:03:20 | 96,159,674 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 27,756 | cpp | /*
*
* r3d_unit_tests.c
*
* Definitions for r3d unit tests.
*
* Devon Powell
* 31 August 2015
*
* This program was prepared by Los Alamos National Security, LLC at Los Alamos National
* Laboratory (LANL) under contract No. DE-AC52-06NA25396 with the U.S. Department of Energy (DOE).
* All rights in the program are reserved by the DOE and Los Alamos National Security, LLC.
* Permission is granted to the public to copy and use this software without charge, provided that
* this Notice and any statement of authorship are reproduced on all copies. Neither the U.S.
* Government nor LANS makes any warranty, express or implied, or assumes any liability
* or responsibility for the use of this software.
*
*/
#include <iostream>
#include <vector>
#include "test_helpers.h"
#include "utest.h"
#include <math.h>
// numerical tolerances for pass/warn/fail tests
#define TOL_WARN 1.0e-8
#define TOL_FAIL 1.0e-4
// minimum volume allowed for test polyhedra
#define MIN_VOL 1.0e-8
// number of trials per test
#define NUM_TRIALS 10
// for recursive tests, the stack capacity and
// maximum recursion depth allowed
#define STACK_SIZE 64
#define MAX_DEPTH 16
// order of polynomial integration for all tests
#define POLY_ORDER 2
// -- unit tests -- //
void test_split_tet_thru_centroid() {
// a very basic sanity check. Splits a tet through its centroid
// and checks to see whether the two resulting volumes add up to equal the original
// variables: the polyhedra and their moments
r3d_int m;
r3d_rvec3 verts[4];
r3d_poly opoly, poly1, poly2;
//r3d_real om[R3D_NUM_MOMENTS(POLY_ORDER)], m1[R3D_NUM_MOMENTS(POLY_ORDER)], m2[R3D_NUM_MOMENTS(POLY_ORDER)];
std::vector<r3d_real> om(R3D_NUM_MOMENTS(POLY_ORDER));
std::vector<r3d_real> m1(R3D_NUM_MOMENTS(POLY_ORDER));
std::vector<r3d_real> m2(R3D_NUM_MOMENTS(POLY_ORDER));
// generate a random tet and clip plane
rand_tet_3d(verts, MIN_VOL);
r3d_init_tet(&opoly, verts);
r3d_plane splane = thru_cent_3d(&opoly);
// split the poly by making two copies of the original poly
// and them clipping them against the same plane, with one
// oriented oppositely
poly1 = opoly;
poly2 = opoly;
r3d_clip(&poly1, &splane, 1);
splane.n.x *= -1;
splane.n.y *= -1;
splane.n.z *= -1;
splane.d *= -1;
r3d_clip(&poly2, &splane, 1);
// reduce the original and its two parts
r3d_reduce(&opoly, om, POLY_ORDER);
r3d_reduce(&poly1, m1, POLY_ORDER);
r3d_reduce(&poly2, m2, POLY_ORDER);
// make sure the sum of moments equals the original
for(m = 0; m < R3D_NUM_MOMENTS(POLY_ORDER); ++m) {
ASSERT_EQ(om[m], m1[m] + m2[m], TOL_FAIL);
EXPECT_EQ(om[m], m1[m] + m2[m], TOL_WARN);
}
// make sure neither of the two resulting volumes is larger than the original
// (within some tolerance)
ASSERT_LT(m1[0], om[0]*(1.0 + TOL_FAIL));
EXPECT_LT(m1[0], om[0]*(1.0 + TOL_WARN));
ASSERT_LT(m2[0], om[0]*(1.0 + TOL_FAIL));
EXPECT_LT(m2[0], om[0]*(1.0 + TOL_WARN));
}
//void test_split_nonconvex() {
//
// // a very basic sanity check. Splits a nonconvex poly (a zig-zag prism of sorts)
// // and checks to see whether the two resulting volumes add up to equal the original
//
// // variables: the polyhedra and their moments
// r3d_int m, v;
// r3d_plane splane;
// r3d_poly opoly, poly1, poly2;
// r3d_real om[R3D_NUM_MOMENTS(POLY_ORDER)], m1[R3D_NUM_MOMENTS(POLY_ORDER)], m2[R3D_NUM_MOMENTS(POLY_ORDER)];
//
// // explicitly create the nonconvex poly
//#define NZIGS 3
//#define ZOFF 0.1
// opoly.nverts = 4*NZIGS;
// for(v = 0; v < NZIGS; ++v) {
// opoly.verts[v].pos.x = 1.0*v;
// opoly.verts[v].pos.y = ZOFF + 1.0*(v%2);
// opoly.verts[v].pos.z = 0.0;
// opoly.verts[v+NZIGS].pos.x = 1.0*(NZIGS-v-1);
// opoly.verts[v+NZIGS].pos.y = 1.0*((NZIGS-v-1)%2);
// opoly.verts[v+NZIGS].pos.z = 0.0;
// opoly.verts[v+2*NZIGS].pos.x = 1.0*v;
// opoly.verts[v+2*NZIGS].pos.y = ZOFF + 1.0*(v%2);
// opoly.verts[v+2*NZIGS].pos.z = 1.0;
// opoly.verts[v+3*NZIGS].pos.x = 1.0*(NZIGS-v-1);
// opoly.verts[v+3*NZIGS].pos.y = 1.0*((NZIGS-v-1)%2);
// opoly.verts[v+3*NZIGS].pos.z = 1.0;
// }
// for(v = 0; v < 2*NZIGS; ++v) {
// opoly.verts[v].pnbrs[0] = (v+1)%(2*NZIGS);
// opoly.verts[v].pnbrs[1] = (v+2*NZIGS-1)%(2*NZIGS);
// opoly.verts[v].pnbrs[2] = (v+2*NZIGS);
// opoly.verts[v+2*NZIGS].pnbrs[0] = (v+2*NZIGS-1)%(2*NZIGS)+2*NZIGS;
// opoly.verts[v+2*NZIGS].pnbrs[1] = (v+1)%(2*NZIGS)+2*NZIGS;
// opoly.verts[v+2*NZIGS].pnbrs[2] = v;
// }
//
// // split along the x-axis (two single connected components this direction)
// poly1 = opoly;
// poly2 = opoly;
// splane.n.x = 1.0;
// splane.n.y = 0.0;
// splane.n.z = 0.0;
// splane.d = -0.5*(NZIGS-1);
// r3d_clip(&poly1, &splane, 1);
// splane.n.x *= -1;
// splane.n.y *= -1;
// splane.n.z *= -1;
// splane.d *= -1;
// r3d_clip(&poly2, &splane, 1);
// r3d_reduce(&opoly, om, POLY_ORDER);
// r3d_reduce(&poly1, m1, POLY_ORDER);
// r3d_reduce(&poly2, m2, POLY_ORDER);
// for(m = 0; m < R3D_NUM_MOMENTS(POLY_ORDER); ++m) {
// ASSERT_EQ(om[m], m1[m] + m2[m], TOL_FAIL);
// EXPECT_EQ(om[m], m1[m] + m2[m], TOL_WARN);
// }
// ASSERT_LT(m1[0], om[0]*(1.0 + TOL_FAIL));
// EXPECT_LT(m1[0], om[0]*(1.0 + TOL_WARN));
// ASSERT_LT(m2[0], om[0]*(1.0 + TOL_FAIL));
// EXPECT_LT(m2[0], om[0]*(1.0 + TOL_WARN));
//
// // split along the z-axis (two single connected components this direction)
// poly1 = opoly;
// poly2 = opoly;
// splane.n.x = 0.0;
// splane.n.y = 0.0;
// splane.n.z = 1.0;
// splane.d = -0.5;
// r3d_clip(&poly1, &splane, 1);
// splane.n.x *= -1;
// splane.n.y *= -1;
// splane.n.z *= -1;
// splane.d *= -1;
// r3d_clip(&poly2, &splane, 1);
// r3d_reduce(&opoly, om, POLY_ORDER);
// r3d_reduce(&poly1, m1, POLY_ORDER);
// r3d_reduce(&poly2, m2, POLY_ORDER);
// for(m = 0; m < R3D_NUM_MOMENTS(POLY_ORDER); ++m) {
// ASSERT_EQ(om[m], m1[m] + m2[m], TOL_FAIL);
// EXPECT_EQ(om[m], m1[m] + m2[m], TOL_WARN);
// }
// ASSERT_LT(m1[0], om[0]*(1.0 + TOL_FAIL));
// EXPECT_LT(m1[0], om[0]*(1.0 + TOL_WARN));
// ASSERT_LT(m2[0], om[0]*(1.0 + TOL_FAIL));
// EXPECT_LT(m2[0], om[0]*(1.0 + TOL_WARN));
//
// // split along the y-axis (multiple connected components this direction)
// poly1 = opoly;
// poly2 = opoly;
// splane.n.x = 0.0;
// splane.n.y = 1.0;
// splane.n.z = 0.0;
// splane.d = -0.5*(1.0+ZOFF);
// r3d_clip(&poly1, &splane, 1);
// splane.n.x *= -1;
// splane.n.y *= -1;
// splane.n.z *= -1;
// splane.d *= -1;
// r3d_clip(&poly2, &splane, 1);
// r3d_reduce(&opoly, om, POLY_ORDER);
// r3d_reduce(&poly1, m1, POLY_ORDER);
// r3d_reduce(&poly2, m2, POLY_ORDER);
// for(m = 0; m < R3D_NUM_MOMENTS(POLY_ORDER); ++m) {
// ASSERT_EQ(om[m], m1[m] + m2[m], TOL_FAIL);
// EXPECT_EQ(om[m], m1[m] + m2[m], TOL_WARN);
// }
// ASSERT_LT(m1[0], om[0]*(1.0 + TOL_FAIL));
// EXPECT_LT(m1[0], om[0]*(1.0 + TOL_WARN));
// ASSERT_LT(m2[0], om[0]*(1.0 + TOL_FAIL));
// EXPECT_LT(m2[0], om[0]*(1.0 + TOL_WARN));
//
//}
//
//
//void test_recursive_splitting_nondegenerate() {
//
// // recursively splits a polyhedron (starting from a tet) through the centroid,
// // checking to see that the resulting volumes add up properly.
//
// // explicit stack-based implementation
// r3d_int nstack, depth, t, m;
// r3d_poly polystack[STACK_SIZE];
// r3d_int depthstack[STACK_SIZE];
//
// // variables: the polyhedra and their moments
// r3d_rvec3 verts[4];
// r3d_plane splane;
// r3d_poly opoly, poly1, poly2;
// r3d_real om[R3D_NUM_MOMENTS(POLY_ORDER)], m1[R3D_NUM_MOMENTS(POLY_ORDER)], m2[R3D_NUM_MOMENTS(POLY_ORDER)];
//
// // do many trials
// printf("Recursively splitting %d tetrahedra, maximum splits per tet is %d.\n", NUM_TRIALS, MAX_DEPTH);
// for(t = 0; t < NUM_TRIALS; ++t) {
//
// // generate a random tet
// rand_tet_3d(verts, MIN_VOL);
// r3d_init_tet(&opoly, verts);
//
// // push the starting tet to the stack
// nstack = 0;
// polystack[nstack] = opoly;
// depthstack[nstack] = 0;
// ++nstack;
//
// // recursively split the poly
// while(nstack > 0) {
//
// // pop the stack
// --nstack;
// opoly = polystack[nstack];
// depth = depthstack[nstack];
//
// // generate a randomly oriented plane
// // through the centroid of the poly
// splane = thru_cent_3d(&opoly);
//
// // split the poly by making two copies of the original poly
// // and them clipping them against the same plane, with one
// // oriented oppositely
// poly1 = opoly;
// poly2 = opoly;
// r3d_clip(&poly1, &splane, 1);
// splane.n.x *= -1;
// splane.n.y *= -1;
// splane.n.z *= -1;
// splane.d *= -1;
// r3d_clip(&poly2, &splane, 1);
//
// // reduce the original and its two parts
// r3d_reduce(&opoly, om, POLY_ORDER);
// r3d_reduce(&poly1, m1, POLY_ORDER);
// r3d_reduce(&poly2, m2, POLY_ORDER);
//
// // make sure the sum of moments equals the original
// for(m = 0; m < R3D_NUM_MOMENTS(POLY_ORDER); ++m) {
// ASSERT_EQ(om[m], m1[m] + m2[m], TOL_FAIL);
// EXPECT_EQ(om[m], m1[m] + m2[m], TOL_WARN);
// }
//
// // make sure neither of the two resulting volumes is larger than the original
// // (within some tolerance)
// ASSERT_LT(m1[0], om[0]*(1.0 + TOL_FAIL));
// EXPECT_LT(m1[0], om[0]*(1.0 + TOL_WARN));
// ASSERT_LT(m2[0], om[0]*(1.0 + TOL_FAIL));
// EXPECT_LT(m2[0], om[0]*(1.0 + TOL_WARN));
//
// //printf("nstack = %d, depth = %d, opoly = %.10e, p1 = %.10e, p2 = %.10e, err = %.10e\n",
// //nstack, depth, om[0], m1[0], m2[0], fabs(1.0 - om[0]/(m1[0] + m2[0])));
//
// // push the children to the stack if they have
// // an acceptably large volume
// if(depth < MAX_DEPTH) {
// if(m1[0] > MIN_VOL) {
// polystack[nstack] = poly1;
// depthstack[nstack] = depth + 1;
// ++nstack;
// }
// if(m2[0] > MIN_VOL) {
// polystack[nstack] = poly2;
// depthstack[nstack] = depth + 1;
// ++nstack;
// }
// }
// }
// }
//}
//
//void test_recursive_splitting_degenerate() {
//
// // recursively splits a polyhedron (starting from a tet) with a cut plane
// // that is always degenerate with the tet in some way,
// // checking to see that the resulting volumes add up properly.
//
// // explicit stack-based implementation
// r3d_int nstack, depth, t, chopt, m;
// r3d_poly polystack[STACK_SIZE];
// r3d_int depthstack[STACK_SIZE];
//
// // variables: the polyhedra and their moments
// r3d_rvec3 verts[4];
// r3d_plane splane;
// r3d_poly opoly, poly1, poly2;
// r3d_real om[R3D_NUM_MOMENTS(POLY_ORDER)], m1[R3D_NUM_MOMENTS(POLY_ORDER)], m2[R3D_NUM_MOMENTS(POLY_ORDER)];
//
// // do many trials
// printf("Recursively splitting %d tetrahedra, maximum splits per tet is %d.\n", NUM_TRIALS, MAX_DEPTH);
// for(t = 0; t < NUM_TRIALS; ++t) {
//
// // generate a random tet
// rand_tet_3d(verts, MIN_VOL);
// r3d_init_tet(&opoly, verts);
//
// // push the starting tet to the stack
// nstack = 0;
// polystack[nstack] = opoly;
// depthstack[nstack] = 0;
// ++nstack;
//
// // recursively split the poly
// while(nstack > 0) {
//
// // pop the stack
// --nstack;
// opoly = polystack[nstack];
// depth = depthstack[nstack];
//
// // generate a random plane from one of a few
// // possible degenerate configurations, ensuring that it
// // has a valid unit normal
// chopt = rand_int(6);
// do {
// splane = choptions_3d[chopt](&opoly);
// } while(splane.n.x == 0.0 && splane.n.y == 0.0 && splane.n.z == 0.0);
//
// // split the poly by making two copies of the original poly
// // and them clipping them against the same plane, with one
// // oriented oppositely
// poly1 = opoly;
// poly2 = opoly;
// r3d_clip(&poly1, &splane, 1);
// splane.n.x *= -1;
// splane.n.y *= -1;
// splane.n.z *= -1;
// splane.d *= -1;
// r3d_clip(&poly2, &splane, 1);
//
// // reduce the original and its two parts
// r3d_reduce(&opoly, om, POLY_ORDER);
// r3d_reduce(&poly1, m1, POLY_ORDER);
// r3d_reduce(&poly2, m2, POLY_ORDER);
//
// // make sure the sum of moments equals the original
// for(m = 0; m < R3D_NUM_MOMENTS(POLY_ORDER); ++m) {
// ASSERT_EQ(om[m], m1[m] + m2[m], TOL_FAIL);
// EXPECT_EQ(om[m], m1[m] + m2[m], TOL_WARN);
// }
//
// // make sure neither of the two resulting volumes is larger than the original
// // (within some tolerance)
// ASSERT_LT(m1[0], om[0]*(1.0 + TOL_FAIL));
// EXPECT_LT(m1[0], om[0]*(1.0 + TOL_WARN));
// ASSERT_LT(m2[0], om[0]*(1.0 + TOL_FAIL));
// EXPECT_LT(m2[0], om[0]*(1.0 + TOL_WARN));
//
// //printf("nstack = %d, depth = %d, opoly = %.10e, p1 = %.10e, p2 = %.10e, err = %.10e\n",
// //nstack, depth, om[0], m1[0], m2[0], fabs(1.0 - om[0]/(m1[0] + m2[0])));
//
// // push the children to the stack if they have
// // an acceptably large volume
// if(depth < MAX_DEPTH) {
// if(m1[0] > MIN_VOL) {
// polystack[nstack] = poly1;
// depthstack[nstack] = depth + 1;
// ++nstack;
// }
// if(m2[0] > MIN_VOL) {
// polystack[nstack] = poly2;
// depthstack[nstack] = depth + 1;
// ++nstack;
// }
// }
// }
// }
//}
//
//void test_recursive_splitting_degenerate_perturbed() {
//
// // recursively splits a polyhedron (starting from a tet) with a cut plane
// // that is always degenerate with the tet in some way,
// // checking to see that the resulting volumes add up properly.
// // In this one, the cut plane is perturbed by a small amount.
//
//#define MIN_PERTURB_ORDER (-17)
//#define MAX_PERTURB_ORDER (-1)
//
// // explicit stack-based implementation
// r3d_int nstack, depth, t, chopt, m;
// r3d_poly polystack[STACK_SIZE];
// r3d_int depthstack[STACK_SIZE];
//
// // variables: the polyhedra and their moments
// r3d_rvec3 verts[4];
// r3d_plane splane;
// r3d_poly opoly, poly1, poly2;
// r3d_real om[R3D_NUM_MOMENTS(POLY_ORDER)], m1[R3D_NUM_MOMENTS(POLY_ORDER)], m2[R3D_NUM_MOMENTS(POLY_ORDER)];
// r3d_real perturb;
//
// // do many trials
// printf("Recursively splitting %d tetrahedra, maximum splits per tet is %d.\n", NUM_TRIALS, MAX_DEPTH);
// for(t = 0; t < NUM_TRIALS; ++t) {
//
// // compute the order of magnitude by which to perturb the clip plane,
// // determined by the trial number
// perturb = pow(10, MIN_PERTURB_ORDER + t%(MAX_PERTURB_ORDER - MIN_PERTURB_ORDER));
// //printf("omag = %d, pow = %.10e\n", MIN_PERTURB_ORDER + t%(MAX_PERTURB_ORDER - MIN_PERTURB_ORDER), perturb);
//
// // generate a random tet
// rand_tet_3d(verts, MIN_VOL);
// r3d_init_tet(&opoly, verts);
//
// // push the starting tet to the stack
// nstack = 0;
// polystack[nstack] = opoly;
// depthstack[nstack] = 0;
// ++nstack;
//
// // recursively split the poly
// while(nstack > 0) {
//
// // pop the stack
// --nstack;
// opoly = polystack[nstack];
// depth = depthstack[nstack];
//
// // generate a random plane from one of a few
// // possible degenerate configurations, ensuring that it
// // has a valid unit normal
// chopt = rand_int(6);
// do {
// splane = choptions_3d[chopt](&opoly);
// } while(splane.n.x == 0.0 && splane.n.y == 0.0 && splane.n.z == 0.0);
//
// // randomly perturb the plane
// splane.n.x *= 1.0 + perturb*(rand_uniform() - 0.5);
// splane.n.y *= 1.0 + perturb*(rand_uniform() - 0.5);
// splane.n.z *= 1.0 + perturb*(rand_uniform() - 0.5);
// splane.d *= 1.0 + perturb*(rand_uniform() - 0.5);
//
// // split the poly by making two copies of the original poly
// // and them clipping them against the same plane, with one
// // oriented oppositely
// poly1 = opoly;
// poly2 = opoly;
// r3d_clip(&poly1, &splane, 1);
// splane.n.x *= -1;
// splane.n.y *= -1;
// splane.n.z *= -1;
// splane.d *= -1;
// r3d_clip(&poly2, &splane, 1);
//
// // reduce the original and its two parts
// r3d_reduce(&opoly, om, POLY_ORDER);
// r3d_reduce(&poly1, m1, POLY_ORDER);
// r3d_reduce(&poly2, m2, POLY_ORDER);
//
// // make sure the sum of moments equals the original
// for(m = 0; m < R3D_NUM_MOMENTS(POLY_ORDER); ++m) {
// ASSERT_EQ(om[m], m1[m] + m2[m], TOL_FAIL);
// EXPECT_EQ(om[m], m1[m] + m2[m], TOL_WARN);
// }
//
// // make sure neither of the two resulting volumes is larger than the original
// // (within some tolerance)
// ASSERT_LT(m1[0], om[0]*(1.0 + TOL_FAIL));
// EXPECT_LT(m1[0], om[0]*(1.0 + TOL_WARN));
// ASSERT_LT(m2[0], om[0]*(1.0 + TOL_FAIL));
// EXPECT_LT(m2[0], om[0]*(1.0 + TOL_WARN));
//
// //printf("nstack = %d, depth = %d, opoly = %.10e, p1 = %.10e, p2 = %.10e, err = %.10e\n",
// //nstack, depth, om[0], m1[0], m2[0], fabs(1.0 - om[0]/(m1[0] + m2[0])));
//
// // push the children to the stack if they have
// // an acceptably large volume
// if(depth < MAX_DEPTH) {
// if(m1[0] > MIN_VOL) {
// polystack[nstack] = poly1;
// depthstack[nstack] = depth + 1;
// ++nstack;
// }
// if(m2[0] > MIN_VOL) {
// polystack[nstack] = poly2;
// depthstack[nstack] = depth + 1;
// ++nstack;
// }
// }
// }
// }
//}
//
//
//
//void test_tet_tet_timing() {
//
// // Intersects pairs of tetrahedra, for timing purposes only.
//
//#undef NUM_TRIALS
//#define NUM_TRIALS 100000
//
// // variables: the polyhedra and their moments
// r3d_poly poly;
// r3d_rvec3 verts[4];
// r3d_plane faces[4];
// r3d_real om[R3D_NUM_MOMENTS(POLY_ORDER)];
//
// // for timing only, no assertions
// r3d_int trial;
// printf("Intersecting %d pairs of tetrahedra.\n", NUM_TRIALS);
// for(trial = 0; trial < NUM_TRIALS; ++trial) {
//
// // generate the first random tet
// rand_tet_3d(verts, MIN_VOL);
// r3d_init_tet(&poly, verts);
//
// // generate the second random tet
// rand_tet_3d(verts, MIN_VOL);
// r3d_tet_faces_from_verts(faces, verts);
//
// // clip the first tet against the faces of the second
// r3d_clip(&poly, faces, 4);
//
// // find the moments (up to quadratic order) of the clipped poly
// r3d_reduce(&poly, om, POLY_ORDER);
//
// }
//}
//
//
//void test_torus_load_and_chop() {
//
// // recursively splits a polyhedron (starting from a torus) with a cut plane
// // that is always degenerate with the poly in some way,
// // checking to see that the resulting volumes add up properly.
// // This checks non-convex geometry, and also r3d_init_poly() when more than
// // three edges per vertex are needed.
//
// r3d_int i, j, f, m;
//
// // explicit stack-based implementation
// r3d_int nstack, depth, chopt;
// r3d_poly polystack[STACK_SIZE];
// r3d_int depthstack[STACK_SIZE];
//
// // variables: the polyhedra and their moments
// r3d_plane splane;
// r3d_poly opoly, poly1, poly2;
// r3d_real om[R3D_NUM_MOMENTS(POLY_ORDER)], m1[R3D_NUM_MOMENTS(POLY_ORDER)], m2[R3D_NUM_MOMENTS(POLY_ORDER)];
//
// // torus parameters
//#define NTHETA 3
//#define NPHI 3
//#define R_MAJ 1.0
//#define R_MIN 0.1
//#define TWOPI 6.28318530718
//
// r3d_int nverts = NTHETA*NPHI;
// r3d_rvec3 vertices[nverts];
//
// // generate the vertex coordinates
// for(i = 0; i < NPHI; ++i)
// for(j = 0; j < NTHETA; ++j) {
// vertices[i*NTHETA + j].x = (R_MAJ + R_MIN*cos(j*TWOPI/NTHETA))*cos(i*TWOPI/NPHI);
// vertices[i*NTHETA + j].y = (R_MAJ + R_MIN*cos(j*TWOPI/NTHETA))*sin(i*TWOPI/NPHI);
// vertices[i*NTHETA + j].z = R_MIN*sin(j*TWOPI/NTHETA);
//
// // shift away from the origin so that none of the moments are identically zero
// vertices[i*NTHETA + j].x += 0.5;
// vertices[i*NTHETA + j].y += 0.7;
// vertices[i*NTHETA + j].z += 0.9;
// }
//
//#if 0
// // generate quadrilateral faces
// r3d_int nfaces = NTHETA*NPHI;
// r3d_int vertsperface[nfaces];
// r3d_int rawinds[nfaces][4];
// for(i = 0; i < NPHI; ++i)
// for(j = 0; j < NTHETA; ++j) {
// vertsperface[i*NTHETA + j] = 4;
// rawinds[i*NTHETA + j][0] = (i)*NTHETA + (j);
// rawinds[i*NTHETA + j][1] = ((i+1)%NPHI)*NTHETA + (j);
// rawinds[i*NTHETA + j][2] = ((i+1)%NPHI)*NTHETA + ((j+1)%NTHETA);
// rawinds[i*NTHETA + j][3] = (i)*NTHETA + ((j+1)%NTHETA);
// }
//#else
// // generate triangular faces
// r3d_int nfaces = 2*NTHETA*NPHI;
// r3d_int vertsperface[nfaces];
// r3d_int rawinds[nfaces][3];
// for(i = 0; i < NPHI; ++i)
// for(j = 0; j < NTHETA; ++j) {
// vertsperface[2*(i*NTHETA + j)] = 3;
// rawinds[2*(i*NTHETA + j)][0] = (i)*NTHETA + (j);
// rawinds[2*(i*NTHETA + j)][1] = ((i+1)%NPHI)*NTHETA + (j);
// rawinds[2*(i*NTHETA + j)][2] = ((i+1)%NPHI)*NTHETA + ((j+1)%NTHETA);
// vertsperface[2*(i*NTHETA + j)+1] = 3;
// rawinds[2*(i*NTHETA + j)+1][0] = (i)*NTHETA + (j);
// rawinds[2*(i*NTHETA + j)+1][1] = ((i+1)%NPHI)*NTHETA + ((j+1)%NTHETA);
// rawinds[2*(i*NTHETA + j)+1][2] = (i)*NTHETA + ((j+1)%NTHETA);
// }
//#endif
//
// // make a double-pointer for the faces
// r3d_int* faceinds[nfaces];
// for(f = 0; f < nfaces; ++f) faceinds[f] = &rawinds[f][0];
//
// // initialize a general polyhedron
// r3d_init_poly(&opoly, vertices, nverts, faceinds, vertsperface, nfaces);
//
// // push the torus to the stack
// nstack = 0;
// polystack[nstack] = opoly;
// depthstack[nstack] = 0;
// ++nstack;
//
// // recursively split the poly
// while(nstack > 0) {
//
// // pop the stack
// --nstack;
// opoly = polystack[nstack];
// depth = depthstack[nstack];
//
// // generate a random plane from one of a few
// // possible degenerate configurations, ensuring that it
// // has a valid unit normal
// chopt = rand_int(6);
// do {
// splane = choptions_3d[chopt](&opoly);
// } while(splane.n.x == 0.0 && splane.n.y == 0.0 && splane.n.z == 0.0);
//
// // split the poly by making two copies of the original poly
// // and them clipping them against the same plane, with one
// // oriented oppositely
// poly1 = opoly;
// poly2 = opoly;
// r3d_clip(&poly1, &splane, 1);
// splane.n.x *= -1;
// splane.n.y *= -1;
// splane.n.z *= -1;
// splane.d *= -1;
// r3d_clip(&poly2, &splane, 1);
//
// // reduce the original and its two parts
// r3d_reduce(&opoly, om, POLY_ORDER);
// r3d_reduce(&poly1, m1, POLY_ORDER);
// r3d_reduce(&poly2, m2, POLY_ORDER);
//
// // make sure the sum of moments equals the original
// for(m = 0; m < R3D_NUM_MOMENTS(POLY_ORDER); ++m) {
// ASSERT_EQ(om[m], m1[m] + m2[m], TOL_FAIL);
// EXPECT_EQ(om[m], m1[m] + m2[m], TOL_WARN);
// }
//
// // make sure neither of the two resulting volumes is larger than the original
// // (within some tolerance)
// ASSERT_LT(m1[0], om[0]*(1.0 + TOL_FAIL));
// EXPECT_LT(m1[0], om[0]*(1.0 + TOL_WARN));
// ASSERT_LT(m2[0], om[0]*(1.0 + TOL_FAIL));
// EXPECT_LT(m2[0], om[0]*(1.0 + TOL_WARN));
//
// //printf("nstack = %d, depth = %d, opoly = %.10e, p1 = %.10e, p2 = %.10e, err = %.10e\n",
// //nstack, depth, om[0], m1[0], m2[0], fabs(1.0 - om[0]/(m1[0] + m2[0])));
//
// // push the children to the stack if they have
// // an acceptably large volume
// if(depth < MAX_DEPTH) {
// if(m1[0] > MIN_VOL) {
// polystack[nstack] = poly1;
// depthstack[nstack] = depth + 1;
// ++nstack;
// }
// if(m2[0] > MIN_VOL) {
// polystack[nstack] = poly2;
// depthstack[nstack] = depth + 1;
// ++nstack;
// }
// }
// }
//}
//
//void test_voxelization() {
//
// // Test r3d_voxelize() by checking that the voxelized moments
// // do indeed sum to those of the original input
//
//#undef POLY_ORDER
//#define POLY_ORDER 4
//#define NGRID 23
//
// // vars
// r3d_int i, j, v, curorder, mind;
// r3d_long gg;
// r3d_int nmom = R3D_NUM_MOMENTS(POLY_ORDER);
// r3d_real voxsum, tmom[nmom];
// r3d_poly poly;
// r3d_rvec3 verts[4];
//
// // create a random tet in the unit box
// rand_tet_3d(verts, MIN_VOL);
// for(v = 0; v < 4; ++v)
// for(i = 0; i < 3; ++i) {
// verts[v].xyz[i] += 1.0;
// verts[v].xyz[i] *= 0.5;
// }
// r3d_init_tet(&poly, verts);
//
// // get its original moments for reference
// r3d_reduce(&poly, tmom, POLY_ORDER);
//
// // voxelize it
// r3d_rvec3 dx = {{1.0/NGRID, 1.0/NGRID, 1.0/NGRID}};
// r3d_dvec3 ibox[2];
// r3d_get_ibox(&poly, ibox, dx);
// printf("Voxelizing a tetrahedron to a grid with dx = %f %f %f and moments of order %d\n", dx.x, dx.y, dx.z, POLY_ORDER);
// printf("Minimum index box = %d %d %d to %d %d %d\n", ibox[0].i, ibox[0].j, ibox[0].k, ibox[1].i, ibox[1].j, ibox[1].k);
// r3d_int nvoxels = (ibox[1].i-ibox[0].i)*(ibox[1].j-ibox[0].j)*(ibox[1].k-ibox[0].k);
// r3d_real* grid = calloc(nvoxels*nmom, sizeof(r3d_real));
// r3d_voxelize(&poly, ibox, grid, dx, POLY_ORDER);
//
// // make sure the sum of each moment equals the original
// for(curorder = 0, mind = 0; curorder <= POLY_ORDER; ++curorder) {
// //printf("Order = %d\n", curorder);
// for(i = curorder; i >= 0; --i)
// for(j = curorder - i; j >= 0; --j, ++mind) {
// //k = curorder - i - j;
// voxsum = 0.0;
// for(gg = 0; gg < nvoxels; ++gg) voxsum += grid[nmom*gg+mind];
// //printf(" Int[ x^%d y^%d z^%d dV ] original = %.10e, voxsum = %.10e, error = %.10e\n",
// //i, j, k, tmom[mind], voxsum, fabs(1.0 - tmom[mind]/voxsum));
// ASSERT_EQ(tmom[mind], voxsum, TOL_FAIL);
// EXPECT_EQ(tmom[mind], voxsum, TOL_WARN);
// }
// }
// free(grid);
//}
//
//
//void test_moments() {
//
// // check the moments against an analytic test case
// // (an axis-aligned box) up to some arbitrary order
//
//#undef POLY_ORDER
//#undef NUM_TRIALS
//#define POLY_ORDER 20
//#define NUM_TRIALS 1000
//
// r3d_int i, j, k, mind, curorder;
// r3d_poly poly;
// r3d_rvec3 box[2];
// r3d_real moments[R3D_NUM_MOMENTS(POLY_ORDER)];
// r3d_real exact;
//
// // initialize the box
// box[0].x = 1.0;
// box[0].y = 1.0;
// box[0].z = 1.0;
// box[1].x = 1.5;
// box[1].y = 2.0;
// box[1].z = 2.5;
// r3d_init_box(&poly, box);
//
//
// r3d_int trial;
// printf("Computing moments of order %d, %d trials.\n", POLY_ORDER, NUM_TRIALS);
// for(trial = 0; trial < NUM_TRIALS; ++trial) {
//
// // get the moments from r3d_reduce
// r3d_reduce(&poly, moments, POLY_ORDER);
//
// // Check all the moments against the analytic solution
// // NOTE: This is the order that r3d_reduce puts out!
// for(curorder = 0, mind = 0; curorder <= POLY_ORDER; ++curorder) {
// //printf("Order = %d\n", curorder);
// for(i = curorder; i >= 0; --i)
// for(j = curorder - i; j >= 0; --j, ++mind) {
// k = curorder - i - j;
// exact = 1.0/((i+1)*(j+1)*(k+1))*(pow(box[1].x, i+1) - pow(box[0].x, i+1))
// *(pow(box[1].y, j+1) - pow(box[0].y, j+1))*(pow(box[1].z, k+1) - pow(box[0].z, k+1));
// //printf(" Int[ x^%d y^%d z^%d dV ] = %.10e, analytic = %.10e, frac = %f, error = %.10e\n",
// //i, j, k, moments[mind], exact, moments[mind]/exact, fabs(1.0 - moments[mind]/exact));
// ASSERT_EQ(moments[mind], exact, TOL_FAIL);
// EXPECT_EQ(moments[mind], exact, TOL_WARN);
// }
// }
// }
//
//}
//
//// -- user-implemented functions declared in utest.h -- //
//
//void register_all_tests() {
//
// register_test(test_split_tet_thru_centroid, "split_tet_thru_centroid");
// register_test(test_split_nonconvex, "split_nonconvex");
// register_test(test_recursive_splitting_nondegenerate, "recursive_splitting_nondegenerate");
// register_test(test_recursive_splitting_degenerate, "recursive_splitting_degenerate");
// register_test(test_recursive_splitting_degenerate_perturbed, "recursive_splitting_degenerate_perturbed");
// register_test(test_tet_tet_timing, "tet_tet_timing");
// register_test(test_torus_load_and_chop, "torus_load_and_chop");
// register_test(test_moments, "moments");
// register_test(test_voxelization, "voxelization");
//
//}
//
//void setup() {
//
// // no print buffer
// setbuf(stdout, NULL);
//
// // random number seed
// srand(time(NULL));
// //srand(10291986);
//
// // initialize random clip plane options
// choptions_3d[0] = thru_cent_3d;
// choptions_3d[1] = thru_face_3d;
// choptions_3d[2] = thru_edge_cent_3d;
// choptions_3d[3] = thru_edge_rand_3d;
// choptions_3d[4] = thru_vert_cent_3d;
// choptions_3d[5] = thru_vert_rand_3d;
//}
/////////////////////////////////////////////////////////
| [
"thony_106@hotmail.com"
] | thony_106@hotmail.com |
51dcde26add4c4325174dbc98fd0bd428794e430 | 7e71bd676112ab5a1971a271f141e6fd33005625 | /third_party/boost/libs/locale/test/test_convert.cpp | 0bc8d9745492e3f4fa4e0ee0bc8d428f81fc5966 | [
"BSL-1.0"
] | permissive | avplayer/httpd | b45ed6151ecd54a3a6306ed320a97aa6deb60c68 | f2c73ffbc5804d20ec6e5b8814d6eddf9be06d37 | refs/heads/master | 2023-07-31T12:03:28.740001 | 2023-07-14T08:39:35 | 2023-07-14T08:39:35 | 72,509,091 | 9 | 3 | null | null | null | null | UTF-8 | C++ | false | false | 5,386 | cpp | //
// Copyright (c) 2009-2011 Artyom Beilis (Tonkikh)
//
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
#include <boost/locale/conversion.hpp>
#include <boost/locale/generator.hpp>
#include <boost/locale/info.hpp>
#include "boostLocale/test/tools.hpp"
#include "boostLocale/test/unit_test.hpp"
#include <iomanip>
#include <iostream>
template<typename Char>
void test_normc(std::basic_string<Char> orig, std::basic_string<Char> normal, boost::locale::norm_type type)
{
std::locale l = boost::locale::generator().generate("en_US.UTF-8");
TEST_EQ(normalize(orig, type, l), normal);
TEST_EQ(normalize(orig.c_str(), type, l), normal);
TEST_EQ(normalize(orig.c_str(), orig.c_str() + orig.size(), type, l), normal);
}
void test_norm(std::string orig, std::string normal, boost::locale::norm_type type)
{
test_normc<char>(orig, normal, type);
test_normc<wchar_t>(to<wchar_t>(orig), to<wchar_t>(normal), type);
#ifdef BOOST_LOCALE_ENABLE_CHAR16_T
test_normc<char16_t>(to<char16_t>(orig), to<char16_t>(normal), type);
#endif
#ifdef BOOST_LOCALE_ENABLE_CHAR32_T
test_normc<char32_t>(to<char32_t>(orig), to<char32_t>(normal), type);
#endif
}
#define TEST_A(Chr, how, source, dest) \
do { \
const boost::locale::info& inf = std::use_facet<boost::locale::info>(std::locale()); \
std::cout << "Testing " #how " for " #Chr ", lang=" << inf.language(); \
if(std::string("char") == #Chr) \
std::cout << " charset=" << inf.encoding(); \
std::cout << std::endl; \
std::basic_string<Chr> source_s = (source), dest_s = (dest); \
TEST_EQ(boost::locale::how(source_s), dest_s); \
TEST_EQ(boost::locale::how(source_s.c_str()), dest_s); \
TEST_EQ(boost::locale::how(source_s.c_str(), source_s.c_str() + source_s.size()), dest_s); \
BOOST_LOCALE_START_CONST_CONDITION \
} while(0) BOOST_LOCALE_END_CONST_CONDITION
#define TEST_ALL_CASES \
do { \
eight_bit = true; \
std::locale::global(gen("en_US.UTF-8")); \
TEST_V(to_upper, "grüßen i", "GRÜSSEN I"); \
TEST_V(to_lower, "Façade", "façade"); \
TEST_V(to_title, "façadE world", "Façade World"); \
TEST_V(fold_case, "Hello World", "hello world"); \
std::locale::global(gen("tr_TR.UTF-8")); \
eight_bit = false; \
TEST_V(to_upper, "i", "İ"); \
TEST_V(to_lower, "İ", "i"); \
BOOST_LOCALE_START_CONST_CONDITION \
} while(0) BOOST_LOCALE_END_CONST_CONDITION
BOOST_LOCALE_DISABLE_UNREACHABLE_CODE_WARNING
void test_main(int /*argc*/, char** /*argv*/)
{
#ifndef BOOST_LOCALE_WITH_ICU
std::cout << "ICU is not build... Skipping\n";
return;
#endif
{
using namespace boost::locale;
std::cout << "Testing Unicode normalization" << std::endl;
test_norm("\xEF\xAC\x81", "\xEF\xAC\x81", norm_nfd); /// ligature fi
test_norm("\xEF\xAC\x81", "\xEF\xAC\x81", norm_nfc);
test_norm("\xEF\xAC\x81", "fi", norm_nfkd);
test_norm("\xEF\xAC\x81", "fi", norm_nfkc);
test_norm("ä", "ä", norm_nfd); // ä to a and accent
test_norm("ä", "ä", norm_nfc);
}
boost::locale::generator gen;
bool eight_bit = true;
#define TEST_V(how, source_s, dest_s) \
do { \
TEST_A(char, how, source_s, dest_s); \
if(eight_bit) { \
std::locale tmp = std::locale(); \
std::locale::global(gen("en_US.ISO8859-1")); \
TEST_A(char, how, to<char>(source_s), to<char>(dest_s)); \
std::locale::global(tmp); \
} \
BOOST_LOCALE_START_CONST_CONDITION \
} while(0) BOOST_LOCALE_END_CONST_CONDITION
TEST_ALL_CASES;
#undef TEST_V
#define TEST_V(how, source_s, dest_s) TEST_A(wchar_t, how, to<wchar_t>(source_s), to<wchar_t>(dest_s))
TEST_ALL_CASES;
#undef TEST_V
#ifdef BOOST_LOCALE_ENABLE_CHAR16_T
# define TEST_V(how, source_s, dest_s) TEST_A(char16_t, how, to<char16_t>(source_s), to<char16_t>(dest_s))
TEST_ALL_CASES;
# undef TEST_V
#endif
#ifdef BOOST_LOCALE_ENABLE_CHAR32_T
# define TEST_V(how, source_s, dest_s) TEST_A(char32_t, how, to<char32_t>(source_s), to<char32_t>(dest_s))
TEST_ALL_CASES;
# undef TEST_V
#endif
}
// boostinspect:noascii
| [
"jack.wgm@gmail.com"
] | jack.wgm@gmail.com |
6aaf11a48972f1d79caec3cae311a02705ce8007 | 90895261e08d3b50e10dfc7eeb37484bb7851c60 | /MouseGestures/multistrokeRecognizers/rectanglegesturesmanager.h | 05d90fd89be50c800d62c32206a5b80907bf8b93 | [] | no_license | qreal/tools | 8286c4cce3c6dc9c7d9daec79504dc489c33f5ae | e9df29b7b4d199e2fd296272352c133c2db9c510 | refs/heads/master | 2021-01-19T02:42:56.589267 | 2017-11-17T10:27:24 | 2017-11-17T10:27:24 | 1,831,652 | 1 | 4 | null | 2014-10-31T11:03:13 | 2011-06-01T12:53:14 | C++ | UTF-8 | C++ | false | false | 374 | h | #pragma once
#include "abstractRecognizer.h"
#include "GeometricForms.h"
class RectangleGesturesManager : public GesturesRecognizer<double *>
{
public:
RectangleGesturesManager();
double getMaxDistance(QString const &);
bool isMultistroke();
double getDistance(double * const & key1, double * const & key2);
double * getKey(PathVector const & path);
};
| [
"ololo@ololo.org"
] | ololo@ololo.org |
f746c10bb3ab69857d44e85fd1c3270d7761c1e5 | 5bc8120d7de29a44a63513b4de6c8ebf2d859e01 | /include/convert.h | 1cffd6cc7ed7c898f086ad9607f75a9cde6e2293 | [] | no_license | timepp/tplib | cee608a7278918dbe82385904317cd4f560da0bb | 7016f1556d9223110b61cc15d8a1395172fa304f | refs/heads/master | 2021-07-01T04:06:09.197948 | 2021-06-23T02:51:04 | 2021-06-23T02:51:04 | 1,198,633 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 587 | h | #pragma once
#include <string>
#include <stdlib.h>
namespace tp
{
struct cvt
{
static int to_int(const wchar_t* s)
{
return _wtoi(s);
}
static int to_int(const std::wstring& s)
{
return to_int(s.c_str());
}
static bool to_bool(const wchar_t* s)
{
return to_int(s)? true : false;
}
static bool to_bool(const std::wstring& s)
{
return to_bool(s.c_str());
}
static std::wstring square_quote(const std::wstring& s)
{
return L"[" + s + L"]";
}
};
} | [
"tongjunhui@live.cn"
] | tongjunhui@live.cn |
4a4a3e06d7e68172cc89c3bcd2996a9d00b697b7 | 0b33d5b91d7c28ceeac36aa8b987a133b8a1bd79 | /code_forces/122_A.cpp | bd2ac8a3c5c12805a2678be832850fa35e52b696 | [] | no_license | yollotltamayo/Online-Judges-Solutions | 8379bc1703ab870157fea932aa13bcafe6584c48 | 78ed1b8af0c73f6ea55f6988782ce94f21fd5222 | refs/heads/master | 2022-10-18T16:59:49.089781 | 2020-06-11T22:39:55 | 2020-06-11T22:39:55 | 271,128,410 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 271 | cpp | #include<iostream>
using namespace std;
int main(){
int veces,ban = 0;
int a[] = {4,7,47,74,477,447,444,777,774,744};
cin>>veces;
for(int y = 0;veces >= a[y];y++){
if(veces%a[y] == 0)
{
ban = 1;
break;
}
}
if(ban)
cout<<"YES";
else
cout<<"NO";
} | [
"yollotltamayo@comunidad.unam.mx"
] | yollotltamayo@comunidad.unam.mx |
39dbba5351e47a3c6669e205404325892c1433bf | 770b7ad3c4e294e9c60d7c0e4f5d90f62daf3de0 | /ComponentRackDetection/smartsoft/src/utils/PointManipulation.cc | 409dbbe6abb99dea7b0e0bd598e8cad6f357dcad | [] | no_license | Servicerobotics-Ulm/ComponentRepository | b1b73ea8871366f05846aedc4ca4df4024b8fe39 | 0c958e9dd9263b525b404bb9581f33c15cfbb3d8 | refs/heads/master | 2022-12-15T07:54:19.437434 | 2022-12-06T14:30:05 | 2022-12-06T14:30:05 | 122,948,164 | 2 | 11 | null | 2021-02-10T12:03:13 | 2018-02-26T09:46:20 | C++ | UTF-8 | C++ | false | false | 10,907 | cc | // --------------------------------------------------------------------------
//
// Copyright (C) 2017 Matthias Rollenhagen
//
// rollenhagen@hs-ulm.de
// schlegel@hs-ulm.de
//
// ZAFH Servicerobotic Ulm
// Christian Schlegel
// University of Applied Sciences
// Prittwitzstr. 10
// 89075 Ulm
// Germany
//
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
//--------------------------------------------------------------------------
#include "PointManipulation.hh"
#include <math.h>
#include <pcl/filters/passthrough.h>
#include <mrpt/poses/include/mrpt/poses/CPoint3D.h>
PointManipulation::PointManipulation() {
}
PointManipulation::PointManipulation(CommBasicObjects::CommPose3d sensor_pose, std::vector<double> depth_intrinsic, std::vector<double> color_intrinsic, DomainVision::CommDepthImage* depth_image) {
this->sensor_pose = sensor_pose;
this->depth_intrinsic = depth_intrinsic;
this->color_intrinsic = color_intrinsic;
this->_depth_image = depth_image;
}
PointManipulation::~PointManipulation() {
// TODO Auto-generated destructor stub
}
/*
* Transforms the inserted point from sensor coordinate system
* to robot coordinate system.
*/
mrpt::poses::CPoint3D PointManipulation::transormPointToRobotCoord(const mrpt::poses::CPoint3D & point) {
double sensor_yaw = this->sensor_pose.get_azimuth(), sensor_pitch = this->sensor_pose.get_elevation(), sensor_roll = this->sensor_pose.get_roll();
double sensor_x = this->sensor_pose.getPosition().getX() / 1000, sensor_y = this->sensor_pose.getPosition().getY() / 1000, sensor_z = this->sensor_pose.getPosition().getZ() / 1000;
mrpt::poses::CPose3D sensorPose(sensor_x, sensor_y, sensor_z,sensor_yaw, sensor_pitch, sensor_roll);
mrpt::poses::CPoint3D result = sensorPose + point;
return result;
}
/*
* Transfers 2D point (row / column) into 3D.
*/
void PointManipulation::pixelToXyz (uint32_t& depth_row, uint32_t& depth_col, float &depth_val_meters, float &x, float &y, float &z, bool transform_to_robot_frame){
const float bad_point = std::numeric_limits<float>::quiet_NaN();
if (std::isnan(depth_val_meters) || depth_val_meters <= 0.001) {
//depth value is not valid
x = y = z = bad_point;
} else {
const float cx(this->depth_intrinsic[2]), cy(this->depth_intrinsic[6]);
const float inv_fx(1/this->depth_intrinsic[0]), inv_fy(1/this->depth_intrinsic[5]);
x = (depth_col + 0.5 - cx) * inv_fx * depth_val_meters;
y = (depth_row + 0.5 - cy) * inv_fy * depth_val_meters;
z = depth_val_meters;
float temp_x, temp_y, temp_z;
temp_x = x;
temp_y = y;
temp_z = z;
//This is now done by the sensor pose rotation
//x = temp_z;
//y = temp_x * (-1);
//z = temp_y * (-1);
if (transform_to_robot_frame) {
mrpt::poses::CPoint3D tmp_point(x, y, z);
tmp_point = transormPointToRobotCoord(tmp_point);
x = tmp_point.x();
y = tmp_point.y();
z = tmp_point.z();
}
}
}
void PointManipulation::pixelToXyz (uint32_t& depth_row, uint32_t& depth_col, float &x, float &y, float &z, bool transform_to_robot_frame){
float depth_val = this->_depth_image->get_distance<float>(depth_col, depth_row);
pixelToXyz (depth_row, depth_col, depth_val, x, y, z, transform_to_robot_frame);
}
void PointManipulation::getDepthValInM(uint32_t& depth_row, uint32_t& depth_col, float &depth_val_m){
DomainVision::DepthFormatType depth_format = this->_depth_image->getFormat();
int depth_width = _depth_image->getWidth();
depth_val_m = 0.0;
if (depth_format == DomainVision::DepthFormatType::UINT16) {
const uint16_t depth_val_ptr = _depth_image->get_distances_uint16()[depth_row * depth_width + depth_col];
depth_val_m = depth_val_ptr / 1000.0f;
} else if (depth_format == DomainVision::DepthFormatType::FLOAT) {
const float depth_val_ptr = _depth_image->get_distances_float()[depth_row * depth_width + depth_col];
depth_val_m = depth_val_ptr;
} else {
std::cout << "Unknow Depth Format" << std::endl;
std::abort();
}
}
void PointManipulation::createColoredPointCloud(pcl::PointCloud<pcl::PointXYZRGB>::Ptr point_cloud_out, DomainVision::CommVideoImage *color_image, bool dense_cloud) {
pcl::PointCloud<pcl::PointXYZRGB>::Ptr point_cloud_ptr(new pcl::PointCloud<pcl::PointXYZRGB>());
point_cloud_ptr->resize(color_image->get_width() * color_image->get_height());
point_cloud_ptr->is_dense = dense_cloud;
float x_in_m, y_in_m, z_in_m;
const uint8_t* imageData = color_image->get_data();
for (uint32_t rgb_row = 0; rgb_row < color_image->get_height(); rgb_row++) {
for (uint32_t rgb_col = 0; rgb_col < color_image->get_width(); rgb_col++) {
float depth_val = this->_depth_image->get_distance<float>(rgb_col, rgb_row);
//depth_val = 0.0;
//getDepthValInM(rgb_row, rgb_col, depth_val);
pixelToXyz(rgb_row, rgb_col, depth_val, x_in_m, y_in_m, z_in_m, true);
// check if measured distance is NaN
// if NaN or inf values are in point cloud it will not be shown
// To get the mapping form RGB pixel (row / column) to
// cloud object index (both having size of (1920x1080)) the invalid values are set to max values
if(dense_cloud && (std::isinf(x_in_m) || std::isinf(z_in_m) || std::isinf(y_in_m) || x_in_m != x_in_m || y_in_m != y_in_m || z_in_m != z_in_m)){
continue;
}
const uint8_t* pixel = (imageData + rgb_row * 3 * color_image->get_width() + rgb_col * 3);
uint8_t r = pixel[0];
uint8_t g = pixel[1];
uint8_t b = pixel[2];
pcl::PointXYZRGB p(r, g, b);
p.x = x_in_m;
p.y = y_in_m;
p.z = z_in_m;
point_cloud_ptr->points[rgb_row * color_image->get_width() + rgb_col] = p;
}
}
point_cloud_out->points.clear();
point_cloud_out->points = point_cloud_ptr->points;
}
void PointManipulation::createPointCloud(pcl::PointCloud<pcl::PointXYZ>::Ptr point_cloud_out, bool dense_cloud) {
pcl::PointCloud<pcl::PointXYZ>::Ptr point_cloud_ptr(new pcl::PointCloud<pcl::PointXYZ>());
point_cloud_ptr->is_dense = dense_cloud;
if(point_cloud_ptr->is_dense){
point_cloud_ptr->resize(_depth_image->getWidth() * _depth_image->getHeight());
}
float x_in_m, y_in_m, z_in_m;
for (uint32_t row = 0; row < _depth_image->getHeight(); row++) {
for (uint32_t col = 0; col < _depth_image->getWidth(); col++) {
float depth_val = this->_depth_image->get_distance<float>(col, row);
//depth_val = 0.0;
//getDepthValInM(row, col, depth_val);
pixelToXyz(row, col, depth_val, x_in_m, y_in_m, z_in_m, true);
if (dense_cloud){
// check if measured distance is NaN
// if NaN or inf values are in point cloud it will not be shown
// To get the mapping form RGB pixel (row / column) to
// cloud object index (both having size of (1920x1080)) the invalid values are set to max values
if(std::isinf(x_in_m) || std::isinf(z_in_m) || std::isinf(y_in_m) || x_in_m != x_in_m || y_in_m != y_in_m || z_in_m != z_in_m){
continue;
}
point_cloud_ptr->points.push_back(pcl::PointXYZ(x_in_m, y_in_m, z_in_m));
}else{
pcl::PointXYZ p(x_in_m, y_in_m, z_in_m);
point_cloud_ptr->points[row * _depth_image->getWidth() + col] = p;
}
}
}
point_cloud_out->points.clear();
point_cloud_out->points = point_cloud_ptr->points;
}
pcl::PointCloud<pcl::PointXYZ>::Ptr PointManipulation::removeObjectFromPC(pcl::PointCloud<pcl::PointXYZ>::Ptr point_cloud, std::vector<float> obj_center_xyz, std::vector<float> obj_dimensions_xyz, mrpt::poses::CPose3D obj_center_pose) {
float min_x, min_y, min_z;
float max_x, max_y, max_z;
min_x = obj_center_xyz[0] - obj_dimensions_xyz[0] / 2;
max_x = obj_center_xyz[0] + obj_dimensions_xyz[0] / 2;
min_y = obj_center_xyz[1] - obj_dimensions_xyz[1] / 2;
max_y = obj_center_xyz[1] + obj_dimensions_xyz[1] / 2;
min_z = obj_center_xyz[2] - obj_dimensions_xyz[2] / 2;
max_z = obj_center_xyz[2] + obj_dimensions_xyz[2] / 2;
// Using object pose for min/max point. This calculation is more accurate,
// but causes problems in sideway picking. Hence, Must be improved for
// side picking.
// min_x = (obj_center_pose - mrpt::poses::CPose3D(obj_dimensions_xyz[0] / 2, 0, 0, 0, 0, 0)).x();
// max_x = (obj_center_pose + mrpt::poses::CPose3D(obj_dimensions_xyz[0] / 2, 0, 0, 0, 0, 0)).x();
// min_y = (obj_center_pose - mrpt::poses::CPose3D(0, obj_dimensions_xyz[1] / 2, 0, 0, 0, 0)).y();
// max_y = (obj_center_pose + mrpt::poses::CPose3D(0, obj_dimensions_xyz[1] / 2, 0, 0, 0, 0)).y();
// min_z = (obj_center_pose - mrpt::poses::CPose3D(0, 0, obj_dimensions_xyz[2] / 2, 0, 0, 0)).z();
// max_z = (obj_center_pose + mrpt::poses::CPose3D(0, 0, obj_dimensions_xyz[2] / 2, 0, 0, 0)).z();
//check each point, if it is within range and delete it
for(int i = 0; i < point_cloud->size(); i ++){
if(point_cloud->at(i).x > min_x && point_cloud->at(i).x < max_x){
if(point_cloud->at(i).y > min_y && point_cloud->at(i).y < max_y){
if(point_cloud->at(i).z > min_z && point_cloud->at(i).z < max_z){
point_cloud->points.erase(point_cloud->points.begin() + i);
i--;
}
}
}
}
return point_cloud;
}
/*
* Delete all points out of range. Get rid of NaN and inf values
*/
pcl::PointCloud<pcl::PointXYZ>::Ptr PointManipulation::distanceFilterCloud (pcl::PointCloud<pcl::PointXYZ>::Ptr cloud, float min_x, float max_x, float min_y, float max_y, float min_z, float max_z){
pcl::PointCloud<pcl::PointXYZ>::Ptr cloud_filtered_x(new pcl::PointCloud<pcl::PointXYZ>);
pcl::PointCloud<pcl::PointXYZ>::Ptr cloud_filtered_y(new pcl::PointCloud<pcl::PointXYZ>);
pcl::PointCloud<pcl::PointXYZ>::Ptr cloud_filtered_z(new pcl::PointCloud<pcl::PointXYZ>);
pcl::PassThrough<pcl::PointXYZ> pass_env_x;
pass_env_x.setInputCloud(cloud);
pass_env_x.setFilterFieldName("x");
pass_env_x.setFilterLimits(min_x, max_x);
pass_env_x.filter(*cloud_filtered_x);
pcl::PassThrough<pcl::PointXYZ> pass_env_y;
pass_env_y.setInputCloud(cloud_filtered_x);
pass_env_y.setFilterFieldName("y");
pass_env_y.setFilterLimits(min_y, max_y);
pass_env_y.filter(*cloud_filtered_y);
pcl::PassThrough<pcl::PointXYZ> pass_env_z;
pass_env_z.setInputCloud(cloud_filtered_y);
pass_env_z.setFilterFieldName("z");
pass_env_z.setFilterLimits(min_z, max_z);
pass_env_z.filter(*cloud_filtered_z);
return cloud_filtered_z;
}
| [
"matthias@mlutz.de"
] | matthias@mlutz.de |
19566f1a0b8d7ca803e110acf993f6cff823988f | c951370324d6e79afeaeb916cf9c0cb52b914cbc | /gurls++/include/gurls++/task.h | 2490b927fba40c771f03929d50a906ca9f58a267 | [] | no_license | kod3r/GURLS | 66dc66349c417dcf8784d94947b94f9a815b371f | 0265bea4ea3aacb9ac43c0e699de5ddfbc272b07 | refs/heads/master | 2020-12-28T21:51:54.778508 | 2015-05-25T13:22:26 | 2015-05-25T13:22:26 | 37,486,916 | 1 | 0 | null | 2015-06-15T19:36:41 | 2015-06-15T19:36:41 | null | UTF-8 | C++ | false | false | 3,131 | h | /*
* The GURLS Package in C++
*
* Copyright (C) 2011-2013, IIT@MIT Lab
* All rights reserved.
*
* author: M. Santoro
* email: msantoro@mit.edu
* website: http://cbcl.mit.edu/IIT@MIT/IIT@MIT.html
*
* 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(s) of the copyright holders nor the names
* of its contributors or of the Massacusetts Institute of
* Technology or of the Italian Institute of Technology may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef _GURLS_TASK_H_
#define _GURLS_TASK_H_
#include "gurls++/taskbase.h"
#include "gurls++/optlist.h"
#include "gurls++/exceptions.h"
namespace gurls
{
template<typename T>
class Task : public TaskBase
{
public:
///
/// \brief Constructor
/// \param fieldName The name to be used to index the task outputin the options list
/// \param taskName The task name
///
Task(const std::string &fieldName, const std::string &taskName)
: TaskBase(fieldName, taskName){}
///
/// \brief Executes the task
/// \param X input data matrix
/// \param Y labels matrix
/// \param opt options with the different required fields based on the sub-class
///
/// \return A gurlsOption containing the output for the task
///
virtual GurlsOption* execute(const gMat2D<T>& X,
const gMat2D<T>& Y,
const GurlsOptionsList& opt) = 0;
};
/**
* \ingroup Exceptions
*
* \brief BadTaskCreation base class of all the exceptions thrown when a factory tries to create an unknown task
*/
class BadTaskCreation : public gException
{
public:
/**
* Exception constructor.
*/
BadTaskCreation(std::string type): gException("Cannot create task " + type) {}
};
}
#endif // _GURLS_TASK_H_
| [
"andrea@camelotbio.com"
] | andrea@camelotbio.com |
cfdab48513ed81c6665810ae39a49ad645248cd2 | 5a34f38e1d0b6a925bb602383705f0e45b449dff | /cf/893/e2.cpp | 68cdfb8fe735f185c48f8352ac8314e3687fa2e2 | [] | no_license | samuraiexx/competitiveProgramming | 15fcbcf75114c80d112473e5ce9d69b9f33d5280 | 1862e381d0d7aecc0082f2416950cd18b26858d4 | refs/heads/master | 2021-06-10T20:53:39.039074 | 2019-03-25T01:02:21 | 2019-03-25T01:02:21 | 106,463,296 | 0 | 1 | null | 2019-10-20T21:18:08 | 2017-10-10T19:43:09 | C++ | UTF-8 | C++ | false | false | 1,012 | cpp | #include<bits/stdc++.h>
#define st first
#define nd second
typedef long long ll;
using namespace std;
const int N = 1e6 + 5;
const int MOD = 1e9 + 7;
int sieve[N];
int dp[N][21];
bool vis[N][21];
ll fexp(ll a, int b){
ll ans = 1;
while(b)
if(b&1) ans = (ans * a)%MOD, b--;
else a = (a*a)%MOD, b/=2;
return ans;
}
int dpf(int sz, int fac){
if(vis[sz][fac]) return dp[sz][fac];
if(fac == 0) return 1;
if(sz <= 0) return 0;
vis[sz][fac] = true;
dp[sz][fac] = (dpf(sz, fac - 1) + dpf(sz - 1, fac))%MOD;
return dp[sz][fac];
}
int main(){
ios_base::sync_with_stdio(false), cin.tie(0);
for(int i = 2; i < N; i++)
if(!sieve[i])
for(int j = i; j < N; j+=i)
sieve[j] = i;
int q;
cin >> q;
while(q--){
int x, y;
cin >> x >> y;
map<int, int> fac;
while(x > 1)
fac[sieve[x]]++, x = x/sieve[x];
ll ans = 1;
for(auto p : fac)
ans = (ans * dpf(y, p.nd))%MOD;
ans = (ans * fexp(2, y - 1))%MOD;
cout << ans << '\n';
}
}
| [
"samuraiexx@gmail.com"
] | samuraiexx@gmail.com |
2c2240bb62cc9c79460248c09a379ca387f4f233 | e07e3f41c9774c9684c4700a9772712bf6ac3533 | /app/Temp/StagingArea/Data/il2cppOutput/AssemblyU2DCSharp_GSN_Skill_Requests_WebRequester_1855886527.h | 88b3d200d79971758096aa6a65f32f037daa9d18 | [] | no_license | gdesmarais-gsn/inprocess-mobile-skill-client | 0171a0d4aaed13dbbc9cca248aec646ec5020025 | 2499d8ab5149a306001995064852353c33208fc3 | refs/heads/master | 2020-12-03T09:22:52.530033 | 2017-06-27T22:08:38 | 2017-06-27T22:08:38 | 95,603,544 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,937 | h | #pragma once
#include "il2cpp-config.h"
#ifndef _MSC_VER
# include <alloca.h>
#else
# include <malloc.h>
#endif
#include <stdint.h>
// Newtonsoft.Json.JsonSerializerSettings
struct JsonSerializerSettings_t842388167;
// System.Text.StringBuilder
struct StringBuilder_t1221177846;
// GSN.Skill.Requests.IWebRequest
struct IWebRequest_t216132554;
// System.String
struct String_t;
#include "mscorlib_System_Object2689449295.h"
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// GSN.Skill.Requests.WebRequester/Parser
struct Parser_t1855886527 : public Il2CppObject
{
public:
// GSN.Skill.Requests.IWebRequest GSN.Skill.Requests.WebRequester/Parser::_request
Il2CppObject * ____request_2;
// System.String GSN.Skill.Requests.WebRequester/Parser::_data
String_t* ____data_3;
// System.Boolean GSN.Skill.Requests.WebRequester/Parser::<ParseComplete>k__BackingField
bool ___U3CParseCompleteU3Ek__BackingField_4;
public:
inline static int32_t get_offset_of__request_2() { return static_cast<int32_t>(offsetof(Parser_t1855886527, ____request_2)); }
inline Il2CppObject * get__request_2() const { return ____request_2; }
inline Il2CppObject ** get_address_of__request_2() { return &____request_2; }
inline void set__request_2(Il2CppObject * value)
{
____request_2 = value;
Il2CppCodeGenWriteBarrier(&____request_2, value);
}
inline static int32_t get_offset_of__data_3() { return static_cast<int32_t>(offsetof(Parser_t1855886527, ____data_3)); }
inline String_t* get__data_3() const { return ____data_3; }
inline String_t** get_address_of__data_3() { return &____data_3; }
inline void set__data_3(String_t* value)
{
____data_3 = value;
Il2CppCodeGenWriteBarrier(&____data_3, value);
}
inline static int32_t get_offset_of_U3CParseCompleteU3Ek__BackingField_4() { return static_cast<int32_t>(offsetof(Parser_t1855886527, ___U3CParseCompleteU3Ek__BackingField_4)); }
inline bool get_U3CParseCompleteU3Ek__BackingField_4() const { return ___U3CParseCompleteU3Ek__BackingField_4; }
inline bool* get_address_of_U3CParseCompleteU3Ek__BackingField_4() { return &___U3CParseCompleteU3Ek__BackingField_4; }
inline void set_U3CParseCompleteU3Ek__BackingField_4(bool value)
{
___U3CParseCompleteU3Ek__BackingField_4 = value;
}
};
struct Parser_t1855886527_StaticFields
{
public:
// Newtonsoft.Json.JsonSerializerSettings GSN.Skill.Requests.WebRequester/Parser::_jsonSerializerSettings
JsonSerializerSettings_t842388167 * ____jsonSerializerSettings_0;
// System.Text.StringBuilder GSN.Skill.Requests.WebRequester/Parser::_stringBuilder
StringBuilder_t1221177846 * ____stringBuilder_1;
public:
inline static int32_t get_offset_of__jsonSerializerSettings_0() { return static_cast<int32_t>(offsetof(Parser_t1855886527_StaticFields, ____jsonSerializerSettings_0)); }
inline JsonSerializerSettings_t842388167 * get__jsonSerializerSettings_0() const { return ____jsonSerializerSettings_0; }
inline JsonSerializerSettings_t842388167 ** get_address_of__jsonSerializerSettings_0() { return &____jsonSerializerSettings_0; }
inline void set__jsonSerializerSettings_0(JsonSerializerSettings_t842388167 * value)
{
____jsonSerializerSettings_0 = value;
Il2CppCodeGenWriteBarrier(&____jsonSerializerSettings_0, value);
}
inline static int32_t get_offset_of__stringBuilder_1() { return static_cast<int32_t>(offsetof(Parser_t1855886527_StaticFields, ____stringBuilder_1)); }
inline StringBuilder_t1221177846 * get__stringBuilder_1() const { return ____stringBuilder_1; }
inline StringBuilder_t1221177846 ** get_address_of__stringBuilder_1() { return &____stringBuilder_1; }
inline void set__stringBuilder_1(StringBuilder_t1221177846 * value)
{
____stringBuilder_1 = value;
Il2CppCodeGenWriteBarrier(&____stringBuilder_1, value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
| [
"gdesmarais@gsngames.com"
] | gdesmarais@gsngames.com |
e79de0e6d70f13de771a6b41950935d20a1d6fbd | 4b9f1933df8b7ec281b7d11362e0336c5af02717 | /Model.cpp | 93054059c33896de97d03f1404fe80afbbc2718d | [] | no_license | misha1125/MashGraphProject | 200f3d46f09fecec6476e4694d7bba6ec04ca8c0 | ca7c9ddf41e4d2eca9c330cc4966ff97d198dd63 | refs/heads/master | 2023-02-03T22:59:02.473234 | 2020-12-22T19:48:19 | 2020-12-22T19:48:19 | 312,877,170 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 11,166 | cpp | //
// Created by михаил on 08.12.2020.
//
#include "Model.h"
// пока без индексов
Model::Model(MyShader &shader, Camera &camera, GLfloat *vertex, size_t vertex_size, size_t vertex_cnt, const char *image_path,
GLfloat width, GLfloat height, bool has_normal):
shader(shader), camera(camera), vertex(vertex), vertex_size(vertex_size), vertex_cnt(vertex_cnt), width(width), height(height) {
glGenVertexArrays(1, &vertex_array);
glGenBuffers(1, &vertex_buffer);
//glGenBuffers(1, &index_buffer);
glBindVertexArray(vertex_array);
glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
glBufferData(GL_ARRAY_BUFFER, vertex_size, vertex, GL_STATIC_DRAW);
if (!has_normal){
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (GLvoid*)0);
glEnableVertexAttribArray(0);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat)));
glEnableVertexAttribArray(2);
} else {
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)0);
glEnableVertexAttribArray(0);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat)));
glEnableVertexAttribArray(2);
glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(5 * sizeof(GLfloat)));
glEnableVertexAttribArray(3);
}
glBindVertexArray(0);
LoadTexture(image_path, texture);
std::cout<<"Created sucsessfully "<< vertex_array<<" "<<texture<<" "<<shader.Program<<"\n";
}
void Model::ApplyTransformation(glm::vec3 position) {
this->ApplyTransformation(shader.Program, position);
}
void Model::ApplyTransformation(GLuint program, glm::vec3 position) {
model = glm::mat4(1.0f);
glm::mat4 view(1.0f);
glm::mat4 projection(1.0f);
view = glm::translate(view, position);
projection = glm::perspective(glm::radians(45.0f), width / height, 0.1f, 100.0f);
GLint modelLoc = glGetUniformLocation(program, "model");
GLint viewLoc = glGetUniformLocation(program, "view");
GLint projLoc = glGetUniformLocation(program, "projection");
glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));
glUniformMatrix4fv(projLoc, 1, GL_FALSE, glm::value_ptr(projection));
GLint camLoc = glGetUniformLocation(program, "cameraView");
glUniformMatrix4fv(camLoc, 1, GL_FALSE, glm::value_ptr(camera.CameraView()));
//std::cout<<shader.Program<<" "<<camera.cameraPos.x<<" "<<width << " "<<height <<"\n";
}
void Model::Show() {
//std::cout<<"Here "<<vertex_array<<" "<<vertex_cnt<<"\n";
glBindVertexArray(vertex_array);
glDrawArrays(GL_TRIANGLES, 0, vertex_cnt);
glBindVertexArray(0);
}
void Model::ApplyRotation(glm::vec3 axis, GLfloat angle) {
this->ApplyRotation(shader.Program, axis, angle);
}
void Model::ApplyScale(glm::vec3 scale) {
this->ApplyScale(shader.Program, scale);
}
void Model::ApplyRotation(GLuint shader, glm::vec3 axis, GLfloat angle) {
model = glm::rotate(model, glm::radians(angle), axis);
GLint modelLoc = glGetUniformLocation(shader, "model");
glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
}
void Model::ApplyScale(GLuint shader, glm::vec3 scale) {
model = glm::scale(model,scale);
GLint modelLoc = glGetUniformLocation(shader, "model");
glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
}
void Model::AddLight(glm::vec3 lightColor, glm::vec3 lightSource) {
GLint lightLoc = glGetUniformLocation(shader.Program, "lightColor");
glUniform3f(lightLoc, lightColor.x, lightColor.y, lightColor.z);
GLint lightPosLoc = glGetUniformLocation(shader.Program, "lightPos");
glUniform3f(lightPosLoc, lightSource.x, lightSource.y, lightSource.z);
GLint viewPosLoc = glGetUniformLocation(shader.Program, "viewPos");
glUniform3f(viewPosLoc, camera.cameraPos.x, camera.cameraPos.y, camera.cameraPos.z);
}
void Model::ApplyShader() {
//glActiveTexture(GL_TEXTURE0);
//std::cout<<"Here "<<shader.Program<<"\n";
shader.Apply();
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, texture);
}
void Model::ApplyLightParameters(glm::vec3 ambient, glm::vec3 diffuse, glm::vec3 specular, GLfloat shines) {
shader.SetVector3("material.ambient", ambient);
shader.SetVector3("material.diffuse", diffuse);
shader.SetVector3("material.specular", specular);
shader.SetFloat("material.shininess", shines);
shader.SetFloat("material.constant", 0.1f);
shader.SetFloat("material.linear", 0.03f);
shader.SetFloat("material.quadratic", 0.005f);
}
void Model::LoadSpectacularTexture(const char *path) {
LoadTexture(path, spectecularTexture);
}
void Model::ApplySpectacularTexture() {
shader.SetInt("material.specularTex", 1);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, spectecularTexture);
}
void Model::LoadNormalTexture(const char *path) {
LoadTexture(path, normalTexture);
}
void Model::ApplyNormalTexture() {
shader.SetInt("normalTexture", 2);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, normalTexture);
}
void Model::LoadDephTexture(const char *path) {
LoadTexture(path, dephMap);
}
void Model::ApplyDephTexture() {
shader.SetInt("depthMap", 3);
glActiveTexture(GL_TEXTURE3);
glBindTexture(GL_TEXTURE_2D, dephMap);
}
void Model::LoadTexture(const char *path, GLuint &texture) {
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
int width_im, height_im;
unsigned char* image = SOIL_load_image(path, &width_im, &height_im, 0, SOIL_LOAD_RGBA);
glTexImage2D(GL_TEXTURE_2D, 0, GL_SRGB_ALPHA, width_im, height_im, 0, GL_RGBA, GL_UNSIGNED_BYTE, image);
glGenerateMipmap(GL_TEXTURE_2D);
SOIL_free_image_data(image);
glBindTexture(GL_TEXTURE_2D, 0);
std::cout<<"Loaded sucsessfully "<< texture<<"\n";
}
void Model::ChangeTexture(GLuint newTexture){
texture = newTexture;
}
void Model::IgnoreCamPosition(){
glm::mat4 view = glm::mat4(glm::mat3(camera.CameraView()));
GLint camLoc = glGetUniformLocation(shader.Program, "cameraView");
glUniformMatrix4fv(camLoc, 1, GL_FALSE, glm::value_ptr(view));
}
Model Model::GeneratePlaneForParalax(MyShader &shader, Camera &camera, const char *path, GLfloat width, GLfloat height) {
Model result(shader, camera, path, width, height);
glm::vec3 pos1(-1.0f, 1.0f, 0.0f);
glm::vec3 pos2(-1.0f, -1.0f, 0.0f);
glm::vec3 pos3( 1.0f, -1.0f, 0.0f);
glm::vec3 pos4( 1.0f, 1.0f, 0.0f);
glm::vec2 uv1(0.0f, 1.0f);
glm::vec2 uv2(0.0f, 0.0f);
glm::vec2 uv3(1.0f, 0.0f);
glm::vec2 uv4(1.0f, 1.0f);
glm::vec3 nm(0.0f, 0.0f, 1.0f);
glm::vec3 tangent1, bitangent1;
glm::vec3 tangent2, bitangent2;
glm::vec3 edge1 = pos2 - pos1;
glm::vec3 edge2 = pos3 - pos1;
glm::vec2 deltaUV1 = uv2 - uv1;
glm::vec2 deltaUV2 = uv3 - uv1;
GLfloat f = 1.0f / (deltaUV1.x * deltaUV2.y - deltaUV2.x * deltaUV1.y);
tangent1.x = f * (deltaUV2.y * edge1.x - deltaUV1.y * edge2.x);
tangent1.y = f * (deltaUV2.y * edge1.y - deltaUV1.y * edge2.y);
tangent1.z = f * (deltaUV2.y * edge1.z - deltaUV1.y * edge2.z);
tangent1 = glm::normalize(tangent1);
bitangent1.x = f * (-deltaUV2.x * edge1.x + deltaUV1.x * edge2.x);
bitangent1.y = f * (-deltaUV2.x * edge1.y + deltaUV1.x * edge2.y);
bitangent1.z = f * (-deltaUV2.x * edge1.z + deltaUV1.x * edge2.z);
bitangent1 = glm::normalize(bitangent1);
edge1 = pos3 - pos1;
edge2 = pos4 - pos1;
deltaUV1 = uv3 - uv1;
deltaUV2 = uv4 - uv1;
f = 1.0f / (deltaUV1.x * deltaUV2.y - deltaUV2.x * deltaUV1.y);
tangent2.x = f * (deltaUV2.y * edge1.x - deltaUV1.y * edge2.x);
tangent2.y = f * (deltaUV2.y * edge1.y - deltaUV1.y * edge2.y);
tangent2.z = f * (deltaUV2.y * edge1.z - deltaUV1.y * edge2.z);
tangent2 = glm::normalize(tangent2);
bitangent2.x = f * (-deltaUV2.x * edge1.x + deltaUV1.x * edge2.x);
bitangent2.y = f * (-deltaUV2.x * edge1.y + deltaUV1.x * edge2.y);
bitangent2.z = f * (-deltaUV2.x * edge1.z + deltaUV1.x * edge2.z);
bitangent2 = glm::normalize(bitangent2);
GLfloat planeVertices[] = {
// координаты // нормали // текст. коорд. // касательные // бикасательные
pos1.x, pos1.y, pos1.z, nm.x, nm.y, nm.z, uv1.x, uv1.y, tangent1.x, tangent1.y, tangent1.z, bitangent1.x, bitangent1.y, bitangent1.z,
pos2.x, pos2.y, pos2.z, nm.x, nm.y, nm.z, uv2.x, uv2.y, tangent1.x, tangent1.y, tangent1.z, bitangent1.x, bitangent1.y, bitangent1.z,
pos3.x, pos3.y, pos3.z, nm.x, nm.y, nm.z, uv3.x, uv3.y, tangent1.x, tangent1.y, tangent1.z, bitangent1.x, bitangent1.y, bitangent1.z,
pos1.x, pos1.y, pos1.z, nm.x, nm.y, nm.z, uv1.x, uv1.y, tangent2.x, tangent2.y, tangent2.z, bitangent2.x, bitangent2.y, bitangent2.z,
pos3.x, pos3.y, pos3.z, nm.x, nm.y, nm.z, uv3.x, uv3.y, tangent2.x, tangent2.y, tangent2.z, bitangent2.x, bitangent2.y, bitangent2.z,
pos4.x, pos4.y, pos4.z, nm.x, nm.y, nm.z, uv4.x, uv4.y, tangent2.x, tangent2.y, tangent2.z, bitangent2.x, bitangent2.y, bitangent2.z
};
result.vertex = planeVertices;
result.vertex_size = sizeof(planeVertices);
result.vertex_cnt = 6;
glGenVertexArrays(1, &result.vertex_array);
glGenBuffers(1, &result.vertex_buffer);
glBindVertexArray(result.vertex_array);
glBindBuffer(GL_ARRAY_BUFFER, result.vertex_buffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(planeVertices), &planeVertices, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 14 * sizeof(GLfloat), (void*)0);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 14 * sizeof(GLfloat), (void*)(3 * sizeof(GLfloat)));
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 14 * sizeof(GLfloat), (void*)(6 * sizeof(GLfloat)));
glEnableVertexAttribArray(3);
glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, 14 * sizeof(GLfloat), (void*)(8 * sizeof(GLfloat)));
glEnableVertexAttribArray(4);
glVertexAttribPointer(4, 3, GL_FLOAT, GL_FALSE, 14 * sizeof(GLfloat), (void*)(11 * sizeof(GLfloat)));
std::cout<<"Plane created sucsessfully "<< result.vertex_array<<" "<<result.texture<<" "<<" "<<shader.Program<<" "<<result.shader.Program<<"\n";
return result;
}
Model::Model(MyShader &shader, Camera &camera, const char *image_path, GLfloat width, GLfloat height):
shader(shader), camera(camera), width(width), height(height) {
LoadTexture(image_path, texture);
}
| [
"mordvincevmisha@mail.ru"
] | mordvincevmisha@mail.ru |
ee8b5de21332651ab1f5f46c47e54fc75e7dd71d | 76b5222a7d501c585e24e9947ebe9eb8b1cfbf2c | /DX_Study/DXEngine/DXEngine03_Draw/AppWindow.cpp | e9d6b09c6907c3b91e22ed86f9ca59df50dd5181 | [] | no_license | HugoRep/GitC_Study | 21033886e81d8c57be7eeb490a81543534b9cf15 | 594310aec7aa31a332f14a5a03f4612104c606ff | refs/heads/master | 2022-01-31T08:49:18.055102 | 2019-07-02T08:59:05 | 2019-07-02T08:59:05 | null | 0 | 0 | null | null | null | null | UHC | C++ | false | false | 2,153 | cpp | #include "AppWindow.h"
#include "Engine.h"
#include <iostream>
AppWindow* app = NULL;
//윈도우 메세지 프로시저 ( 메세지 처리자);
LRESULT CALLBACK WindowProcessor(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam)
{
if (app != NULL)
return app->MessageProcessor(hwnd, msg, wParam, lParam);
else
return DefWindowProc(hwnd, msg, wParam, lParam);
}
AppWindow::AppWindow(HINSTANCE hinstance)
{
hwnd = NULL;
this->hinstance = hinstance;
screenWidth = 1600;
screenHeight = 900;
applicationName = TEXT("Engine02 - Window Setup");
windowStyle = WS_OVERLAPPEDWINDOW;
app = this;
}
AppWindow::~AppWindow()
{
}
int AppWindow::Run(Engine * engine)
{
MSG msg; //메시지 변수
ZeroMemory(&msg, sizeof(MSG)); //메모리 초기화
while (msg.message != WM_QUIT)
{
if (PeekMessage(&msg, NULL, 0, 0,PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
else
{
engine->Update();
engine->Render();
}
}
return 0;
}
bool AppWindow::InitializeWindow()
{
WNDCLASSEX wc;
ZeroMemory(&wc, sizeof(WNDCLASSEX));
//창 구조체 값 설정.
wc.cbSize = sizeof(WNDCLASSEX);
wc.hInstance = hinstance;
wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = NULL;
wc.lpszClassName = TEXT("DXEngine");
wc.lpfnWndProc = WindowProcessor;
if (!RegisterClassEx(&wc))
{
return false;
}
//창 핸들 만들기
hwnd = CreateWindow(wc.lpszClassName, applicationName, windowStyle, 0, 0, screenWidth, screenHeight, NULL, NULL, hinstance, NULL);
if (hwnd == NULL)
{
return false;
}
ShowWindow(hwnd, SW_SHOW);
return true;
}
LRESULT AppWindow::MessageProcessor(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg)
{
case WM_KEYDOWN :
{
if (wParam == VK_ESCAPE)
{
if (MessageBox(NULL,
TEXT("종료 하시겠습니까?"),
TEXT("종료"), MB_YESNO | MB_ICONQUESTION) == IDYES)
{
//예 버튼 눌리면 창 삭제
DestroyWindow(this->hwnd);
}
}
break;
}
case WM_DESTROY:
{
PostQuitMessage(0);
break;
}
}
return DefWindowProc(hwnd, msg , wParam , lParam);
} | [
"bluezigi@gmail.com"
] | bluezigi@gmail.com |
ca02a0247758859f05974206dda07ad5bdffb8ec | ef68b62f4a1dd2e26e26ef2fc67e18f8fbe96418 | /libs/cg_nui/ray_tool.cxx | 21b14fcfcbf7b1be73ca27f9b8e77a9c8189efa9 | [] | no_license | lintianfang/cleaning_cobotics | 68d9a4b418cdadab9dde1c24f529f45e7fc3bd4f | 26ccba618aec0b1176fcfc889e95ed5320ccbe75 | refs/heads/master | 2023-02-25T21:36:10.777059 | 2021-01-29T09:49:16 | 2021-01-29T09:49:16 | 281,898,712 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,153 | cxx | #include <cgv/base/base.h>
#include "ray_tool.h"
#include <cgv/math/pose.h>
#include <cgv/math/ftransform.h>
namespace cgv {
namespace nui {
ray_tool::ray_tool(const std::string& _name, int32_t _controller_index)
: controller_tool(_name, _controller_index)
{
ray_length = 3.0f;
pick_all = false;
}
void ray_tool::check_for_contacts(const cgv::gui::vr_pose_event& vrpe)
{
// compute intersections
vec3 origin, direction;
vrpe.get_state().controller[vrpe.get_trackable_index()].put_ray(&origin(0), &direction(0));
if (pick_all)
scene_node->compute_all_intersections(contact, origin, direction);
else
scene_node->compute_first_intersection(contact, origin, direction);
}
void ray_tool::on_set(void* member_ptr)
{
}
int ray_tool::mri_ref_count = 0;
cgv::render::mesh_render_info ray_tool::mri;
bool ray_tool::init(cgv::render::context& ctx)
{
if (!mri.is_constructed()) {
cgv::media::mesh::simple_mesh<> mesh;
if (mesh.read("D:/data/mesh/vive_controller_1_5/vr_controller_vive_1_5.obj")) {
mri.construct(ctx, mesh);
mri.bind(ctx, ctx.ref_surface_shader_program(true), true);
}
}
++mri_ref_count;
return controller_tool::init(ctx);
}
void ray_tool::clear(cgv::render::context& ctx)
{
controller_tool::clear(ctx);
if (--mri_ref_count == 0)
mri.destruct(ctx);
}
void ray_tool::draw(cgv::render::context& ctx)
{
if (mri.is_constructed()) {
ctx.push_modelview_matrix();
ctx.mul_modelview_matrix(cgv::math::pose4<float>(controller_pose));
mri.draw_all(ctx);
ctx.pop_modelview_matrix();
}
// draw ray
std::vector<vec3> P;
std::vector<float> R;
std::vector<rgb> C;
vec3 ray_origin = reinterpret_cast<const vec3&>(controller_pose(0,3));
vec3 ray_direction = -reinterpret_cast<const vec3&>(controller_pose(0, 2));
P.push_back(ray_origin);
R.push_back(0.002f);
P.push_back(ray_origin + ray_length * ray_direction);
R.push_back(0.003f);
rgb c(float(1 - controller_index), 0.5f * (int)interaction_state, float(controller_index));
C.push_back(c);
C.push_back(c);
auto& cr = cgv::render::ref_rounded_cone_renderer(ctx);
cr.set_render_style(rcrs);
cr.set_position_array(ctx, P);
cr.set_color_array(ctx, C);
cr.set_radius_array(ctx, R);
cr.render(ctx, 0, P.size());
controller_tool::draw(ctx);
}
void ray_tool::stream_help(std::ostream& os)
{
controller_tool::stream_help(os);
}
bool ray_tool::handle(cgv::gui::event& e)
{
if ((e.get_flags() & cgv::gui::EF_VR) == 0)
return false;
if (controller_tool::handle(e))
return true;
return false;
/* // check event id
switch (e.get_kind()) {
case cgv::gui::EID_KEY:
{
cgv::gui::vr_key_event& vrke = static_cast<cgv::gui::vr_key_event&>(e);
if (vrke.get_controller_index() != controller_index)
return false;
if (vrke.get_action() != cgv::gui::KA_RELEASE) {
switch (vrke.get_key()) {
case vr::VR_LEFT_STICK_DOWN:
case vr::VR_RIGHT_STICK_DOWN:
if (interaction_state == IS_GRAB) {
const vec3& z = reinterpret_cast<const vec3&>(controller_pose(0, 2));
for (auto& c : contact.contacts) {
if (!c.container->translatable())
continue;
float delta = std::min(0.1f, c.distance);
c.position += delta * z;
c.container->set_position(c.primitive_index,
c.container->get_position(c.primitive_index)
+ delta * z);
}
return true;
}
break;
case vr::VR_LEFT_STICK_UP:
case vr::VR_RIGHT_STICK_UP:
if (interaction_state == IS_GRAB) {
const vec3& z = reinterpret_cast<const vec3&>(controller_pose(0, 2));
for (auto& c : contact.contacts) {
if (!c.container->translatable())
continue;
float delta = -0.1f;
c.position += delta * z;
c.container->set_position(c.primitive_index,
c.container->get_position(c.primitive_index)
+ delta * z);
}
return true;
}
break;
case vr::VR_LEFT_BUTTON0:
case vr::VR_RIGHT_BUTTON0:
break;
}
}
break;
}
case cgv::gui::EID_THROTTLE:
{
cgv::gui::vr_throttle_event& vrte = static_cast<cgv::gui::vr_throttle_event&>(e);
if (vrte.get_controller_index() != controller_index)
return false;
break;
}
case cgv::gui::EID_STICK:
{
cgv::gui::vr_stick_event& vrse = static_cast<cgv::gui::vr_stick_event&>(e);
if (vrse.get_controller_index() != controller_index)
return false;
switch (vrse.get_action()) {
case cgv::gui::SA_TOUCH:
start_grab(reinterpret_cast<const mat34&>(vrse.get_state().controller[vrse.get_controller_index()].pose[0]));
break;
case cgv::gui::SA_RELEASE:
end_grab();
break;
case cgv::gui::SA_PRESS:
case cgv::gui::SA_UNPRESS:
break;
case cgv::gui::SA_MOVE:
case cgv::gui::SA_DRAG:
break;
}
break;
}
case cgv::gui::EID_POSE:
cgv::gui::vr_pose_event& vrpe = static_cast<cgv::gui::vr_pose_event&>(e);
if (vrpe.get_trackable_index() != controller_index)
return false;
controller_pose = reinterpret_cast<const mat34&>(vrpe.get_state().controller[controller_index].pose[0]);
move(vrpe);
post_redraw();
return true;
}
return false;
*/
}
void ray_tool::create_gui()
{
add_member_control(this, "pick_all", pick_all, "check");
controller_tool::create_gui();
}
}
} | [
"tianfang.lin@tu-dresden.de"
] | tianfang.lin@tu-dresden.de |
76faaa5be4ed7ad066c07e673be4038fdbcb4691 | d57e80d2c7cce697a4f2cb2b2f5f143b89c777bd | /Core/interface/TextIO.h | 3b18e4cf48b8f093e345d3a79f5f2d57d9020250 | [] | no_license | cms-hh/HHStatAnalysis | 0b4a3c6c0c34da2f12dc20f4cf5fbc5157f3cb58 | c41e37f10ccaac71d37500a4917d08f65c29385e | refs/heads/master | 2023-01-13T08:16:31.247041 | 2021-04-12T13:44:39 | 2021-04-12T13:44:39 | 54,017,549 | 2 | 9 | null | 2022-12-30T21:00:34 | 2016-03-16T09:18:25 | C++ | UTF-8 | C++ | false | false | 4,383 | h | /*! Definition of primitives for a text based input/output.
This file is part of https://github.com/hh-italian-group/AnalysisTools. */
#pragma once
#include "exception.h"
#include <unordered_set>
#include <boost/algorithm/string.hpp>
namespace analysis {
template<typename T, typename CharT = char>
std::basic_string<CharT> ToString(const T& t)
{
std::basic_ostringstream<CharT> ss;
ss << t;
return ss.str();
}
template<typename T, typename CharT>
bool TryParse(const std::basic_string<CharT>& str, T& t)
{
try {
std::basic_istringstream<CharT> ss(str);
ss >> t;
return !ss.fail();
} catch(std::exception&) {}
return false;
}
template<typename T, typename CharT>
T Parse(const std::basic_string<CharT>& str)
{
T t;
std::basic_istringstream<CharT> ss(str);
ss >> t;
if(ss.fail())
throw exception("Parse of string '%1%' to %2% is failed.") % str % typeid(T).name();
return t;
}
template<typename T>
std::vector<std::string> ToStringVector(const std::vector<T>& v)
{
std::vector<std::string> result;
std::transform(v.begin(), v.end(), std::back_inserter(result),
[](const T& x) { std::ostringstream ss; ss << x; return ss.str(); });
return result;
}
template<typename Collection>
static std::string CollectionToString(const Collection& col, const std::string& separator = ", ")
{
std::ostringstream ss;
auto iter = col.begin();
if(iter != col.end())
ss << *iter++;
for(; iter != col.end(); ++iter)
ss << separator << *iter;
return ss.str();
}
inline std::vector<std::string> SplitValueList(std::string values_str, bool allow_duplicates = true,
const std::string& separators = " \t",
bool enable_token_compress = true)
{
std::vector<std::string> result;
if(enable_token_compress)
boost::trim_if(values_str, boost::is_any_of(separators));
const auto token_compress = enable_token_compress ? boost::algorithm::token_compress_on
: boost::algorithm::token_compress_off;
boost::split(result, values_str, boost::is_any_of(separators), token_compress);
if(!allow_duplicates) {
std::unordered_set<std::string> set_result;
for(const std::string& value : result) {
if(set_result.count(value))
throw exception("Value '%1%' listed more than once in the value list '%2%'.") % value % values_str;
set_result.insert(value);
}
}
return result;
}
inline std::vector<std::string> ReadValueList(std::istream& stream, size_t number_of_items,
bool allow_duplicates = true,
const std::string& separators = " \t",
bool enable_token_compress = true)
{
const auto stream_exceptions = stream.exceptions();
stream.exceptions(std::istream::goodbit);
try {
std::vector<std::string> result;
std::unordered_set<std::string> set_result;
const auto predicate = boost::is_any_of(separators);
size_t n = 0;
for(; n < number_of_items; ++n) {
std::string value;
while(true) {
const auto c = stream.get();
if(!stream.good()) {
if(stream.eof()) break;
throw exception("Failed to read values from stream.");
}
if(predicate(c)) {
if(!value.size() && enable_token_compress) continue;
break;
}
value.push_back(c);
}
if(!allow_duplicates && set_result.count(value))
throw exception("Value '%1%' listed more than once in the input stream.") % value;
result.push_back(value);
set_result.insert(value);
}
if(n != number_of_items)
throw exception("Expected %1% items, while read only %2%.") % number_of_items % n;
stream.clear();
stream.exceptions(stream_exceptions);
return result;
} catch(exception&) {
stream.clear();
stream.exceptions(stream_exceptions);
throw;
}
}
} // namespace analysis
| [
"konstantin.androsov@cern.ch"
] | konstantin.androsov@cern.ch |
97f490d967f9af2a102ce8bcd462b4145b92e729 | 7bdde4a5fb84764fb8f46a984e03062c65889013 | /Code/Visualization/Imports.h | c9d6322b84ecb1e6562618bdebd2f037661334ec | [] | no_license | ahillbs/bachelor-thesis | 249852458498471e776478e8fb39459bfe05c5ea | 0da0b674bf2c3ff775b9d739e098900eb56b27c0 | refs/heads/master | 2021-08-12T01:52:27.256503 | 2017-11-14T09:20:49 | 2017-11-14T09:20:49 | 110,665,876 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 656 | h | //
// Created by gharg on 30.08.17.
//
#ifndef PROJECT_SVGIMPORT_H
#define PROJECT_SVGIMPORT_H
#include <vector>
#include "../Utilities/GeoUtil.h"
#include "../Capturing/Header/Capturing2D.h"
#include <boost/property_tree/xml_parser.hpp>
#include <boost/property_tree/ptree.hpp>
struct Polyline {
std::vector<Vector2D> points;
};
struct Line {
Vector2D vec1;
Vector2D vec2;
};
class Imports {
// read_xml(is, pt);
public:
static Capturing2D importSVG(std::istream & istream);
static std::vector<Vector2D> importCSV(std::ifstream &ifstream, const char *lineseparator,
const char *columnseparator);
};
#endif //PROJECT_SVGIMPORT_H
| [
"a.hill@tu-bs.de"
] | a.hill@tu-bs.de |
fc82a6cfdbcc28d7dca6f9c449d8258f4a0bdf56 | d5e8b4237d0da18fa8c82d2a5d16383790ce39fc | /C++/libevent_demo/fork_server.cpp | 860ece82b2ca40d2c8c1d0f92d5c05539d802285 | [] | no_license | CodevilWang/code_snippet | 1768a161ce2bb4f3584c9ea2ee6fb88ebf9c71c2 | 755b6c6896b9b8064baad1d8585a461bf63cf8d9 | refs/heads/master | 2021-01-19T20:16:08.733764 | 2020-03-09T15:12:18 | 2020-03-09T15:12:18 | 18,260,238 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,198 | cpp | // code from libevent tutorial
/* For sockaddr_in */
#include <netinet/in.h>
/* For socket functions */
#include <sys/socket.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#define MAX_LINE 16384
char
rot13_char(char c)
{
/* We don't want to use isalpha here; setting the locale would change
* which characters are considered alphabetical. */
if ((c >= 'a' && c <= 'm') || (c >= 'A' && c <= 'M'))
return c + 13;
else if ((c >= 'n' && c <= 'z') || (c >= 'N' && c <= 'Z'))
return c - 13;
else
return c;
}
void
child(int fd)
{
char outbuf[MAX_LINE+1];
size_t outbuf_used = 0;
ssize_t result;
while (1) {
char ch;
result = recv(fd, &ch, 1, 0);
if (result == 0) {
break;
} else if (result == -1) {
perror("read");
break;
}
/* We do this test to keep the user from overflowing the buffer. */
if (outbuf_used < sizeof(outbuf)) {
outbuf[outbuf_used++] = rot13_char(ch);
}
if (ch == '\n') {
send(fd, outbuf, outbuf_used, 0);
outbuf_used = 0;
continue;
}
}
}
void
run(void)
{
int listener;
struct sockaddr_in sin;
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = 0;
sin.sin_port = htons(40713);
listener = socket(AF_INET, SOCK_STREAM, 0);
#ifndef WIN32
{
int one = 1;
setsockopt(listener, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
}
#endif
if (bind(listener, (struct sockaddr*)&sin, sizeof(sin)) < 0) {
perror("bind");
return;
}
if (listen(listener, 16)<0) {
perror("listen");
return;
}
while (1) {
struct sockaddr_storage ss;
socklen_t slen = sizeof(ss);
int fd = accept(listener, (struct sockaddr*)&ss, &slen);
if (fd < 0) {
perror("accept");
} else {
if (fork() == 0) {
child(fd);
exit(0);
}
}
}
}
int
main(int c, char **v)
{
run();
return 0;
}
/* vim: set expandtab ts=2 sw=2 sts=2 tw=80: */
| [
"codevil.w.m@gmail.com"
] | codevil.w.m@gmail.com |
a69f4bdad206769e13ac0808f1cf0af5ee539622 | 2cbdcb198b63dbdc63b9d3ec6f3c7741283b0e71 | /src/util/PacketDump.h | 72a730b067ac0ef391c3f874744121bc6d836e8c | [] | no_license | lasfar1008/inetmanet-2.0 | 2a4245ae864ee5222d601ce32bc0c94cd7fdf63d | 6691287e2c2c03025c2ab238ed3ffd967bad0ec2 | refs/heads/master | 2021-01-16T09:51:11.479991 | 2011-11-05T12:30:30 | 2011-11-05T12:30:30 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,732 | h | //
// Copyright (C) 2005 Michael Tuexen
// Copyright (C) 2008 Irene Ruengeler
// Copyright (C) 2009 Thomas Dreibholz
// Copyright (C) 2011 Zoltan Bojthe
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program; if not, see <http://www.gnu.org/licenses/>.
//
#ifndef __INET_PACKETDUMP_H
#define __INET_PACKETDUMP_H
#include "INETDefs.h"
// Foreign declarations:
class IPv4Datagram;
class IPv6Datagram;
class SCTPMessage;
class TCPSegment;
class UDPPacket;
/**
* Utility class that provides tcpdump-like functionality. It prints
* information about each packet on the given output stream.
*/
class PacketDump
{
protected:
bool verbose;
std::ostream *outp;
public:
/**
* Constructor. The output stream initially points to the C++ standard
* output (std::cout); you probably want to call
* <code>setOutStream(ev.getOStream())</code> to redirect it to EV.
*/
PacketDump();
/**
* Destructor. It does not close the output stream.
*/
~PacketDump();
/**
* Sets the output stream.
*/
void setOutStream(std::ostream& o) { outp = &o; }
/**
* Returns the output stream.
*/
std::ostream& getOutStream() const { return *outp; }
/**
* Enable/disable verbose output.
*/
void setVerbose(bool verb) { verbose = verb; }
/**
* Returns the verbosity flag.
*/
bool isVerbose() const { return verbose; }
/**
* Writes the given text on the output stream.
*/
void dump(const char *label, const char *msg);
/**
* Dumps info about the given packet. It dispatches to the more specific
* dump functions. The l2r parameter denotes the direction of the packet.
*/
void dumpPacket(bool l2r, cPacket *packet);
/**
* Dumps info about the given IPv4 datagram. The l2r parameter denotes the
* direction of the packet.
*/
void dumpIPv4(bool l2r, const char *label, IPv4Datagram *dgram, const char *comment = NULL);
/**
* Dumps info about the given IPv6 datagram. The l2r parameter denotes
* the direction of the packet.
*/
void dumpIPv6(bool l2r, const char *label, IPv6Datagram *dgram, const char *comment = NULL);
/**
* Dumps info about the given SCTP message.
*/
void sctpDump(const char *label, SCTPMessage *sctpmsg, const std::string& srcAddr,
const std::string& destAddr, const char *comment=NULL);
/**
* Dumps info about the given TCP segment.
*/
void tcpDump(bool l2r, const char *label, TCPSegment *tcpseg, const std::string& srcAddr,
const std::string& destAddr, const char *comment=NULL);
/**
* Dumps info about the given UDP packet.
*/
void udpDump(bool l2r, const char *label, UDPPacket* udppkt, const std::string& srcAddr,
const std::string& destAddr, const char *comment);
};
#endif // __INET_PACKETDUMP_H
| [
"alfonso@alfonso-System-Product-Name.(none)"
] | alfonso@alfonso-System-Product-Name.(none) |
4337952c86e542ac98700730911fa56eb607b86b | 72a599527a8105ad809c372edc9bc7fd206669bd | /library/utilities/jsonparsehelper.cpp | 9a08fb681fdb5e8e10c0d372e1ee4aef7c68bbde | [] | no_license | The-Professional/agk-game-engine | 26f3d40b919a818d106c603e199221064b580640 | 84f25b1a2c92e4814699ce0b002b0ab1523f2522 | refs/heads/master | 2021-05-09T02:40:35.844133 | 2018-04-01T04:50:03 | 2018-04-01T04:50:03 | 119,218,126 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 12,205 | cpp | // Physical component dependency
#include "jsonparsehelper.h"
// Game lib dependencies
#include <agk.h>
#include <common\bitmask.h>
#include <common\vector2.h>
#include <common\vector3.h>
#include <common\vector4.h>
#include <common\iobject.h>
#include <common\collectionobject.h>
#include <input\inputstate.h>
#include <input\inputmapping.h>
#include <managers\inputmanager.h>
// Standard lib dependencies
#include <utility>
using namespace nlohmann;
using namespace std;
using namespace NDefs;
namespace NParseHelper
{
/// *************************************************************************
/// <summary>
/// Whether the tag exists.
/// </summary>
/// <param name="iter"> JSON node to parse. </param>
/// <param name="tag"> Tag to find. </param>
/// <returns> If the tag exists. </returns>
/// *************************************************************************
bool TagExists( json::const_iterator iter, const string & tag )
{
auto tagIter = iter->find( tag );
if( tagIter != iter->end() )
return true;
return false;
}
/// *************************************************************************
/// <summary>
/// Parse mesh type tags.
/// </summary>
/// <param name="iter"> JSON node to parse. </param>
/// <param name="meshType"> Value to set. </param>
/// <returns> If the tag exists. </returns>
/// *************************************************************************
bool GetMeshType( json::const_iterator iter, NDefs::EMeshType & meshType )
{
string str;
if( GetValue( iter, "type", str ) )
{
meshType = CDefs::Instance().GetMeshType( str );
return true;
}
return false;
}
/// *************************************************************************
/// <summary>
/// Parse orientation tag.
/// </summary>
/// <param name="iter"> JSON node to parse. </param>
/// <param name="orientation"> Value to set. </param>
/// <returns> If the tag exists. </returns>
/// *************************************************************************
bool GetOrientation( json::const_iterator iter, EOrentation & orientation )
{
string str;
if( GetValue( iter, "orientation", str ) )
{
orientation = CDefs::Instance().GetOrientation( str );
return true;
}
return false;
}
/// *************************************************************************
/// <summary>
/// Parse text alignment tag.
/// </summary>
/// <param name="iter"> JSON node to parse. </param>
/// <param name="alignment"> Value to set. </param>
/// <returns> If the tag exists. </returns>
/// *************************************************************************
bool GetTextAlignment( json::const_iterator iter, ETextAlignment & alignment )
{
string str;
if( GetValue( iter, "textAlignment", str ) )
{
alignment = CDefs::Instance().GetTextAlignment( str );
return true;
}
return false;
}
/// *************************************************************************
/// <summary>
/// Parse script end type tags.
/// </summary>
/// <param name="iter"> JSON node to parse. </param>
/// <param name="endType"> Value to set. </param>
/// <returns> If the tag exists. </returns>
/// *************************************************************************
bool GetEndType( json::const_iterator iter, NDefs::EEndType & endType )
{
string str;
if( GetValue( iter, "end", str ) )
{
endType = CDefs::Instance().GetEndType( str );
return true;
}
return false;
}
/// *************************************************************************
/// <summary>
/// Parse animation list tags.
/// </summary>
/// <param name="iter"> JSON node to parse. </param>
/// <param name="tag"> Tag to find. </param>
/// <param name="fieldType"> Value to set. </param>
/// <returns> If the tag exists. </returns>
/// *************************************************************************
bool GetAnimationList( json::const_iterator iter, const string & tag, vector<vector<string>> & animationList )
{
auto listIter = iter->find( tag );
if( listIter != iter->end() )
{
for( auto conflictIter = listIter->begin(); conflictIter != listIter->end(); ++conflictIter )
{
animationList.push_back( vector<string>() );
for( auto animIter = conflictIter->begin(); animIter != conflictIter->end(); ++animIter )
animationList.back().push_back( animIter->get<string>() );
}
return true;
}
return false;
}
/// *************************************************************************
/// <summary>
/// Parse control type tags.
/// </summary>
/// <param name="iter"> JSON node to parse. </param>
/// <param name="tag"> Tag to find. </param>
/// <param name="fieldType"> Value to set. </param>
/// <returns> If the tag exists. </returns>
/// *************************************************************************
bool GetControlType( json::const_iterator iter, const string & tag, EControlType & controlType )
{
string str;
if( GetValue( iter, tag, str ) )
{
controlType = CDefs::Instance().GetControlType( str );
return true;
}
return false;
}
/// *************************************************************************
/// <summary>
/// Parse control state tags.
/// </summary>
/// <param name="iter"> JSON node to parse. </param>
/// <param name="tag"> Tag to find. </param>
/// <param name="fieldType"> Value to set. </param>
/// <returns> If the tag exists. </returns>
/// *************************************************************************
bool GetControlState( json::const_iterator iter, const string & tag, EControlState & controlState )
{
string str;
if( GetValue( iter, tag, str ) )
{
controlState = CDefs::Instance().GetControlState( str );
return true;
}
return false;
}
/// *************************************************************************
/// <summary>
/// Parse the dimension tags.
/// </summary>
/// <param name="iter"> JSON node to parse. </param>
/// <returns> If the tag exists. </returns>
/// *************************************************************************
void GetDimensions( json::const_iterator iter, float & width, float & height, float & depth, float & radius, int & rows, int & columns )
{
GetValue( iter, "width", width );
GetValue( iter, "height", height );
GetValue( iter, "depth", depth );
if( !GetValue( iter, "radius", radius ) )
{
GetValue( iter, "diameter", radius );
radius *= 0.5f;
}
GetValue( iter, "rows", rows );
GetValue( iter, "columns", columns );
}
/// *************************************************************************
/// <summary>
/// Parse the input state tags.
/// </summary>
/// <param name="iter"> JSON node to parse. </param>
/// <param name="inputState"> Value to set. </param>
/// *************************************************************************
void GetInputState( json::const_iterator iter, CInputState & inputState )
{
auto inputIter = iter->find( "input" );
if( inputIter != iter->end() )
{
auto actionIter = inputIter->begin();
while( actionIter != inputIter->end() )
{
string name;
GetValue( actionIter, "name", name );
CInputMapping mapping;
GetInputMapping( actionIter, mapping );
inputState.AddAction( name, mapping );
++actionIter;
}
}
}
/// *************************************************************************
/// <summary>
/// Parse the input mapping tags.
/// </summary>
/// <param name="iter"> JSON node to parse. </param>
/// <param name="mapping"> Value to set. </param>
/// *************************************************************************
void GetInputMapping( json::const_iterator iter, CInputMapping & mapping )
{
auto deviceIter = iter->find( "mouse" );
if( deviceIter != iter->end() )
{
auto mappingIter = deviceIter->begin();
while( mappingIter != deviceIter->end() )
{
mapping.AddInput( EID_MOUSE,
CInputManager::Instance().GetInputID(
EID_MOUSE,
mappingIter->get<string>() ) );
++mappingIter;
}
}
deviceIter = iter->find( "keyboard" );
if( deviceIter != iter->end() )
{
auto mappingIter = deviceIter->begin();
while( mappingIter != deviceIter->end() )
{
mapping.AddInput( EID_KEYBOARD,
CInputManager::Instance().GetInputID(
EID_KEYBOARD,
mappingIter->get<string>() ) );
++mappingIter;
}
}
deviceIter = iter->find( "gamepad" );
if( deviceIter != iter->end() )
{
auto mappingIter = deviceIter->begin();
while( mappingIter != deviceIter->end() )
{
mapping.AddInput( EID_GAMEPAD, mappingIter->get<int>() );
++mappingIter;
}
}
}
/// *************************************************************************
/// <summary>
/// Parse object data tags.
/// </summary>
/// <param name="iter"> JSON node to parse. </param>
/// <param name="collectionObject"> Value to set. </param>
/// *************************************************************************
void GetCollectionObject( json::const_iterator iter, CCollectionObject & collectionObject )
{
string type;
if( GetValue( iter, "type", type ) )
{
collectionObject.type = CDefs::Instance().GetObjectType( type );
collectionObject.fields.Add( CCollectionObject::TYPE );
}
if( GetValue( iter, "name", collectionObject.name ) )
collectionObject.fields.Add( CCollectionObject::NAME );
if( GetXYZ( iter, "position", collectionObject.position ) )
collectionObject.fields.Add( CCollectionObject::POSITION );
if( GetXYZ( iter, "rotation", collectionObject.rotation ) )
collectionObject.fields.Add( CCollectionObject::ROTATION );
if( GetWHD( iter, "size", collectionObject.size ) )
collectionObject.fields.Add( CCollectionObject::SIZE );
else if( GetValue( iter, "size", collectionObject.size.d ) )
collectionObject.fields.Add( CCollectionObject::TEXT_SIZE );
if( GetColor( iter, collectionObject.color ) )
collectionObject.fields.Add( CCollectionObject::COLOR );
if( GetValue( iter, "visible", collectionObject.visible ) )
collectionObject.fields.Add( CCollectionObject::VISIBLE );
if( GetAlignment( iter, "alignment", collectionObject.alignment ) )
collectionObject.fields.Add( CCollectionObject::ALIGNMENT );
if( GetValue( iter, "text", collectionObject.text ) )
collectionObject.fields.Add( CCollectionObject::TEXT );
if( GetTextAlignment( iter, collectionObject.textAlignment ) )
collectionObject.fields.Add( CCollectionObject::TEXT_ALIGNMENT );
}
} | [
"crosenorn@gmail.com"
] | crosenorn@gmail.com |
599922bcce46d2b8ac857bbad7c0bfe19236c58c | f598f1493e6357b62880240717d8c9dc957f5d0c | /src/net.cpp | 93aea06a8df00cbc0ad2380c8a54bdb7def9097b | [
"MIT"
] | permissive | franksalinas2/hvc | e7814c1f48b093a6a3fc7e7f44023fe88cf7ddf6 | abc5590b653df10089c7b4cc4c8794f2421f1106 | refs/heads/master | 2021-01-13T08:53:36.795661 | 2016-10-25T03:05:02 | 2016-10-25T03:05:02 | 71,853,866 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 62,179 | cpp | // Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2012 The Bitcoin developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "irc.h"
#include "db.h"
#include "net.h"
#include "init.h"
#include "strlcpy.h"
#include "addrman.h"
#include "ui_interface.h"
#ifdef WIN32
#include <string.h>
#endif
#ifdef USE_UPNP
#include <miniupnpc/miniwget.h>
#include <miniupnpc/miniupnpc.h>
#include <miniupnpc/upnpcommands.h>
#include <miniupnpc/upnperrors.h>
#endif
using namespace std;
using namespace boost;
static const int MAX_OUTBOUND_CONNECTIONS = 16;
void ThreadMessageHandler2(void* parg);
void ThreadSocketHandler2(void* parg);
void ThreadOpenConnections2(void* parg);
void ThreadOpenAddedConnections2(void* parg);
#ifdef USE_UPNP
void ThreadMapPort2(void* parg);
#endif
void ThreadDNSAddressSeed2(void* parg);
bool OpenNetworkConnection(const CAddress& addrConnect, CSemaphoreGrant *grantOutbound = NULL, const char *strDest = NULL, bool fOneShot = false);
struct LocalServiceInfo {
int nScore;
int nPort;
};
//
// Global state variables
//
bool fDiscover = true;
bool fUseUPnP = false;
uint64_t nLocalServices = NODE_NETWORK;
static CCriticalSection cs_mapLocalHost;
static map<CNetAddr, LocalServiceInfo> mapLocalHost;
static bool vfReachable[NET_MAX] = {};
static bool vfLimited[NET_MAX] = {};
static CNode* pnodeLocalHost = NULL;
CAddress addrSeenByPeer(CService("0.0.0.0", 0), nLocalServices);
uint64_t nLocalHostNonce = 0;
boost::array<int, THREAD_MAX> vnThreadsRunning;
static std::vector<SOCKET> vhListenSocket;
CAddrMan addrman;
vector<CNode*> vNodes;
CCriticalSection cs_vNodes;
map<CInv, CDataStream> mapRelay;
deque<pair<int64_t, CInv> > vRelayExpiration;
CCriticalSection cs_mapRelay;
map<CInv, int64_t> mapAlreadyAskedFor;
static deque<string> vOneShots;
CCriticalSection cs_vOneShots;
set<CNetAddr> setservAddNodeAddresses;
CCriticalSection cs_setservAddNodeAddresses;
static CSemaphore *semOutbound = NULL;
void AddOneShot(string strDest)
{
LOCK(cs_vOneShots);
vOneShots.push_back(strDest);
}
unsigned short GetListenPort()
{
return (unsigned short)(GetArg("-port", GetDefaultPort()));
}
void CNode::PushGetBlocks(CBlockIndex* pindexBegin, uint256 hashEnd)
{
// Filter out duplicate requests
if (pindexBegin == pindexLastGetBlocksBegin && hashEnd == hashLastGetBlocksEnd)
return;
pindexLastGetBlocksBegin = pindexBegin;
hashLastGetBlocksEnd = hashEnd;
PushMessage("getblocks", CBlockLocator(pindexBegin), hashEnd);
}
// find 'best' local address for a particular peer
bool GetLocal(CService& addr, const CNetAddr *paddrPeer)
{
if (fNoListen)
return false;
int nBestScore = -1;
int nBestReachability = -1;
{
LOCK(cs_mapLocalHost);
for (map<CNetAddr, LocalServiceInfo>::iterator it = mapLocalHost.begin(); it != mapLocalHost.end(); it++)
{
int nScore = (*it).second.nScore;
int nReachability = (*it).first.GetReachabilityFrom(paddrPeer);
if (nReachability > nBestReachability || (nReachability == nBestReachability && nScore > nBestScore))
{
addr = CService((*it).first, (*it).second.nPort);
nBestReachability = nReachability;
nBestScore = nScore;
}
}
}
return nBestScore >= 0;
}
// get best local address for a particular peer as a CAddress
CAddress GetLocalAddress(const CNetAddr *paddrPeer)
{
CAddress ret(CService("0.0.0.0",0),0);
CService addr;
if (GetLocal(addr, paddrPeer))
{
ret = CAddress(addr);
ret.nServices = nLocalServices;
ret.nTime = GetAdjustedTime();
}
return ret;
}
bool RecvLine(SOCKET hSocket, string& strLine)
{
strLine = "";
while (true)
{
char c;
int nBytes = recv(hSocket, &c, 1, 0);
if (nBytes > 0)
{
if (c == '\n')
continue;
if (c == '\r')
return true;
strLine += c;
if (strLine.size() >= 9000)
return true;
}
else if (nBytes <= 0)
{
if (fShutdown)
return false;
if (nBytes < 0)
{
int nErr = WSAGetLastError();
if (nErr == WSAEMSGSIZE)
continue;
if (nErr == WSAEWOULDBLOCK || nErr == WSAEINTR || nErr == WSAEINPROGRESS)
{
MilliSleep(10);
continue;
}
}
if (!strLine.empty())
return true;
if (nBytes == 0)
{
// socket closed
printf("socket closed\n");
return false;
}
else
{
// socket error
int nErr = WSAGetLastError();
printf("recv failed: %d\n", nErr);
return false;
}
}
}
}
// used when scores of local addresses may have changed
// pushes better local address to peers
void static AdvertizeLocal()
{
LOCK(cs_vNodes);
BOOST_FOREACH(CNode* pnode, vNodes)
{
if (pnode->fSuccessfullyConnected)
{
CAddress addrLocal = GetLocalAddress(&pnode->addr);
if (addrLocal.IsRoutable() && (CService)addrLocal != (CService)pnode->addrLocal)
{
pnode->PushAddress(addrLocal);
pnode->addrLocal = addrLocal;
}
}
}
}
void SetReachable(enum Network net, bool fFlag)
{
LOCK(cs_mapLocalHost);
vfReachable[net] = fFlag;
if (net == NET_IPV6 && fFlag)
vfReachable[NET_IPV4] = true;
}
// learn a new local address
bool AddLocal(const CService& addr, int nScore)
{
if (!addr.IsRoutable())
return false;
if (!fDiscover && nScore < LOCAL_MANUAL)
return false;
if (IsLimited(addr))
return false;
printf("AddLocal(%s,%i)\n", addr.ToString().c_str(), nScore);
{
LOCK(cs_mapLocalHost);
bool fAlready = mapLocalHost.count(addr) > 0;
LocalServiceInfo &info = mapLocalHost[addr];
if (!fAlready || nScore >= info.nScore) {
info.nScore = nScore + (fAlready ? 1 : 0);
info.nPort = addr.GetPort();
}
SetReachable(addr.GetNetwork());
}
AdvertizeLocal();
return true;
}
bool AddLocal(const CNetAddr &addr, int nScore)
{
return AddLocal(CService(addr, GetListenPort()), nScore);
}
/** Make a particular network entirely off-limits (no automatic connects to it) */
void SetLimited(enum Network net, bool fLimited)
{
if (net == NET_UNROUTABLE)
return;
LOCK(cs_mapLocalHost);
vfLimited[net] = fLimited;
}
bool IsLimited(enum Network net)
{
LOCK(cs_mapLocalHost);
return vfLimited[net];
}
bool IsLimited(const CNetAddr &addr)
{
return IsLimited(addr.GetNetwork());
}
/** vote for a local address */
bool SeenLocal(const CService& addr)
{
{
LOCK(cs_mapLocalHost);
if (mapLocalHost.count(addr) == 0)
return false;
mapLocalHost[addr].nScore++;
}
AdvertizeLocal();
return true;
}
/** check whether a given address is potentially local */
bool IsLocal(const CService& addr)
{
LOCK(cs_mapLocalHost);
return mapLocalHost.count(addr) > 0;
}
/** check whether a given address is in a network we can probably connect to */
bool IsReachable(const CNetAddr& addr)
{
LOCK(cs_mapLocalHost);
enum Network net = addr.GetNetwork();
return vfReachable[net] && !vfLimited[net];
}
bool GetMyExternalIP2(const CService& addrConnect, const char* pszGet, const char* pszKeyword, CNetAddr& ipRet)
{
SOCKET hSocket;
if (!ConnectSocket(addrConnect, hSocket))
return error("GetMyExternalIP() : connection to %s failed", addrConnect.ToString().c_str());
send(hSocket, pszGet, strlen(pszGet), MSG_NOSIGNAL);
string strLine;
while (RecvLine(hSocket, strLine))
{
if (strLine.empty()) // HTTP response is separated from headers by blank line
{
while (true)
{
if (!RecvLine(hSocket, strLine))
{
closesocket(hSocket);
return false;
}
if (pszKeyword == NULL)
break;
if (strLine.find(pszKeyword) != string::npos)
{
strLine = strLine.substr(strLine.find(pszKeyword) + strlen(pszKeyword));
break;
}
}
closesocket(hSocket);
if (strLine.find("<") != string::npos)
strLine = strLine.substr(0, strLine.find("<"));
strLine = strLine.substr(strspn(strLine.c_str(), " \t\n\r"));
while (strLine.size() > 0 && isspace(strLine[strLine.size()-1]))
strLine.resize(strLine.size()-1);
CService addr(strLine,0,true);
printf("GetMyExternalIP() received [%s] %s\n", strLine.c_str(), addr.ToString().c_str());
if (!addr.IsValid() || !addr.IsRoutable())
return false;
ipRet.SetIP(addr);
return true;
}
}
closesocket(hSocket);
return error("GetMyExternalIP() : connection closed");
}
// We now get our external IP from the IRC server first and only use this as a backup
bool GetMyExternalIP(CNetAddr& ipRet)
{
CService addrConnect;
const char* pszGet;
const char* pszKeyword;
for (int nLookup = 0; nLookup <= 1; nLookup++)
for (int nHost = 1; nHost <= 2; nHost++)
{
// We should be phasing out our use of sites like these. If we need
// replacements, we should ask for volunteers to put this simple
// php file on their web server that prints the client IP:
// <?php echo $_SERVER["REMOTE_ADDR"]; ?>
if (nHost == 1)
{
addrConnect = CService("216.146.43.70",80); // checkip.dyndns.org
if (nLookup == 1)
{
CService addrIP("checkip.dyndns.org", 80, true);
if (addrIP.IsValid())
addrConnect = addrIP;
}
pszGet = "GET / HTTP/1.1\r\n"
"Host: checkip.dyndns.org\r\n"
"User-Agent: HIVE\r\n"
"Connection: close\r\n"
"\r\n";
pszKeyword = "Address:";
}
else if (nHost == 2)
{
addrConnect = CService("74.208.43.192", 80); // www.showmyip.com
if (nLookup == 1)
{
CService addrIP("www.showmyip.com", 80, true);
if (addrIP.IsValid())
addrConnect = addrIP;
}
pszGet = "GET /simple/ HTTP/1.1\r\n"
"Host: www.showmyip.com\r\n"
"User-Agent: HIVE\r\n"
"Connection: close\r\n"
"\r\n";
pszKeyword = NULL; // Returns just IP address
}
if (GetMyExternalIP2(addrConnect, pszGet, pszKeyword, ipRet))
return true;
}
return false;
}
void ThreadGetMyExternalIP(void* parg)
{
// Make this thread recognisable as the external IP detection thread
RenameThread("hive-ext-ip");
CNetAddr addrLocalHost;
if (GetMyExternalIP(addrLocalHost))
{
printf("GetMyExternalIP() returned %s\n", addrLocalHost.ToStringIP().c_str());
AddLocal(addrLocalHost, LOCAL_HTTP);
}
}
void AddressCurrentlyConnected(const CService& addr)
{
addrman.Connected(addr);
}
CNode* FindNode(const CNetAddr& ip)
{
{
LOCK(cs_vNodes);
BOOST_FOREACH(CNode* pnode, vNodes)
if ((CNetAddr)pnode->addr == ip)
return (pnode);
}
return NULL;
}
CNode* FindNode(std::string addrName)
{
LOCK(cs_vNodes);
BOOST_FOREACH(CNode* pnode, vNodes)
if (pnode->addrName == addrName)
return (pnode);
return NULL;
}
CNode* FindNode(const CService& addr)
{
{
LOCK(cs_vNodes);
BOOST_FOREACH(CNode* pnode, vNodes)
if ((CService)pnode->addr == addr)
return (pnode);
}
return NULL;
}
CNode* ConnectNode(CAddress addrConnect, const char *pszDest)
{
if (pszDest == NULL) {
if (IsLocal(addrConnect))
return NULL;
// Look for an existing connection
CNode* pnode = FindNode((CService)addrConnect);
if (pnode)
{
pnode->AddRef();
return pnode;
}
}
/// debug print
printf("trying connection %s lastseen=%.1fhrs\n",
pszDest ? pszDest : addrConnect.ToString().c_str(),
pszDest ? 0 : (double)(GetAdjustedTime() - addrConnect.nTime)/3600.0);
// Connect
SOCKET hSocket;
if (pszDest ? ConnectSocketByName(addrConnect, hSocket, pszDest, GetDefaultPort()) : ConnectSocket(addrConnect, hSocket))
{
addrman.Attempt(addrConnect);
/// debug print
printf("connected %s\n", pszDest ? pszDest : addrConnect.ToString().c_str());
// Set to non-blocking
#ifdef WIN32
u_long nOne = 1;
if (ioctlsocket(hSocket, FIONBIO, &nOne) == SOCKET_ERROR)
printf("ConnectSocket() : ioctlsocket non-blocking setting failed, error %d\n", WSAGetLastError());
#else
if (fcntl(hSocket, F_SETFL, O_NONBLOCK) == SOCKET_ERROR)
printf("ConnectSocket() : fcntl non-blocking setting failed, error %d\n", errno);
#endif
// Add node
CNode* pnode = new CNode(hSocket, addrConnect, pszDest ? pszDest : "", false);
pnode->AddRef();
{
LOCK(cs_vNodes);
vNodes.push_back(pnode);
}
pnode->nTimeConnected = GetTime();
return pnode;
}
else
{
return NULL;
}
}
void CNode::CloseSocketDisconnect()
{
fDisconnect = true;
if (hSocket != INVALID_SOCKET)
{
printf("disconnecting node %s\n", addrName.c_str());
closesocket(hSocket);
hSocket = INVALID_SOCKET;
// in case this fails, we'll empty the recv buffer when the CNode is deleted
TRY_LOCK(cs_vRecvMsg, lockRecv);
if (lockRecv)
vRecvMsg.clear();
}
}
void CNode::PushVersion()
{
/// when NTP implemented, change to just nTime = GetAdjustedTime()
int64_t nTime = (fInbound ? GetAdjustedTime() : GetTime());
CAddress addrYou = (addr.IsRoutable() && !IsProxy(addr) ? addr : CAddress(CService("0.0.0.0",0)));
CAddress addrMe = GetLocalAddress(&addr);
RAND_bytes((unsigned char*)&nLocalHostNonce, sizeof(nLocalHostNonce));
printf("send version message: version %d, blocks=%d, us=%s, them=%s, peer=%s\n", PROTOCOL_VERSION, nBestHeight, addrMe.ToString().c_str(), addrYou.ToString().c_str(), addr.ToString().c_str());
PushMessage("version", PROTOCOL_VERSION, nLocalServices, nTime, addrYou, addrMe,
nLocalHostNonce, FormatSubVersion(CLIENT_NAME, CLIENT_VERSION, std::vector<string>()), nBestHeight);
}
std::map<CNetAddr, int64_t> CNode::setBanned;
CCriticalSection CNode::cs_setBanned;
void CNode::ClearBanned()
{
setBanned.clear();
}
bool CNode::IsBanned(CNetAddr ip)
{
bool fResult = false;
{
LOCK(cs_setBanned);
std::map<CNetAddr, int64_t>::iterator i = setBanned.find(ip);
if (i != setBanned.end())
{
int64_t t = (*i).second;
if (GetTime() < t)
fResult = true;
}
}
return fResult;
}
bool CNode::Misbehaving(int howmuch)
{
if (addr.IsLocal())
{
printf("Warning: Local node %s misbehaving (delta: %d)!\n", addrName.c_str(), howmuch);
return false;
}
nMisbehavior += howmuch;
if (nMisbehavior >= GetArg("-banscore", 100))
{
int64_t banTime = GetTime()+GetArg("-bantime", 60*60*24); // Default 24-hour ban
printf("Misbehaving: %s (%d -> %d) DISCONNECTING\n", addr.ToString().c_str(), nMisbehavior-howmuch, nMisbehavior);
{
LOCK(cs_setBanned);
if (setBanned[addr] < banTime)
setBanned[addr] = banTime;
}
CloseSocketDisconnect();
return true;
} else
printf("Misbehaving: %s (%d -> %d)\n", addr.ToString().c_str(), nMisbehavior-howmuch, nMisbehavior);
return false;
}
#undef X
#define X(name) stats.name = name
void CNode::copyStats(CNodeStats &stats)
{
X(nServices);
X(nLastSend);
X(nLastRecv);
X(nTimeConnected);
X(addrName);
X(nVersion);
X(strSubVer);
X(fInbound);
X(nStartingHeight);
X(nMisbehavior);
}
#undef X
// requires LOCK(cs_vRecvMsg)
bool CNode::ReceiveMsgBytes(const char *pch, unsigned int nBytes)
{
while (nBytes > 0) {
// get current incomplete message, or create a new one
if (vRecvMsg.empty() ||
vRecvMsg.back().complete())
vRecvMsg.push_back(CNetMessage(SER_NETWORK, nRecvVersion));
CNetMessage& msg = vRecvMsg.back();
// absorb network data
int handled;
if (!msg.in_data)
handled = msg.readHeader(pch, nBytes);
else
handled = msg.readData(pch, nBytes);
if (handled < 0)
return false;
pch += handled;
nBytes -= handled;
}
return true;
}
int CNetMessage::readHeader(const char *pch, unsigned int nBytes)
{
// copy data to temporary parsing buffer
unsigned int nRemaining = 24 - nHdrPos;
unsigned int nCopy = std::min(nRemaining, nBytes);
memcpy(&hdrbuf[nHdrPos], pch, nCopy);
nHdrPos += nCopy;
// if header incomplete, exit
if (nHdrPos < 24)
return nCopy;
// deserialize to CMessageHeader
try {
hdrbuf >> hdr;
}
catch (std::exception &e) {
return -1;
}
// reject messages larger than MAX_SIZE
if (hdr.nMessageSize > MAX_SIZE)
return -1;
// switch state to reading message data
in_data = true;
return nCopy;
}
int CNetMessage::readData(const char *pch, unsigned int nBytes)
{
unsigned int nRemaining = hdr.nMessageSize - nDataPos;
unsigned int nCopy = std::min(nRemaining, nBytes);
if (vRecv.size() < nDataPos + nCopy) {
// Allocate up to 256 KiB ahead, but never more than the total message size.
vRecv.resize(std::min(hdr.nMessageSize, nDataPos + nCopy + 256 * 1024));
}
memcpy(&vRecv[nDataPos], pch, nCopy);
nDataPos += nCopy;
return nCopy;
}
// requires LOCK(cs_vSend)
void SocketSendData(CNode *pnode)
{
std::deque<CSerializeData>::iterator it = pnode->vSendMsg.begin();
while (it != pnode->vSendMsg.end()) {
const CSerializeData &data = *it;
assert(data.size() > pnode->nSendOffset);
int nBytes = send(pnode->hSocket, &data[pnode->nSendOffset], data.size() - pnode->nSendOffset, MSG_NOSIGNAL | MSG_DONTWAIT);
if (nBytes > 0) {
pnode->nLastSend = GetTime();
pnode->nSendOffset += nBytes;
if (pnode->nSendOffset == data.size()) {
pnode->nSendOffset = 0;
pnode->nSendSize -= data.size();
it++;
} else {
// could not send full message; stop sending more
break;
}
} else {
if (nBytes < 0) {
// error
int nErr = WSAGetLastError();
if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)
{
printf("socket send error %d\n", nErr);
pnode->CloseSocketDisconnect();
}
}
// couldn't send anything at all
break;
}
}
if (it == pnode->vSendMsg.end()) {
assert(pnode->nSendOffset == 0);
assert(pnode->nSendSize == 0);
}
pnode->vSendMsg.erase(pnode->vSendMsg.begin(), it);
}
void ThreadSocketHandler(void* parg)
{
// Make this thread recognisable as the networking thread
RenameThread("hive-net");
try
{
vnThreadsRunning[THREAD_SOCKETHANDLER]++;
ThreadSocketHandler2(parg);
vnThreadsRunning[THREAD_SOCKETHANDLER]--;
}
catch (std::exception& e) {
vnThreadsRunning[THREAD_SOCKETHANDLER]--;
PrintException(&e, "ThreadSocketHandler()");
} catch (...) {
vnThreadsRunning[THREAD_SOCKETHANDLER]--;
throw; // support pthread_cancel()
}
printf("ThreadSocketHandler exited\n");
}
void ThreadSocketHandler2(void* parg)
{
printf("ThreadSocketHandler started\n");
list<CNode*> vNodesDisconnected;
unsigned int nPrevNodeCount = 0;
while (true)
{
//
// Disconnect nodes
//
{
LOCK(cs_vNodes);
// Disconnect unused nodes
vector<CNode*> vNodesCopy = vNodes;
BOOST_FOREACH(CNode* pnode, vNodesCopy)
{
if (pnode->fDisconnect ||
(pnode->GetRefCount() <= 0 && pnode->vRecvMsg.empty() && pnode->nSendSize == 0 && pnode->ssSend.empty()))
{
// remove from vNodes
vNodes.erase(remove(vNodes.begin(), vNodes.end(), pnode), vNodes.end());
// release outbound grant (if any)
pnode->grantOutbound.Release();
// close socket and cleanup
pnode->CloseSocketDisconnect();
// hold in disconnected pool until all refs are released
if (pnode->fNetworkNode || pnode->fInbound)
pnode->Release();
vNodesDisconnected.push_back(pnode);
}
}
// Delete disconnected nodes
list<CNode*> vNodesDisconnectedCopy = vNodesDisconnected;
BOOST_FOREACH(CNode* pnode, vNodesDisconnectedCopy)
{
// wait until threads are done using it
if (pnode->GetRefCount() <= 0)
{
bool fDelete = false;
{
TRY_LOCK(pnode->cs_vSend, lockSend);
if (lockSend)
{
TRY_LOCK(pnode->cs_vRecvMsg, lockRecv);
if (lockRecv)
{
TRY_LOCK(pnode->cs_mapRequests, lockReq);
if (lockReq)
{
TRY_LOCK(pnode->cs_inventory, lockInv);
if (lockInv)
fDelete = true;
}
}
}
}
if (fDelete)
{
vNodesDisconnected.remove(pnode);
delete pnode;
}
}
}
}
if (vNodes.size() != nPrevNodeCount)
{
nPrevNodeCount = vNodes.size();
uiInterface.NotifyNumConnectionsChanged(vNodes.size());
}
//
// Find which sockets have data to receive
//
struct timeval timeout;
timeout.tv_sec = 0;
timeout.tv_usec = 50000; // frequency to poll pnode->vSend
fd_set fdsetRecv;
fd_set fdsetSend;
fd_set fdsetError;
FD_ZERO(&fdsetRecv);
FD_ZERO(&fdsetSend);
FD_ZERO(&fdsetError);
SOCKET hSocketMax = 0;
bool have_fds = false;
BOOST_FOREACH(SOCKET hListenSocket, vhListenSocket) {
FD_SET(hListenSocket, &fdsetRecv);
hSocketMax = max(hSocketMax, hListenSocket);
have_fds = true;
}
{
LOCK(cs_vNodes);
BOOST_FOREACH(CNode* pnode, vNodes)
{
if (pnode->hSocket == INVALID_SOCKET)
continue;
{
TRY_LOCK(pnode->cs_vSend, lockSend);
if (lockSend) {
// do not read, if draining write queue
if (!pnode->vSendMsg.empty())
FD_SET(pnode->hSocket, &fdsetSend);
else
FD_SET(pnode->hSocket, &fdsetRecv);
FD_SET(pnode->hSocket, &fdsetError);
hSocketMax = max(hSocketMax, pnode->hSocket);
have_fds = true;
}
}
}
}
vnThreadsRunning[THREAD_SOCKETHANDLER]--;
int nSelect = select(have_fds ? hSocketMax + 1 : 0,
&fdsetRecv, &fdsetSend, &fdsetError, &timeout);
vnThreadsRunning[THREAD_SOCKETHANDLER]++;
if (fShutdown)
return;
if (nSelect == SOCKET_ERROR)
{
if (have_fds)
{
int nErr = WSAGetLastError();
printf("socket select error %d\n", nErr);
for (unsigned int i = 0; i <= hSocketMax; i++)
FD_SET(i, &fdsetRecv);
}
FD_ZERO(&fdsetSend);
FD_ZERO(&fdsetError);
MilliSleep(timeout.tv_usec/1000);
}
//
// Accept new connections
//
BOOST_FOREACH(SOCKET hListenSocket, vhListenSocket)
if (hListenSocket != INVALID_SOCKET && FD_ISSET(hListenSocket, &fdsetRecv))
{
struct sockaddr_storage sockaddr;
socklen_t len = sizeof(sockaddr);
SOCKET hSocket = accept(hListenSocket, (struct sockaddr*)&sockaddr, &len);
CAddress addr;
int nInbound = 0;
if (hSocket != INVALID_SOCKET)
if (!addr.SetSockAddr((const struct sockaddr*)&sockaddr))
printf("Warning: Unknown socket family\n");
{
LOCK(cs_vNodes);
BOOST_FOREACH(CNode* pnode, vNodes)
if (pnode->fInbound)
nInbound++;
}
if (hSocket == INVALID_SOCKET)
{
int nErr = WSAGetLastError();
if (nErr != WSAEWOULDBLOCK)
printf("socket error accept failed: %d\n", nErr);
}
else if (nInbound >= GetArg("-maxconnections", 125) - MAX_OUTBOUND_CONNECTIONS)
{
closesocket(hSocket);
}
else if (CNode::IsBanned(addr))
{
printf("connection from %s dropped (banned)\n", addr.ToString().c_str());
closesocket(hSocket);
}
else
{
printf("accepted connection %s\n", addr.ToString().c_str());
CNode* pnode = new CNode(hSocket, addr, "", true);
pnode->AddRef();
{
LOCK(cs_vNodes);
vNodes.push_back(pnode);
}
}
}
//
// Service each socket
//
vector<CNode*> vNodesCopy;
{
LOCK(cs_vNodes);
vNodesCopy = vNodes;
BOOST_FOREACH(CNode* pnode, vNodesCopy)
pnode->AddRef();
}
BOOST_FOREACH(CNode* pnode, vNodesCopy)
{
if (fShutdown)
return;
//
// Receive
//
if (pnode->hSocket == INVALID_SOCKET)
continue;
if (FD_ISSET(pnode->hSocket, &fdsetRecv) || FD_ISSET(pnode->hSocket, &fdsetError))
{
TRY_LOCK(pnode->cs_vRecvMsg, lockRecv);
if (lockRecv)
{
if (pnode->GetTotalRecvSize() > ReceiveFloodSize()) {
if (!pnode->fDisconnect)
printf("socket recv flood control disconnect (%u bytes)\n", pnode->GetTotalRecvSize());
pnode->CloseSocketDisconnect();
}
else {
// typical socket buffer is 8K-64K
char pchBuf[0x10000];
int nBytes = recv(pnode->hSocket, pchBuf, sizeof(pchBuf), MSG_DONTWAIT);
if (nBytes > 0)
{
if (!pnode->ReceiveMsgBytes(pchBuf, nBytes))
pnode->CloseSocketDisconnect();
pnode->nLastRecv = GetTime();
}
else if (nBytes == 0)
{
// socket closed gracefully
if (!pnode->fDisconnect)
printf("socket closed\n");
pnode->CloseSocketDisconnect();
}
else if (nBytes < 0)
{
// error
int nErr = WSAGetLastError();
if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)
{
if (!pnode->fDisconnect)
printf("socket recv error %d\n", nErr);
pnode->CloseSocketDisconnect();
}
}
}
}
}
//
// Send
//
if (pnode->hSocket == INVALID_SOCKET)
continue;
if (FD_ISSET(pnode->hSocket, &fdsetSend))
{
TRY_LOCK(pnode->cs_vSend, lockSend);
if (lockSend)
SocketSendData(pnode);
}
//
// Inactivity checking
//
if (pnode->vSendMsg.empty())
pnode->nLastSendEmpty = GetTime();
if (GetTime() - pnode->nTimeConnected > 60)
{
if (pnode->nLastRecv == 0 || pnode->nLastSend == 0)
{
printf("socket no message in first 60 seconds, %d %d\n", pnode->nLastRecv != 0, pnode->nLastSend != 0);
pnode->fDisconnect = true;
}
else if (GetTime() - pnode->nLastSend > 90*60 && GetTime() - pnode->nLastSendEmpty > 90*60)
{
printf("socket not sending\n");
pnode->fDisconnect = true;
}
else if (GetTime() - pnode->nLastRecv > 90*60)
{
printf("socket inactivity timeout\n");
pnode->fDisconnect = true;
}
}
}
{
LOCK(cs_vNodes);
BOOST_FOREACH(CNode* pnode, vNodesCopy)
pnode->Release();
}
MilliSleep(10);
}
}
#ifdef USE_UPNP
void ThreadMapPort(void* parg)
{
// Make this thread recognisable as the UPnP thread
RenameThread("hive-UPnP");
try
{
vnThreadsRunning[THREAD_UPNP]++;
ThreadMapPort2(parg);
vnThreadsRunning[THREAD_UPNP]--;
}
catch (std::exception& e) {
vnThreadsRunning[THREAD_UPNP]--;
PrintException(&e, "ThreadMapPort()");
} catch (...) {
vnThreadsRunning[THREAD_UPNP]--;
PrintException(NULL, "ThreadMapPort()");
}
printf("ThreadMapPort exited\n");
}
void ThreadMapPort2(void* parg)
{
printf("ThreadMapPort started\n");
std::string port = strprintf("%u", GetListenPort());
const char * multicastif = 0;
const char * minissdpdpath = 0;
struct UPNPDev * devlist = 0;
char lanaddr[64];
#ifndef UPNPDISCOVER_SUCCESS
/* miniupnpc 1.5 */
devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0);
#else
/* miniupnpc 1.6 */
int error = 0;
devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0, 0, &error);
#endif
struct UPNPUrls urls;
struct IGDdatas data;
int r;
r = UPNP_GetValidIGD(devlist, &urls, &data, lanaddr, sizeof(lanaddr));
if (r == 1)
{
if (fDiscover) {
char externalIPAddress[40];
r = UPNP_GetExternalIPAddress(urls.controlURL, data.first.servicetype, externalIPAddress);
if(r != UPNPCOMMAND_SUCCESS)
printf("UPnP: GetExternalIPAddress() returned %d\n", r);
else
{
if(externalIPAddress[0])
{
printf("UPnP: ExternalIPAddress = %s\n", externalIPAddress);
AddLocal(CNetAddr(externalIPAddress), LOCAL_UPNP);
}
else
printf("UPnP: GetExternalIPAddress failed.\n");
}
}
string strDesc = "HIVE " + FormatFullVersion();
#ifndef UPNPDISCOVER_SUCCESS
/* miniupnpc 1.5 */
r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
port.c_str(), port.c_str(), lanaddr, strDesc.c_str(), "TCP", 0);
#else
/* miniupnpc 1.6 */
r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
port.c_str(), port.c_str(), lanaddr, strDesc.c_str(), "TCP", 0, "0");
#endif
if(r!=UPNPCOMMAND_SUCCESS)
printf("AddPortMapping(%s, %s, %s) failed with code %d (%s)\n",
port.c_str(), port.c_str(), lanaddr, r, strupnperror(r));
else
printf("UPnP Port Mapping successful.\n");
int i = 1;
while (true)
{
if (fShutdown || !fUseUPnP)
{
r = UPNP_DeletePortMapping(urls.controlURL, data.first.servicetype, port.c_str(), "TCP", 0);
printf("UPNP_DeletePortMapping() returned : %d\n", r);
freeUPNPDevlist(devlist); devlist = 0;
FreeUPNPUrls(&urls);
return;
}
if (i % 600 == 0) // Refresh every 20 minutes
{
#ifndef UPNPDISCOVER_SUCCESS
/* miniupnpc 1.5 */
r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
port.c_str(), port.c_str(), lanaddr, strDesc.c_str(), "TCP", 0);
#else
/* miniupnpc 1.6 */
r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
port.c_str(), port.c_str(), lanaddr, strDesc.c_str(), "TCP", 0, "0");
#endif
if(r!=UPNPCOMMAND_SUCCESS)
printf("AddPortMapping(%s, %s, %s) failed with code %d (%s)\n",
port.c_str(), port.c_str(), lanaddr, r, strupnperror(r));
else
printf("UPnP Port Mapping successful.\n");;
}
MilliSleep(2000);
i++;
}
} else {
printf("No valid UPnP IGDs found\n");
freeUPNPDevlist(devlist); devlist = 0;
if (r != 0)
FreeUPNPUrls(&urls);
while (true)
{
if (fShutdown || !fUseUPnP)
return;
MilliSleep(2000);
}
}
}
void MapPort()
{
if (fUseUPnP && vnThreadsRunning[THREAD_UPNP] < 1)
{
if (!NewThread(ThreadMapPort, NULL))
printf("Error: ThreadMapPort(ThreadMapPort) failed\n");
}
}
#else
void MapPort()
{
// Intentionally left blank.
}
#endif
// DNS seeds
// Each pair gives a source name and a seed name.
// The first name is used as information source for addrman.
// The second name should resolve to a list of seed addresses.
static const char *strDNSSeed[][2] = {
{"walletbuilders.com", "node.walletbuilders.com"},
};
void ThreadDNSAddressSeed(void* parg)
{
// Make this thread recognisable as the DNS seeding thread
RenameThread("hive-dnsseed");
try
{
vnThreadsRunning[THREAD_DNSSEED]++;
ThreadDNSAddressSeed2(parg);
vnThreadsRunning[THREAD_DNSSEED]--;
}
catch (std::exception& e) {
vnThreadsRunning[THREAD_DNSSEED]--;
PrintException(&e, "ThreadDNSAddressSeed()");
} catch (...) {
vnThreadsRunning[THREAD_DNSSEED]--;
throw; // support pthread_cancel()
}
printf("ThreadDNSAddressSeed exited\n");
}
void ThreadDNSAddressSeed2(void* parg)
{
printf("ThreadDNSAddressSeed started\n");
int found = 0;
if (!fTestNet)
{
printf("Loading addresses from DNS seeds (could take a while)\n");
for (unsigned int seed_idx = 0; seed_idx < ARRAYLEN(strDNSSeed); seed_idx++) {
if (HaveNameProxy()) {
AddOneShot(strDNSSeed[seed_idx][1]);
} else {
vector<CNetAddr> vaddr;
vector<CAddress> vAdd;
if (LookupHost(strDNSSeed[seed_idx][1], vaddr))
{
BOOST_FOREACH(CNetAddr& ip, vaddr)
{
int nOneDay = 24*3600;
CAddress addr = CAddress(CService(ip, GetDefaultPort()));
addr.nTime = GetTime() - 3*nOneDay - GetRand(4*nOneDay); // use a random age between 3 and 7 days old
vAdd.push_back(addr);
found++;
}
}
addrman.Add(vAdd, CNetAddr(strDNSSeed[seed_idx][0], true));
}
}
}
printf("%d addresses found from DNS seeds\n", found);
}
unsigned int pnSeed[] =
{
};
void DumpAddresses()
{
int64_t nStart = GetTimeMillis();
CAddrDB adb;
adb.Write(addrman);
printf("Flushed %d addresses to peers.dat %"PRId64"ms\n",
addrman.size(), GetTimeMillis() - nStart);
}
void ThreadDumpAddress2(void* parg)
{
vnThreadsRunning[THREAD_DUMPADDRESS]++;
while (!fShutdown)
{
DumpAddresses();
vnThreadsRunning[THREAD_DUMPADDRESS]--;
MilliSleep(600000);
vnThreadsRunning[THREAD_DUMPADDRESS]++;
}
vnThreadsRunning[THREAD_DUMPADDRESS]--;
}
void ThreadDumpAddress(void* parg)
{
// Make this thread recognisable as the address dumping thread
RenameThread("hive-adrdump");
try
{
ThreadDumpAddress2(parg);
}
catch (std::exception& e) {
PrintException(&e, "ThreadDumpAddress()");
}
printf("ThreadDumpAddress exited\n");
}
void ThreadOpenConnections(void* parg)
{
// Make this thread recognisable as the connection opening thread
RenameThread("hive-opencon");
try
{
vnThreadsRunning[THREAD_OPENCONNECTIONS]++;
ThreadOpenConnections2(parg);
vnThreadsRunning[THREAD_OPENCONNECTIONS]--;
}
catch (std::exception& e) {
vnThreadsRunning[THREAD_OPENCONNECTIONS]--;
PrintException(&e, "ThreadOpenConnections()");
} catch (...) {
vnThreadsRunning[THREAD_OPENCONNECTIONS]--;
PrintException(NULL, "ThreadOpenConnections()");
}
printf("ThreadOpenConnections exited\n");
}
void static ProcessOneShot()
{
string strDest;
{
LOCK(cs_vOneShots);
if (vOneShots.empty())
return;
strDest = vOneShots.front();
vOneShots.pop_front();
}
CAddress addr;
CSemaphoreGrant grant(*semOutbound, true);
if (grant) {
if (!OpenNetworkConnection(addr, &grant, strDest.c_str(), true))
AddOneShot(strDest);
}
}
void static ThreadStakeMiner(void* parg)
{
printf("ThreadStakeMiner started\n");
CWallet* pwallet = (CWallet*)parg;
try
{
vnThreadsRunning[THREAD_STAKE_MINER]++;
StakeMiner(pwallet);
vnThreadsRunning[THREAD_STAKE_MINER]--;
}
catch (std::exception& e) {
vnThreadsRunning[THREAD_STAKE_MINER]--;
PrintException(&e, "ThreadStakeMiner()");
} catch (...) {
vnThreadsRunning[THREAD_STAKE_MINER]--;
PrintException(NULL, "ThreadStakeMiner()");
}
printf("ThreadStakeMiner exiting, %d threads remaining\n", vnThreadsRunning[THREAD_STAKE_MINER]);
}
void ThreadOpenConnections2(void* parg)
{
printf("ThreadOpenConnections started\n");
// Connect to specific addresses
if (mapArgs.count("-connect") && mapMultiArgs["-connect"].size() > 0)
{
for (int64_t nLoop = 0;; nLoop++)
{
ProcessOneShot();
BOOST_FOREACH(string strAddr, mapMultiArgs["-connect"])
{
CAddress addr;
OpenNetworkConnection(addr, NULL, strAddr.c_str());
for (int i = 0; i < 10 && i < nLoop; i++)
{
MilliSleep(500);
if (fShutdown)
return;
}
}
MilliSleep(500);
}
}
// Initiate network connections
int64_t nStart = GetTime();
while (true)
{
ProcessOneShot();
vnThreadsRunning[THREAD_OPENCONNECTIONS]--;
MilliSleep(500);
vnThreadsRunning[THREAD_OPENCONNECTIONS]++;
if (fShutdown)
return;
vnThreadsRunning[THREAD_OPENCONNECTIONS]--;
CSemaphoreGrant grant(*semOutbound);
vnThreadsRunning[THREAD_OPENCONNECTIONS]++;
if (fShutdown)
return;
// Add seed nodes if IRC isn't working
if (addrman.size()==0 && (GetTime() - nStart > 60) && !fTestNet)
{
std::vector<CAddress> vAdd;
for (unsigned int i = 0; i < ARRAYLEN(pnSeed); i++)
{
// It'll only connect to one or two seed nodes because once it connects,
// it'll get a pile of addresses with newer timestamps.
// Seed nodes are given a random 'last seen time' of between one and two
// weeks ago.
const int64_t nOneWeek = 7*24*60*60;
struct in_addr ip;
memcpy(&ip, &pnSeed[i], sizeof(ip));
CAddress addr(CService(ip, GetDefaultPort()));
addr.nTime = GetTime()-GetRand(nOneWeek)-nOneWeek;
vAdd.push_back(addr);
}
addrman.Add(vAdd, CNetAddr("127.0.0.1"));
}
//
// Choose an address to connect to based on most recently seen
//
CAddress addrConnect;
// Only connect out to one peer per network group (/16 for IPv4).
// Do this here so we don't have to critsect vNodes inside mapAddresses critsect.
int nOutbound = 0;
set<vector<unsigned char> > setConnected;
{
LOCK(cs_vNodes);
BOOST_FOREACH(CNode* pnode, vNodes) {
if (!pnode->fInbound) {
setConnected.insert(pnode->addr.GetGroup());
nOutbound++;
}
}
}
int64_t nANow = GetAdjustedTime();
int nTries = 0;
while (true)
{
// use an nUnkBias between 10 (no outgoing connections) and 90 (8 outgoing connections)
CAddress addr = addrman.Select(10 + min(nOutbound,8)*10);
// if we selected an invalid address, restart
if (!addr.IsValid() || setConnected.count(addr.GetGroup()) || IsLocal(addr))
break;
// If we didn't find an appropriate destination after trying 100 addresses fetched from addrman,
// stop this loop, and let the outer loop run again (which sleeps, adds seed nodes, recalculates
// already-connected network ranges, ...) before trying new addrman addresses.
nTries++;
if (nTries > 100)
break;
if (IsLimited(addr))
continue;
// only consider very recently tried nodes after 30 failed attempts
if (nANow - addr.nLastTry < 600 && nTries < 30)
continue;
// do not allow non-default ports, unless after 50 invalid addresses selected already
if (addr.GetPort() != GetDefaultPort() && nTries < 50)
continue;
addrConnect = addr;
break;
}
if (addrConnect.IsValid())
OpenNetworkConnection(addrConnect, &grant);
}
}
void ThreadOpenAddedConnections(void* parg)
{
// Make this thread recognisable as the connection opening thread
RenameThread("hive-opencon");
try
{
vnThreadsRunning[THREAD_ADDEDCONNECTIONS]++;
ThreadOpenAddedConnections2(parg);
vnThreadsRunning[THREAD_ADDEDCONNECTIONS]--;
}
catch (std::exception& e) {
vnThreadsRunning[THREAD_ADDEDCONNECTIONS]--;
PrintException(&e, "ThreadOpenAddedConnections()");
} catch (...) {
vnThreadsRunning[THREAD_ADDEDCONNECTIONS]--;
PrintException(NULL, "ThreadOpenAddedConnections()");
}
printf("ThreadOpenAddedConnections exited\n");
}
void ThreadOpenAddedConnections2(void* parg)
{
printf("ThreadOpenAddedConnections started\n");
if (mapArgs.count("-addnode") == 0)
return;
if (HaveNameProxy()) {
while(!fShutdown) {
BOOST_FOREACH(string& strAddNode, mapMultiArgs["-addnode"]) {
CAddress addr;
CSemaphoreGrant grant(*semOutbound);
OpenNetworkConnection(addr, &grant, strAddNode.c_str());
MilliSleep(500);
}
vnThreadsRunning[THREAD_ADDEDCONNECTIONS]--;
MilliSleep(120000); // Retry every 2 minutes
vnThreadsRunning[THREAD_ADDEDCONNECTIONS]++;
}
return;
}
vector<vector<CService> > vservAddressesToAdd(0);
BOOST_FOREACH(string& strAddNode, mapMultiArgs["-addnode"])
{
vector<CService> vservNode(0);
if(Lookup(strAddNode.c_str(), vservNode, GetDefaultPort(), fNameLookup, 0))
{
vservAddressesToAdd.push_back(vservNode);
{
LOCK(cs_setservAddNodeAddresses);
BOOST_FOREACH(CService& serv, vservNode)
setservAddNodeAddresses.insert(serv);
}
}
}
while (true)
{
vector<vector<CService> > vservConnectAddresses = vservAddressesToAdd;
// Attempt to connect to each IP for each addnode entry until at least one is successful per addnode entry
// (keeping in mind that addnode entries can have many IPs if fNameLookup)
{
LOCK(cs_vNodes);
BOOST_FOREACH(CNode* pnode, vNodes)
for (vector<vector<CService> >::iterator it = vservConnectAddresses.begin(); it != vservConnectAddresses.end(); it++)
BOOST_FOREACH(CService& addrNode, *(it))
if (pnode->addr == addrNode)
{
it = vservConnectAddresses.erase(it);
it--;
break;
}
}
BOOST_FOREACH(vector<CService>& vserv, vservConnectAddresses)
{
CSemaphoreGrant grant(*semOutbound);
OpenNetworkConnection(CAddress(*(vserv.begin())), &grant);
MilliSleep(500);
if (fShutdown)
return;
}
if (fShutdown)
return;
vnThreadsRunning[THREAD_ADDEDCONNECTIONS]--;
MilliSleep(120000); // Retry every 2 minutes
vnThreadsRunning[THREAD_ADDEDCONNECTIONS]++;
if (fShutdown)
return;
}
}
// if successful, this moves the passed grant to the constructed node
bool OpenNetworkConnection(const CAddress& addrConnect, CSemaphoreGrant *grantOutbound, const char *strDest, bool fOneShot)
{
//
// Initiate outbound network connection
//
if (fShutdown)
return false;
if (!strDest)
if (IsLocal(addrConnect) ||
FindNode((CNetAddr)addrConnect) || CNode::IsBanned(addrConnect) ||
FindNode(addrConnect.ToStringIPPort().c_str()))
return false;
if (strDest && FindNode(strDest))
return false;
vnThreadsRunning[THREAD_OPENCONNECTIONS]--;
CNode* pnode = ConnectNode(addrConnect, strDest);
vnThreadsRunning[THREAD_OPENCONNECTIONS]++;
if (fShutdown)
return false;
if (!pnode)
return false;
if (grantOutbound)
grantOutbound->MoveTo(pnode->grantOutbound);
pnode->fNetworkNode = true;
if (fOneShot)
pnode->fOneShot = true;
return true;
}
void ThreadMessageHandler(void* parg)
{
// Make this thread recognisable as the message handling thread
RenameThread("hive-msghand");
try
{
vnThreadsRunning[THREAD_MESSAGEHANDLER]++;
ThreadMessageHandler2(parg);
vnThreadsRunning[THREAD_MESSAGEHANDLER]--;
}
catch (std::exception& e) {
vnThreadsRunning[THREAD_MESSAGEHANDLER]--;
PrintException(&e, "ThreadMessageHandler()");
} catch (...) {
vnThreadsRunning[THREAD_MESSAGEHANDLER]--;
PrintException(NULL, "ThreadMessageHandler()");
}
printf("ThreadMessageHandler exited\n");
}
void ThreadMessageHandler2(void* parg)
{
printf("ThreadMessageHandler started\n");
SetThreadPriority(THREAD_PRIORITY_BELOW_NORMAL);
while (!fShutdown)
{
vector<CNode*> vNodesCopy;
{
LOCK(cs_vNodes);
vNodesCopy = vNodes;
BOOST_FOREACH(CNode* pnode, vNodesCopy)
pnode->AddRef();
}
// Poll the connected nodes for messages
CNode* pnodeTrickle = NULL;
if (!vNodesCopy.empty())
pnodeTrickle = vNodesCopy[GetRand(vNodesCopy.size())];
BOOST_FOREACH(CNode* pnode, vNodesCopy)
{
if (pnode->fDisconnect)
continue;
// Receive messages
{
TRY_LOCK(pnode->cs_vRecvMsg, lockRecv);
if (lockRecv)
if (!ProcessMessages(pnode))
pnode->CloseSocketDisconnect();
}
if (fShutdown)
return;
// Send messages
{
TRY_LOCK(pnode->cs_vSend, lockSend);
if (lockSend)
SendMessages(pnode, pnode == pnodeTrickle);
}
if (fShutdown)
return;
}
{
LOCK(cs_vNodes);
BOOST_FOREACH(CNode* pnode, vNodesCopy)
pnode->Release();
}
// Wait and allow messages to bunch up.
// Reduce vnThreadsRunning so StopNode has permission to exit while
// we're sleeping, but we must always check fShutdown after doing this.
vnThreadsRunning[THREAD_MESSAGEHANDLER]--;
MilliSleep(100);
if (fRequestShutdown)
StartShutdown();
vnThreadsRunning[THREAD_MESSAGEHANDLER]++;
if (fShutdown)
return;
}
}
bool BindListenPort(const CService &addrBind, string& strError)
{
strError = "";
int nOne = 1;
#ifdef WIN32
// Initialize Windows Sockets
WSADATA wsadata;
int ret = WSAStartup(MAKEWORD(2,2), &wsadata);
if (ret != NO_ERROR)
{
strError = strprintf("Error: TCP/IP socket library failed to start (WSAStartup returned error %d)", ret);
printf("%s\n", strError.c_str());
return false;
}
#endif
// Create socket for listening for incoming connections
struct sockaddr_storage sockaddr;
socklen_t len = sizeof(sockaddr);
if (!addrBind.GetSockAddr((struct sockaddr*)&sockaddr, &len))
{
strError = strprintf("Error: bind address family for %s not supported", addrBind.ToString().c_str());
printf("%s\n", strError.c_str());
return false;
}
SOCKET hListenSocket = socket(((struct sockaddr*)&sockaddr)->sa_family, SOCK_STREAM, IPPROTO_TCP);
if (hListenSocket == INVALID_SOCKET)
{
strError = strprintf("Error: Couldn't open socket for incoming connections (socket returned error %d)", WSAGetLastError());
printf("%s\n", strError.c_str());
return false;
}
#ifdef SO_NOSIGPIPE
// Different way of disabling SIGPIPE on BSD
setsockopt(hListenSocket, SOL_SOCKET, SO_NOSIGPIPE, (void*)&nOne, sizeof(int));
#endif
#ifndef WIN32
// Allow binding if the port is still in TIME_WAIT state after
// the program was closed and restarted. Not an issue on windows.
setsockopt(hListenSocket, SOL_SOCKET, SO_REUSEADDR, (void*)&nOne, sizeof(int));
#endif
#ifdef WIN32
// Set to non-blocking, incoming connections will also inherit this
if (ioctlsocket(hListenSocket, FIONBIO, (u_long*)&nOne) == SOCKET_ERROR)
#else
if (fcntl(hListenSocket, F_SETFL, O_NONBLOCK) == SOCKET_ERROR)
#endif
{
strError = strprintf("Error: Couldn't set properties on socket for incoming connections (error %d)", WSAGetLastError());
printf("%s\n", strError.c_str());
return false;
}
// some systems don't have IPV6_V6ONLY but are always v6only; others do have the option
// and enable it by default or not. Try to enable it, if possible.
if (addrBind.IsIPv6()) {
#ifdef IPV6_V6ONLY
#ifdef WIN32
setsockopt(hListenSocket, IPPROTO_IPV6, IPV6_V6ONLY, (const char*)&nOne, sizeof(int));
#else
setsockopt(hListenSocket, IPPROTO_IPV6, IPV6_V6ONLY, (void*)&nOne, sizeof(int));
#endif
#endif
#ifdef WIN32
int nProtLevel = 10 /* PROTECTION_LEVEL_UNRESTRICTED */;
int nParameterId = 23 /* IPV6_PROTECTION_LEVEl */;
// this call is allowed to fail
setsockopt(hListenSocket, IPPROTO_IPV6, nParameterId, (const char*)&nProtLevel, sizeof(int));
#endif
}
if (::bind(hListenSocket, (struct sockaddr*)&sockaddr, len) == SOCKET_ERROR)
{
int nErr = WSAGetLastError();
if (nErr == WSAEADDRINUSE)
strError = strprintf(_("Unable to bind to %s on this computer. HIVE is probably already running."), addrBind.ToString().c_str());
else
strError = strprintf(_("Unable to bind to %s on this computer (bind returned error %d, %s)"), addrBind.ToString().c_str(), nErr, strerror(nErr));
printf("%s\n", strError.c_str());
return false;
}
printf("Bound to %s\n", addrBind.ToString().c_str());
// Listen for incoming connections
if (listen(hListenSocket, SOMAXCONN) == SOCKET_ERROR)
{
strError = strprintf("Error: Listening for incoming connections failed (listen returned error %d)", WSAGetLastError());
printf("%s\n", strError.c_str());
return false;
}
vhListenSocket.push_back(hListenSocket);
if (addrBind.IsRoutable() && fDiscover)
AddLocal(addrBind, LOCAL_BIND);
return true;
}
void static Discover()
{
if (!fDiscover)
return;
#ifdef WIN32
// Get local host IP
char pszHostName[1000] = "";
if (gethostname(pszHostName, sizeof(pszHostName)) != SOCKET_ERROR)
{
vector<CNetAddr> vaddr;
if (LookupHost(pszHostName, vaddr))
{
BOOST_FOREACH (const CNetAddr &addr, vaddr)
{
AddLocal(addr, LOCAL_IF);
}
}
}
#else
// Get local host ip
struct ifaddrs* myaddrs;
if (getifaddrs(&myaddrs) == 0)
{
for (struct ifaddrs* ifa = myaddrs; ifa != NULL; ifa = ifa->ifa_next)
{
if (ifa->ifa_addr == NULL) continue;
if ((ifa->ifa_flags & IFF_UP) == 0) continue;
if (strcmp(ifa->ifa_name, "lo") == 0) continue;
if (strcmp(ifa->ifa_name, "lo0") == 0) continue;
if (ifa->ifa_addr->sa_family == AF_INET)
{
struct sockaddr_in* s4 = (struct sockaddr_in*)(ifa->ifa_addr);
CNetAddr addr(s4->sin_addr);
if (AddLocal(addr, LOCAL_IF))
printf("IPv4 %s: %s\n", ifa->ifa_name, addr.ToString().c_str());
}
else if (ifa->ifa_addr->sa_family == AF_INET6)
{
struct sockaddr_in6* s6 = (struct sockaddr_in6*)(ifa->ifa_addr);
CNetAddr addr(s6->sin6_addr);
if (AddLocal(addr, LOCAL_IF))
printf("IPv6 %s: %s\n", ifa->ifa_name, addr.ToString().c_str());
}
}
freeifaddrs(myaddrs);
}
#endif
// Don't use external IPv4 discovery, when -onlynet="IPv6"
if (!IsLimited(NET_IPV4))
NewThread(ThreadGetMyExternalIP, NULL);
}
void StartNode(void* parg)
{
// Make this thread recognisable as the startup thread
RenameThread("hive-start");
if (semOutbound == NULL) {
// initialize semaphore
int nMaxOutbound = min(MAX_OUTBOUND_CONNECTIONS, (int)GetArg("-maxconnections", 125));
semOutbound = new CSemaphore(nMaxOutbound);
}
if (pnodeLocalHost == NULL)
pnodeLocalHost = new CNode(INVALID_SOCKET, CAddress(CService("127.0.0.1", 0), nLocalServices));
Discover();
//
// Start threads
//
if (!GetBoolArg("-dnsseed", true))
printf("DNS seeding disabled\n");
else
if (!NewThread(ThreadDNSAddressSeed, NULL))
printf("Error: NewThread(ThreadDNSAddressSeed) failed\n");
// Map ports with UPnP
if (fUseUPnP)
MapPort();
// Get addresses from IRC and advertise ours
if (!NewThread(ThreadIRCSeed, NULL))
printf("Error: NewThread(ThreadIRCSeed) failed\n");
// Send and receive from sockets, accept connections
if (!NewThread(ThreadSocketHandler, NULL))
printf("Error: NewThread(ThreadSocketHandler) failed\n");
// Initiate outbound connections from -addnode
if (!NewThread(ThreadOpenAddedConnections, NULL))
printf("Error: NewThread(ThreadOpenAddedConnections) failed\n");
// Initiate outbound connections
if (!NewThread(ThreadOpenConnections, NULL))
printf("Error: NewThread(ThreadOpenConnections) failed\n");
// Process messages
if (!NewThread(ThreadMessageHandler, NULL))
printf("Error: NewThread(ThreadMessageHandler) failed\n");
// Dump network addresses
if (!NewThread(ThreadDumpAddress, NULL))
printf("Error; NewThread(ThreadDumpAddress) failed\n");
// Mine proof-of-stake blocks in the background
if (!GetBoolArg("-staking", true))
printf("Staking disabled\n");
else
if (!NewThread(ThreadStakeMiner, pwalletMain))
printf("Error: NewThread(ThreadStakeMiner) failed\n");
}
bool StopNode()
{
printf("StopNode()\n");
fShutdown = true;
nTransactionsUpdated++;
int64_t nStart = GetTime();
if (semOutbound)
for (int i=0; i<MAX_OUTBOUND_CONNECTIONS; i++)
semOutbound->post();
do
{
int nThreadsRunning = 0;
for (int n = 0; n < THREAD_MAX; n++)
nThreadsRunning += vnThreadsRunning[n];
if (nThreadsRunning == 0)
break;
if (GetTime() - nStart > 20)
break;
MilliSleep(20);
} while(true);
if (vnThreadsRunning[THREAD_SOCKETHANDLER] > 0) printf("ThreadSocketHandler still running\n");
if (vnThreadsRunning[THREAD_OPENCONNECTIONS] > 0) printf("ThreadOpenConnections still running\n");
if (vnThreadsRunning[THREAD_MESSAGEHANDLER] > 0) printf("ThreadMessageHandler still running\n");
if (vnThreadsRunning[THREAD_RPCLISTENER] > 0) printf("ThreadRPCListener still running\n");
if (vnThreadsRunning[THREAD_RPCHANDLER] > 0) printf("ThreadsRPCServer still running\n");
#ifdef USE_UPNP
if (vnThreadsRunning[THREAD_UPNP] > 0) printf("ThreadMapPort still running\n");
#endif
if (vnThreadsRunning[THREAD_DNSSEED] > 0) printf("ThreadDNSAddressSeed still running\n");
if (vnThreadsRunning[THREAD_ADDEDCONNECTIONS] > 0) printf("ThreadOpenAddedConnections still running\n");
if (vnThreadsRunning[THREAD_DUMPADDRESS] > 0) printf("ThreadDumpAddresses still running\n");
if (vnThreadsRunning[THREAD_STAKE_MINER] > 0) printf("ThreadStakeMiner still running\n");
while (vnThreadsRunning[THREAD_MESSAGEHANDLER] > 0 || vnThreadsRunning[THREAD_RPCHANDLER] > 0)
MilliSleep(20);
MilliSleep(50);
DumpAddresses();
return true;
}
class CNetCleanup
{
public:
CNetCleanup()
{
}
~CNetCleanup()
{
// Close sockets
BOOST_FOREACH(CNode* pnode, vNodes)
if (pnode->hSocket != INVALID_SOCKET)
closesocket(pnode->hSocket);
BOOST_FOREACH(SOCKET hListenSocket, vhListenSocket)
if (hListenSocket != INVALID_SOCKET)
if (closesocket(hListenSocket) == SOCKET_ERROR)
printf("closesocket(hListenSocket) failed with error %d\n", WSAGetLastError());
#ifdef WIN32
// Shutdown Windows Sockets
WSACleanup();
#endif
}
}
instance_of_cnetcleanup;
void RelayTransaction(const CTransaction& tx, const uint256& hash)
{
CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
ss.reserve(10000);
ss << tx;
RelayTransaction(tx, hash, ss);
}
void RelayTransaction(const CTransaction& tx, const uint256& hash, const CDataStream& ss)
{
CInv inv(MSG_TX, hash);
{
LOCK(cs_mapRelay);
// Expire old relay messages
while (!vRelayExpiration.empty() && vRelayExpiration.front().first < GetTime())
{
mapRelay.erase(vRelayExpiration.front().second);
vRelayExpiration.pop_front();
}
// Save original serialized message so newer versions are preserved
mapRelay.insert(std::make_pair(inv, ss));
vRelayExpiration.push_back(std::make_pair(GetTime() + 15 * 60, inv));
}
RelayInventory(inv);
}
| [
"empowrcoin@gmail.com"
] | empowrcoin@gmail.com |
96861a41f87b24681bded5123b0a082847c04afd | 50d3b6becb84460c6a4087330b60dbd9b067b2bd | /rbf.cpp | 1d56cab7e466b3d0d8b446bffa3758f7197cbeb9 | [] | no_license | TheDwoon/SpectralSensorProfiles | 72c9abafd28be56e3f3cdc917c2c2bd0339bbc6b | d81cdf1b15f1c400c106c9596ad1c290bfd3229c | refs/heads/master | 2023-05-14T06:26:58.714126 | 2021-06-07T01:06:07 | 2021-06-07T01:06:07 | 374,496,430 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,824 | cpp | #include "rbf.h"
#include <iostream>
double rbf::rbf_kernel(double x) const {
return exp(-m_weight * m_weight * x * x);
}
Eigen::MatrixXd compute_distance_matrix(const Eigen::MatrixX2d &xs) {
const size_t num_rows = xs.rows();
Eigen::MatrixXd m(num_rows, num_rows);
for (Eigen::Index i = 0; i < num_rows; ++i) {
for (Eigen::Index j = 0; j < num_rows; ++j) {
double dx = xs(i, 0) - xs(j, 0);
double dy = xs(i, 1) - xs(j, 1);
m(i, j) = sqrt(dx * dx + dy * dy);
}
}
return m;
}
rbf::rbf() : m_weight(0) {
}
rbf::rbf(double weight, const double *xs, const double *ys, size_t count) : m_weight(weight) {
m_xs = Eigen::MatrixX2d();
m_xs.resize(count, 2);
for (Eigen::Index i = 0; i < count; ++i) {
m_xs(i, 0) = xs[i * 2 + 0];
m_xs(i, 1) = xs[i * 2 + 1];
}
Eigen::MatrixX2d fs;
fs.resize(count, 2);
for (Eigen::Index i = 0; i < count; ++i) {
fs(i, 0) = ys[i * 2 + 0];
fs(i, 1) = ys[i * 2 + 1];
}
Eigen::MatrixXd phi = compute_distance_matrix(m_xs);
for (Eigen::Index i = 0; i < phi.rows(); ++i) {
for (Eigen::Index j = 0; j < phi.cols(); ++j) {
phi(i, j) = rbf_kernel(phi(i, j));
}
}
// Validate inverse is correct
assert(!std::isnan(phi(0, 0)));
assert(!std::isnan(phi.inverse()(0, 0)));
assert(!std::isnan(fs(0, 0)));
m_weights = phi.inverse() * fs;
}
Eigen::VectorXd rbf::eval(const double *x) const {
Eigen::VectorXd phi;
phi.resize(m_xs.rows());
for (Eigen::Index i = 0; i < m_xs.rows(); ++i) {
double dx = x[0] - m_xs(i, 0);
double dy = x[1] - m_xs(i, 1);
double dist = sqrt(dx * dx + dy * dy);
phi(i) = rbf_kernel(dist);
}
return phi.transpose() * m_weights;
}
| [
"TheDwoon@users.noreply.github.com"
] | TheDwoon@users.noreply.github.com |
5d5bb75a672a7f66b5746d32dca7606ad76c520f | 428f52ac651ca0ed50abd318023492f3e5f2c446 | /src/result.cpp | 94e141827f6c2b1870a9ddbc22ea9ea98f455470 | [] | no_license | hemirt/mariadb | 4baf68a5fb14b0b36c20a788ad6a0c3de937cf5c | 2186bd19aa4f2c9b1e1de5a735f3c82d2e5e27a3 | refs/heads/master | 2021-10-23T01:11:49.409355 | 2021-10-18T09:11:52 | 2021-10-18T09:11:52 | 110,337,882 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 893 | cpp | #include "hemirt/result.hpp"
namespace hemirt {
namespace DB {
ErrorResult::ErrorResult(const std::string& error)
: err(error)
{
}
ErrorResult::ErrorResult(std::string&& error)
: err(error)
{
}
AffectedRowsResult::AffectedRowsResult(std::uint64_t num)
: numAffected(num)
{
}
Result::Result(ErrorResult&& err)
: result(err)
{
}
Result::Result(ReturnedRowsResult&& rrr)
: result(rrr)
{
}
Result::Result(AffectedRowsResult&& arr)
: result(arr)
{
}
std::size_t
Result::getType() const noexcept
{
return this->result.index();
}
ErrorResult*
Result::error()
{
return std::get_if<ErrorResult>(&this->result);
}
ReturnedRowsResult*
Result::returned()
{
return std::get_if<ReturnedRowsResult>(&this->result);
}
AffectedRowsResult*
Result::affected()
{
return std::get_if<AffectedRowsResult>(&this->result);
}
} // namespace DB
} // namespace hemirt | [
"hemirt@email.cz"
] | hemirt@email.cz |
bd8568cb065fb54e1d7082d3c4f38ed4b413a303 | 7eec256284530e38e2e3b34cfb003fb27d592ccd | /PSEGTREE - Make Versions in Segment Tree.cpp | 6ff80e196d1523e24358bc32325e79c7c376975f | [] | no_license | rudyjayk/SPOJ | 88c6c1c504c0570305737b14249c2e39dc61cb39 | dd961a5efff3c30fbb03dea957e03674f4dea255 | refs/heads/master | 2022-03-04T03:36:39.429095 | 2019-10-28T09:14:42 | 2019-10-28T09:14:42 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,190 | cpp | #include<bits/stdc++.h>
using namespace std;
#define ll long long
#define mx 100005
int arr[mx];
struct Node
{
Node* left;
Node* right;
int val;
Node(int _val=0, Node* _left = NULL, Node* _right = NULL)
{
val = _val;
left = _left;
right = _right;
}
}*root[mx];
void build(Node* curr, int low, int high)
{
if(low == high){
curr->val = arr[low];
return;
}
int mid = (low+high)/2;
curr->left = new Node();
curr->right = new Node();
build(curr->left, low, mid);
build(curr->right, mid+1, high);
curr->val = (curr->left->val + curr->right->val);
}
void update(Node* prev, Node* curr, int low, int high, int idx, int value)
{
if(idx>high || idx<low || low>high) return;
if(low==high){
curr->val = (prev->val + value);
return;
}
int mid = (low+high)/2;
if(idx<=mid){
curr->right = prev->right;
curr->left = new Node();
update(prev->left, curr->left, low, mid, idx, value);
}
else{
curr->left = prev->left;
curr->right = new Node();
update(prev->right, curr->right, mid+1, high, idx, value);
}
curr->val = (curr->left->val + curr->right->val);
}
int query(Node* curr, int low, int high, int l, int r)
{
if(l>high || r<low || low>high) return 0;
if(low>=l && high<=r)
return curr->val;
int mid = (low+high)/2;
int ret1 = query(curr->left, low, mid, l, r);
int ret2 = query(curr->right, mid+1, high, l, r);
return (ret1+ret2);
}
int main()
{
int n;
scanf("%d",&n);
for(int i=1; i<=n; i++)
scanf("%d",&arr[i]);
root[0] = new Node();
build(root[0],1,n);
int q,idx,pos,v,l,r,id=0,typ;
scanf("%d",&q);
while(q--){
scanf("%d",&typ);
if(typ==1){
scanf("%d%d%d",&idx,&pos,&v);
root[++id] = new Node();
update(root[idx], root[id],1,n,pos,v);
}
else{
scanf("%d%d%d",&idx,&l,&r);
int ans = query(root[idx],1,n,l,r);
printf("%d\n",ans);
}
}
}
| [
"noreply@github.com"
] | noreply@github.com |
226d3964666edbc6b395d19d563bd21b419adf5c | ebf214d3eeeadd99abc5952882d4552f4e39c107 | /HFO_mgm/src/chain_action/pass_checker.h | 3e0df1b9c27bb6e936d0816420ff8a306b76be5a | [
"MIT"
] | permissive | goncamateus/graduationMgm | b87e5a068864253ab7704b247600802ef816a15b | ee264d6f1bffdbbbb04c55c8f43146604d54cc88 | refs/heads/master | 2022-04-10T20:37:45.231599 | 2020-03-06T13:21:31 | 2020-03-06T13:21:31 | 197,375,982 | 6 | 3 | MIT | 2020-02-01T18:14:22 | 2019-07-17T11:26:36 | C++ | UTF-8 | C++ | false | false | 1,359 | h | // -*-c++-*-
/*
*Copyright:
Copyright (C) Hiroki SHIMORA
This code is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
This code is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this code; see the file COPYING. If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
*EndCopyright:
*/
/////////////////////////////////////////////////////////////////////
#ifndef PASS_CHECKER_H
#define PASS_CHECKER_H
#include "predict_state.h"
namespace rcsc {
class AbstractPlayerObject;
class Vector2D;
}
class PassChecker {
protected:
virtual
~PassChecker()
{ }
public:
virtual
bool operator()( const PredictState & state,
const rcsc::AbstractPlayerObject & from,
const rcsc::AbstractPlayerObject & to,
const rcsc::Vector2D & receive_point,
const double & first_ball_speed ) const = 0;
};
#endif
| [
"mgm4@cin.ufpe.br"
] | mgm4@cin.ufpe.br |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.