blob_id stringlengths 40 40 | directory_id stringlengths 40 40 | path stringlengths 3 264 | content_id stringlengths 40 40 | detected_licenses listlengths 0 85 | license_type stringclasses 2
values | repo_name stringlengths 5 140 | snapshot_id stringlengths 40 40 | revision_id stringlengths 40 40 | branch_name stringclasses 905
values | visit_date timestamp[us]date 2015-08-09 11:21:18 2023-09-06 10:45:07 | revision_date timestamp[us]date 1997-09-14 05:04:47 2023-09-17 19:19:19 | committer_date timestamp[us]date 1997-09-14 05:04:47 2023-09-06 06:22:19 | github_id int64 3.89k 681M ⌀ | star_events_count int64 0 209k | fork_events_count int64 0 110k | gha_license_id stringclasses 22
values | gha_event_created_at timestamp[us]date 2012-06-07 00:51:45 2023-09-14 21:58:39 ⌀ | gha_created_at timestamp[us]date 2008-03-27 23:40:48 2023-08-21 23:17:38 ⌀ | gha_language stringclasses 141
values | src_encoding stringclasses 34
values | language stringclasses 1
value | is_vendor bool 1
class | is_generated bool 2
classes | length_bytes int64 3 10.4M | extension stringclasses 115
values | content stringlengths 3 10.4M | authors listlengths 1 1 | author_id stringlengths 0 158 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
fccbc59758405790f5e8f2cf335532824ba3bd6d | 9f087cfdb02d3f1de0091876fad0504934bef17c | /CustomWindow/Dialog/frmmessagedialog.cpp | 4876b8e9d43e6493a60ffd969df672f9af940ce0 | [] | no_license | kknet/qt_client | 0ac41592856048510f7c470521845b89f0078a41 | 6c71db967369f07bd37cfbe52690565e2be9924d | refs/heads/master | 2022-04-04T17:24:41.731274 | 2018-11-08T03:51:11 | 2018-11-08T03:51:11 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 271 | cpp | #include "frmmessagedialog.h"
#include "ui_frmmessagedialog.h"
frmMessageDialog::frmMessageDialog(QWidget *parent) :
frmFramelessDialogBase(parent),
ui(new Ui::frmMessageDialog)
{
ui->setupUi(this);
}
frmMessageDialog::~frmMessageDialog()
{
delete ui;
}
| [
"ypdxcn@163.com"
] | ypdxcn@163.com |
4592013c7db7489907f2e3ef2af92452c3225206 | 7f0a0660cc25e4a61172170b8e57f15f19417b48 | /2021-22-2/monday10-12/while.cpp | f214b147ce2112e90874a6eff0eb958d9c432061 | [] | no_license | Szelethus/cpp_courses | f1e38b477b6d81cb4563b6829ecdf0c8bd14c346 | 6673a62f5bda4d4d81dfb9478b0098fde90e826c | refs/heads/master | 2023-08-18T03:59:28.960836 | 2023-05-23T07:43:00 | 2023-05-23T07:43:00 | 171,329,370 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 516 | cpp | #include <iostream>
double mulByTwo(double p) {
return 2*p;
}
int main() {
char input;
std::cout << "Provide a character to encode: ";
std::cin >> input;
char from[] = {'a', 'e', 'i', 'o', 'u'};
char to [] = {'u', 'a', 'e', 'i', 'o'};
char output;
for (int i = 0; i < sizeof(from) / sizeof(from[0]); ++i) {
if (input == from[i]) {
output = to[i];
break;
}
}
decltype(mulByTwo(6.6)) d = mulByTwo(6.6);
std::cout << "Your encoded character: " << output << '\n';
}
| [
"dkszelethus@gmail.com"
] | dkszelethus@gmail.com |
898cdc8cc3dc4364ec85b58d8c9545342389f650 | 682cf7a054a5be30372f6c3cdb6c81d2cd2e6802 | /test/common/custom_allocators.h | 09d61bf6e11aa86af63a6b5b1d6a0e78844a5d12 | [
"Apache-2.0"
] | permissive | zmajeed/tbb | 2c20f640a833f9d7700d92ac4b396a37b8fbd312 | 70bf10c0a9e65e3a954156f801b0a11c96f7f6bd | refs/heads/master | 2021-10-11T06:51:48.200397 | 2021-10-04T15:59:40 | 2021-10-04T15:59:40 | 192,191,740 | 0 | 1 | Apache-2.0 | 2019-06-16T13:04:20 | 2019-06-16T13:04:19 | null | UTF-8 | C++ | false | false | 23,253 | h | /*
Copyright (c) 2005-2021 Intel Corporation
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 __TBB_test_common_custom_allocators_H
#define __TBB_test_common_custom_allocators_H
#include "test.h"
#include <oneapi/tbb/detail/_allocator_traits.h>
#include <memory>
#include <atomic>
#include <scoped_allocator>
template <typename CounterType>
struct ArenaData {
char* const my_buffer;
const std::size_t my_size;
CounterType my_allocated; // in bytes
template <typename T>
ArenaData( T* buf, std::size_t sz ) noexcept
: my_buffer(reinterpret_cast<char*>(buf)),
my_size(sz * sizeof(T))
{
my_allocated = 0;
}
ArenaData& operator=( const ArenaData& ) = delete;
}; // struct ArenaData
template <typename T, typename POCMA = std::false_type, typename CounterType = std::size_t>
struct ArenaAllocator {
using arena_data_type = ArenaData<CounterType>;
arena_data_type* my_data;
using value_type = T;
using propagate_on_container_move_assignment = POCMA;
template <typename U>
struct rebind {
using other = ArenaAllocator<U, POCMA, CounterType>;
};
ArenaAllocator() = default;
ArenaAllocator( arena_data_type& data ) noexcept : my_data(&data) {}
template <typename U, typename POCMA2>
ArenaAllocator( const ArenaAllocator<U, POCMA2, CounterType>& other ) noexcept
: my_data(other.my_data) {}
friend void swap( ArenaAllocator& lhs, ArenaAllocator& rhs ) {
using std::swap;
swap(lhs.my_data, rhs.my_data);
}
value_type* address( value_type& x ) const { return &x; }
const value_type* address( const value_type& x ) const { return &x; }
value_type* allocate( std::size_t n ) {
std::size_t new_size = (my_data->my_allocated += n * sizeof(T));
REQUIRE_MESSAGE(my_data->my_allocated <= my_data->my_size, "Trying to allocate more than was reserved");
char* result = &(my_data->my_buffer[new_size - n * sizeof(T)]);
return reinterpret_cast<value_type*>(result);
}
void deallocate( value_type* ptr, std::size_t n ) {
char* p = reinterpret_cast<char*>(ptr);
REQUIRE_MESSAGE((p >= my_data->my_buffer && p <= my_data->my_buffer + my_data->my_size),
"Trying to deallocate pointer not from arena");
REQUIRE_MESSAGE((p + n * sizeof(T) <= my_data->my_buffer + my_data->my_size),
"Trying to deallocate pointer not from arena");
// utils::suppress_unused_warning(p, n);
}
std::size_t max_size() const noexcept {
return my_data->my_size / sizeof(T);
}
}; // class ArenaAllocator
template <typename T, typename U, typename POCMA, typename C>
bool operator==( const ArenaAllocator<T, POCMA, C>& lhs, const ArenaAllocator<U, POCMA, C>& rhs ) {
return lhs.my_data == rhs.my_data;
}
template <typename T, typename U, typename POCMA, typename C>
bool operator!=( const ArenaAllocator<T, POCMA, C>& lhs, const ArenaAllocator<U, POCMA, C>& rhs ) {
return !(lhs == rhs);
}
template <typename BaseAllocatorType>
class LocalCountingAllocator : public BaseAllocatorType {
using base_type = BaseAllocatorType;
using base_traits = tbb::detail::allocator_traits<base_type>;
using counter_type = std::atomic<std::size_t>;
public:
using value_type = typename base_type::value_type;
std::size_t max_items;
counter_type items_allocated;
counter_type items_freed;
counter_type items_constructed;
counter_type items_destroyed;
counter_type allocations;
counter_type frees;
void set_counters( std::size_t it_allocated, std::size_t it_freed,
std::size_t it_constructed, std::size_t it_destroyed,
std::size_t allocs, std::size_t fres ) {
items_allocated = it_allocated; // TODO: may be store
items_freed = it_freed;
items_constructed = it_constructed;
items_destroyed = it_destroyed;
allocations = allocs;
frees = fres;
}
template <typename Allocator>
void set_counters( const Allocator& alloc ) {
set_counters(alloc.items_allocated, alloc.items_freed, alloc.items_constructed,
alloc.items_destroyed, alloc.allocations, alloc.frees);
}
void clear_counters() {
set_counters(0, 0, 0, 0, 0, 0);
}
template <typename U>
struct rebind {
using other = LocalCountingAllocator<typename base_traits::template rebind_alloc<U>>;
};
LocalCountingAllocator() : max_items{0} { clear_counters(); }
LocalCountingAllocator( const LocalCountingAllocator& other )
: base_type(other), max_items{other.max_items} { set_counters(other); }
template <typename U>
LocalCountingAllocator( const LocalCountingAllocator<U>& other )
: base_type(other), max_items{other.max_items} { set_counters(other); }
LocalCountingAllocator& operator=( const LocalCountingAllocator& other ) {
base_type::operator=(other);
max_items = other.max_items;
set_counters(other);
return *this;
}
value_type* allocate( std::size_t n ) {
if (max_items != 0 && items_allocated + n >= max_items) {
TBB_TEST_THROW(std::bad_alloc());
}
value_type* ptr = static_cast<base_type*>(this)->allocate(n);
++allocations;
items_allocated += n;
return ptr;
}
void deallocate( value_type* ptr, std::size_t n ) {
++frees;
items_freed += n;
static_cast<base_type*>(this)->deallocate(ptr, n);
}
template <typename U, typename... Args>
void construct( U* ptr, Args&&... args ) {
base_traits::construct(*this, ptr, std::forward<Args>(args)...);
++items_constructed;
}
template <typename U>
void destroy( U* ptr ) {
base_traits::destroy(*this, ptr);
++items_destroyed;
}
void set_limits( std::size_t max ) {
max_items = max;
}
}; // class LocalCountingAllocator
struct AllocatorCounters {
using counter_type = std::atomic<std::size_t>;
counter_type items_allocated;
counter_type items_freed;
counter_type items_constructed;
counter_type items_destroyed;
counter_type allocations;
counter_type frees;
AllocatorCounters() = default;
AllocatorCounters( std::size_t it_allocated, std::size_t it_freed, std::size_t it_constructed,
std::size_t it_destroyed, std::size_t allocs, std::size_t fres )
: items_allocated(it_allocated), items_freed(it_freed),
items_constructed(it_constructed), items_destroyed(it_destroyed),
allocations(allocs), frees(fres) {}
AllocatorCounters( const AllocatorCounters& other )
: items_allocated(other.items_allocated.load()),
items_freed(other.items_allocated.load()),
items_constructed(other.items_constructed.load()),
items_destroyed(other.items_destroyed.load()),
allocations(other.allocations.load()),
frees(other.allocations.load()) {}
AllocatorCounters& operator=( const AllocatorCounters& other ) {
items_allocated.store(other.items_allocated.load());
items_freed.store(other.items_freed.load());
items_constructed.store(other.items_constructed.load());
items_destroyed.store(other.items_destroyed.load());
allocations.store(other.allocations.load());
frees.store(other.frees.load());
return *this;
}
friend bool operator==( const AllocatorCounters& lhs, const AllocatorCounters& rhs ) {
return lhs.items_allocated == rhs.items_allocated &&
lhs.items_freed == rhs.items_freed &&
lhs.items_constructed == rhs.items_constructed &&
lhs.items_destroyed == rhs.items_destroyed &&
lhs.allocations == rhs.allocations &&
lhs.frees == rhs.frees;
}
}; // struct AllocatorCounters
template <typename BaseAllocatorType>
class StaticCountingAllocator : public BaseAllocatorType {
using base_type = BaseAllocatorType;
using base_traits = tbb::detail::allocator_traits<BaseAllocatorType>;
using counter_type = std::atomic<std::size_t>;
public:
using value_type = typename base_type::value_type;
using pointer = value_type*;
using counters_type = AllocatorCounters;
static std::size_t max_items;
static counter_type items_allocated;
static counter_type items_freed;
static counter_type items_constructed;
static counter_type items_destroyed;
static counter_type allocations;
static counter_type frees;
static bool throwing;
template <typename U>
struct rebind {
using other = StaticCountingAllocator<typename base_traits::template rebind_alloc<U>>;
};
StaticCountingAllocator() = default;
template <typename U>
StaticCountingAllocator( const StaticCountingAllocator<U>& other ) : base_type(other) {}
value_type* allocate( std::size_t n ) {
if (max_items != 0 && items_allocated + n >= max_items) {
if (throwing) {
TBB_TEST_THROW(std::bad_alloc{});
}
return nullptr;
}
value_type* ptr = static_cast<base_type*>(this)->allocate(n);
++allocations;
items_allocated += n;
return ptr;
}
void deallocate(const pointer ptr, const std::size_t n){
++frees;
items_freed += n;
static_cast<base_type*>(this)->deallocate(ptr, n);
}
template <typename U, typename... Args>
void construct( U* ptr, Args&&... args ) {
++items_constructed;
base_traits::construct(*this, ptr, std::forward<Args>(args)...);
}
template <typename U>
void destroy( U* ptr ) {
++items_destroyed;
base_traits::destroy(*this, ptr);
}
static AllocatorCounters counters() {
return {items_allocated, items_freed, items_constructed, items_destroyed, allocations, frees};
}
static void init_counters() {
items_allocated = 0;
items_freed = 0;
items_constructed = 0;
items_destroyed = 0;
allocations = 0;
frees = 0;
}
static void set_limits( std::size_t max = 0, bool do_throw = true ) {
max_items = max;
throwing = do_throw;
}
}; // class StaticCountingAllocator
template <typename T>
std::size_t StaticCountingAllocator<T>::max_items;
template <typename T>
std::atomic<std::size_t> StaticCountingAllocator<T>::items_allocated;
template <typename T>
std::atomic<std::size_t> StaticCountingAllocator<T>::items_freed;
template <typename T>
std::atomic<std::size_t> StaticCountingAllocator<T>::items_constructed;
template <typename T>
std::atomic<std::size_t> StaticCountingAllocator<T>::items_destroyed;
template <typename T>
std::atomic<std::size_t> StaticCountingAllocator<T>::allocations;
template <typename T>
std::atomic<std::size_t> StaticCountingAllocator<T>::frees;
template <typename T>
bool StaticCountingAllocator<T>::throwing;
struct StaticSharedCountingAllocatorBase {
using counter_type = std::atomic<std::size_t>;
using counters_type = AllocatorCounters;
static std::size_t max_items;
static counter_type items_allocated;
static counter_type items_freed;
static counter_type items_constructed;
static counter_type items_destroyed;
static counter_type allocations;
static counter_type frees;
static bool throwing;
static counters_type counters() {
return { items_allocated.load(), items_freed.load(), items_constructed.load(),
items_destroyed.load(), allocations.load(), frees.load() };
}
static void init_counters() {
items_allocated = 0;
items_freed = 0;
items_constructed = 0;
items_destroyed = 0;
allocations = 0;
frees = 0;
}
static void set_limits( std::size_t max = 0, bool do_throw = true ) {
max_items = max;
throwing = do_throw;
}
}; // class StaticSharedCountingAllocatorBase
std::size_t StaticSharedCountingAllocatorBase::max_items;
std::atomic<std::size_t> StaticSharedCountingAllocatorBase::items_constructed;
std::atomic<std::size_t> StaticSharedCountingAllocatorBase::items_destroyed;
std::atomic<std::size_t> StaticSharedCountingAllocatorBase::items_allocated;
std::atomic<std::size_t> StaticSharedCountingAllocatorBase::items_freed;
std::atomic<std::size_t> StaticSharedCountingAllocatorBase::allocations;
std::atomic<std::size_t> StaticSharedCountingAllocatorBase::frees;
bool StaticSharedCountingAllocatorBase::throwing;
template <typename BaseAllocatorType>
class StaticSharedCountingAllocator
: public StaticSharedCountingAllocatorBase, public BaseAllocatorType
{
using base_type = StaticSharedCountingAllocatorBase;
using alloc_base_type = BaseAllocatorType;
using base_traits = tbb::detail::allocator_traits<BaseAllocatorType>;
public:
using value_type = typename alloc_base_type::value_type;
using counters_type = AllocatorCounters;
template <typename U>
struct rebind {
using other = StaticSharedCountingAllocator<typename base_traits::template rebind_alloc<U>>;
};
StaticSharedCountingAllocator() = default;
StaticSharedCountingAllocator( const StaticSharedCountingAllocator& ) = default;
template <typename U>
StaticSharedCountingAllocator( const StaticSharedCountingAllocator<U>& other) : alloc_base_type(other) {}
// Constructor from the base allocator with any type
template <typename Alloc>
StaticSharedCountingAllocator( const Alloc& src ) noexcept
: alloc_base_type(src) {}
value_type* allocate( std::size_t n ) {
if (base_type::max_items != 0 &&
base_type::items_allocated + n >= base_type::max_items) {
if (base_type::throwing) {
TBB_TEST_THROW(std::bad_alloc());
}
return nullptr;
}
++base_type::allocations;
base_type::items_allocated += n;
return static_cast<alloc_base_type*>(this)->allocate(n);
}
void deallocate( value_type* ptr, std::size_t n ) {
++base_type::frees;
base_type::items_freed += n;
static_cast<alloc_base_type*>(this)->deallocate(ptr, n);
}
template <typename U, typename... Args>
void construct( U* ptr, Args&&... args ) {
base_traits::construct(*this, ptr, std::forward<Args>(args)...);
++base_type::items_constructed;
}
template <typename U>
void destroy( U* ptr ) {
base_traits::destroy(*this, ptr);
++base_type::items_destroyed;
}
}; // class StaticSharedCountingAllocator
template <typename Allocator>
class AllocatorAwareData {
public:
static bool assert_on_constructions;
using allocator_type = Allocator;
AllocatorAwareData( const allocator_type& allocator = allocator_type() )
: my_allocator(allocator), my_value(0) {}
AllocatorAwareData( int v, const allocator_type& allocator = allocator_type() )
: my_allocator(allocator), my_value(v) {}
AllocatorAwareData( const AllocatorAwareData& rhs )
: my_allocator(rhs.my_allocator), my_value(rhs.my_value)
{
REQUIRE_MESSAGE(!assert_on_constructions, "Allocator should propagate to the data during copy construction");
}
AllocatorAwareData( AllocatorAwareData&& rhs)
: my_allocator(rhs.my_allocator), my_value(rhs.my_value)
{
REQUIRE_MESSAGE(!assert_on_constructions, "Allocator should propagate to the data during move construction");
}
AllocatorAwareData( const AllocatorAwareData& rhs, const allocator_type& allocator )
: my_allocator(allocator), my_value(rhs.my_value) {}
AllocatorAwareData( AllocatorAwareData&& rhs, const allocator_type& allocator )
: my_allocator(allocator), my_value(rhs.my_value) {}
AllocatorAwareData& operator=( const AllocatorAwareData& other ) {
my_value = other.my_value;
return *this;
}
int value() const { return my_value; }
static void activate() { assert_on_constructions = true; }
static void deactivate() { assert_on_constructions = false; }
private:
allocator_type my_allocator;
int my_value;
}; // class AllocatorAwareData
template <typename Allocator>
bool AllocatorAwareData<Allocator>::assert_on_constructions = false;
template <typename Allocator>
bool operator==( const AllocatorAwareData<Allocator>& lhs, const AllocatorAwareData<Allocator>& rhs ) {
return lhs.value() == rhs.value();
}
template <typename Allocator>
bool operator<( const AllocatorAwareData<Allocator>& lhs, const AllocatorAwareData<Allocator>& rhs ) {
return lhs.value() < rhs.value();
}
namespace std {
template <typename Allocator>
struct hash<AllocatorAwareData<Allocator>> {
std::size_t operator()(const AllocatorAwareData<Allocator>& obj) const {
return std::hash<int>()(obj.value());
}
};
}
template <typename Allocator, typename POCMA = std::false_type, typename POCCA = std::false_type,
typename POCS = std::false_type>
struct PropagatingAllocator : Allocator {
using base_allocator_traits = std::allocator_traits<Allocator>;
using propagate_on_container_copy_assignment = POCCA;
using propagate_on_container_move_assignment = POCMA;
using propagate_on_container_swap = POCS;
bool* propagated_on_copy_assignment;
bool* propagated_on_move_assignment;
bool* propagated_on_swap;
bool* selected_on_copy_construction;
template <typename U>
struct rebind {
using other = PropagatingAllocator<typename base_allocator_traits::template rebind_alloc<U>,
POCMA, POCCA, POCS>;
};
PropagatingAllocator()
: propagated_on_copy_assignment(nullptr),
propagated_on_move_assignment(nullptr),
propagated_on_swap(nullptr),
selected_on_copy_construction(nullptr) {}
PropagatingAllocator( bool& poca, bool& poma, bool& pos, bool& soc )
: propagated_on_copy_assignment(&poca),
propagated_on_move_assignment(&poma),
propagated_on_swap(&pos),
selected_on_copy_construction(&soc) {}
PropagatingAllocator( const PropagatingAllocator& other )
: Allocator(other),
propagated_on_copy_assignment(other.propagated_on_copy_assignment),
propagated_on_move_assignment(other.propagated_on_move_assignment),
propagated_on_swap(other.propagated_on_swap),
selected_on_copy_construction(other.selected_on_copy_construction) {}
template <typename Allocator2>
PropagatingAllocator( const PropagatingAllocator<Allocator2, POCMA, POCCA, POCS>& other )
: Allocator(other),
propagated_on_copy_assignment(other.propagated_on_copy_assignment),
propagated_on_move_assignment(other.propagated_on_move_assignment),
propagated_on_swap(other.propagated_on_swap),
selected_on_copy_construction(other.selected_on_copy_construction) {}
PropagatingAllocator& operator=( const PropagatingAllocator& ) {
REQUIRE_MESSAGE(POCCA::value, "Allocator should not copy assign if POCCA is false");
if (propagated_on_copy_assignment)
*propagated_on_copy_assignment = true;
return *this;
}
PropagatingAllocator& operator=( PropagatingAllocator&& ) {
REQUIRE_MESSAGE(POCMA::value, "Allocator should not move assign if POCMA is false");
if (propagated_on_move_assignment)
*propagated_on_move_assignment = true;
return *this;
}
PropagatingAllocator select_on_container_copy_construction() const {
if (selected_on_copy_construction)
*selected_on_copy_construction = true;
return *this;
}
}; // struct PropagatingAllocator
template <typename Allocator, typename POCMA, typename POCCA, typename POCS>
void swap( PropagatingAllocator<Allocator, POCMA, POCCA, POCS>& lhs,
PropagatingAllocator<Allocator, POCMA, POCCA, POCS>& )
{
REQUIRE_MESSAGE(POCS::value, "Allocator should not swap if POCS is false");
if (lhs.propagated_on_swap)
*lhs.propagated_on_swap = true;
}
template <typename T>
using AlwaysPropagatingAllocator = PropagatingAllocator<std::allocator<T>, /*POCMA = */std::true_type,
/*POCCA = */std::true_type, /*POCS = */std::true_type>;
template <typename T>
using NeverPropagatingAllocator = PropagatingAllocator<std::allocator<T>>;
template <typename T>
using PocmaAllocator = PropagatingAllocator<std::allocator<T>, /*POCMA = */std::true_type>;
template <typename T>
using PoccaAllocator = PropagatingAllocator<std::allocator<T>, /*POCMA = */std::false_type, /*POCCA = */std::true_type>;
template <typename T>
using PocsAllocator = PropagatingAllocator<std::allocator<T>, /*POCMA = */std::false_type, /*POCCA = */std::false_type,
/*POCS = */std::true_type>;
template <typename T>
class AlwaysEqualAllocator : public std::allocator<T> {
using base_allocator = std::allocator<T>;
public:
using is_always_equal = std::true_type;
using value_type = typename base_allocator::value_type;
using propagate_on_container_move_assignment = std::false_type;
template <typename U>
struct rebind {
using other = AlwaysEqualAllocator<U>;
};
AlwaysEqualAllocator() = default;
AlwaysEqualAllocator( const AlwaysEqualAllocator& ) = default;
template <typename U>
AlwaysEqualAllocator( const AlwaysEqualAllocator<U>& other )
: base_allocator(other) {}
}; // class AlwaysEqualAllocator
template <typename T>
class NotAlwaysEqualAllocator : public std::allocator<T> {
using base_allocator = std::allocator<T>;
public:
using is_always_equal = std::false_type;
using value_type = typename base_allocator::value_type;
using propagate_on_container_swap = std::false_type;
template <typename U>
struct rebind {
using other = NotAlwaysEqualAllocator<U>;
};
NotAlwaysEqualAllocator() = default;
NotAlwaysEqualAllocator( const NotAlwaysEqualAllocator& ) = default;
template <typename U>
NotAlwaysEqualAllocator( const NotAlwaysEqualAllocator<U>& other )
: base_allocator(other) {}
};
template <typename T>
bool operator==( const AlwaysEqualAllocator<T>&, const AlwaysEqualAllocator<T>& ) {
#ifndef __TBB_TEST_SKIP_IS_ALWAYS_EQUAL_CHECK
REQUIRE_MESSAGE(false, "operator== should not be called if is_always_equal is true");
#endif
return true;
}
#endif // __TBB_test_common_custom_allocators_H
| [
"inteltbbdevelopers@intel.com"
] | inteltbbdevelopers@intel.com |
55ac979c6d83477c58cc9c5fca33a45e4470627c | dd24a3a4de139825cf6e16378a3f21a2645292c9 | /compiler-rt/lib/tsan/rtl/tsan_flags.cc | 4c06600ebc4385f9786168bdca32839ca7507d68 | [
"NCSA",
"MIT"
] | permissive | yonglongliu/external | 986215aba5d5b627ab5ec249b7da55c9a01b7b3b | eeec7b9a6073dab97c7b6a3f0dc35f6bba61d101 | refs/heads/master | 2022-11-08T19:14:23.779887 | 2019-01-25T07:56:25 | 2019-01-25T07:56:25 | 128,770,204 | 1 | 4 | null | 2022-10-28T22:07:46 | 2018-04-09T12:44:41 | C | UTF-8 | C++ | false | false | 2,853 | cc | //===-- tsan_flags.cc -----------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file is a part of ThreadSanitizer (TSan), a race detector.
//
//===----------------------------------------------------------------------===//
#include "sanitizer_common/sanitizer_flags.h"
#include "sanitizer_common/sanitizer_flag_parser.h"
#include "sanitizer_common/sanitizer_libc.h"
#include "tsan_flags.h"
#include "tsan_rtl.h"
#include "tsan_mman.h"
namespace __tsan {
Flags *flags() {
return &ctx->flags;
}
// Can be overriden in frontend.
#ifdef TSAN_EXTERNAL_HOOKS
extern "C" const char* __tsan_default_options();
#else
extern "C" SANITIZER_INTERFACE_ATTRIBUTE
const char *WEAK __tsan_default_options() {
return "";
}
#endif
void Flags::SetDefaults() {
#define TSAN_FLAG(Type, Name, DefaultValue, Description) Name = DefaultValue;
#include "tsan_flags.inc"
#undef TSAN_FLAG
// DDFlags
second_deadlock_stack = false;
}
void RegisterTsanFlags(FlagParser *parser, Flags *f) {
#define TSAN_FLAG(Type, Name, DefaultValue, Description) \
RegisterFlag(parser, #Name, Description, &f->Name);
#include "tsan_flags.inc"
#undef TSAN_FLAG
// DDFlags
RegisterFlag(parser, "second_deadlock_stack",
"Report where each mutex is locked in deadlock reports",
&f->second_deadlock_stack);
}
void InitializeFlags(Flags *f, const char *env) {
FlagParser parser;
RegisterTsanFlags(&parser, f);
RegisterCommonFlags(&parser);
f->SetDefaults();
SetCommonFlagsDefaults();
{
// Override some common flags defaults.
CommonFlags cf;
cf.CopyFrom(*common_flags());
cf.allow_addr2line = true;
#ifndef SANITIZER_GO
cf.detect_deadlocks = true;
#endif
cf.print_suppressions = false;
cf.stack_trace_format = " #%n %f %S %M";
OverrideCommonFlags(cf);
}
// Let a frontend override.
parser.ParseString(__tsan_default_options());
// Override from command line.
parser.ParseString(env);
// Sanity check.
if (!f->report_bugs) {
f->report_thread_leaks = false;
f->report_destroy_locked = false;
f->report_signal_unsafe = false;
}
SetVerbosity(common_flags()->verbosity);
if (Verbosity()) ReportUnrecognizedFlags();
if (common_flags()->help) parser.PrintFlagDescriptions();
if (f->history_size < 0 || f->history_size > 7) {
Printf("ThreadSanitizer: incorrect value for history_size"
" (must be [0..7])\n");
Die();
}
if (f->io_sync < 0 || f->io_sync > 2) {
Printf("ThreadSanitizer: incorrect value for io_sync"
" (must be [0..2])\n");
Die();
}
}
} // namespace __tsan
| [
"yonglong_liu@xunrui.com.cn"
] | yonglong_liu@xunrui.com.cn |
51f3915e2c554944c71178ea3af6ed9c3a0fb353 | cf6ae38d4adf41e3eb219b8ac477aa7ca7c7d18a | /trunk/boost/date_time/posix_time/posix_time_io.hpp | c71d5d353cc0b4fdd712469e4801457572151f8c | [
"LicenseRef-scancode-unknown-license-reference",
"BSL-1.0"
] | permissive | ryppl/boost-history | a560df2bc79ffc7640f09d258599891dbbb8f6d0 | 934c80ff671f3afeb72b38d5fdf4396acc2dc58c | HEAD | 2016-09-07T08:08:33.930543 | 2011-07-10T13:15:08 | 2011-07-10T13:15:08 | 3,539,914 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 9,425 | hpp | #ifndef DATE_TIME_POSIX_TIME_IO_HPP__
#define DATE_TIME_POSIX_TIME_IO_HPP__
/* Copyright (c) 2004-2005 CrystalClear Software, Inc.
* Use, modification and distribution is subject to the
* Boost Software License, Version 1.0. (See accompanying
* file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
* Author: Jeff Garland, Bart Garst
* $Date$
*/
#include "boost/date_time/time_facet.hpp"
#include "boost/date_time/period_formatter.hpp"
#include "boost/date_time/posix_time/time_period.hpp"
#include "boost/date_time/posix_time/posix_time_duration.hpp"
//#include "boost/date_time/gregorian/gregorian_io.hpp"
#include "boost/io/ios_state.hpp"
#include <iostream>
#include <locale>
namespace boost {
namespace posix_time {
//! wptime_facet is depricated and will be phased out. use wtime_facet instead
//typedef boost::date_time::time_facet<ptime, wchar_t> wptime_facet;
//! ptime_facet is depricated and will be phased out. use time_facet instead
//typedef boost::date_time::time_facet<ptime, char> ptime_facet;
//! wptime_input_facet is depricated and will be phased out. use wtime_input_facet instead
//typedef boost::date_time::time_input_facet<ptime,wchar_t> wptime_input_facet;
//! ptime_input_facet is depricated and will be phased out. use time_input_facet instead
//typedef boost::date_time::time_input_facet<ptime,char> ptime_input_facet;
typedef boost::date_time::time_facet<ptime, wchar_t> wtime_facet;
typedef boost::date_time::time_facet<ptime, char> time_facet;
typedef boost::date_time::time_input_facet<ptime, wchar_t> wtime_input_facet;
typedef boost::date_time::time_input_facet<ptime, char> time_input_facet;
template <class CharT, class TraitsT>
inline
std::basic_ostream<CharT, TraitsT>&
operator<<(std::basic_ostream<CharT, TraitsT>& os,
const ptime& p) {
boost::io::ios_flags_saver iflags(os);
typedef boost::date_time::time_facet<ptime, CharT> custom_ptime_facet;
typedef std::time_put<CharT> std_ptime_facet;
std::ostreambuf_iterator<CharT> oitr(os);
if (std::has_facet<custom_ptime_facet>(os.getloc()))
std::use_facet<custom_ptime_facet>(os.getloc()).put(oitr, os, os.fill(), p);
else {
//instantiate a custom facet for dealing with times since the user
//has not put one in the stream so far. This is for efficiency
//since we would always need to reconstruct for every time period
//if the locale did not already exist. Of course this will be overridden
//if the user imbues as some later point.
std::ostreambuf_iterator<CharT> oitr(os);
custom_ptime_facet* f = new custom_ptime_facet();
std::locale l = std::locale(os.getloc(), f);
os.imbue(l);
f->put(oitr, os, os.fill(), p);
}
return os;
}
//! input operator for ptime
template <class CharT, class Traits>
inline
std::basic_istream<CharT, Traits>&
operator>>(std::basic_istream<CharT, Traits>& is, ptime& pt)
{
boost::io::ios_flags_saver iflags(is);
typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
if (strm_sentry) {
try {
typedef typename date_time::time_input_facet<ptime, CharT> time_input_facet;
std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
if(std::has_facet<time_input_facet>(is.getloc())) {
std::use_facet<time_input_facet>(is.getloc()).get(sit, str_end, is, pt);
}
else {
time_input_facet* f = new time_input_facet();
std::locale l = std::locale(is.getloc(), f);
is.imbue(l);
f->get(sit, str_end, is, pt);
}
}
catch(...) {
// mask tells us what exceptions are turned on
std::ios_base::iostate exception_mask = is.exceptions();
// if the user wants exceptions on failbit, we'll rethrow our
// date_time exception & set the failbit
if(std::ios_base::failbit & exception_mask) {
try { is.setstate(std::ios_base::failbit); }
catch(std::ios_base::failure&) {} // ignore this one
throw; // rethrow original exception
}
else {
// if the user want's to fail quietly, we simply set the failbit
is.setstate(std::ios_base::failbit);
}
}
}
return is;
}
template <class CharT, class TraitsT>
inline
std::basic_ostream<CharT, TraitsT>&
operator<<(std::basic_ostream<CharT, TraitsT>& os,
const boost::posix_time::time_period& p) {
boost::io::ios_flags_saver iflags(os);
typedef boost::date_time::time_facet<ptime, CharT> custom_ptime_facet;
typedef std::time_put<CharT> std_time_facet;
std::ostreambuf_iterator<CharT> oitr(os);
if (std::has_facet<custom_ptime_facet>(os.getloc())) {
std::use_facet<custom_ptime_facet>(os.getloc()).put(oitr, os, os.fill(), p);
}
else {
//instantiate a custom facet for dealing with periods since the user
//has not put one in the stream so far. This is for efficiency
//since we would always need to reconstruct for every time period
//if the local did not already exist. Of course this will be overridden
//if the user imbues as some later point.
std::ostreambuf_iterator<CharT> oitr(os);
custom_ptime_facet* f = new custom_ptime_facet();
std::locale l = std::locale(os.getloc(), f);
os.imbue(l);
f->put(oitr, os, os.fill(), p);
}
return os;
}
//! input operator for time_period
template <class CharT, class Traits>
inline
std::basic_istream<CharT, Traits>&
operator>>(std::basic_istream<CharT, Traits>& is, time_period& tp)
{
boost::io::ios_flags_saver iflags(is);
typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
if (strm_sentry) {
try {
typedef typename date_time::time_input_facet<ptime, CharT> time_input_facet;
std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
if(std::has_facet<time_input_facet>(is.getloc())) {
std::use_facet<time_input_facet>(is.getloc()).get(sit, str_end, is, tp);
}
else {
time_input_facet* f = new time_input_facet();
std::locale l = std::locale(is.getloc(), f);
is.imbue(l);
f->get(sit, str_end, is, tp);
}
}
catch(...) {
std::ios_base::iostate exception_mask = is.exceptions();
if(std::ios_base::failbit & exception_mask) {
try { is.setstate(std::ios_base::failbit); }
catch(std::ios_base::failure&) {}
throw; // rethrow original exception
}
else {
is.setstate(std::ios_base::failbit);
}
}
}
return is;
}
//! ostream operator for posix_time::time_duration
// todo fix to use facet -- place holder for now...
template <class CharT, class Traits>
inline
std::basic_ostream<CharT, Traits>&
operator<<(std::basic_ostream<CharT, Traits>& os, const time_duration& td)
{
boost::io::ios_flags_saver iflags(os);
typedef boost::date_time::time_facet<ptime, CharT> custom_ptime_facet;
typedef std::time_put<CharT> std_ptime_facet;
std::ostreambuf_iterator<CharT> oitr(os);
if (std::has_facet<custom_ptime_facet>(os.getloc()))
std::use_facet<custom_ptime_facet>(os.getloc()).put(oitr, os, os.fill(), td);
else {
//instantiate a custom facet for dealing with times since the user
//has not put one in the stream so far. This is for efficiency
//since we would always need to reconstruct for every time period
//if the locale did not already exist. Of course this will be overridden
//if the user imbues as some later point.
std::ostreambuf_iterator<CharT> oitr(os);
custom_ptime_facet* f = new custom_ptime_facet();
std::locale l = std::locale(os.getloc(), f);
os.imbue(l);
f->put(oitr, os, os.fill(), td);
}
return os;
}
//! input operator for time_duration
template <class CharT, class Traits>
inline
std::basic_istream<CharT, Traits>&
operator>>(std::basic_istream<CharT, Traits>& is, time_duration& td)
{
boost::io::ios_flags_saver iflags(is);
typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
if (strm_sentry) {
try {
typedef typename date_time::time_input_facet<ptime, CharT> time_input_facet;
std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
if(std::has_facet<time_input_facet>(is.getloc())) {
std::use_facet<time_input_facet>(is.getloc()).get(sit, str_end, is, td);
}
else {
time_input_facet* f = new time_input_facet();
std::locale l = std::locale(is.getloc(), f);
is.imbue(l);
f->get(sit, str_end, is, td);
}
}
catch(...) {
std::ios_base::iostate exception_mask = is.exceptions();
if(std::ios_base::failbit & exception_mask) {
try { is.setstate(std::ios_base::failbit); }
catch(std::ios_base::failure&) {}
throw; // rethrow original exception
}
else {
is.setstate(std::ios_base::failbit);
}
}
}
return is;
}
} } // namespaces
#endif // DATE_TIME_POSIX_TIME_IO_HPP__
| [
"doug.gregor@gmail.com"
] | doug.gregor@gmail.com |
469d87405ff6d2dd4372abecc2458c38df1f81a4 | 6199676f32ee3e2313a6c16acb458b00eae38ed5 | /src/qt/receiverequestdialog.h | 91b5118df2d3497c6b66650053d61632fd69624b | [
"MIT"
] | permissive | Darrenshome40/shitecoin | bd54de78abbba5e922f659f0ca43db3d295e44d5 | a2535c8fc5a43ee21ec818d5367439f6302cd084 | refs/heads/master | 2023-02-21T08:45:30.848297 | 2021-01-19T13:00:14 | 2021-01-19T13:00:14 | 330,753,516 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 928 | h | // Copyright (c) 2011-2020 The shitecoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#ifndef shitecoin_QT_RECEIVEREQUESTDIALOG_H
#define shitecoin_QT_RECEIVEREQUESTDIALOG_H
#include <qt/sendcoinsrecipient.h>
#include <QDialog>
class WalletModel;
namespace Ui {
class ReceiveRequestDialog;
}
class ReceiveRequestDialog : public QDialog
{
Q_OBJECT
public:
explicit ReceiveRequestDialog(QWidget *parent = nullptr);
~ReceiveRequestDialog();
void setModel(WalletModel *model);
void setInfo(const SendCoinsRecipient &info);
private Q_SLOTS:
void on_btnCopyURI_clicked();
void on_btnCopyAddress_clicked();
void updateDisplayUnit();
private:
Ui::ReceiveRequestDialog *ui;
WalletModel *model;
SendCoinsRecipient info;
};
#endif // shitecoin_QT_RECEIVEREQUESTDIALOG_H
| [
"darren.conroy@ickonic.com"
] | darren.conroy@ickonic.com |
2901abd841d8ed00cbfe575e3825bff90ecbd8d1 | e2275db4f9ec9d38b087dd5434e119df8e2c4d11 | /include/cam_exploration/MarkerPublisher.h | ec698edc6c447283e27394ca5a1b28d4fd5f9fff | [
"MIT"
] | permissive | procopiostein/cam_exploration | d6e395c524887ee38e8558088ab9348fec59f155 | dac1dc7330f29f75f4c102d32b498a2d6780740d | refs/heads/master | 2020-12-25T03:21:00.279053 | 2016-06-02T07:02:54 | 2016-06-02T07:02:54 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,687 | h |
/*
* MIT License
*
* Copyright (c) 2016 Jordi Soler Busquets
*
* 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 CAM_EXPLORATION_MARKER_SERVER_H
#define CAM_EXPLORATION_MARKER_SERVER_H
/**
* @file MarkerPublisher.h
* @brief Handles all the marker publications of the project cam_exploration
* @author Jordi Soler
* @version 1
* @date 2016-04-21
*/
#include <ros/ros.h>
#include "visualization_msgs/Marker.h"
#include "geometry_msgs/Pose.h"
namespace cam_exploration {
/**
* @brief Represents a publishable object. It only supports visualisation_msgs::Marker messages
*/
class pub
{
public:
/**
* @brief Constructor
* It advertises to publish visualisation_msgs::Marker to the topic \p topic
* @param name Name representing this object. It is an identifier
* @param topic Topic to be advertised
* @param n NodeHandle to advertise the topic \p topic
* @param m Marker with the properties that the sent messages should have
*/
pub(const char* name, const char* topic, ros::NodeHandle n, visualization_msgs::Marker m) :
topic_(topic), name_(name), n_(n), m_(m) {initialise();}
/**
* @brief Constructor
* It advertises to publish visualisation_msgs::Marker to the topic \p topic
* @param name Name representing this object. It is an identifier
* @param topic Topic to be advertised
* @param n NodeHandle to advertise the topic \p topic
* @param type Type of the visualisation_msgs::Marker to be published
*/
pub(const char* name, const char* topic, ros::NodeHandle n, int type);
/**
* @brief Publish a marker at given point(s)
*
* @param p Location of the marker
*/
void publish(geometry_msgs::Pose p) const { publish_(p);}
/**
* @copydoc publish(geometry_msgs::Pose) const
*
* @param yaw Yaw angle to deduce orientation in the XY plane
*/
void publish(geometry_msgs::Point p, int yaw) const;
/**
* @copydoc publish(geometry_msgs::Pose) const
* Uses line strips type
*/
void publish(const std::vector<geometry_msgs::Point> & p) const { publish_(p);}
void publish(const std::vector<int> & p) const;
/**
* @brief Set some base property(ies) of the marker message to be published
*
* @param m Marker from which to copy the properties
*/
void setProperty(visualization_msgs::Marker m) {m_ = m;}
/**
* @copybrief setProperties(visualisation_msgs::Marker)
*
* @param type Type of the marker to be published
*/
void setProperty(int type) {m_.type = type;}
/**
* @copybrief setProperties(visualisation_msgs::Marker)
*
* @param color Color of the marker to be published
*/
void setProperty(std_msgs::ColorRGBA color) {m_.color = color;}
/**
* @copybrief setProperties(visualisation_msgs::Marker)
*
* @param scale Scale of the marker to be published
*/
void setProperty(geometry_msgs::Vector3 scale) {m_.scale = scale;}
/**
* @brief Checks wether the object has a certain identifier
*
* @param name Object's identifier
*
* @return True if there is a match
*/
bool is(const char* name) const { return name == name_; }
private:
const char *topic_; ///< Topic where the messages are published
const char *name_; ///< Identifier (name) of the object
ros::NodeHandle n_; ///< NodeHandle to advertise the topic
visualization_msgs::Marker m_; ///< Base marker message to be publided. Contains the properties to be used
ros::Publisher p_; ///< Ros publisher to publish the messages
/**
* @brief Advertises the topic
*/
void initialise();
/**
* @brief Publishes a unique-point marker
*
* @param p Position of the marker
*/
void publish_(const geometry_msgs::Pose p) const;
/**
* @brief Publishes a series-of-points marker
*
* @param points Position of the points of the marker
*/
void publish_(const std::vector<geometry_msgs::Point>& points) const;
};
/**
* @brief Server class to handle marker publications.
* It facilitates the marker publication by storing a collection of publishers with proper defaults
*/
class MarkerPublisher
{
public:
/**
* @brief Parameterless constructor. Forwards its work to MarkerPublisher::initialise()
*/
MarkerPublisher();
/**
* @brief Constructor. Initialises the ros::NodeHandle and forwards its work to MarkerPublisher::initialise()
*
* @param n_in Node handle to advertise the publishers
*/
MarkerPublisher(ros::NodeHandle n_in);
/**
* @copydoc publish(geometry_msgs::Point,const char*)
*
* @param frame Frame to wich the message should be attached
*/
void publish(geometry_msgs::Point point, const char* topic, const char* frame);
/**
* @copydoc publish(geometry_msgs::Point)
*
* @param topic Topic where the message should be published
*/
void publish(geometry_msgs::Point point, const char* topic) { publish(point, topic, "/map"); }
/**
* @brief Publish a marker representing a single point
*
* @param point Marker location
*/
void publish(geometry_msgs::Point point) {publish(point, "Point");}
/**
* @copydoc publishRel(geometry_msgs::Point)
* @param topic Topic to be used
*/
void publishRel(geometry_msgs::Point point, const char* topic) { publish(point, "Point", topic);}
/**
* @brief Publishes a single point
*
* Such point is considered relative to the robot frame
*
* @param point Point to be published
*/
void publishRel(geometry_msgs::Point point) { publishRel(point, "/base_footprint");}
/**
* @brief Sets the internal ros::NodeHandle
*
* @param n_in Handler to be used
*/
void setNh(ros::NodeHandle n_in);
/**
* @copydoc add(const char*,const char*)
*
* @param type Type of marker to be added
*/
void add(const char* name, const char* topic, int type);
/**
* @brief Adds a new publicable object
*
* @param name The name to reference the publicable object
* @param topic Topic to be advertised
*/
void add(const char* name, const char* topic) { add(name, topic, visualization_msgs::Marker::SPHERE);}
/**
* @brief Publishes a publicable object
*
* @param name Name of the publicable object
* @param publicable Publicable message
*/
template <typename T>
void publish(const char* name, T publicable)
{
for(std::vector<pub>::iterator it = pubs.begin(); it != pubs.end(); ++it){
if (it->is(name)){
it->publish(publicable);
return;
}
}
}
/**
* @brief Set a certain property for a publicable object
*
* @param name Name of the publicable object
* @param property Property to be changed
*/
template <typename T>
void setProperty(const char* name, T property){
for(std::vector<pub>::iterator it = pubs.begin(); it != pubs.end(); ++it){
if (it->is(name)){
it->setProperty(property);
return;
}
}
}
bool has(const char* name) const;
private:
ros::NodeHandle n; ///< Internal node handle to advertise publications
visualization_msgs::Marker marker; ///< Default marker for direct publications
static std::vector<pub> pubs; ///< Collection of publicable objects stored to facilitate marker publication
/**
* @brief Initial procedure. Sets up the default marker.
*/
void initialise();
};
} // namespace cam_exploration
#endif
| [
"jordi.solerbusquets@gmail.com"
] | jordi.solerbusquets@gmail.com |
447e8f516ff1c64031ce058adcf7f9b5d9211f84 | 0254f2ee4fde7362762a32cf8e59612271c63c87 | /src/plugins/interfaces/fastcgi/fastcgisocketmanager.cpp | 379046d449fad9b6b23b598b5bc68149fe4fcbc6 | [] | no_license | alexey-zayats/athletic | 9a97f7f221bd3671df43ac65642df2916ba42a0b | 0c65552d32a7bf581b03f0311e6764aaa60e1690 | refs/heads/master | 2020-05-22T01:31:14.186306 | 2017-07-10T12:06:58 | 2017-07-10T12:06:58 | 64,463,265 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,419 | cpp | #include "fastcgisocketmanager.h"
#include "beginrequestrecord.h"
#include "endrequestrecord.h"
#include <server/enumhelpers.h>
#include "fastcgistream.h"
#include "parametersrecord.h"
#include "recordheader.h"
#include "standardinputrecord.h"
#include "fastcgi.h"
#include <QCoreApplication>
#include <QDebug>
#include <QMutexLocker>
#include <QSocketNotifier>
#include <QTcpSocket>
#include <QTimer>
namespace FastCgi
{
SocketManager::SocketManager(QTcpSocket* socket, QObject* parent)
: Server::CommunicationInterface::Worker(parent)
{
m_socket = socket;
m_socket->setParent(this);
connect(
m_socket,
SIGNAL(readyRead()),
this,
SLOT(processSocketData())
);
}
SocketManager::~SocketManager()
{
}
void SocketManager::processSocketData()
{
bool success;
do
{
if(!m_recordHeader.isValid())
{
success = processNewRecord();
}
else
{
success = processRecordData();
}
}
while(success && m_socket->bytesAvailable() > 0);
}
bool SocketManager::processRecordData()
{
RecordHeader header(m_recordHeader);
if(m_socket->bytesAvailable() < header.payloadLength())
{
return false;
}
int expected = header.payloadLength();
QByteArray data;
while( data.size() < expected ) {
data.append( m_socket->read( expected - data.length() ) );
if (m_socket->bytesAvailable() == 0 )
m_socket->waitForReadyRead(5000);
}
qint64 bytesRead = data.length();
if(bytesRead != header.payloadLength())
{
qFatal("Couldn't read payload - tried to read %d bytes, got %lld", header.payloadLength(), bytesRead);
}
switch(header.type())
{
case RecordHeader::BeginRequestRecord:
beginRequest(data);
break;
case RecordHeader::ParametersRecord:
if(!loadParameters(data))
{
respond();
}
break;
case RecordHeader::StandardInputRecord:
readStandardInput(data);
break;
default:
qFatal("Don't know how to deal with payload for type %s", ENUM_DEBUG_STRING(RecordHeader,RecordType,header.type()));
}
m_recordHeader = RecordHeader();
return true;
}
bool SocketManager::loadParameters(const QByteArray& data)
{
quint16 requestId = m_recordHeader.requestId();
Q_ASSERT(m_recordHeader.type() == RecordHeader::ParametersRecord);
ParametersRecord record(m_recordHeader, data);
if(record.isEmpty())
{
return false;
}
else
{
m_requestHeaders[requestId].unite(record.parameters());
return true;
}
}
void SocketManager::readStandardInput(const QByteArray& data)
{
const quint16 requestId = m_recordHeader.requestId();
Q_ASSERT(m_recordHeader.type() == RecordHeader::StandardInputRecord);
QMutexLocker lock(&m_streamMutex);
if(m_streams[requestId])
{
StandardInputRecord record(m_recordHeader, data);
m_streams[requestId]->appendData(record.streamData());
}
// Otherwise, the request is dealt with, and the remaining standard input
// was ignored.
}
void SocketManager::beginRequest(const QByteArray& data)
{
quint16 requestId = m_recordHeader.requestId();
Q_ASSERT(m_recordHeader.type() == RecordHeader::BeginRequestRecord);
BeginRequestRecord record(m_recordHeader, *reinterpret_cast<const FCGI_BeginRequestBody*>(data.constData()));
Q_ASSERT(record.role() == BeginRequestRecord::ResponderRole);
if(m_requestHeaders.size() <= requestId)
{
const int newSize = (requestId + 1) * 2;
m_requestHeaders.resize(newSize);
m_closeSocketOnExit.resize(newSize);
m_streams.resize(newSize);
}
m_requestHeaders[requestId].clear();
m_streams[requestId] = 0;
m_closeSocketOnExit[requestId] = ! (record.flags() & BeginRequestRecord::KeepConnection);
}
void SocketManager::queueSocketCheck()
{
QTimer::singleShot(0, this, SLOT(processSocketData()));
}
void SocketManager::cleanupStream(QObject* _stream)
{
QMutexLocker lock(&m_streamMutex);
Stream* stream = static_cast<Stream*>(_stream);
Q_ASSERT(m_requestMap.contains(stream));
const quint16 requestId = m_requestMap.value(stream);
m_requestMap.remove(stream);
// close and delete if the server's lazy
if(m_closeSocketOnExit.value(requestId))
{
emit finished(thread());
deleteLater();
}
m_requestHeaders[requestId].clear();
m_streams[requestId] = 0;
}
void SocketManager::respond()
{
const quint16 requestId = m_recordHeader.requestId();
Stream* stream = new Stream(m_requestHeaders[requestId], requestId, m_socket, this);
m_requestMap.insert(stream, requestId);
m_streams[requestId] = stream;
connect(
stream,
SIGNAL(destroyed(QObject*)),
SLOT(cleanupStream(QObject*))
);
// in case we have more local data...
m_recordHeader = RecordHeader();
queueSocketCheck();
// actually start the response
emit newRequest(stream);
}
bool SocketManager::processNewRecord()
{
if(m_socket->bytesAvailable() < FCGI_HEADER_LEN)
{
return false;
}
FCGI_Header fcgiHeader;
qint64 bytesRead = m_socket->read(reinterpret_cast<char*>(&fcgiHeader), FCGI_HEADER_LEN);
if(bytesRead != FCGI_HEADER_LEN)
{
qFatal("Couldn't read FCGI header - tried to read %d bytes, got %lld", FCGI_HEADER_LEN, bytesRead);
}
m_recordHeader = RecordHeader(fcgiHeader);
if(m_socket->bytesAvailable() >= m_recordHeader.payloadLength())
{
processRecordData();
}
return true;
}
}
| [
"alexey.zayats@gmail.com"
] | alexey.zayats@gmail.com |
ac6d21bac60acc2e661d546cff4bd7a4f2eecbce | 473c029a06681a339adf95263556dca2dc1741fe | /src/VM.cpp | c417992a6749d06eb970232156ffd712a2785cfd | [
"MIT"
] | permissive | preda/pepper | 1b17b55e00ecada35de115eb778c5e20cda8febb | 6834dc9e88639b32c761597b71e0de6a95461d91 | refs/heads/master | 2020-05-18T05:51:36.533135 | 2013-06-24T13:27:20 | 2013-06-24T13:27:20 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 12,297 | cpp | #include "VM.h"
#include "Array.h"
#include "Map.h"
#include "String.h"
#include "Func.h"
#include "CFunc.h"
#include "Proto.h"
#include "Value.h"
#include "Object.h"
#include "RetInfo.h"
#include "GC.h"
#include "NameValue.h"
#include "Stack.h"
#include "Decompile.h"
#include "Pepper.h"
#include "Type.h"
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <setjmp.h>
#include <math.h>
#include <stdio.h>
#define FAST_CALL 0
#define DO_CALL(f, n, regs, base, stack) ({ \
const unsigned p1 = regs - (stack)->base, p2 = base - (stack)->base;\
int ret = call(f, n, base, stack);\
regs = (stack)->base + p1; base = (stack)->base + p2;\
copyUpvals(activeFunc, regs);\
if (ret > 0 && IS_O_TYPE(f, O_FUNC)) { fprintf(stderr, "Error at bytecode #%d\n", ret-1); printFunc((Func *) GET_OBJ(f)); }\
else if (ret) { fprintf(stderr, "Error %d\n", ret); } ret; })
#define STEP code=*pc++; ptrC=regs+OC(code); A=regs[OA(code)]; B=regs[OB(code)]; goto *dispatch[OP(code)];
#define INT(x) VAL_INT((signed char)x)
inline Value doAdd(GC *gc, Value a, Value b) {
int ta = TAG(a);
if (IS_NUM_TAG(ta) && IS_NUM(b)) {
return VAL_NUM(GET_NUM(a) + GET_NUM(b));
} else if (IS_STRING(a)) {
return String::concat(gc, a, b);
} else {
if (ta != T_OBJ) { return E_WRONG_TYPE; }
int type = O_TYPE(a);
if (type == O_ARRAY && (IS_ARRAY(b) || IS_MAP(b) || IS_STRING(b))) {
Array *array = Array::alloc(gc);
array->add(a);
array->add(b);
return VAL_OBJ(array);
} else if (type == O_MAP && (IS_ARRAY(b) || IS_MAP(b) || IS_STRING(b))) {
Map *map = MAP(a)->copy(gc);
map->add(b);
return VAL_OBJ(map);
} else {
return VERR;
}
}
}
Value doMod(Value a, Value b) {
if (!IS_NUM(a) || !IS_NUM(b)) { return VERR; }
double da = GET_NUM(a);
double db = GET_NUM(b);
return VAL_NUM(da - floor(da / db) * db);
}
Value doPow(Value a, Value b) {
if(!IS_NUM(a) || !IS_NUM(b)) { return VERR; }
return VAL_NUM(pow(GET_NUM(a), GET_NUM(b)));
}
static Value doSHL(Value v, int shift) {
if (!IS_NUM(v)) { return VERR; }
if (shift < 0) { shift = 0; }
return VAL_NUM(shift >= 32 ? 0 : ((unsigned)GET_NUM(v) << shift));
}
static Value doSHR(Value v, int shift) {
if (!IS_NUM(v)) { return VERR; }
if (shift < 0) { shift = 0; }
return VAL_NUM(shift >= 32 ? 0 : ((unsigned)GET_NUM(v) >> shift));
}
static Value getSlice(GC *gc, Value a, Value b1, Value b2) {
return
IS_ARRAY(a) ? ARRAY(a)->getSliceV(gc, b1, b2) :
IS_STRING(a) ? String::getSlice(gc, a, b1, b2) :
VERR;
}
static int setSlice(Value c, Value a1, Value a2, Value b) {
if (IS_ARRAY(c)) {
ARRAY(c)->setSliceV(a1, a2, b);
return 0;
} else {
return E_NOT_SLICEABLE;
}
}
VM::VM(Pepper *pepper) :
gc(pepper->gc()),
types(0),
_pepper(pepper),
constUps{gc->EMPTY_MAP, gc->EMPTY_ARRAY, EMPTY_STRING, VAL_NUM(-1), ONE, ZERO, VNIL},
emptyArray(ARRAY(gc->EMPTY_ARRAY)),
emptyMap(MAP(gc->EMPTY_MAP))
{
}
VM::~VM() {
}
bool objEquals(Object *a, Object *b) {
unsigned atype = a->type();
if (atype == b->type()) {
switch (atype) {
case O_STR: return ((String*)a)->equals((String*)b);
case O_ARRAY: return ((Array*)a)->equals((Array*)b);
case O_MAP: return ((Map*)a)->equals((Map*)b);
}
}
return false;
}
static bool lessThanNonNum(Value a, Value b) {
if (IS_STRING(a) && IS_STRING(b)) {
char *p1 = GET_CSTR(a);
char *p2 = GET_CSTR(b);
unsigned len1 = len(a);
unsigned len2 = len(b);
int cmp = strncmp(p1, p2, min(len1, len2));
return cmp < 0 || (cmp == 0 && len1 < len2);
}
if (IS_ARRAY(a) && IS_ARRAY(b)) {
return ARRAY(a)->lessThan(ARRAY(b));
}
return false;
}
bool lessThan(Value a, Value b) {
return (IS_NUM(a) && IS_NUM(b)) ? GET_NUM(a) < GET_NUM(b) : lessThanNonNum(a, b);
}
void VM::copyUpvals(Func *f, Value *regs) {
if (f) {
unsigned nUp = f->proto->nUp();
if (nUp) {
memcpy(regs + (256 - N_CONST_UPS - nUp), f->ups, nUp * sizeof(Value));
}
memcpy(regs + (256 - N_CONST_UPS), constUps, N_CONST_UPS * sizeof(Value));
}
}
Value VM::run(Value fv, int nArg, Value *args) {
static const int nExtra = 1;
Stack stack;
Value *regs = stack.maybeGrow(0, nArg + nExtra + 1);
regs[0] = fv;
Value *base = regs + nExtra;
base[0] = VNIL;
memcpy(base+1, args, nArg * sizeof(Value));
Func *activeFunc = 0; // no active func
int err = DO_CALL(fv, nArg, regs, base, &stack);
return !err ? base[0] : VNIL;
}
#define NARGS_CFUNC 128
static int prepareStackForCall(Value *base, int nArgs, int nEffArgs, GC *gc) {
Array *tail = 0;
int tailSize = 0;
if (nEffArgs < 0) { //last arg is *args
nEffArgs = -nEffArgs;
Value v = base[nEffArgs - 1];
if (!IS_ARRAY(v)) {
fprintf(stderr, "*args in call is not Array");
__builtin_abort();
}
tail = ARRAY(v);
--nEffArgs;
tailSize = tail->size();
}
bool hasEllipsis = nArgs < 0;
if (hasEllipsis) {
nArgs = -nArgs - 1;
}
int nFromTail = clamp(nArgs - nEffArgs, 0, tailSize);
for (int i = 0; i < nFromTail; ++i) {
base[nEffArgs + i] = tail->getI(i);
}
nEffArgs += nFromTail;
if (nArgs != NARGS_CFUNC) {
for (Value *p = base + nEffArgs, *end = base + nArgs; p < end; ++p) {
*p = VNIL;
}
}
if (hasEllipsis) {
Array *a = Array::alloc(gc);
for (Value *p = base + nArgs, *end = base + nEffArgs; p < end; ++p) {
a->push(*p);
}
if (nFromTail < tailSize) {
a->append(tail->buf() + nFromTail, tailSize - nFromTail);
}
base[nArgs] = VAL_OBJ(a);
}
return nEffArgs;
}
// extern __thread jmp_buf jumpBuf;
int VM::call(Value A, int nEffArgs, Value *regs, Stack *stack) {
Vector<RetInfo> retInfo; // only used if FAST_CALL
if (!(IS_O_TYPE(A, O_FUNC) || IS_CF(A) || IS_O_TYPE(A, O_CFUNC))) { return -1; }
regs = stack->maybeGrow(regs, 256);
int nExpectedArgs = IS_O_TYPE(A, O_FUNC) ? ((Func *)GET_OBJ(A))->proto->nArgs : NARGS_CFUNC;
nEffArgs = prepareStackForCall(regs, nExpectedArgs, nEffArgs, gc);
if (IS_CF(A) || IS_O_TYPE(A, O_CFUNC)) {
if (IS_CF(A)) {
tfunc f = GET_CF(A);
*regs = f(this, CFunc::CFUNC_CALL, 0, regs, nEffArgs);
} else {
((CFunc *) GET_OBJ(A))->call(this, regs, nEffArgs);
}
return 0;
}
unsigned code = 0;
Value B;
Value *ptrC;
Func *activeFunc = (Func *) GET_OBJ(A);
unsigned *pc = (unsigned *) activeFunc->proto->code.buf();
static void *dispatch[] = {
#define _(name) &&name
#include "opcodes.inc"
#undef _
};
assert(sizeof(dispatch)/sizeof(dispatch[0]) == N_OPCODES);
copyUpvals(activeFunc, regs);
STEP;
JMP: pc += OD(code); STEP;
JT: if (!IS_FALSE(*ptrC)) { pc += OD(code); } STEP;
JF: if ( IS_FALSE(*ptrC)) { pc += OD(code); } STEP;
JLT: if (lessThan(A, B)) { pc += OSC(code); } STEP;
JNIS: if (A != B) { pc += OSC(code); } STEP;
FOR:
A = *(ptrC + 1);
B = *(ptrC + 2);
if (!IS_NUM(A) || !IS_NUM(B)) { goto error; } // E_FOR_NOT_NUMBER
*ptrC = B;
if (!(GET_NUM(B) < GET_NUM(A))) { pc += OD(code); }
STEP;
LOOP: {
const double counter = GET_NUM(*ptrC) + 1;
if (counter < GET_NUM(*(ptrC+1))) { pc += OD(code); }
*ptrC = VAL_NUM(counter);
STEP;
}
FUNC:
assert(IS_PROTO(A));
*ptrC = VAL_OBJ(Func::alloc(gc, PROTO(A), regs + 256, regs, OB(code)));
STEP;
// index, A[B]
GETI: *ptrC = types->type(A)->indexGet(A, B); if (*ptrC == VERR) { goto error; } STEP;
GETF: *ptrC = types->type(A)->fieldGet(A, B); if (*ptrC == VERR) { goto error; } STEP;
SETI: if (!types->type(*ptrC)->indexSet(*ptrC, A, B)) { goto error; } STEP;
SETF: if (!types->type(*ptrC)->fieldSet(*ptrC, A, B)) { goto error; } STEP;
/*
const int oa = OA(code);
const int ob = OB(code);
int top = max(oa, ob) + 1;
top = max(top, activeFunc->proto->localsTop);
Value *base = regs + top;
printf("top %d\n", top);
base[0] = A;
base[1] = B;
int cPos = ptrC - regs;
DO_CALL(v, 2, regs, base, stack);
regs[cPos] = base[0];
break;
if (*ptrC == VERR) { goto error; }
*/
GETS: *ptrC = getSlice(gc, A, B, regs[OB(code)+1]); if (*ptrC==VERR) { goto error; } STEP;
SETS: if (setSlice(*ptrC, A, regs[OA(code)+1], B)) { goto error; } STEP;
RET: {
regs[0] = A;
Value *root = stack->base;
gc->maybeCollect(root, regs - root + 1);
#if FAST_CALL
if (!retInfo.size()) {
return 0;
}
RetInfo *ri = retInfo.top();
pc = ri->pc;
regs = stack->base + ri->base;
activeFunc = ri->func;
retInfo.pop();
copyUpvals(activeFunc, regs);
STEP;
#else
return 0;
#endif
}
CALL: {
if (!IS_OBJ(A) && !IS_CF(A)) { goto error; } // E_CALL_NOT_FUNC
int nEffArgs = OSB(code);
assert(nEffArgs != 0);
Value *base = ptrC;
#if FAST_CALL
if (IS_O_TYPE(A, O_FUNC)) {
Func *f = (Func *) GET_OBJ(A);
Proto *proto = f->proto;
prepareStackForCall(base, proto->nArgs, nEffArgs, gc);
RetInfo *ret = retInfo.push();
ret->pc = pc;
ret->base = regs - stack->base;
ret->func = activeFunc;
regs = stack->maybeGrow(base, 256);
copyUpvals(f, regs);
pc = proto->code.buf();
activeFunc = f;
} else {
#endif
int ret = DO_CALL(A, nEffArgs, regs, base, stack);
if (ret) { goto error; }
#if FAST_CALL
}
#endif
STEP;
}
MOVEUP: {
const int slot = regs + 256 - ptrC;
activeFunc->setUp(slot, A);
}
MOVE_R: *ptrC = A; STEP;
MOVE_I: *ptrC = VAL_NUM(OD(code)); STEP;
MOVE_V: {
int id = OA(code);
*ptrC =
id == CONST_NIL ? VNIL :
id == CONST_EMPTY_STRING ? EMPTY_STRING :
id == CONST_EMPTY_ARRAY ? VAL_OBJ(emptyArray->copy(gc)) :
VAL_OBJ(emptyMap->copy(gc));
STEP;
}
MOVE_C: {
Value v = *pc | (((u64) *(pc+1)) << 32);
pc += 2;
if (IS_ARRAY(v)) {
v = VAL_OBJ(ARRAY(v)->copy(gc));
} else if (IS_MAP(v)) {
v = VAL_OBJ(MAP(v)->copy(gc));
}
*ptrC = v;
STEP;
}
LEN: *ptrC = VAL_NUM(len(A)); STEP;
NOTL: *ptrC = IS_FALSE(A) ? TRUE : FALSE; STEP;
// notb: *ptrC = IS_INT(A)? VAL_INT(~getInteger(A)):ERROR(E_WRONG_TYPE); STEP;
ADD: *ptrC = doAdd(gc, A, B); if (*ptrC == VERR) { goto error; } STEP;
SUB: *ptrC = BINOP(-, A, B); STEP;
MUL: *ptrC = BINOP(*, A, B); STEP;
DIV: *ptrC = BINOP(/, A, B); STEP;
MOD: *ptrC = doMod(A, B); if (*ptrC == VERR) { goto error; } STEP;
POW: *ptrC = doPow(A, B); if (*ptrC == VERR) { goto error; } STEP;
AND: *ptrC = BITOP(&, A, B); STEP;
OR: *ptrC = BITOP(|, A, B); STEP;
XOR: *ptrC = BITOP(^, A, B); STEP;
SHL_RR: ERR(!IS_NUM(B), E_WRONG_TYPE); *ptrC = doSHL(A, (int)GET_NUM(B)); STEP;
SHR_RR: ERR(!IS_NUM(B), E_WRONG_TYPE); *ptrC = doSHR(A, (int)GET_NUM(B)); STEP;
SHL_RI: *ptrC = doSHL(A, OSB(code)); STEP;
SHR_RI: *ptrC = doSHR(A, OSB(code)); STEP;
EQ: *ptrC = equals(A, B) ? TRUE : FALSE; STEP;
NEQ: *ptrC = !equals(A, B) ? TRUE : FALSE; STEP;
IS: *ptrC = A == B ? TRUE : FALSE; STEP;
NIS: *ptrC = A != B ? TRUE : FALSE; STEP;
LT: *ptrC = lessThan(A, B) ? TRUE : FALSE; STEP;
LE: *ptrC = (equals(A, B) || lessThan(A, B)) ? TRUE : FALSE; STEP;
error: return pc - (unsigned *) activeFunc->proto->code.buf();
}
bool opcodeHasDest(int op) {
switch (op) {
case JMP:
case CALL:
case RET:
case SETI:
case SETF:
return false;
}
return true;
}
| [
"mhpreda@gmail.com"
] | mhpreda@gmail.com |
d3e5637ba12d0648441417ba97cbb06e6fc3dbd0 | f0b7bcc41298354b471a72a7eeafe349aa8655bf | /codebase/apps/mm5/src/MM5Split/MM5Split.cc | a215139112d2d51ae1a69170f04e8a351a4eb091 | [
"BSD-3-Clause"
] | permissive | NCAR/lrose-core | 23abeb4e4f1b287725dc659fb566a293aba70069 | be0d059240ca442883ae2993b6aa112011755688 | refs/heads/master | 2023-09-01T04:01:36.030960 | 2023-08-25T00:41:16 | 2023-08-25T00:41:16 | 51,408,988 | 90 | 53 | NOASSERTION | 2023-08-18T21:59:40 | 2016-02-09T23:36:25 | C++ | UTF-8 | C++ | false | false | 7,335 | cc | // *=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*
// ** Copyright UCAR (c) 1990 - 2016
// ** University Corporation for Atmospheric Research (UCAR)
// ** National Center for Atmospheric Research (NCAR)
// ** Boulder, Colorado, USA
// ** BSD licence applies - redistribution and use in source and binary
// ** forms, with or without modification, are permitted provided that
// ** the following conditions are met:
// ** 1) If the software is modified to produce derivative works,
// ** such modified software should be clearly marked, so as not
// ** to confuse it with the version available from UCAR.
// ** 2) Redistributions of source code must retain the above copyright
// ** notice, this list of conditions and the following disclaimer.
// ** 3) 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.
// ** 4) Neither the name of UCAR nor the names of its contributors,
// ** if any, may be used to endorse or promote products derived from
// ** this software without specific prior written permission.
// ** DISCLAIMER: THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS
// ** OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
// ** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
// *=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*
///////////////////////////////////////////////////////////////
// MM5Split.cc
//
// MM5Split object
//
// Mike Dixon, RAP, NCAR, P.O.Box 3000, Boulder, CO, 80307-3000, USA
//
// Nov 1999
//
///////////////////////////////////////////////////////////////
#include <toolsa/umisc.h>
#include <toolsa/pmu.h>
#include <toolsa/Path.hh>
#include <toolsa/file_io.h>
#include <toolsa/DateTime.hh>
#include <didss/DsInputPath.hh>
#include <mm5/MM5Data.hh>
#include <cstdio>
#include <cerrno>
#include <sys/stat.h>
#include "MM5Split.hh"
#include "SplitV2.hh"
#include "SplitV3.hh"
using namespace std;
// Constructor
MM5Split::MM5Split(int argc, char **argv)
{
OK = TRUE;
_input = NULL;
// set programe name
_progName = "MM5Split";
ucopyright((char *) _progName.c_str());
// get command line args
if (_args.parse(argc, argv, _progName)) {
fprintf(stderr, "ERROR: %s\n", _progName.c_str());
fprintf(stderr, "Problem with command line args\n");
OK = FALSE;
return;
}
// get TDRP params
_paramsPath = (char *) "unknown";
if (_params.loadFromArgs(argc, argv,
_args.override.list,
&_paramsPath)) {
fprintf(stderr, "ERROR: %s\n", _progName.c_str());
fprintf(stderr, "Problem with TDRP parameters\n");
OK = FALSE;
return;
}
// set up input object
if (_params.mode == Params::REALTIME) {
_input = new DsInputPath(_progName,
_params.debug,
_params.input_dir,
_params.max_realtime_valid_age,
PMU_auto_register,
_params.latest_data_info_avail);
} else {
_input = new DsInputPath(_progName,
_params.debug,
_args.inputFileList);
}
// init process mapper registration
PMU_auto_init(_progName.c_str(), _params.instance,
PROCMAP_REGISTER_INTERVAL);
}
// destructor
MM5Split::~MM5Split()
{
if (_input) {
delete _input;
}
// unregister process
PMU_auto_unregister();
}
//////////////////////////////////////////////////
// Run
int MM5Split::Run ()
{
int iret = 0;
PMU_auto_register("MM5Split::Run");
char *input_path = NULL;
while((input_path = _input->next()) != NULL) {
int version;
if (MM5Data::getVersion(input_path, version)) {
iret = -1;
continue;
}
if (_params.debug) {
cerr << " File is mm5 output version: " << version << endl;
}
// if requested, find and print out fortran record headers
if (_params.find_fortran_records) {
if (_findFortRecs(input_path)) {
iret = -1;
}
continue;
}
// create and use split objects
if (version == 2) {
SplitV2 split(_progName, _params, input_path);
if (split.doSplit()) {
iret = -1;
}
} else {
SplitV3 split(_progName, _params, input_path);
if (split.doSplit()) {
iret = -1;
}
}
} // while
return iret;
}
//////////////////////////////////
// Find the FORTRAN record headers
//
// Returns 0 on success, -1 on failure
int MM5Split::_findFortRecs(const char *input_path)
{
// open the file
FILE *in;
if ((in = fopen(input_path, "rb")) == NULL) {
int errNum = errno;
cerr << "ERROR - MM5Split::_findFortRecs" << endl;
cerr << " Cannot open input file: " << input_path << endl;
cerr << " " << strerror(errNum) << endl;
return -1;
}
while (!feof(in)) {
long start_reclen = _readFortRecLen(in);
if (start_reclen < 0) {
break;
}
cout << "Start F rec len: " << start_reclen << endl;
fseek(in, start_reclen, SEEK_CUR);
long end_reclen = _readFortRecLen(in);
if (end_reclen < 0) {
break;
}
cout << "End F rec len: " << end_reclen << endl;
cout << "=============================" << endl;
if (start_reclen != end_reclen) {
cerr << "ERROR - start and end reclen not the same" << endl;
fclose(in);
return -1;
}
}
fclose(in);
return 0;
}
///////////////////////////////
// _readFortRecLen()
//
// Read a fortran record length
//
long MM5Split::_readFortRecLen(FILE *in)
{
si32 reclen;
if (ufread(&reclen, sizeof(si32), 1, in) != 1) {
if (feof(in)) {
return -1;
}
int errNum = errno;
cerr << "ERROR - SplitV3::_readFortRecLen" << endl;
cerr << "Cannot read fortran rec len" << endl;
cerr << " " << strerror(errNum) << endl;
return -1;
}
BE_to_array_32(&reclen, sizeof(si32));
if (_params.debug >= Params::DEBUG_VERBOSE) {
fprintf(stderr, " Fortran rec len: %d\n", reclen);
}
return reclen;
}
///////////////////////////////
// copyBuffer()
//
// copy a buffer from one file to another
//
// Returns 0 on success, -1 on failure
int MM5Split::copyBuffer(FILE *in, FILE *out,
long in_offset,
long nbytes)
{
int bufsize = BUFSIZ;
ui08 buf[BUFSIZ];
// copy over the data set
fseek(in, in_offset, SEEK_SET);
long nleft = nbytes;
while (nleft > 0) {
if (nleft < BUFSIZ) {
bufsize = nleft;
}
if (ufread(buf, 1, bufsize, in) != bufsize) {
int errNum = errno;
cerr << "ERROR - MM5Split::copyBuffer" << endl;
cerr << " Cannot read for buffer copy" << endl;
cerr << " " << strerror(errNum) << endl;
return -1;
}
if (ufwrite(buf, 1, bufsize, out) != bufsize) {
int errNum = errno;
cerr << "ERROR - MM5Split::copyBuffer" << endl;
cerr << " Cannot write to buffer" << endl;
cerr << " " << strerror(errNum) << endl;
return -1;
}
nleft -= bufsize;
}
return 0;
}
| [
"dixon@ucar.edu"
] | dixon@ucar.edu |
855bb27eabddba91b90da006b48f1b774fde422e | 28ad42397234dd0b756b9d740dbc6923e98cfc32 | /Source/EscapeRoom_CM/EscapeRoom_CMCharacter.cpp | 84d95331f5a5e71dc6f648a8b152fd1b4e1370e3 | [] | no_license | Dragnyl/TP_EscapeRoom | 3e9f0384a289361f12eecee5651902847ed4e4eb | 9a88dfb85482403e1d9d8e73a3254ef24ce3c007 | refs/heads/master | 2021-01-11T19:18:57.252029 | 2017-01-25T16:43:09 | 2017-01-25T16:43:09 | 79,352,319 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,269 | cpp | // Copyright 1998-2016 Epic Games, Inc. All Rights Reserved.
#include "EscapeRoom_CM.h"
#include "EscapeRoom_CMCharacter.h"
#include "EscapeRoom_CMProjectile.h"
#include "Animation/AnimInstance.h"
#include "GameFramework/InputSettings.h"
#include "Kismet/HeadMountedDisplayFunctionLibrary.h"
#include "MotionControllerComponent.h"
DEFINE_LOG_CATEGORY_STATIC(LogFPChar, Warning, All);
//////////////////////////////////////////////////////////////////////////
// AEscapeRoom_CMCharacter
AEscapeRoom_CMCharacter::AEscapeRoom_CMCharacter()
{
// Set size for collision capsule
GetCapsuleComponent()->InitCapsuleSize(55.f, 96.0f);
// set our turn rates for input
BaseTurnRate = 45.f;
BaseLookUpRate = 45.f;
// Create a CameraComponent
FirstPersonCameraComponent = CreateDefaultSubobject<UCameraComponent>(TEXT("FirstPersonCamera"));
FirstPersonCameraComponent->SetupAttachment(GetCapsuleComponent());
FirstPersonCameraComponent->RelativeLocation = FVector(-39.56f, 1.75f, 64.f); // Position the camera
FirstPersonCameraComponent->bUsePawnControlRotation = true;
// Create a mesh component that will be used when being viewed from a '1st person' view (when controlling this pawn)
Mesh1P = CreateDefaultSubobject<USkeletalMeshComponent>(TEXT("CharacterMesh1P"));
Mesh1P->SetOnlyOwnerSee(true);
Mesh1P->SetupAttachment(FirstPersonCameraComponent);
Mesh1P->bCastDynamicShadow = false;
Mesh1P->CastShadow = false;
Mesh1P->RelativeRotation = FRotator(1.9f, -19.19f, 5.2f);
Mesh1P->RelativeLocation = FVector(-0.5f, -4.4f, -155.7f);
// Create a gun mesh component
FP_Gun = CreateDefaultSubobject<USkeletalMeshComponent>(TEXT("FP_Gun"));
FP_Gun->SetOnlyOwnerSee(true); // only the owning player will see this mesh
FP_Gun->bCastDynamicShadow = false;
FP_Gun->CastShadow = false;
// FP_Gun->SetupAttachment(Mesh1P, TEXT("GripPoint"));
FP_Gun->SetupAttachment(RootComponent);
FP_MuzzleLocation = CreateDefaultSubobject<USceneComponent>(TEXT("MuzzleLocation"));
FP_MuzzleLocation->SetupAttachment(FP_Gun);
FP_MuzzleLocation->SetRelativeLocation(FVector(0.2f, 48.4f, -10.6f));
// Default offset from the character location for projectiles to spawn
GunOffset = FVector(100.0f, 0.0f, 10.0f);
// Note: The ProjectileClass and the skeletal mesh/anim blueprints for Mesh1P, FP_Gun, and VR_Gun
// are set in the derived blueprint asset named MyCharacter to avoid direct content references in C++.
// Create VR Controllers.
R_MotionController = CreateDefaultSubobject<UMotionControllerComponent>(TEXT("R_MotionController"));
R_MotionController->Hand = EControllerHand::Right;
R_MotionController->SetupAttachment(RootComponent);
L_MotionController = CreateDefaultSubobject<UMotionControllerComponent>(TEXT("L_MotionController"));
L_MotionController->SetupAttachment(RootComponent);
// Create a gun and attach it to the right-hand VR controller.
// Create a gun mesh component
VR_Gun = CreateDefaultSubobject<USkeletalMeshComponent>(TEXT("VR_Gun"));
VR_Gun->SetOnlyOwnerSee(true); // only the owning player will see this mesh
VR_Gun->bCastDynamicShadow = false;
VR_Gun->CastShadow = false;
VR_Gun->SetupAttachment(R_MotionController);
VR_Gun->SetRelativeRotation(FRotator(0.0f, -90.0f, 0.0f));
VR_MuzzleLocation = CreateDefaultSubobject<USceneComponent>(TEXT("VR_MuzzleLocation"));
VR_MuzzleLocation->SetupAttachment(VR_Gun);
VR_MuzzleLocation->SetRelativeLocation(FVector(0.000004, 53.999992, 10.000000));
VR_MuzzleLocation->SetRelativeRotation(FRotator(0.0f, 90.0f, 0.0f)); // Counteract the rotation of the VR gun model.
// Uncomment the following line to turn motion controllers on by default:
//bUsingMotionControllers = true;
}
void AEscapeRoom_CMCharacter::BeginPlay()
{
// Call the base class
Super::BeginPlay();
//Attach gun mesh component to Skeleton, doing it here because the skeleton is not yet created in the constructor
FP_Gun->AttachToComponent(Mesh1P, FAttachmentTransformRules(EAttachmentRule::SnapToTarget, true), TEXT("GripPoint"));
// Show or hide the two versions of the gun based on whether or not we're using motion controllers.
if (bUsingMotionControllers)
{
VR_Gun->SetHiddenInGame(false, true);
Mesh1P->SetHiddenInGame(true, true);
}
else
{
VR_Gun->SetHiddenInGame(true, true);
Mesh1P->SetHiddenInGame(false, true);
}
}
//////////////////////////////////////////////////////////////////////////
// Input
void AEscapeRoom_CMCharacter::SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent)
{
// set up gameplay key bindings
check(PlayerInputComponent);
PlayerInputComponent->BindAction("Jump", IE_Pressed, this, &ACharacter::Jump);
PlayerInputComponent->BindAction("Jump", IE_Released, this, &ACharacter::StopJumping);
PlayerInputComponent->BindAction("Fire", IE_Pressed, this, &AEscapeRoom_CMCharacter::OnFire);
PlayerInputComponent->BindAction("ResetVR", IE_Pressed, this, &AEscapeRoom_CMCharacter::OnResetVR);
PlayerInputComponent->BindAxis("MoveForward", this, &AEscapeRoom_CMCharacter::MoveForward);
PlayerInputComponent->BindAxis("MoveRight", this, &AEscapeRoom_CMCharacter::MoveRight);
// We have 2 versions of the rotation bindings to handle different kinds of devices differently
// "turn" handles devices that provide an absolute delta, such as a mouse.
// "turnrate" is for devices that we choose to treat as a rate of change, such as an analog joystick
PlayerInputComponent->BindAxis("Turn", this, &APawn::AddControllerYawInput);
PlayerInputComponent->BindAxis("TurnRate", this, &AEscapeRoom_CMCharacter::TurnAtRate);
PlayerInputComponent->BindAxis("LookUp", this, &APawn::AddControllerPitchInput);
PlayerInputComponent->BindAxis("LookUpRate", this, &AEscapeRoom_CMCharacter::LookUpAtRate);
}
void AEscapeRoom_CMCharacter::OnFire()
{
// try and fire a projectile
if (ProjectileClass != NULL)
{
UWorld* const World = GetWorld();
if (World != NULL)
{
if (bUsingMotionControllers)
{
const FRotator SpawnRotation = VR_MuzzleLocation->GetComponentRotation();
const FVector SpawnLocation = VR_MuzzleLocation->GetComponentLocation();
World->SpawnActor<AEscapeRoom_CMProjectile>(ProjectileClass, SpawnLocation, SpawnRotation);
}
else
{
const FRotator SpawnRotation = GetControlRotation();
// MuzzleOffset is in camera space, so transform it to world space before offsetting from the character location to find the final muzzle position
const FVector SpawnLocation = ((FP_MuzzleLocation != nullptr) ? FP_MuzzleLocation->GetComponentLocation() : GetActorLocation()) + SpawnRotation.RotateVector(GunOffset);
//Set Spawn Collision Handling Override
FActorSpawnParameters ActorSpawnParams;
ActorSpawnParams.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AdjustIfPossibleButDontSpawnIfColliding;
// spawn the projectile at the muzzle
World->SpawnActor<AEscapeRoom_CMProjectile>(ProjectileClass, SpawnLocation, SpawnRotation, ActorSpawnParams);
}
}
}
// try and play the sound if specified
if (FireSound != NULL)
{
UGameplayStatics::PlaySoundAtLocation(this, FireSound, GetActorLocation());
}
// try and play a firing animation if specified
if (FireAnimation != NULL)
{
// Get the animation object for the arms mesh
UAnimInstance* AnimInstance = Mesh1P->GetAnimInstance();
if (AnimInstance != NULL)
{
AnimInstance->Montage_Play(FireAnimation, 1.f);
}
}
}
void AEscapeRoom_CMCharacter::OnResetVR()
{
UHeadMountedDisplayFunctionLibrary::ResetOrientationAndPosition();
}
void AEscapeRoom_CMCharacter::MoveForward(float Value)
{
if (Value != 0.0f)
{
// add movement in that direction
AddMovementInput(GetActorForwardVector(), Value);
}
}
void AEscapeRoom_CMCharacter::MoveRight(float Value)
{
if (Value != 0.0f)
{
// add movement in that direction
AddMovementInput(GetActorRightVector(), Value);
}
}
void AEscapeRoom_CMCharacter::TurnAtRate(float Rate)
{
// calculate delta for this frame from the rate information
AddControllerYawInput(Rate * BaseTurnRate * GetWorld()->GetDeltaSeconds());
}
void AEscapeRoom_CMCharacter::LookUpAtRate(float Rate)
{
// calculate delta for this frame from the rate information
AddControllerPitchInput(Rate * BaseLookUpRate * GetWorld()->GetDeltaSeconds());
}
| [
"cmorganx@hotmail.fr"
] | cmorganx@hotmail.fr |
ce53a84def127cb3350e707dab6f458e51e555f7 | ad4268fca6ac3bb9a356b2a50c742b269f76f0aa | /src/test/sighash_tests.cpp | 7cd160e4ae5b5be9e44faefe3869a33644f7b24e | [
"MIT"
] | permissive | bnxxbitcoinnexx/bitcoinnexx-core | 3af6af089d5282ad9dfce6d23041a82628f901fb | c1522c0f95a0b27989dbe8c08d2a3b1055a9ddb1 | refs/heads/master | 2022-12-07T12:18:54.792384 | 2020-08-27T10:59:22 | 2020-08-27T10:59:22 | 283,929,104 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,953 | cpp | // Copyright (c) 2013 The Bitcoin Core developers
// Copyright (c) 2017 The PIVX developers
// Copyright (c) 2019 The BitcoinNexx developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "data/sighash.json.h"
#include "main.h"
#include "random.h"
#include "serialize.h"
#include "script/script.h"
#include "script/interpreter.h"
#include "util.h"
#include "version.h"
#include <iostream>
#include <boost/test/unit_test.hpp>
#include <univalue.h>
extern UniValue read_json(const std::string& jsondata);
// Old script.cpp SignatureHash function
uint256 static SignatureHashOld(CScript scriptCode, const CTransaction& txTo, unsigned int nIn, int nHashType)
{
if (nIn >= txTo.vin.size())
{
printf("ERROR: SignatureHash() : nIn=%d out of range\n", nIn);
return 1;
}
CMutableTransaction txTmp(txTo);
// In case concatenating two scripts ends up with two codeseparators,
// or an extra one at the end, this prevents all those possible incompatibilities.
scriptCode.FindAndDelete(CScript(OP_CODESEPARATOR));
// Blank out other inputs' signatures
for (unsigned int i = 0; i < txTmp.vin.size(); i++)
txTmp.vin[i].scriptSig = CScript();
txTmp.vin[nIn].scriptSig = scriptCode;
// Blank out some of the outputs
if ((nHashType & 0x1f) == SIGHASH_NONE)
{
// Wildcard payee
txTmp.vout.clear();
// Let the others update at will
for (unsigned int i = 0; i < txTmp.vin.size(); i++)
if (i != nIn)
txTmp.vin[i].nSequence = 0;
}
else if ((nHashType & 0x1f) == SIGHASH_SINGLE)
{
// Only lock-in the txout payee at same index as txin
unsigned int nOut = nIn;
if (nOut >= txTmp.vout.size())
{
printf("ERROR: SignatureHash() : nOut=%d out of range\n", nOut);
return 1;
}
txTmp.vout.resize(nOut+1);
for (unsigned int i = 0; i < nOut; i++)
txTmp.vout[i].SetNull();
// Let the others update at will
for (unsigned int i = 0; i < txTmp.vin.size(); i++)
if (i != nIn)
txTmp.vin[i].nSequence = 0;
}
// Blank out other inputs completely, not recommended for open transactions
if (nHashType & SIGHASH_ANYONECANPAY)
{
txTmp.vin[0] = txTmp.vin[nIn];
txTmp.vin.resize(1);
}
// Serialize and hash
CHashWriter ss(SER_GETHASH, 0);
ss << txTmp << nHashType;
return ss.GetHash();
}
void static RandomScript(CScript &script) {
static const opcodetype oplist[] = {OP_FALSE, OP_1, OP_2, OP_3, OP_CHECKSIG, OP_IF, OP_VERIF, OP_RETURN, OP_CODESEPARATOR};
script = CScript();
int ops = (insecure_rand() % 10);
for (int i=0; i<ops; i++)
script << oplist[insecure_rand() % (sizeof(oplist)/sizeof(oplist[0]))];
}
void static RandomTransaction(CMutableTransaction &tx, bool fSingle) {
tx.nVersion = insecure_rand();
tx.vin.clear();
tx.vout.clear();
tx.nLockTime = (insecure_rand() % 2) ? insecure_rand() : 0;
int ins = (insecure_rand() % 4) + 1;
int outs = fSingle ? ins : (insecure_rand() % 4) + 1;
for (int in = 0; in < ins; in++) {
tx.vin.push_back(CTxIn());
CTxIn &txin = tx.vin.back();
txin.prevout.hash = GetRandHash();
txin.prevout.n = insecure_rand() % 4;
RandomScript(txin.scriptSig);
txin.nSequence = (insecure_rand() % 2) ? insecure_rand() : (unsigned int)-1;
}
for (int out = 0; out < outs; out++) {
tx.vout.push_back(CTxOut());
CTxOut &txout = tx.vout.back();
txout.nValue = insecure_rand() % 100000000;
RandomScript(txout.scriptPubKey);
}
}
BOOST_AUTO_TEST_SUITE(sighash_tests)
BOOST_AUTO_TEST_CASE(sighash_test)
{
seed_insecure_rand(false);
#if defined(PRINT_SIGHASH_JSON)
std::cout << "[\n";
std::cout << "\t[\"raw_transaction, script, input_index, hashType, signature_hash (result)\"],\n";
#endif
int nRandomTests = 50000;
#if defined(PRINT_SIGHASH_JSON)
nRandomTests = 500;
#endif
for (int i=0; i<nRandomTests; i++) {
int nHashType = insecure_rand();
CMutableTransaction txTo;
RandomTransaction(txTo, (nHashType & 0x1f) == SIGHASH_SINGLE);
CScript scriptCode;
RandomScript(scriptCode);
int nIn = insecure_rand() % txTo.vin.size();
uint256 sh, sho;
sho = SignatureHashOld(scriptCode, txTo, nIn, nHashType);
sh = SignatureHash(scriptCode, txTo, nIn, nHashType);
#if defined(PRINT_SIGHASH_JSON)
CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
ss << txTo;
std::cout << "\t[\"" ;
std::cout << HexStr(ss.begin(), ss.end()) << "\", \"";
std::cout << HexStr(scriptCode) << "\", ";
std::cout << nIn << ", ";
std::cout << nHashType << ", \"";
std::cout << sho.GetHex() << "\"]";
if (i+1 != nRandomTests) {
std::cout << ",";
}
std::cout << "\n";
#endif
BOOST_CHECK(sh == sho);
}
#if defined(PRINT_SIGHASH_JSON)
std::cout << "]\n";
#endif
}
// Goal: check that SignatureHash generates correct hash
BOOST_AUTO_TEST_CASE(sighash_from_data)
{
UniValue tests = read_json(std::string(json_tests::sighash, json_tests::sighash + sizeof(json_tests::sighash)));
for (unsigned int idx = 0; idx < tests.size(); idx++) {
UniValue test = tests[idx];
std::string strTest = test.write();
if (test.size() < 1) // Allow for extra stuff (useful for comments)
{
BOOST_ERROR("Bad test: " << strTest);
continue;
}
if (test.size() == 1) continue; // comment
std::string raw_tx, raw_script, sigHashHex;
int nIn, nHashType;
uint256 sh;
CTransaction tx;
CScript scriptCode = CScript();
try {
// deserialize test data
raw_tx = test[0].get_str();
raw_script = test[1].get_str();
nIn = test[2].get_int();
nHashType = test[3].get_int();
sigHashHex = test[4].get_str();
uint256 sh;
CDataStream stream(ParseHex(raw_tx), SER_NETWORK, PROTOCOL_VERSION);
stream >> tx;
CValidationState state;
BOOST_CHECK_MESSAGE(CheckTransaction(tx, false, false, state), strTest);
BOOST_CHECK(state.IsValid());
std::vector<unsigned char> raw = ParseHex(raw_script);
scriptCode.insert(scriptCode.end(), raw.begin(), raw.end());
} catch (...) {
BOOST_ERROR("Bad test, couldn't deserialize data: " << strTest);
continue;
}
sh = SignatureHash(scriptCode, tx, nIn, nHashType);
BOOST_CHECK_MESSAGE(sh.GetHex() == sigHashHex, strTest);
}
}
BOOST_AUTO_TEST_SUITE_END()
| [
"bitcoinnexx7@gmail.com"
] | bitcoinnexx7@gmail.com |
b2d28106302b7bd95c2fb3781ea222b5257b25cc | a55372600d9da8c8b857bb2b8257c0b887276019 | /core/platform/include/platform/common/unsupported-operation.hpp | 1c2ba3846248acec3b342b7e0545a4ff5b8b4d44 | [] | no_license | epfl-dias/proteus | 75ae8036f19b9a41f295903233f08beecd28fa86 | 575c0bcfc5d280d2d1c98c0a907302c5ad9d5b22 | refs/heads/main | 2023-09-03T16:23:07.999208 | 2023-08-18T22:31:29 | 2023-08-19T00:19:09 | 158,891,236 | 8 | 3 | null | null | null | null | UTF-8 | C++ | false | false | 2,050 | hpp | /*
Proteus -- High-performance query processing on heterogeneous hardware.
Copyright (c) 2021
Data Intensive Applications and Systems Laboratory (DIAS)
École Polytechnique Fédérale de Lausanne
All Rights Reserved.
Permission to use, copy, modify and distribute this software and
its documentation is hereby granted, provided that both the
copyright notice and this permission notice appear in all copies of
the software, derivative works or modified versions, and any
portions thereof, and that both notices appear in supporting
documentation.
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. THE AUTHORS
DISCLAIM ANY LIABILITY OF ANY KIND FOR ANY DAMAGES WHATSOEVER
RESULTING FROM THE USE OF THIS SOFTWARE.
*/
#ifndef PROTEUS_UNSUPPORTED_OPERATION_HPP
#define PROTEUS_UNSUPPORTED_OPERATION_HPP
#include <exception>
#include <sstream>
#include <string>
namespace proteus {
class unsupported_operation : public std::exception {
// shared_ptr as exceptions are not allowed to throw during copy
std::shared_ptr<std::string> msg;
public:
unsupported_operation(std::string msg)
: msg(std::make_shared<std::string>(std::move(msg))) {}
[[nodiscard]] const char* what() const noexcept override {
return msg->c_str();
}
};
class abort : public std::runtime_error {
public:
abort() : runtime_error("tx abort") {}
};
class runtime_error : public std::runtime_error {
protected:
explicit runtime_error(std::string msg)
: std::runtime_error(std::move(msg)) {}
public:
runtime_error() : runtime_error("") {}
template <typename T>
[[nodiscard]] inline runtime_error operator<<(const T& v) {
std::stringstream ss;
ss << what() << v;
return runtime_error{ss.str()};
}
};
} // namespace proteus
#endif // PROTEUS_UNSUPPORTED_OPERATION_HPP
| [
"periklis93@yahoo.gr"
] | periklis93@yahoo.gr |
d2cad1bbeed041d273eb77db4db1657ab0110683 | 877fff5bb313ccd23d1d01bf23b1e1f2b13bb85a | /app/src/main/cpp/dir521/dir522/dir572/dir1838/dir1839/dir2043/file2179.cpp | 5bfdec06108a0f0d753ce5f23f592475b8a89982 | [] | no_license | tgeng/HugeProject | 829c3bdfb7cbaf57727c41263212d4a67e3eb93d | 4488d3b765e8827636ce5e878baacdf388710ef2 | refs/heads/master | 2022-08-21T16:58:54.161627 | 2020-05-28T01:54:03 | 2020-05-28T01:54:03 | 267,468,475 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 111 | cpp | #ifndef file2179
#error "macro file2179 must be defined"
#endif
static const char* file2179String = "file2179"; | [
"tgeng@google.com"
] | tgeng@google.com |
58e20d14d1fc907fc2c01eaf41f63953b4d42d1e | eee0588d6c92b1bc093716ac84969a47a8159e38 | /Cluiche/UnitTests/Tests/Application/UnitTestApplication.h | cdc755507de04abb0e903bada35759b2d9fd4ec5 | [] | no_license | LenihanConor/Cluiche | bf919ef721d901ba2a23646e70444803e0fe5781 | 1b65c5861a2354a81fbf1ed63fb0e7620b635d0d | refs/heads/master | 2023-06-28T19:45:52.811023 | 2023-06-20T18:20:58 | 2023-06-20T18:20:58 | 37,433,420 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 266 | h | #pragma once
#include "UnitTests/Tests/Core/UnitTestCore.h"
namespace UnitTests
{
class UnitTestApplication: public UnitTestCore
{
public:
UnitTestApplication(const Dia::Core::Containers::String32& name);
UnitTestApplication(void);
void DoTest();
};
} | [
"lenihan.conor@gmail.com"
] | lenihan.conor@gmail.com |
4d90a4e99c6eac489a58a095cf85ef379bb073b0 | df7828c62e02cc5cb91239b3802b851bca377b0d | /experiment/tests/test_tag_lgp.cc | 6d76403b724f5ff1144a7ed9d4c0ec0a44573df9 | [
"MIT"
] | permissive | amlalejini/gp-tag-accessed-memory | 8e314e8d1cecaf046e6c7417c92d9de04fb4cedf | 197f0208bfe2e526b6f320987c08acd32944f57a | refs/heads/master | 2020-04-15T03:29:20.149745 | 2019-04-30T15:26:08 | 2019-04-30T15:26:08 | 164,350,786 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 131,868 | cc | #define CATCH_CONFIG_MAIN
#include "third-party/Catch/single_include/catch.hpp"
#include <iostream>
#include <cmath>
#include "base/Ptr.h"
#include "base/vector.h"
#include "tools/Random.h"
#include "TagLinearGP.h"
#include "TagLinearGP_InstLib.h"
#include "TagLinearGP_Utilities.h"
#include "Utilities.h"
// String => number; number=>string conversion
// - If str.numeric: return double(str)
// else: return 0.0
// Number to string
// return to_string(number)
/*
TEST_CASE("Inst_Add", "[taglgp]") {
// Constants
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 2;
// Convenient aliases
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
using callstate_t = typename hardware_t::CallState;
using memory_t = typename hardware_t::Memory;
// Create new random number generator
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
// Create new instruction library
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
// Create virtual hardware w/inst_lib
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix);
// Create new program
program_t prog(inst_lib);
/////////////////////////////////////
// Instruction testing
inst_lib->AddInst("Add", hardware_t::Inst_Add, 3, "mem[C] = mem[A] + mem[B]");
// RND + RND = (RND + RND)
for (size_t i = 0; i < 1000; ++i) {
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
const size_t posA = random->GetUInt(0, matrix.size());
const size_t posB = random->GetUInt(0, matrix.size());
const size_t posC = random->GetUInt(0, matrix.size());
prog.PushInst("Add", {matrix[posA], matrix[posB], matrix[posC]});
cpu.SetProgram(prog);
cpu.CallModule(0);
callstate_t & state = cpu.GetCurCallState();
memory_t & wmem = state.GetWorkingMem();
const double A = (double)random->GetInt(-1000, 1000);
const double B = (double)random->GetInt(-1000, 1000);
const double C = (posA != posB) ? A + B : B + B;
wmem.Set(posA, A);
wmem.Set(posB, B);
cpu.SingleProcess();
double memC = wmem.AccessVal(posC).GetNum();
if (memC != C) {
cpu.PrintHardwareState();
std::cout << "posA = " << posA << "; posB = " << posB << "; posC = " << posC << std::endl;
std::cout << "A = " << A << "; B = " << B << "; C = " << C << std::endl;
}
REQUIRE(memC == C);
}
/////////////////////////////////////
// Clean up
inst_lib.Delete();
random.Delete();
}
TEST_CASE("Inst_Sub", "[taglgp]") {
// Constants
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 3;
// Convenient aliases
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
using callstate_t = typename hardware_t::CallState;
using memory_t = typename hardware_t::Memory;
// Create new random number generator
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
// Create new instruction library
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
// Create virtual hardware w/inst_lib
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix);
// Create new program
program_t prog(inst_lib);
/////////////////////////////////////
// Instruction testing
inst_lib->AddInst("Sub", hardware_t::Inst_Sub, 3, "mem[C] = mem[A] - mem[B]");
// RND + RND = (RND + RND)
for (size_t i = 0; i < 1000; ++i) {
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
const size_t posA = random->GetUInt(0, matrix.size());
const size_t posB = random->GetUInt(0, matrix.size());
const size_t posC = random->GetUInt(0, matrix.size());
prog.PushInst("Sub", {matrix[posA], matrix[posB], matrix[posC]});
cpu.SetProgram(prog);
cpu.CallModule(0);
callstate_t & state = cpu.GetCurCallState();
memory_t & wmem = state.GetWorkingMem();
const double A = (double)random->GetInt(-1000, 1000);
const double B = (double)random->GetInt(-1000, 1000);
const double C = (posA != posB) ? A - B : B - B;
wmem.Set(posA, A);
wmem.Set(posB, B);
cpu.SingleProcess();
double memC = wmem.AccessVal(posC).GetNum();
if (memC != C) {
cpu.GetProgram().Print();
cpu.PrintHardwareState();
std::cout << "posA = " << posA << "; posB = " << posB << "; posC = " << posC << std::endl;
std::cout << "A = " << A << "; B = " << B << "; C = " << C << std::endl;
}
REQUIRE(memC == C);
}
}
TEST_CASE("Inst_Mult", "[taglgp]") {
// Constants
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 4;
// Convenient aliases
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
using callstate_t = typename hardware_t::CallState;
using memory_t = typename hardware_t::Memory;
// Create new random number generator
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
// Create new instruction library
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
// Create virtual hardware w/inst_lib
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix);
// Create new program
program_t prog(inst_lib);
/////////////////////////////////////
// Instruction testing
inst_lib->AddInst("Mult", hardware_t::Inst_Mult, 3, "mem[C] = mem[A] * mem[B]");
// RND + RND = (RND + RND)
for (size_t i = 0; i < 1000; ++i) {
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
const size_t posA = random->GetUInt(0, matrix.size());
const size_t posB = random->GetUInt(0, matrix.size());
const size_t posC = random->GetUInt(0, matrix.size());
prog.PushInst("Mult", {matrix[posA], matrix[posB], matrix[posC]});
cpu.SetProgram(prog);
cpu.CallModule(0);
callstate_t & state = cpu.GetCurCallState();
memory_t & wmem = state.GetWorkingMem();
const double A = (double)random->GetDouble(-1000, 1000);
const double B = (double)random->GetDouble(-1000, 1000);
const double C = (posA != posB) ? A * B : B * B;
wmem.Set(posA, A);
wmem.Set(posB, B);
cpu.SingleProcess();
double memC = wmem.AccessVal(posC).GetNum();
if (memC != C) {
cpu.GetProgram().Print();
cpu.PrintHardwareState();
std::cout << "posA = " << posA << "; posB = " << posB << "; posC = " << posC << std::endl;
std::cout << "A = " << A << "; B = " << B << "; C = " << C << std::endl;
}
REQUIRE(memC == C);
}
}
TEST_CASE("Inst_Inc", "[taglgp]") {
// Constants
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 4;
// Convenient aliases
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
using callstate_t = typename hardware_t::CallState;
using memory_t = typename hardware_t::Memory;
// Create new random number generator
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
// Create new instruction library
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
// Create virtual hardware w/inst_lib
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix);
// Create new program
program_t prog(inst_lib);
/////////////////////////////////////
// Instruction testing
inst_lib->AddInst("Inc", hardware_t::Inst_Inc, 1, "++mem-NUM[A]");
for (size_t i = 0; i < 1000; ++i) {
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
const size_t posA = random->GetUInt(0, matrix.size());
const size_t posB = random->GetUInt(0, matrix.size());
const size_t posC = random->GetUInt(0, matrix.size());
prog.PushInst("Inc", {matrix[posA], matrix[posB], matrix[posC]});
cpu.SetProgram(prog);
cpu.CallModule(0);
callstate_t & state = cpu.GetCurCallState();
memory_t & wmem = state.GetWorkingMem();
const double A = (double)random->GetDouble(-1000, 1000);
wmem.Set(posA, A);
cpu.SingleProcess();
double memA = wmem.AccessVal(posA).GetNum();
REQUIRE(memA == A+1);
}
}
TEST_CASE("Inst_Dec", "[taglgp]") {
// Constants
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 5;
// Convenient aliases
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
using callstate_t = typename hardware_t::CallState;
using memory_t = typename hardware_t::Memory;
// Create new random number generator
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
// Create new instruction library
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
// Create virtual hardware w/inst_lib
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix);
// Create new program
program_t prog(inst_lib);
/////////////////////////////////////
// Instruction testing
inst_lib->AddInst("Dec", hardware_t::Inst_Dec, 1, "--mem-NUM[A]");
for (size_t i = 0; i < 1000; ++i) {
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
const size_t posA = random->GetUInt(0, matrix.size());
const size_t posB = random->GetUInt(0, matrix.size());
const size_t posC = random->GetUInt(0, matrix.size());
prog.PushInst("Dec", {matrix[posA], matrix[posB], matrix[posC]});
cpu.SetProgram(prog);
cpu.CallModule(0);
callstate_t & state = cpu.GetCurCallState();
memory_t & wmem = state.GetWorkingMem();
const double A = (double)random->GetDouble(-1000, 1000);
wmem.Set(posA, A);
cpu.SingleProcess();
double memA = wmem.AccessVal(posA).GetNum();
REQUIRE(memA == A-1);
}
}
TEST_CASE("Inst_Div", "[taglgp]") {
// Constants
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 6;
// Convenient aliases
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
using callstate_t = typename hardware_t::CallState;
using memory_t = typename hardware_t::Memory;
// Create new random number generator
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
// Create new instruction library
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
// Create virtual hardware w/inst_lib
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix);
// Create new program
program_t prog(inst_lib);
/////////////////////////////////////
// Instruction testing
inst_lib->AddInst("Div", hardware_t::Inst_Div, 3, "mem-ANY[C] = mem-NUM[A] / mem-NUM[B]");
for (size_t i = 0; i < 1000; ++i) {
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
const size_t posA = random->GetUInt(0, matrix.size());
const size_t posB = random->GetUInt(0, matrix.size());
const size_t posC = random->GetUInt(0, matrix.size());
prog.PushInst("Div", {matrix[posA], matrix[posB], matrix[posC]});
cpu.SetProgram(prog);
cpu.CallModule(0);
callstate_t & state = cpu.GetCurCallState();
memory_t & wmem = state.GetWorkingMem();
const double A = (double)random->GetDouble(-1000, 1000);
const double B = (double)random->GetDouble(-1000, 1000);
double C = 0;
wmem.Set(posA, A);
wmem.Set(posB, B);
if (B != 0.0) C = (posA != posB) ? A / B : B / B;
else C = wmem.AccessVal(posC).GetNum();
cpu.SingleProcess();
double memC = wmem.AccessVal(posC).GetNum();
if (memC != C) {
cpu.GetProgram().Print();
cpu.PrintHardwareState();
std::cout << "posA = " << posA << "; posB = " << posB << "; posC = " << posC << std::endl;
std::cout << "A = " << A << "; B = " << B << "; C = " << C << std::endl;
}
REQUIRE(memC == C);
}
}
TEST_CASE("Inst_Mod", "[taglgp]") {
// Constants
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 7;
// Convenient aliases
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
using callstate_t = typename hardware_t::CallState;
using memory_t = typename hardware_t::Memory;
// Create new random number generator
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
// Create new instruction library
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
// Create virtual hardware w/inst_lib
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix);
// Create new program
program_t prog(inst_lib);
/////////////////////////////////////
// Instruction testing
inst_lib->AddInst("Mod", hardware_t::Inst_Mod, 3, "mem-ANY[C] = mem-NUM[A] % mem-NUM[B]");
for (size_t i = 0; i < 1000; ++i) {
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
const size_t posA = random->GetUInt(0, matrix.size());
const size_t posB = random->GetUInt(0, matrix.size());
const size_t posC = random->GetUInt(0, matrix.size());
prog.PushInst("Mod", {matrix[posA], matrix[posB], matrix[posC]});
cpu.SetProgram(prog);
cpu.CallModule(0);
callstate_t & state = cpu.GetCurCallState();
memory_t & wmem = state.GetWorkingMem();
const double A = (double)random->GetDouble(-1000, 1000);
const double B = (double)random->GetDouble(-1000, 1000);
double C = 0;
wmem.Set(posA, A);
wmem.Set(posB, B);
if ((int)B != 0.0) C = (posA != posB) ? (int)A % (int)B : (int)B % (int)B;
else C = wmem.AccessVal(posC).GetNum();
cpu.SingleProcess();
double memC = wmem.AccessVal(posC).GetNum();
if (memC != C) {
cpu.GetProgram().Print();
cpu.PrintHardwareState();
std::cout << "posA = " << posA << "; posB = " << posB << "; posC = " << posC << std::endl;
std::cout << "A = " << A << "; B = " << B << "; C = " << C << std::endl;
}
REQUIRE(memC == C);
}
}
TEST_CASE("Inst_TestNumEqu", "[taglgp]") {
// Constants
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 8;
// Convenient aliases
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
using callstate_t = typename hardware_t::CallState;
using memory_t = typename hardware_t::Memory;
// Create new random number generator
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
// Create new instruction library
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
// Create virtual hardware w/inst_lib
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix);
// Create new program
program_t prog(inst_lib);
/////////////////////////////////////
// Instruction testing
inst_lib->AddInst("TestNumEqu", hardware_t::Inst_TestNumEqu, 3, "mem[C] = mem[A] == mem[B]");
// RND + RND = (RND + RND)
for (size_t i = 0; i < 1000; ++i) {
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
const size_t posA = random->GetUInt(0, matrix.size());
const size_t posB = random->GetUInt(0, matrix.size());
const size_t posC = random->GetUInt(0, matrix.size());
prog.PushInst("TestNumEqu", {matrix[posA], matrix[posB], matrix[posC]});
prog.PushInst("TestNumEqu", {matrix[posC], matrix[posC], matrix[posC]});
cpu.SetProgram(prog);
cpu.CallModule(0);
callstate_t & state = cpu.GetCurCallState();
memory_t & wmem = state.GetWorkingMem();
const double A = (double)random->GetDouble(-1000, 1000);
const double B = (double)random->GetDouble(-1000, 1000);
const double C = (posA != posB) ? A == B : B == B;
wmem.Set(posA, A);
wmem.Set(posB, B);
cpu.SingleProcess();
double memC = wmem.AccessVal(posC).GetNum();
if (memC != C) {
cpu.GetProgram().Print();
cpu.PrintHardwareState();
std::cout << "posA = " << posA << "; posB = " << posB << "; posC = " << posC << std::endl;
std::cout << "A = " << A << "; B = " << B << "; C = " << C << std::endl;
}
REQUIRE(memC == C);
cpu.SingleProcess();
REQUIRE(wmem.AccessVal(posC).GetNum() == 1.0);
}
}
TEST_CASE("Inst_TestNumNEqu", "[taglgp]") {
// Constants
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 8;
// Convenient aliases
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
using callstate_t = typename hardware_t::CallState;
using memory_t = typename hardware_t::Memory;
// Create new random number generator
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
// Create new instruction library
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
// Create virtual hardware w/inst_lib
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix);
// Create new program
program_t prog(inst_lib);
/////////////////////////////////////
// Instruction testing
inst_lib->AddInst("TestNumNEqu", hardware_t::Inst_TestNumNEqu, 3, "mem[C] = mem[A] != mem[B]");
// RND + RND = (RND + RND)
for (size_t i = 0; i < 1000; ++i) {
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
const size_t posA = random->GetUInt(0, matrix.size());
const size_t posB = random->GetUInt(0, matrix.size());
const size_t posC = random->GetUInt(0, matrix.size());
prog.PushInst("TestNumNEqu", {matrix[posA], matrix[posB], matrix[posC]});
prog.PushInst("TestNumNEqu", {matrix[posC], matrix[posC], matrix[posC]});
cpu.SetProgram(prog);
cpu.CallModule(0);
callstate_t & state = cpu.GetCurCallState();
memory_t & wmem = state.GetWorkingMem();
const double A = (double)random->GetDouble(-1000, 1000);
const double B = (double)random->GetDouble(-1000, 1000);
const double C = (posA != posB) ? A != B : B != B;
wmem.Set(posA, A);
wmem.Set(posB, B);
cpu.SingleProcess();
double memC = wmem.AccessVal(posC).GetNum();
if (memC != C) {
cpu.GetProgram().Print();
cpu.PrintHardwareState();
std::cout << "posA = " << posA << "; posB = " << posB << "; posC = " << posC << std::endl;
std::cout << "A = " << A << "; B = " << B << "; C = " << C << std::endl;
}
REQUIRE(memC == C);
cpu.SingleProcess();
REQUIRE(wmem.AccessVal(posC).GetNum() == 0.0);
}
}
TEST_CASE("Inst_TestNumLess", "[taglgp]") {
// Constants
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 8;
// Convenient aliases
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
using callstate_t = typename hardware_t::CallState;
using memory_t = typename hardware_t::Memory;
// Create new random number generator
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
// Create new instruction library
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
// Create virtual hardware w/inst_lib
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix);
// Create new program
program_t prog(inst_lib);
/////////////////////////////////////
// Instruction testing
inst_lib->AddInst("TestNumLess", hardware_t::Inst_TestNumLess, 3, "mem[C] = mem[A] < mem[B]");
for (size_t i = 0; i < 1000; ++i) {
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
const size_t posA = random->GetUInt(0, matrix.size());
const size_t posB = random->GetUInt(0, matrix.size());
const size_t posC = random->GetUInt(0, matrix.size());
prog.PushInst("TestNumLess", {matrix[posA], matrix[posB], matrix[posC]});
prog.PushInst("TestNumLess", {matrix[posC], matrix[posC], matrix[posC]});
cpu.SetProgram(prog);
cpu.CallModule(0);
callstate_t & state = cpu.GetCurCallState();
memory_t & wmem = state.GetWorkingMem();
const double A = (double)random->GetDouble(-1000, 1000);
const double B = (double)random->GetDouble(-1000, 1000);
const double C = (posA != posB) ? A < B : B < B;
wmem.Set(posA, A);
wmem.Set(posB, B);
cpu.SingleProcess();
double memC = wmem.AccessVal(posC).GetNum();
if (memC != C) {
cpu.GetProgram().Print();
cpu.PrintHardwareState();
std::cout << "posA = " << posA << "; posB = " << posB << "; posC = " << posC << std::endl;
std::cout << "A = " << A << "; B = " << B << "; C = " << C << std::endl;
}
REQUIRE(memC == C);
cpu.SingleProcess();
REQUIRE(wmem.AccessVal(posC).GetNum() == 0.0);
}
}
TEST_CASE("Inst_Floor", "[taglgp]") {
// Constants
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 10;
// Convenient aliases
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
using callstate_t = typename hardware_t::CallState;
using memory_t = typename hardware_t::Memory;
// Create new random number generator
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
// Create new instruction library
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
// Create virtual hardware w/inst_lib
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix);
// Create new program
program_t prog(inst_lib);
/////////////////////////////////////
// Instruction testing
inst_lib->AddInst("Floor", hardware_t::Inst_Floor, 1, "mem-NUM[A] = FLOOR(mem-NUM[A])");
for (size_t i = 0; i < 1000; ++i) {
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
const size_t posA = random->GetUInt(0, matrix.size());
const size_t posB = random->GetUInt(0, matrix.size());
const size_t posC = random->GetUInt(0, matrix.size());
prog.PushInst("Floor", {matrix[posA], matrix[posB], matrix[posC]});
cpu.SetProgram(prog);
cpu.CallModule(0);
callstate_t & state = cpu.GetCurCallState();
memory_t & wmem = state.GetWorkingMem();
const double A = (double)random->GetDouble(-1000, 1000);
wmem.Set(posA, A);
cpu.SingleProcess();
double memA = wmem.AccessVal(posA).GetNum();
if (memA != std::floor(A)) {
cpu.PrintHardwareState();
std::cout << "posA = " << posA << std::endl;
std::cout << "A = " << A << std::endl;
}
REQUIRE(memA == std::floor(A));
}
}
TEST_CASE("Inst_CopyMem", "[taglgp]") {
// Constants
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 11;
// Convenient aliases
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
using callstate_t = typename hardware_t::CallState;
using memory_t = typename hardware_t::Memory;
using mem_val_t = typename hardware_t::MemoryValue;
// Create new random number generator
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
// Create new instruction library
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
// Create virtual hardware w/inst_lib
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix);
// Create new program
program_t prog(inst_lib);
/////////////////////////////////////
// Instruction testing
inst_lib->AddInst("CopyMem", hardware_t::Inst_CopyMem, 3, "mem-ANY[B] = mem-ANY[A]");
for (size_t i = 0; i < 1000; ++i) {
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
const size_t posA = random->GetUInt(0, matrix.size());
const size_t posB = random->GetUInt(0, matrix.size());
const size_t posC = random->GetUInt(0, matrix.size());
prog.PushInst("CopyMem", {matrix[posA], matrix[posB], matrix[posC]});
cpu.SetProgram(prog);
cpu.CallModule(0);
callstate_t & state = cpu.GetCurCallState();
memory_t & wmem = state.GetWorkingMem();
size_t sA = random->GetUInt(0, 3);
size_t sB = random->GetUInt(0, 3);
size_t sC = random->GetUInt(0, 3);
size_t sD = random->GetUInt(0, 3);
double baseA = random->GetDouble(-1000, 1000);
double baseB = random->GetDouble(-1000, 1000);
double baseC = random->GetDouble(-1000, 1000);
double baseD = random->GetDouble(-1000, 1000);
// Set wmem to base values
(sA == 1) ? wmem.Set(0, emp::to_string(baseA)) : wmem.Set(0, baseA);
(sB == 1) ? wmem.Set(1, emp::to_string(baseB)) : wmem.Set(1, baseB);
(sC == 1) ? wmem.Set(2, emp::to_string(baseC)) : wmem.Set(2, baseC);
(sD == 1) ? wmem.Set(3, emp::to_string(baseD)) : wmem.Set(3, baseD);
// drop some vectors in
if (sA == 2) wmem.Set(0, emp::vector<std::string>{"hello", "world"});
if (sB == 2) wmem.Set(1, emp::vector<mem_val_t>{wmem.AccessVal(0)});
if (sC == 2) wmem.Set(2, emp::vector<mem_val_t>{wmem.AccessVal(1), wmem.AccessVal(2), wmem.AccessVal(3)});
if (sD == 2) wmem.Set(3, emp::vector<std::string>{"blah", "blah", "blah"});
cpu.SingleProcess();
REQUIRE(wmem.GetPos(posA) == wmem.GetPos(posB));
}
}
TEST_CASE("Inst_SwapMem", "[taglgp]") {
// Constants
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 12;
// Convenient aliases
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
using callstate_t = typename hardware_t::CallState;
using memory_t = typename hardware_t::Memory;
using mem_val_t = typename hardware_t::MemoryValue;
// Create new random number generator
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
// Create new instruction library
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
// Create virtual hardware w/inst_lib
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix);
// Create new program
program_t prog(inst_lib);
/////////////////////////////////////
// Instruction testing
inst_lib->AddInst("SwapMem", hardware_t::Inst_SwapMem, 3, "SWAP(mem-ANY[A], mem-ANY[B])");
for (size_t i = 0; i < 1000; ++i) {
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
const size_t posA = random->GetUInt(0, matrix.size());
const size_t posB = random->GetUInt(0, matrix.size());
const size_t posC = random->GetUInt(0, matrix.size());
prog.PushInst("SwapMem", {matrix[posA], matrix[posB], matrix[posC]});
cpu.SetProgram(prog);
cpu.CallModule(0);
callstate_t & state = cpu.GetCurCallState();
memory_t & wmem = state.GetWorkingMem();
size_t sA = random->GetUInt(0, 3);
size_t sB = random->GetUInt(0, 3);
size_t sC = random->GetUInt(0, 3);
size_t sD = random->GetUInt(0, 3);
double baseA = random->GetDouble(-1000, 1000);
double baseB = random->GetDouble(-1000, 1000);
double baseC = random->GetDouble(-1000, 1000);
double baseD = random->GetDouble(-1000, 1000);
// Set wmem to base values
(sA == 1) ? wmem.Set(0, emp::to_string(baseA)) : wmem.Set(0, baseA);
(sB == 1) ? wmem.Set(1, emp::to_string(baseB)) : wmem.Set(1, baseB);
(sC == 1) ? wmem.Set(2, emp::to_string(baseC)) : wmem.Set(2, baseC);
(sD == 1) ? wmem.Set(3, emp::to_string(baseD)) : wmem.Set(3, baseD);
// drop some vectors in
if (sA == 2) wmem.Set(0, emp::vector<std::string>{"hello", "world"});
if (sB == 2) wmem.Set(1, emp::vector<mem_val_t>{wmem.AccessVal(0)});
if (sC == 2) wmem.Set(2, emp::vector<mem_val_t>{wmem.AccessVal(1), wmem.AccessVal(2), wmem.AccessVal(3)});
if (sD == 2) wmem.Set(3, emp::vector<std::string>{"blah", "blah", "blah"});
auto A(wmem.GetPos(posA));
auto B(wmem.GetPos(posB));
cpu.SingleProcess();
REQUIRE(wmem.GetPos(posA) == B);
REQUIRE(wmem.GetPos(posB) == A);
}
}
TEST_CASE("Inst_Input", "[taglgp]") {
// Constants
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 14;
// Convenient aliases
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
using callstate_t = typename hardware_t::CallState;
using memory_t = typename hardware_t::Memory;
// Create new random number generator
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
// Create new instruction library
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
// Create virtual hardware w/inst_lib
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix);
// Create new program
program_t prog(inst_lib);
/////////////////////////////////////
// Instruction testing
inst_lib->AddInst("Input", hardware_t::Inst_Input, 2, "wmem-ANY[B] = imem-ANY[A]");
for (size_t i = 0; i < 1000; ++i) {
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
const size_t posA = random->GetUInt(0, matrix.size());
const size_t posB = random->GetUInt(0, matrix.size());
const size_t posC = random->GetUInt(0, matrix.size());
prog.PushInst("Input", {matrix[posA], matrix[posB], matrix[posC]});
cpu.SetProgram(prog);
cpu.CallModule(0);
callstate_t & state = cpu.GetCurCallState();
memory_t & wmem = state.GetWorkingMem();
memory_t & imem = state.GetInputMem();
size_t sA = random->GetUInt(0, 3);
size_t sB = random->GetUInt(0, 3);
double baseA = random->GetDouble(-1000, 1000);
double baseB = random->GetDouble(-1000, 1000);
// Set wmem to base values
(sA == 1) ? imem.Set(posA, emp::to_string(baseA)) : imem.Set(posA, baseA);
(sB == 1) ? wmem.Set(posB, emp::to_string(baseB)) : wmem.Set(posB, baseB);
// drop some vectors in
if (sA == 2) imem.Set(posA, emp::vector<std::string>{"hello", "world"});
if (sB == 2) wmem.Set(posB, emp::vector<double>{random->GetDouble(-100, 100), random->GetDouble(-100, 100), random->GetDouble(-100, 100), random->GetDouble(-100, 100), random->GetDouble(-100, 100)});
cpu.SingleProcess();
REQUIRE(imem.GetPos(posA) == wmem.GetPos(posB));
}
}
TEST_CASE("Inst_Output", "[taglgp]") {
// Constants
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 14;
// Convenient aliases
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
using callstate_t = typename hardware_t::CallState;
using memory_t = typename hardware_t::Memory;
// Create new random number generator
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
// Create new instruction library
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
// Create virtual hardware w/inst_lib
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix);
// Create new program
program_t prog(inst_lib);
/////////////////////////////////////
// Instruction testing
inst_lib->AddInst("Output", hardware_t::Inst_Output, 2, "omem-ANY[B] = wmem-ANY[A]");
for (size_t i = 0; i < 1000; ++i) {
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
const size_t posA = random->GetUInt(0, matrix.size());
const size_t posB = random->GetUInt(0, matrix.size());
const size_t posC = random->GetUInt(0, matrix.size());
prog.PushInst("Output", {matrix[posA], matrix[posB], matrix[posC]});
cpu.SetProgram(prog);
cpu.CallModule(0);
callstate_t & state = cpu.GetCurCallState();
memory_t & omem = state.GetOutputMem();
memory_t & wmem = state.GetWorkingMem();
size_t sA = random->GetUInt(0, 3);
size_t sB = random->GetUInt(0, 3);
double baseA = random->GetDouble(-1000, 1000);
double baseB = random->GetDouble(-1000, 1000);
// Set wmem to base values
(sA == 1) ? wmem.Set(posA, emp::to_string(baseA)) : wmem.Set(posA, baseA);
(sB == 1) ? omem.Set(posB, emp::to_string(baseB)) : omem.Set(posB, baseB);
// drop some vectors in
if (sA == 2) wmem.Set(posA, emp::vector<std::string>{"hello", "world"});
if (sB == 2) omem.Set(posB, emp::vector<double>{random->GetDouble(-100, 100), random->GetDouble(-100, 100), random->GetDouble(-100, 100), random->GetDouble(-100, 100), random->GetDouble(-100, 100)});
cpu.SingleProcess();
if (wmem.GetPos(posA) != omem.GetPos(posB)) {
cpu.GetProgram().Print();
cpu.PrintHardwareState();
break;
}
REQUIRE(wmem.GetPos(posA) == omem.GetPos(posB));
}
}
TEST_CASE("Inst_CommitGlobal", "[taglgp]") {
// Constants
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 15;
// Convenient aliases
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
using callstate_t = typename hardware_t::CallState;
using memory_t = typename hardware_t::Memory;
// Create new random number generator
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
// Create new instruction library
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
// Create virtual hardware w/inst_lib
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix);
// Create new program
program_t prog(inst_lib);
/////////////////////////////////////
// Instruction testing
inst_lib->AddInst("CommitGlobal", hardware_t::Inst_CommitGlobal, 2, "gmem-ANY[B] = wmem-ANY[A]");
for (size_t i = 0; i < 1000; ++i) {
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
const size_t posA = random->GetUInt(0, matrix.size());
const size_t posB = random->GetUInt(0, matrix.size());
const size_t posC = random->GetUInt(0, matrix.size());
prog.PushInst("CommitGlobal", {matrix[posA], matrix[posB], matrix[posC]});
cpu.SetProgram(prog);
cpu.CallModule(0);
callstate_t & state = cpu.GetCurCallState();
memory_t & gmem = cpu.GetGlobalMem();
memory_t & wmem = state.GetWorkingMem();
size_t sA = random->GetUInt(0, 3);
size_t sB = random->GetUInt(0, 3);
double baseA = random->GetDouble(-1000, 1000);
double baseB = random->GetDouble(-1000, 1000);
// Set wmem to base values
(sA == 1) ? wmem.Set(posA, emp::to_string(baseA)) : wmem.Set(posA, baseA);
(sB == 1) ? gmem.Set(posB, emp::to_string(baseB)) : gmem.Set(posB, baseB);
// drop some vectors in
if (sA == 2) wmem.Set(posA, emp::vector<std::string>{"hello", "world"});
if (sB == 2) gmem.Set(posB, emp::vector<double>{random->GetDouble(-100, 100), random->GetDouble(-100, 100), random->GetDouble(-100, 100), random->GetDouble(-100, 100), random->GetDouble(-100, 100)});
cpu.SingleProcess();
if (wmem.GetPos(posA) != gmem.GetPos(posB)) {
cpu.GetProgram().Print();
cpu.PrintHardwareState();
break;
}
REQUIRE(wmem.GetPos(posA) == gmem.GetPos(posB));
}
}
TEST_CASE("Inst_PullGlobal", "[taglgp]") {
// Constants
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 21;
// Convenient aliases
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
using callstate_t = typename hardware_t::CallState;
using memory_t = typename hardware_t::Memory;
// Create new random number generator
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
// Create new instruction library
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
// Create virtual hardware w/inst_lib
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix);
// Create new program
program_t prog(inst_lib);
/////////////////////////////////////
// Instruction testing
inst_lib->AddInst("PullGlobal", hardware_t::Inst_PullGlobal, 2, "wmem-ANY[B] = gmem-ANY[A]");
for (size_t i = 0; i < 1000; ++i) {
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
const size_t posA = random->GetUInt(0, matrix.size());
const size_t posB = random->GetUInt(0, matrix.size());
const size_t posC = random->GetUInt(0, matrix.size());
prog.PushInst("PullGlobal", {matrix[posA], matrix[posB], matrix[posC]});
cpu.SetProgram(prog);
cpu.CallModule(0);
callstate_t & state = cpu.GetCurCallState();
memory_t & wmem = state.GetWorkingMem();
memory_t & gmem = cpu.GetGlobalMem();
size_t sA = random->GetUInt(0, 3);
size_t sB = random->GetUInt(0, 3);
double baseA = random->GetDouble(-1000, 1000);
double baseB = random->GetDouble(-1000, 1000);
// Set wmem to base values
(sA == 1) ? gmem.Set(posA, emp::to_string(baseA)) : gmem.Set(posA, baseA);
(sB == 1) ? wmem.Set(posB, emp::to_string(baseB)) : wmem.Set(posB, baseB);
// drop some vectors in
if (sA == 2) gmem.Set(posA, emp::vector<std::string>{"hello", "world"});
if (sB == 2) wmem.Set(posB, emp::vector<double>{random->GetDouble(-100, 100), random->GetDouble(-100, 100), random->GetDouble(-100, 100), random->GetDouble(-100, 100), random->GetDouble(-100, 100)});
cpu.SingleProcess();
REQUIRE(gmem.GetPos(posA) == wmem.GetPos(posB));
}
}
TEST_CASE("Inst_TestMemEqu", "[taglgp]") {
// Constants
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 12;
// Convenient aliases
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
using callstate_t = typename hardware_t::CallState;
using memory_t = typename hardware_t::Memory;
using mem_val_t = typename hardware_t::MemoryValue;
// Create new random number generator
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
// Create new instruction library
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
// Create virtual hardware w/inst_lib
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix);
// Create new program
program_t prog(inst_lib);
/////////////////////////////////////
// Instruction testing
inst_lib->AddInst("TestMemEqu", hardware_t::Inst_TestMemEqu, 3, "mem-ANY[C] = mem-ANY[A] == mem-ANY[B])");
for (size_t i = 0; i < 1000; ++i) {
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
const size_t posA = random->GetUInt(0, matrix.size());
const size_t posB = random->GetUInt(0, matrix.size());
const size_t posC = random->GetUInt(0, matrix.size());
prog.PushInst("TestMemEqu", {matrix[posA], matrix[posB], matrix[posC]});
prog.PushInst("TestMemEqu", {matrix[posC], matrix[posC], matrix[posA]});
cpu.SetProgram(prog);
cpu.CallModule(0);
callstate_t & state = cpu.GetCurCallState();
memory_t & wmem = state.GetWorkingMem();
size_t sA = random->GetUInt(0, 3);
size_t sB = random->GetUInt(0, 3);
size_t sC = random->GetUInt(0, 3);
size_t sD = random->GetUInt(0, 3);
double baseA = random->GetDouble(-1000, 1000);
double baseB = random->GetDouble(-1000, 1000);
double baseC = random->GetDouble(-1000, 1000);
double baseD = random->GetDouble(-1000, 1000);
// Set wmem to base values
(sA == 1) ? wmem.Set(0, emp::to_string(baseA)) : wmem.Set(0, baseA);
(sB == 1) ? wmem.Set(1, emp::to_string(baseB)) : wmem.Set(1, baseB);
(sC == 1) ? wmem.Set(2, emp::to_string(baseC)) : wmem.Set(2, baseC);
(sD == 1) ? wmem.Set(3, emp::to_string(baseD)) : wmem.Set(3, baseD);
// drop some vectors in
if (sA == 2) wmem.Set(0, emp::vector<std::string>{"hello", "world"});
if (sB == 2) wmem.Set(1, emp::vector<mem_val_t>{wmem.AccessVal(0)});
if (sC == 2) wmem.Set(2, emp::vector<mem_val_t>{wmem.AccessVal(1), wmem.AccessVal(2), wmem.AccessVal(3)});
if (sD == 2) wmem.Set(3, emp::vector<std::string>{"blah", "blah", "blah"});
double correct = (double)(wmem.GetPos(posA) == wmem.GetPos(posB));
cpu.SingleProcess();
REQUIRE(correct == wmem.AccessVal(posC).GetNum());
cpu.SingleProcess();
REQUIRE(wmem.AccessVal(posA).GetNum() == 1.0);
}
}
TEST_CASE("Inst_TestMemNEqu", "[taglgp]") {
// Constants
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 12;
// Convenient aliases
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
using callstate_t = typename hardware_t::CallState;
using memory_t = typename hardware_t::Memory;
using mem_val_t = typename hardware_t::MemoryValue;
// Create new random number generator
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
// Create new instruction library
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
// Create virtual hardware w/inst_lib
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix);
// Create new program
program_t prog(inst_lib);
/////////////////////////////////////
// Instruction testing
inst_lib->AddInst("TestMemNEqu", hardware_t::Inst_TestMemNEqu, 3, "mem-ANY[C] = mem-ANY[A] != mem-ANY[B])");
for (size_t i = 0; i < 1000; ++i) {
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
const size_t posA = random->GetUInt(0, matrix.size());
const size_t posB = random->GetUInt(0, matrix.size());
const size_t posC = random->GetUInt(0, matrix.size());
prog.PushInst("TestMemNEqu", {matrix[posA], matrix[posB], matrix[posC]});
prog.PushInst("TestMemNEqu", {matrix[posC], matrix[posC], matrix[posA]});
cpu.SetProgram(prog);
cpu.CallModule(0);
callstate_t & state = cpu.GetCurCallState();
memory_t & wmem = state.GetWorkingMem();
size_t sA = random->GetUInt(0, 3);
size_t sB = random->GetUInt(0, 3);
size_t sC = random->GetUInt(0, 3);
size_t sD = random->GetUInt(0, 3);
double baseA = random->GetDouble(-1000, 1000);
double baseB = random->GetDouble(-1000, 1000);
double baseC = random->GetDouble(-1000, 1000);
double baseD = random->GetDouble(-1000, 1000);
// Set wmem to base values
(sA == 1) ? wmem.Set(0, emp::to_string(baseA)) : wmem.Set(0, baseA);
(sB == 1) ? wmem.Set(1, emp::to_string(baseB)) : wmem.Set(1, baseB);
(sC == 1) ? wmem.Set(2, emp::to_string(baseC)) : wmem.Set(2, baseC);
(sD == 1) ? wmem.Set(3, emp::to_string(baseD)) : wmem.Set(3, baseD);
// drop some vectors in
if (sA == 2) wmem.Set(0, emp::vector<std::string>{"hello", "world"});
if (sB == 2) wmem.Set(1, emp::vector<mem_val_t>{wmem.AccessVal(0)});
if (sC == 2) wmem.Set(2, emp::vector<mem_val_t>{wmem.AccessVal(1), wmem.AccessVal(2), wmem.AccessVal(3)});
if (sD == 2) wmem.Set(3, emp::vector<std::string>{"blah", "blah", "blah"});
double correct = (double)(wmem.GetPos(posA) != wmem.GetPos(posB));
cpu.SingleProcess();
REQUIRE(correct == wmem.AccessVal(posC).GetNum());
cpu.SingleProcess();
REQUIRE(wmem.AccessVal(posA).GetNum() == 0.0);
}
}
TEST_CASE("Inst_MakeVector", "[taglgp]") {
// Constants
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 12;
// Convenient aliases
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
using callstate_t = typename hardware_t::CallState;
using memory_t = typename hardware_t::Memory;
using mem_val_t = typename hardware_t::MemoryValue;
// Create new random number generator
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
// Create new instruction library
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
// Create virtual hardware w/inst_lib
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix);
// Create new program
program_t prog(inst_lib);
/////////////////////////////////////
// Instruction testing
inst_lib->AddInst("MakeVector", hardware_t::Inst_MakeVector, 3, "mem-ANY[C] = mem-ANY[A] == mem-ANY[B])");
for (size_t i = 0; i < 1000; ++i) {
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
const size_t posA = random->GetUInt(0, matrix.size());
const size_t posB = random->GetUInt(0, matrix.size());
const size_t posC = random->GetUInt(0, matrix.size());
prog.PushInst("MakeVector", {matrix[posA], matrix[posB], matrix[posC]});
cpu.SetProgram(prog);
cpu.CallModule(0);
callstate_t & state = cpu.GetCurCallState();
memory_t & wmem = state.GetWorkingMem();
size_t sA = random->GetUInt(0, 3);
size_t sB = random->GetUInt(0, 3);
size_t sC = random->GetUInt(0, 3);
size_t sD = random->GetUInt(0, 3);
double baseA = random->GetDouble(-1000, 1000);
double baseB = random->GetDouble(-1000, 1000);
double baseC = random->GetDouble(-1000, 1000);
double baseD = random->GetDouble(-1000, 1000);
// Set wmem to base values
(sA == 1) ? wmem.Set(0, emp::to_string(baseA)) : wmem.Set(0, baseA);
(sB == 1) ? wmem.Set(1, emp::to_string(baseB)) : wmem.Set(1, baseB);
(sC == 1) ? wmem.Set(2, emp::to_string(baseC)) : wmem.Set(2, baseC);
(sD == 1) ? wmem.Set(3, emp::to_string(baseD)) : wmem.Set(3, baseD);
// drop some vectors in
if (sA == 2) wmem.Set(0, emp::vector<std::string>{"hello", "world"});
if (sB == 2) wmem.Set(1, emp::vector<double>{random->GetDouble(-100, 100), random->GetDouble(-100, 100)});
if (sC == 2) wmem.Set(2, emp::vector<double>{0.0, 42.0, 256.0});
if (sD == 2) wmem.Set(3, emp::vector<std::string>{"blah", "blah", "blah"});
// What should the vector @ posC look like?
emp::vector<mem_val_t> vec;
size_t iA = (posA <= posB) ? posA : posB;
for (size_t k = iA; k <= posB; ++k) {
if (wmem.IsVec(k)) continue;
vec.emplace_back(wmem.AccessVal(k));
}
cpu.SingleProcess();
REQUIRE(wmem.IsVec(posC));
REQUIRE(wmem.AccessVec(posC) == vec);
}
}
TEST_CASE("Inst_VecGet", "[taglgp]") {
// Constants
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 12;
// Convenient aliases
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
using callstate_t = typename hardware_t::CallState;
using memory_t = typename hardware_t::Memory;
using mem_val_t = typename hardware_t::MemoryValue;
// Create new random number generator
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
// Create new instruction library
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
// Create virtual hardware w/inst_lib
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix);
// Create new program
program_t prog(inst_lib);
/////////////////////////////////////
// Instruction testing
inst_lib->AddInst("VecGet", hardware_t::Inst_VecGet, 3, "mem-ANY[C] = mem-VEC[A][mem-NUM[B]])");
for (size_t i = 0; i < 1000; ++i) {
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
size_t posA = random->GetUInt(0, matrix.size());
size_t posB = random->GetUInt(0, matrix.size());
while (posB == posA) posB = random->GetUInt(0, matrix.size());
size_t posC = random->GetUInt(0, matrix.size());
prog.PushInst("VecGet", {matrix[posA], matrix[posB], matrix[posC]});
cpu.SetProgram(prog);
cpu.CallModule(0);
callstate_t & state = cpu.GetCurCallState();
memory_t & wmem = state.GetWorkingMem();
emp::vector<mem_val_t> vec(random->GetUInt(10));
for (size_t vi = 0; vi < vec.size(); ++vi) {
if (random->P(0.5)) {
vec[vi] = random->GetDouble(-100, 100);
} else {
vec[vi] = emp::to_string(random->GetDouble(-100, 100));
}
}
size_t B = random->GetUInt(vec.size());
wmem.Set(posA, vec);
wmem.Set(posB, B);
if (vec.size()) {
mem_val_t C(vec[B]);
cpu.SingleProcess();
REQUIRE(wmem.IsVec(posC) == false);
if (C != wmem.AccessVal(posC)) {
cpu.GetProgram().Print();
cpu.PrintHardwareState();
}
REQUIRE(C == wmem.AccessVal(posC));
} else { // Vec is empty, instruction should do nothing.
auto pos = wmem.GetPos(posC);
cpu.SingleProcess();
REQUIRE(wmem.GetPos(posC) == pos);
}
}
}
TEST_CASE("Inst_VecSet", "[taglgp]") {
// Constants
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 12;
// Convenient aliases
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
using callstate_t = typename hardware_t::CallState;
using memory_t = typename hardware_t::Memory;
using mem_val_t = typename hardware_t::MemoryValue;
// Create new random number generator
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
// Create new instruction library
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
// Create virtual hardware w/inst_lib
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix);
// Create new program
program_t prog(inst_lib);
/////////////////////////////////////
// Instruction testing
inst_lib->AddInst("VecSet", hardware_t::Inst_VecSet, 3, "mem-VEC[A][mem-NUM[B]] = mem-NUM,STR[C]");
for (size_t i = 0; i < 1000; ++i) {
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
size_t posA = random->GetUInt(0, matrix.size());
size_t posB = random->GetUInt(0, matrix.size());
while (posB == posA) posB = random->GetUInt(0, matrix.size());
size_t posC = random->GetUInt(0, matrix.size());
while (posC == posA || posC == posB) posC = random->GetUInt(0, matrix.size());
prog.PushInst("VecSet", {matrix[posA], matrix[posB], matrix[posC]});
cpu.SetProgram(prog);
cpu.CallModule(0);
callstate_t & state = cpu.GetCurCallState();
memory_t & wmem = state.GetWorkingMem();
emp::vector<mem_val_t> vec(random->GetUInt(10));
for (size_t vi = 0; vi < vec.size(); ++vi) {
if (random->P(0.5)) {
vec[vi] = random->GetDouble(-100, 100);
} else {
vec[vi] = emp::to_string(random->GetDouble(-100, 100));
}
}
size_t B = random->GetUInt(vec.size());
mem_val_t C;
if (random->P(0.5)) {
C = emp::to_string(random->GetDouble(-100, 100));
} else {
C = random->GetDouble(-100, 100);
}
wmem.Set(posA, vec);
wmem.Set(posB, B);
wmem.Set(posC, C);
if (vec.size()) {
cpu.SingleProcess();
REQUIRE(wmem.IsVec(posA) == true);
REQUIRE(wmem.GetPosType(posB) == hardware_t::MemPosType::NUM);
REQUIRE(wmem.AccessVec(posA)[B] == C);
} else { // Vec is empty, instruction should do nothing.
auto pos = wmem.GetPos(posA);
cpu.SingleProcess();
REQUIRE(wmem.GetPos(posA) == pos);
}
}
}
TEST_CASE("Inst_VecLen", "[taglgp]") {
// Constants
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 12;
// Convenient aliases
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
using callstate_t = typename hardware_t::CallState;
using memory_t = typename hardware_t::Memory;
using mem_val_t = typename hardware_t::MemoryValue;
// Create new random number generator
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
// Create new instruction library
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
// Create virtual hardware w/inst_lib
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix);
// Create new program
program_t prog(inst_lib);
/////////////////////////////////////
// Instruction testing
inst_lib->AddInst("VecLen", hardware_t::Inst_VecLen, 2, "mem-ANY[B] = LEN(mem-VEC[A])");
for (size_t i = 0; i < 1000; ++i) {
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
size_t posA = random->GetUInt(0, matrix.size());
size_t posB = random->GetUInt(0, matrix.size());
size_t posC = random->GetUInt(0, matrix.size());
prog.PushInst("VecLen", {matrix[posA], matrix[posB], matrix[posC]});
prog.PushInst("VecLen", {matrix[posA], matrix[posB], matrix[posC]});
cpu.SetProgram(prog);
cpu.CallModule(0);
callstate_t & state = cpu.GetCurCallState();
memory_t & wmem = state.GetWorkingMem();
emp::vector<mem_val_t> vec(random->GetUInt(128));
for (size_t vi = 0; vi < vec.size(); ++vi) {
if (random->P(0.5)) {
vec[vi] = random->GetDouble(-100, 100);
} else {
vec[vi] = emp::to_string(random->GetDouble(-100, 100));
}
}
wmem.Set(posA, vec);
cpu.SingleProcess();
REQUIRE(wmem.GetPosType(posB) == hardware_t::MemPosType::NUM);
REQUIRE(wmem.AccessVal(posB).GetNum() == vec.size());
// Get rid of vectors and make sure instruction did nothing
wmem.Set(0, 0);
wmem.Set(1, 0);
wmem.Set(2, 0);
wmem.Set(3, 0);
cpu.SingleProcess();
REQUIRE(wmem.AccessVal(0).GetNum() == 0);
REQUIRE(wmem.AccessVal(1).GetNum() == 0);
REQUIRE(wmem.AccessVal(2).GetNum() == 0);
REQUIRE(wmem.AccessVal(3).GetNum() == 0);
}
}
TEST_CASE("Inst_VecAppend", "[taglgp]") {
// Constants
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 12;
// Convenient aliases
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
using callstate_t = typename hardware_t::CallState;
using memory_t = typename hardware_t::Memory;
using mem_val_t = typename hardware_t::MemoryValue;
// Create new random number generator
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
// Create new instruction library
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
// Create virtual hardware w/inst_lib
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix);
// Create new program
program_t prog(inst_lib);
/////////////////////////////////////
// Instruction testing
inst_lib->AddInst("VecAppend", hardware_t::Inst_VecAppend, 2, "mem-VEC[A].append(mem-NUM,STR[B])");
for (size_t i = 0; i < 1000; ++i) {
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
size_t posA = random->GetUInt(0, matrix.size());
size_t posB = random->GetUInt(0, matrix.size());
size_t posC = random->GetUInt(0, matrix.size());
prog.PushInst("VecAppend", {matrix[posA], matrix[posB], matrix[posC]});
cpu.SetProgram(prog);
cpu.CallModule(0);
callstate_t & state = cpu.GetCurCallState();
memory_t & wmem = state.GetWorkingMem();
emp::vector<mem_val_t> vec(random->GetUInt(128));
for (size_t vi = 0; vi < vec.size(); ++vi) {
if (random->P(0.5)) {
vec[vi] = random->GetDouble(-100, 100);
} else {
vec[vi] = emp::to_string(random->GetDouble(-100, 100));
}
}
mem_val_t B;
if (random->P(0.5)) {
B = emp::to_string(random->GetDouble(-100, 100));
} else {
B = random->GetDouble(-100, 100);
}
wmem.Set(posA, vec);
wmem.Set(posB, B);
vec.emplace_back(B);
cpu.SingleProcess();
if (posA == posB) {
// No vectors, nothing should happen.
REQUIRE(wmem.IsVec(posA) == false);
REQUIRE(wmem.AccessVal(posA) == wmem.AccessVal(posB));
} else {
// Did an append happen?
if (wmem.AccessVec(posA) != vec) {
cpu.GetProgram().Print();
cpu.PrintHardwareState();
}
REQUIRE(wmem.IsVec(posA));
REQUIRE(wmem.AccessVec(posA) == vec);
}
}
}
TEST_CASE("Inst_VecPop", "[taglgp]") {
// Constants
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 12;
// Convenient aliases
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
using callstate_t = typename hardware_t::CallState;
using memory_t = typename hardware_t::Memory;
using mem_val_t = typename hardware_t::MemoryValue;
// Create new random number generator
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
// Create new instruction library
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
// Create virtual hardware w/inst_lib
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix);
// Create new program
program_t prog(inst_lib);
/////////////////////////////////////
// Instruction testing
inst_lib->AddInst("VecPop", hardware_t::Inst_VecPop, 2, "mem-ANY[B] = mem-VEC[A].pop()");
for (size_t i = 0; i < 1000; ++i) {
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
size_t posA = random->GetUInt(0, matrix.size());
size_t posB = random->GetUInt(0, matrix.size());
while (posB == posA) posB = random->GetUInt(0, matrix.size());
size_t posC = random->GetUInt(0, matrix.size());
prog.PushInst("VecPop", {matrix[posA], matrix[posB], matrix[posC]});
cpu.SetProgram(prog);
cpu.CallModule(0);
callstate_t & state = cpu.GetCurCallState();
memory_t & wmem = state.GetWorkingMem();
emp::vector<mem_val_t> vec(random->GetUInt(128));
for (size_t vi = 0; vi < vec.size(); ++vi) {
if (random->P(0.5)) {
vec[vi] = random->GetDouble(-100, 100);
} else {
vec[vi] = emp::to_string(random->GetDouble(-100, 100));
}
}
wmem.Set(posA, vec);
wmem.Set(posB, 0);
mem_val_t B;
if (vec.size()) {
B = vec.back();
} else {
B = 0;
}
cpu.SingleProcess();
if (vec.size()) {
vec.pop_back();
REQUIRE(wmem.IsVec(posA));
REQUIRE(wmem.AccessVec(posA) == vec);
}
REQUIRE(!wmem.IsVec(posB));
REQUIRE(wmem.AccessVal(posB) == B);
}
}
TEST_CASE("Inst_VecRemove", "[taglgp]") {
// Constants
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 12;
// Convenient aliases
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
using callstate_t = typename hardware_t::CallState;
using memory_t = typename hardware_t::Memory;
using mem_val_t = typename hardware_t::MemoryValue;
// Create new random number generator
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
// Create new instruction library
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
// Create virtual hardware w/inst_lib
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix);
// Create new program
program_t prog(inst_lib);
/////////////////////////////////////
// Instruction testing
inst_lib->AddInst("VecRemove", hardware_t::Inst_VecRemove, 2, "mem-VEC[A].Remove(mem-NUM[A])");
for (size_t i = 0; i < 1000; ++i) {
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
size_t posA = random->GetUInt(0, matrix.size());
size_t posB = random->GetUInt(0, matrix.size());
while (posB == posA) posB = random->GetUInt(0, matrix.size());
size_t posC = random->GetUInt(0, matrix.size());
prog.PushInst("VecRemove", {matrix[posA], matrix[posB], matrix[posC]});
cpu.SetProgram(prog);
cpu.CallModule(0);
callstate_t & state = cpu.GetCurCallState();
memory_t & wmem = state.GetWorkingMem();
emp::vector<mem_val_t> vec(random->GetUInt(128));
for (size_t vi = 0; vi < vec.size(); ++vi) {
if (random->P(0.5)) {
vec[vi] = random->GetDouble(-100, 100);
} else {
vec[vi] = emp::to_string(random->GetDouble(-100, 100));
}
}
double B = (double)random->GetUInt(0, 128);
wmem.Set(posA, vec);
wmem.Set(posB, B);
cpu.SingleProcess();
if (B < vec.size()) {
// VecRemove should have actually removed element B.
vec.erase(vec.begin()+(size_t)B);
REQUIRE(wmem.IsVec(posA));
REQUIRE(wmem.AccessVec(posA) == vec);
}
REQUIRE(wmem.IsVec(posA));
REQUIRE(wmem.AccessVec(posA) == vec);
}
}
TEST_CASE("Inst_VecReplaceAll", "[taglgp]") {
// Constants
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 12;
// Convenient aliases
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
using callstate_t = typename hardware_t::CallState;
using memory_t = typename hardware_t::Memory;
using mem_val_t = typename hardware_t::MemoryValue;
// Create new random number generator
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
// Create new instruction library
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
// Create virtual hardware w/inst_lib
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix);
// Create new program
program_t prog(inst_lib);
/////////////////////////////////////
// Instruction testing
inst_lib->AddInst("VecReplaceAll", hardware_t::Inst_VecReplaceAll, 3, "mem-VEC[A].Replace(mem-NUM,STR[B], mem-NUM[C])");
for (size_t i = 0; i < 1000; ++i) {
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
size_t posA = random->GetUInt(0, matrix.size());
size_t posB = random->GetUInt(0, matrix.size());
while (posB == posA) posB = random->GetUInt(0, matrix.size());
size_t posC = random->GetUInt(0, matrix.size());
while (posC == posA || posC == posB) posC = random->GetUInt(0, matrix.size());
prog.PushInst("VecReplaceAll", {matrix[posA], matrix[posB], matrix[posC]});
cpu.SetProgram(prog);
cpu.CallModule(0);
callstate_t & state = cpu.GetCurCallState();
memory_t & wmem = state.GetWorkingMem();
emp::vector<mem_val_t> vec(random->GetUInt(128));
for (size_t vi = 0; vi < vec.size(); ++vi) {
if (random->P(0.5)) {
vec[vi] = random->GetUInt(0, 5);
} else {
vec[vi] = emp::to_string(random->GetUInt(0, 5));
}
}
mem_val_t B;
B = random->GetUInt(0, 5);
mem_val_t C;
C = "REPLACE VAL";
wmem.Set(posA, vec);
wmem.Set(posB, B);
wmem.Set(posC, C);
cpu.SingleProcess();
for (size_t vi = 0; vi < vec.size(); ++vi) {
if (vec[vi] == B) vec[vi] = C;
}
REQUIRE(wmem.IsVec(posA));
REQUIRE(vec == wmem.AccessVec(posA));
}
}
TEST_CASE("Inst_VecIndexOf", "[taglgp]") {
// Constants
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 12;
// Convenient aliases
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
using callstate_t = typename hardware_t::CallState;
using memory_t = typename hardware_t::Memory;
using mem_val_t = typename hardware_t::MemoryValue;
// Create new random number generator
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
// Create new instruction library
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
// Create virtual hardware w/inst_lib
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix);
// Create new program
program_t prog(inst_lib);
/////////////////////////////////////
// Instruction testing
inst_lib->AddInst("VecIndexOf", hardware_t::Inst_VecIndexOf, 3, "");
for (size_t i = 0; i < 1000; ++i) {
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
size_t posA = random->GetUInt(0, matrix.size());
size_t posB = random->GetUInt(0, matrix.size());
while (posB == posA) posB = random->GetUInt(0, matrix.size());
size_t posC = random->GetUInt(0, matrix.size());
while (posC == posA || posC == posB) posC = random->GetUInt(0, matrix.size());
prog.PushInst("VecIndexOf", {matrix[posA], matrix[posB], matrix[posC]});
cpu.SetProgram(prog);
cpu.CallModule(0);
callstate_t & state = cpu.GetCurCallState();
memory_t & wmem = state.GetWorkingMem();
emp::vector<mem_val_t> vec(random->GetUInt(1,128));
for (size_t vi = 0; vi < vec.size(); ++vi) {
if (random->P(0.5)) {
vec[vi] = random->GetUInt(0, 5);
} else {
vec[vi] = emp::to_string(random->GetUInt(0, 5));
}
}
size_t pos = random->GetUInt(vec.size());
mem_val_t B;
B = "FIND ME";
vec[pos] = B;
wmem.Set(posA, vec);
wmem.Set(posB, B);
cpu.SingleProcess();
REQUIRE(wmem.AccessVal(posC).GetNum() == pos);
}
}
TEST_CASE("Inst_VecOccurrencesOf", "[taglgp]") {
// Constants
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 12;
// Convenient aliases
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
using callstate_t = typename hardware_t::CallState;
using memory_t = typename hardware_t::Memory;
using mem_val_t = typename hardware_t::MemoryValue;
// Create new random number generator
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
// Create new instruction library
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
// Create virtual hardware w/inst_lib
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix);
// Create new program
program_t prog(inst_lib);
/////////////////////////////////////
// Instruction testing
inst_lib->AddInst("VecOccurrencesOf", hardware_t::Inst_VecOccurrencesOf, 3, "");
for (size_t i = 0; i < 1000; ++i) {
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
size_t posA = random->GetUInt(0, matrix.size());
size_t posB = random->GetUInt(0, matrix.size());
while (posB == posA) posB = random->GetUInt(0, matrix.size());
size_t posC = random->GetUInt(0, matrix.size());
while (posC == posA || posC == posB) posC = random->GetUInt(0, matrix.size());
prog.PushInst("VecOccurrencesOf", {matrix[posA], matrix[posB], matrix[posC]});
cpu.SetProgram(prog);
cpu.CallModule(0);
callstate_t & state = cpu.GetCurCallState();
memory_t & wmem = state.GetWorkingMem();
emp::vector<mem_val_t> vec(random->GetUInt(128));
for (size_t vi = 0; vi < vec.size(); ++vi) {
if (random->P(0.5)) {
vec[vi] = random->GetUInt(0, 5);
} else {
vec[vi] = emp::to_string(random->GetUInt(0, 5));
}
}
mem_val_t B;
B = random->GetUInt(0, 5);
wmem.Set(posA, vec);
wmem.Set(posB, B);
cpu.SingleProcess();
size_t cnt = 0;
for (size_t vi = 0; vi < vec.size(); ++vi) {
if (vec[vi] == B) cnt++;
}
REQUIRE(cnt == wmem.AccessVal(posC).GetNum());
}
}
TEST_CASE("Inst_VecReverse", "[taglgp]") {
// Constants
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 12;
// Convenient aliases
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
using callstate_t = typename hardware_t::CallState;
using memory_t = typename hardware_t::Memory;
using mem_val_t = typename hardware_t::MemoryValue;
// Create new random number generator
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
// Create new instruction library
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
// Create virtual hardware w/inst_lib
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix);
// Create new program
program_t prog(inst_lib);
/////////////////////////////////////
// Instruction testing
inst_lib->AddInst("VecReverse", hardware_t::Inst_VecReverse, 1, "");
for (size_t i = 0; i < 1000; ++i) {
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
size_t posA = random->GetUInt(0, matrix.size());
size_t posB = random->GetUInt(0, matrix.size());
size_t posC = random->GetUInt(0, matrix.size());
prog.PushInst("VecReverse", {matrix[posA], matrix[posB], matrix[posC]});
cpu.SetProgram(prog);
cpu.CallModule(0);
callstate_t & state = cpu.GetCurCallState();
memory_t & wmem = state.GetWorkingMem();
emp::vector<mem_val_t> vec(random->GetUInt(128));
for (size_t vi = 0; vi < vec.size(); ++vi) {
if (random->P(0.5)) {
vec[vi] = random->GetUInt(0, 5);
} else {
vec[vi] = emp::to_string(random->GetUInt(0, 5));
}
}
wmem.Set(posA, vec);
cpu.SingleProcess();
std::reverse(std::begin(vec), std::end(vec));
REQUIRE(wmem.AccessVec(posA) == vec);
}
}
TEST_CASE("Inst_VecSwapIfLess", "[taglgp]") {
// Constants
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 12;
// Convenient aliases
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
using callstate_t = typename hardware_t::CallState;
using memory_t = typename hardware_t::Memory;
using mem_val_t = typename hardware_t::MemoryValue;
// Create new random number generator
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
// Create new instruction library
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
// Create virtual hardware w/inst_lib
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix);
// Create new program
program_t prog(inst_lib);
/////////////////////////////////////
// Instruction testing
inst_lib->AddInst("VecSwapIfLess", hardware_t::Inst_VecSwapIfLess, 1, "");
for (size_t i = 0; i < 1000; ++i) {
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
size_t posA = random->GetUInt(0, matrix.size());
size_t posB = random->GetUInt(0, matrix.size());
while (posB == posA) posB = random->GetUInt(0, matrix.size());
size_t posC = random->GetUInt(0, matrix.size());
while (posC == posA || posC == posB) posC = random->GetUInt(0, matrix.size());
prog.PushInst("VecSwapIfLess", {matrix[posA], matrix[posB], matrix[posC]});
cpu.SetProgram(prog);
cpu.CallModule(0);
callstate_t & state = cpu.GetCurCallState();
memory_t & wmem = state.GetWorkingMem();
emp::vector<mem_val_t> vec(random->GetUInt(1,128));
for (size_t vi = 0; vi < vec.size(); ++vi) {
if (random->P(0.5)) {
vec[vi] = random->GetUInt(0, 5);
} else {
vec[vi] = emp::to_string(random->GetUInt(0, 5));
}
}
size_t B = random->GetUInt(vec.size());
size_t C = random->GetUInt(vec.size());
wmem.Set(posA, vec);
wmem.Set(posB, B);
wmem.Set(posC, C);
// cpu.GetProgram().Print();
// cpu.PrintHardwareState();
cpu.SingleProcess();
if (((vec[B].GetType() == mem_val_t::MemoryType::NUM) ? vec[B].GetNum() : 0) <
((vec[C].GetType() == mem_val_t::MemoryType::NUM) ? vec[C].GetNum() : 0)) {
std::swap(vec[B], vec[C]);
}
// if (vec != wmem.AccessVec(posA)) {
// cpu.PrintHardwareState();
// }
REQUIRE(vec == wmem.AccessVec(posA));
}
}
TEST_CASE("Inst_VecGetFront", "[taglgp]") {
// Constants
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 12;
// Convenient aliases
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
using callstate_t = typename hardware_t::CallState;
using memory_t = typename hardware_t::Memory;
using mem_val_t = typename hardware_t::MemoryValue;
// Create new random number generator
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
// Create new instruction library
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
// Create virtual hardware w/inst_lib
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix);
// Create new program
program_t prog(inst_lib);
/////////////////////////////////////
// Instruction testing
inst_lib->AddInst("VecGetFront", hardware_t::Inst_VecGetFront, 2, "");
for (size_t i = 0; i < 1000; ++i) {
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
size_t posA = random->GetUInt(0, matrix.size());
size_t posB = random->GetUInt(0, matrix.size());
size_t posC = random->GetUInt(0, matrix.size());
prog.PushInst("VecGetFront", {matrix[posA], matrix[posB], matrix[posC]});
cpu.SetProgram(prog);
cpu.CallModule(0);
callstate_t & state = cpu.GetCurCallState();
memory_t & wmem = state.GetWorkingMem();
emp::vector<mem_val_t> vec(random->GetUInt(1,128));
for (size_t vi = 0; vi < vec.size(); ++vi) {
if (random->P(0.5)) {
vec[vi] = random->GetUInt(0, 5);
} else {
vec[vi] = emp::to_string(random->GetUInt(0, 5));
}
}
mem_val_t B(vec.front());
wmem.Set(posA, vec);
cpu.SingleProcess();
REQUIRE(wmem.AccessVal(posB) == B);
}
}
TEST_CASE("Inst_VecGetBack", "[taglgp]") {
// Constants
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 13;
// Convenient aliases
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
using callstate_t = typename hardware_t::CallState;
using memory_t = typename hardware_t::Memory;
using mem_val_t = typename hardware_t::MemoryValue;
// Create new random number generator
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
// Create new instruction library
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
// Create virtual hardware w/inst_lib
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix);
// Create new program
program_t prog(inst_lib);
/////////////////////////////////////
// Instruction testing
inst_lib->AddInst("VecGetBack", hardware_t::Inst_VecGetBack, 2, "");
for (size_t i = 0; i < 1000; ++i) {
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
size_t posA = random->GetUInt(0, matrix.size());
size_t posB = random->GetUInt(0, matrix.size());
size_t posC = random->GetUInt(0, matrix.size());
prog.PushInst("VecGetBack", {matrix[posA], matrix[posB], matrix[posC]});
cpu.SetProgram(prog);
cpu.CallModule(0);
callstate_t & state = cpu.GetCurCallState();
memory_t & wmem = state.GetWorkingMem();
emp::vector<mem_val_t> vec(random->GetUInt(1,128));
for (size_t vi = 0; vi < vec.size(); ++vi) {
if (random->P(0.5)) {
vec[vi] = random->GetUInt(0, 5);
} else {
vec[vi] = emp::to_string(random->GetUInt(0, 5));
}
}
mem_val_t B(vec.back());
wmem.Set(posA, vec);
cpu.SingleProcess();
REQUIRE(wmem.AccessVal(posB) == B);
}
}
TEST_CASE("Inst_IsStr", "[taglgp]") {
// Constants
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 13;
// Convenient aliases
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
using callstate_t = typename hardware_t::CallState;
using memory_t = typename hardware_t::Memory;
// Create new random number generator
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
// Create new instruction library
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
// Create virtual hardware w/inst_lib
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix);
// Create new program
program_t prog(inst_lib);
/////////////////////////////////////
// Instruction testing
inst_lib->AddInst("IsStr", hardware_t::Inst_IsStr, 2, "");
for (size_t i = 0; i < 1000; ++i) {
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
size_t posA = random->GetUInt(0, matrix.size());
size_t posB = random->GetUInt(0, matrix.size());
size_t posC = random->GetUInt(0, matrix.size());
prog.PushInst("IsStr", {matrix[posA], matrix[posB], matrix[posC]});
cpu.SetProgram(prog);
cpu.CallModule(0);
callstate_t & state = cpu.GetCurCallState();
memory_t & wmem = state.GetWorkingMem();
size_t sA = random->GetUInt(3);
if (sA == 0) {
wmem.Set(posA, random->GetUInt(0, 5));
} else if (sA == 1) {
wmem.Set(posA, emp::to_string(random->GetUInt(0, 5)));
} else {
wmem.Set(posA, emp::vector<std::string>{emp::to_string(random->GetUInt(0, 5)), emp::to_string(random->GetUInt(0, 5)), emp::to_string(random->GetUInt(0, 5)), emp::to_string(random->GetUInt(0, 5)), emp::to_string(random->GetUInt(0, 5))});
}
cpu.SingleProcess();
if (sA == 1) {
REQUIRE(wmem.AccessVal(posB).GetNum() == 1.0);
} else {
REQUIRE(wmem.AccessVal(posB).GetNum() == 0.0);
}
}
}
TEST_CASE("Inst_IsNum", "[taglgp]") {
// Constants
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 13;
// Convenient aliases
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
using callstate_t = typename hardware_t::CallState;
using memory_t = typename hardware_t::Memory;
// Create new random number generator
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
// Create new instruction library
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
// Create virtual hardware w/inst_lib
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix);
// Create new program
program_t prog(inst_lib);
/////////////////////////////////////
// Instruction testing
inst_lib->AddInst("IsNum", hardware_t::Inst_IsNum, 2, "");
for (size_t i = 0; i < 1000; ++i) {
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
size_t posA = random->GetUInt(0, matrix.size());
size_t posB = random->GetUInt(0, matrix.size());
size_t posC = random->GetUInt(0, matrix.size());
prog.PushInst("IsNum", {matrix[posA], matrix[posB], matrix[posC]});
cpu.SetProgram(prog);
cpu.CallModule(0);
callstate_t & state = cpu.GetCurCallState();
memory_t & wmem = state.GetWorkingMem();
size_t sA = random->GetUInt(3);
if (sA == 0) {
wmem.Set(posA, random->GetUInt(0, 5));
} else if (sA == 1) {
wmem.Set(posA, emp::to_string(random->GetUInt(0, 5)));
} else {
wmem.Set(posA, emp::vector<std::string>{emp::to_string(random->GetUInt(0, 5)), emp::to_string(random->GetUInt(0, 5)), emp::to_string(random->GetUInt(0, 5)), emp::to_string(random->GetUInt(0, 5)), emp::to_string(random->GetUInt(0, 5))});
}
cpu.SingleProcess();
if (sA == 0) {
REQUIRE(wmem.AccessVal(posB).GetNum() == 1.0);
} else {
REQUIRE(wmem.AccessVal(posB).GetNum() == 0.0);
}
}
}
TEST_CASE("Inst_IsVec", "[taglgp]") {
// Constants
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 13;
// Convenient aliases
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
using callstate_t = typename hardware_t::CallState;
using memory_t = typename hardware_t::Memory;
// Create new random number generator
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
// Create new instruction library
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
// Create virtual hardware w/inst_lib
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix);
// Create new program
program_t prog(inst_lib);
/////////////////////////////////////
// Instruction testing
inst_lib->AddInst("IsVec", hardware_t::Inst_IsVec, 2, "");
for (size_t i = 0; i < 1000; ++i) {
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
size_t posA = random->GetUInt(0, matrix.size());
size_t posB = random->GetUInt(0, matrix.size());
size_t posC = random->GetUInt(0, matrix.size());
prog.PushInst("IsVec", {matrix[posA], matrix[posB], matrix[posC]});
cpu.SetProgram(prog);
cpu.CallModule(0);
callstate_t & state = cpu.GetCurCallState();
memory_t & wmem = state.GetWorkingMem();
size_t sA = random->GetUInt(3);
if (sA == 0) {
wmem.Set(posA, random->GetUInt(0, 5));
} else if (sA == 1) {
wmem.Set(posA, emp::to_string(random->GetUInt(0, 5)));
} else {
wmem.Set(posA, emp::vector<std::string>{emp::to_string(random->GetUInt(0, 5)), emp::to_string(random->GetUInt(0, 5)), emp::to_string(random->GetUInt(0, 5)), emp::to_string(random->GetUInt(0, 5)), emp::to_string(random->GetUInt(0, 5))});
}
cpu.SingleProcess();
if (sA == 2) {
REQUIRE(wmem.AccessVal(posB).GetNum() == 1.0);
} else {
REQUIRE(wmem.AccessVal(posB).GetNum() == 0.0);
}
}
}
TEST_CASE("Inst_If", "[taglgp]") {
// Constants
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 13;
// Convenient aliases
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
using callstate_t = typename hardware_t::CallState;
using memory_t = typename hardware_t::Memory;
// Create new random number generator
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
// Create new instruction library
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
// Create virtual hardware w/inst_lib
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix);
// Create new program
program_t prog(inst_lib);
/////////////////////////////////////
// Instruction testing
// InstProperty BEGIN_FLOW END_FLOW MODULE
inst_lib->AddInst("Inc", hardware_t::Inst_Inc, 1, "");
inst_lib->AddInst("Dec", hardware_t::Inst_Dec, 1, "");
inst_lib->AddInst("Nop", hardware_t::Inst_Nop, 0, "");
inst_lib->AddInst("If", hardware_t::Inst_If, 1, "", {inst_lib_t::InstProperty::BEGIN_FLOW});
inst_lib->AddInst("Close", hardware_t::Inst_Close, 0, "", {inst_lib_t::InstProperty::END_FLOW});
inst_lib->AddInst("Break", hardware_t::Inst_Break, 0, "");
// ---------------------------------------
// - TEST: If(true) ... Close ...
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
prog.PushInst("Inc", {matrix[0]});
prog.PushInst("If", {matrix[0]});
prog.PushInst("Inc", {matrix[1]});
prog.PushInst("Inc", {matrix[1]});
prog.PushInst("Close", {matrix[0]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
cpu.SetProgram(prog);
cpu.CallModule(0);
// std::cout << "\n\n---PROGRAM---\n\n";
// cpu.GetProgram().Print();
// std::cout << "\n\n--- INITIAL STATE ---" << std::endl;
// cpu.PrintHardwareState();
for (size_t i = 0; i < 9; ++i) {
// std::cout << "\n\n--- AFTER CYCLE " << i << std::endl;
cpu.SingleProcess();
// cpu.PrintHardwareState();
}
callstate_t & state = cpu.GetCurCallState();
memory_t & wmem = state.GetWorkingMem();
REQUIRE(wmem.AccessVal(0).GetNum() == 1);
REQUIRE(wmem.AccessVal(1).GetNum() == 2);
REQUIRE(wmem.AccessVal(2).GetNum() == 4);
// ---------------------------------------
// ---------------------------------------
// - TEST: If(false) ... Close ...
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
prog.PushInst("Nop", {matrix[0]});
prog.PushInst("If", {matrix[0]});
prog.PushInst("Inc", {matrix[1]});
prog.PushInst("Inc", {matrix[1]});
prog.PushInst("Close", {matrix[0]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
cpu.SetProgram(prog);
cpu.CallModule(0);
// std::cout << "\n\n---PROGRAM---\n\n";
// cpu.GetProgram().Print();
// std::cout << "\n\n--- INITIAL STATE ---" << std::endl;
// cpu.PrintHardwareState();
for (size_t i = 0; i < 6; ++i) {
// std::cout << "\n\n--- AFTER CYCLE " << i << std::endl;
cpu.SingleProcess();
// cpu.PrintHardwareState();
}
callstate_t & state0 = cpu.GetCurCallState();
memory_t & wmem0 = state0.GetWorkingMem();
REQUIRE(wmem0.AccessVal(0).GetNum() == 0);
REQUIRE(wmem0.AccessVal(1).GetNum() == 0);
REQUIRE(wmem0.AccessVal(2).GetNum() == 4);
// ---------------------------------------
// ---------------------------------------
// - TEST: If(true) ... - Implicit close
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
prog.PushInst("Inc", {matrix[0]});
prog.PushInst("If", {matrix[0]});
prog.PushInst("Inc", {matrix[1]});
prog.PushInst("Inc", {matrix[1]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
cpu.SetProgram(prog);
cpu.CallModule(0);
// std::cout << "\n\n---PROGRAM---\n\n";
// cpu.GetProgram().Print();
// std::cout << "\n\n--- INITIAL STATE ---" << std::endl;
// cpu.PrintHardwareState();
for (size_t i = 0; i < 8; ++i) {
// std::cout << "\n\n--- AFTER CYCLE " << i << "---" << std::endl;
cpu.SingleProcess();
// cpu.PrintHardwareState();
}
callstate_t & state1 = cpu.GetCurCallState();
memory_t & wmem1 = state1.GetWorkingMem();
REQUIRE(wmem1.AccessVal(0).GetNum() == 1);
REQUIRE(wmem1.AccessVal(1).GetNum() == 2);
REQUIRE(wmem1.AccessVal(2).GetNum() == 4);
// ---------------------------------------
// ---------------------------------------
// - TEST: If(false) ... - Implicit close
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
prog.PushInst("Nop", {matrix[0]});
prog.PushInst("Nop", {matrix[0]});
prog.PushInst("If", {matrix[0]});
prog.PushInst("Inc", {matrix[1]});
prog.PushInst("Inc", {matrix[1]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
cpu.SetProgram(prog);
cpu.CallModule(0, true, true);
// std::cout << "\n\n---PROGRAM---\n\n";
// cpu.GetProgram().Print();
// std::cout << "\n\n--- INITIAL STATE ---" << std::endl;
// cpu.PrintHardwareState();
for (size_t i = 0; i < 16; ++i) {
// std::cout << "\n\n--- AFTER CYCLE " << i << "---" << std::endl;
cpu.SingleProcess();
// cpu.PrintHardwareState();
}
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(0).GetNum() == 0);
// ---------------------------------------
// ---------------------------------------
// - TEST: If(true) .. break .. - Implicit close
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
prog.PushInst("Inc", {matrix[0]});
prog.PushInst("If", {matrix[0]});
prog.PushInst("Inc", {matrix[1]});
prog.PushInst("Break", {});
prog.PushInst("Inc", {matrix[1]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
cpu.SetProgram(prog);
cpu.CallModule(0);
// std::cout << "\n\n---PROGRAM---\n\n";
// cpu.GetProgram().Print();
// std::cout << "\n\n--- INITIAL STATE ---" << std::endl;
// cpu.PrintHardwareState();
for (size_t i = 0; i < 4; ++i) {
// std::cout << "\n\n--- AFTER CYCLE " << i << "---" << std::endl;
cpu.SingleProcess();
// cpu.PrintHardwareState();
}
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(0).GetNum() == 1);
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(1).GetNum() == 1);
// ---------------------------------------
// ---------------------------------------
// - TEST: If(true) .. break .. Close
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
prog.PushInst("Inc", {matrix[0]});
prog.PushInst("If", {matrix[0]});
prog.PushInst("Inc", {matrix[1]});
prog.PushInst("Break", {});
prog.PushInst("Inc", {matrix[1]});
prog.PushInst("Close", {});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
cpu.SetProgram(prog);
cpu.CallModule(0);
// std::cout << "\n\n---PROGRAM---\n\n";
// cpu.GetProgram().Print();
// std::cout << "\n\n--- INITIAL STATE ---" << std::endl;
// cpu.PrintHardwareState();
for (size_t i = 0; i < 8; ++i) {
// std::cout << "\n\n--- AFTER CYCLE " << i << "---" << std::endl;
cpu.SingleProcess();
// cpu.PrintHardwareState();
}
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(0).GetNum() == 1);
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(1).GetNum() == 1);
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(2).GetNum() == 4);
// ---------------------------------------
// ---------------------------------------
// - TEST: nested ifs
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
prog.PushInst("Inc", {matrix[0]});
prog.PushInst("If", {matrix[0]});
prog.PushInst("Inc", {matrix[1]});
prog.PushInst("If", {matrix[1]});
prog.PushInst("Nop", {});
prog.PushInst("Break", {});
prog.PushInst("Inc", {matrix[0]});
prog.PushInst("Close", {});
prog.PushInst("Inc", {matrix[1]});
prog.PushInst("Close", {});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
cpu.SetProgram(prog);
cpu.CallModule(0);
// std::cout << "\n\n---PROGRAM---\n\n";
// cpu.GetProgram().Print();
// std::cout << "\n\n--- INITIAL STATE ---" << std::endl;
// cpu.PrintHardwareState();
for (size_t i = 0; i < 12; ++i) {
// std::cout << "\n\n--- AFTER CYCLE " << i << "---" << std::endl;
cpu.SingleProcess();
// cpu.PrintHardwareState();
}
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(0).GetNum() == 1);
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(1).GetNum() == 2);
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(2).GetNum() == 4);
// ---------------------------------------
/////////////////////////////////////
}
TEST_CASE("Inst_While", "[taglgp]") {
// Constants
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 13;
// Convenient aliases
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
// Create new random number generator
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
// Create new instruction library
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
// Create virtual hardware w/inst_lib
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix);
// Create new program
program_t prog(inst_lib);
/////////////////////////////////////
// Instruction testing
// InstProperty BEGIN_FLOW END_FLOW MODULE
inst_lib->AddInst("Inc", hardware_t::Inst_Inc, 1, "");
inst_lib->AddInst("Dec", hardware_t::Inst_Dec, 1, "");
inst_lib->AddInst("Nop", hardware_t::Inst_Nop, 0, "");
inst_lib->AddInst("If", hardware_t::Inst_If, 1, "", {inst_lib_t::InstProperty::BEGIN_FLOW});
inst_lib->AddInst("While", hardware_t::Inst_While, 1, "", {inst_lib_t::InstProperty::BEGIN_FLOW});
inst_lib->AddInst("Close", hardware_t::Inst_Close, 0, "", {inst_lib_t::InstProperty::END_FLOW});
inst_lib->AddInst("Break", hardware_t::Inst_Break, 0, "");
// ---------------------------------------
// - TEST: If(true) ... Close ...
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
prog.PushInst("Inc", {matrix[0]});
prog.PushInst("Inc", {matrix[0]});
prog.PushInst("Inc", {matrix[0]});
prog.PushInst("While", {matrix[0]});
prog.PushInst("Inc", {matrix[1]});
prog.PushInst("Dec", {matrix[0]});
prog.PushInst("Close", {matrix[0]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
cpu.SetProgram(prog);
cpu.CallModule(0);
// std::cout << "\n\n---PROGRAM---\n\n";
// cpu.GetProgram().Print();
// std::cout << "\n\n--- INITIAL STATE ---" << std::endl;
// cpu.PrintHardwareState();
for (size_t i = 0; i < 20; ++i) {
// std::cout << "\n\n--- AFTER CYCLE " << i << std::endl;
cpu.SingleProcess();
// cpu.PrintHardwareState();
}
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(0).GetNum() == 0);
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(1).GetNum() == 3);
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(2).GetNum() == 4);
// ---------------------------------------
// ---------------------------------------
// - TEST: If(false) ... Close ...
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
prog.PushInst("Nop", {matrix[0]});
prog.PushInst("Nop", {matrix[0]});
prog.PushInst("Nop", {matrix[0]});
prog.PushInst("While", {matrix[0]});
prog.PushInst("Inc", {matrix[1]});
prog.PushInst("Dec", {matrix[0]});
prog.PushInst("Close", {matrix[0]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
cpu.SetProgram(prog);
cpu.CallModule(0);
// std::cout << "\n\n---PROGRAM---\n\n";
// cpu.GetProgram().Print();
// std::cout << "\n\n--- INITIAL STATE ---" << std::endl;
// cpu.PrintHardwareState();
for (size_t i = 0; i < 8; ++i) {
// std::cout << "\n\n--- AFTER CYCLE " << i << std::endl;
cpu.SingleProcess();
// cpu.PrintHardwareState();
}
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(0).GetNum() == 0);
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(1).GetNum() == 0);
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(2).GetNum() == 4);
// ---------------------------------------
// ---------------------------------------
// - TEST: If(true) ... Implicit close
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
prog.PushInst("Inc", {matrix[0]});
prog.PushInst("Inc", {matrix[0]});
prog.PushInst("Inc", {matrix[0]});
prog.PushInst("While", {matrix[0]});
prog.PushInst("Inc", {matrix[1]});
prog.PushInst("Dec", {matrix[0]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
cpu.SetProgram(prog);
cpu.CallModule(0);
// std::cout << "\n\n---PROGRAM---\n\n";
// cpu.GetProgram().Print();
// std::cout << "\n\n--- INITIAL STATE ---" << std::endl;
// cpu.PrintHardwareState();
for (size_t i = 0; i < 25; ++i) {
// std::cout << "\n\n--- AFTER CYCLE " << i << std::endl;
cpu.SingleProcess();
// cpu.PrintHardwareState();
}
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(0).GetNum() == 0);
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(1).GetNum() == 3);
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(2).GetNum() == 12);
// ---------------------------------------
// ---------------------------------------
// - TEST: If(false) ... Implicit close
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
prog.PushInst("Nop", {matrix[0]});
prog.PushInst("Nop", {matrix[0]});
prog.PushInst("Nop", {matrix[0]});
prog.PushInst("While", {matrix[0]});
prog.PushInst("Inc", {matrix[1]});
prog.PushInst("Dec", {matrix[0]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
cpu.SetProgram(prog);
cpu.CallModule(0);
// std::cout << "\n\n---PROGRAM---\n\n";
// cpu.GetProgram().Print();
// std::cout << "\n\n--- INITIAL STATE ---" << std::endl;
// cpu.PrintHardwareState();
for (size_t i = 0; i < 4; ++i) {
// std::cout << "\n\n--- AFTER CYCLE " << i << std::endl;
cpu.SingleProcess();
// cpu.PrintHardwareState();
}
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(0).GetNum() == 0);
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(1).GetNum() == 0);
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(2).GetNum() == 0);
// ---------------------------------------
// ---------------------------------------
// - TEST: while(true) ... break ... Close ...
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
prog.PushInst("Inc", {matrix[0]});
prog.PushInst("Inc", {matrix[0]});
prog.PushInst("Inc", {matrix[0]});
prog.PushInst("While", {matrix[0]});
prog.PushInst("Inc", {matrix[1]});
prog.PushInst("Dec", {matrix[0]});
prog.PushInst("Break", {});
prog.PushInst("Inc", {matrix[1]});
prog.PushInst("Close", {matrix[0]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
cpu.SetProgram(prog);
cpu.CallModule(0);
// std::cout << "\n\n---PROGRAM---\n\n";
// cpu.GetProgram().Print();
// std::cout << "\n\n--- INITIAL STATE ---" << std::endl;
// cpu.PrintHardwareState();
for (size_t i = 0; i < 11; ++i) {
// std::cout << "\n\n--- AFTER CYCLE " << i << std::endl;
cpu.SingleProcess();
// cpu.PrintHardwareState();
}
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(0).GetNum() == 2);
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(1).GetNum() == 1);
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(2).GetNum() == 4);
// ---------------------------------------
// ---------------------------------------
// - TEST: while(true) ... break ... Close ...
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
prog.PushInst("Inc", {matrix[0]});
prog.PushInst("Inc", {matrix[0]});
prog.PushInst("Inc", {matrix[0]});
prog.PushInst("While", {matrix[0]});
prog.PushInst("Inc", {matrix[1]});
prog.PushInst("Dec", {matrix[0]});
prog.PushInst("While", {matrix[1]});
prog.PushInst("Nop", {});
prog.PushInst("Dec", {matrix[1]});
prog.PushInst("Break", {});
prog.PushInst("Inc", {matrix[1]});
prog.PushInst("Close", {matrix[0]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
cpu.SetProgram(prog);
cpu.CallModule(0);
// std::cout << "\n\n---PROGRAM---\n\n";
// cpu.GetProgram().Print();
// std::cout << "\n\n--- INITIAL STATE ---" << std::endl;
// cpu.PrintHardwareState();
for (size_t i = 0; i < 37; ++i) {
// std::cout << "\n\n--- AFTER CYCLE " << i << std::endl;
cpu.SingleProcess();
// cpu.PrintHardwareState();
}
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(0).GetNum() == 0);
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(1).GetNum() == 0);
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(2).GetNum() == 12);
// ---------------------------------------
///////////////////////////////////////////
}
TEST_CASE("Inst_Countdown", "[taglgp]") {
// Constants
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 13;
// Convenient aliases
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
// Create new random number generator
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
// Create new instruction library
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
// Create virtual hardware w/inst_lib
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix);
// Create new program
program_t prog(inst_lib);
/////////////////////////////////////
// Instruction testing
// InstProperty BEGIN_FLOW END_FLOW MODULE
inst_lib->AddInst("Inc", hardware_t::Inst_Inc, 1, "");
inst_lib->AddInst("Dec", hardware_t::Inst_Dec, 1, "");
inst_lib->AddInst("Nop", hardware_t::Inst_Nop, 0, "");
inst_lib->AddInst("If", hardware_t::Inst_If, 1, "", {inst_lib_t::InstProperty::BEGIN_FLOW});
inst_lib->AddInst("Countdown", hardware_t::Inst_Countdown, 1, "", {inst_lib_t::InstProperty::BEGIN_FLOW});
inst_lib->AddInst("Close", hardware_t::Inst_Close, 0, "", {inst_lib_t::InstProperty::END_FLOW});
inst_lib->AddInst("Break", hardware_t::Inst_Break, 0, "");
// ---------------------------------------
// - TEST: If(true) ... Close ...
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
prog.PushInst("Inc", {matrix[0]});
prog.PushInst("Inc", {matrix[0]});
prog.PushInst("Inc", {matrix[0]});
prog.PushInst("Countdown", {matrix[0]});
prog.PushInst("Inc", {matrix[1]});
prog.PushInst("Close", {matrix[0]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
cpu.SetProgram(prog);
cpu.CallModule(0);
// std::cout << "\n\n---PROGRAM---\n\n";
// cpu.GetProgram().Print();
// std::cout << "\n\n--- INITIAL STATE ---" << std::endl;
// cpu.PrintHardwareState();
for (size_t i = 0; i < 17; ++i) {
// std::cout << "\n\n--- AFTER CYCLE " << i << std::endl;
cpu.SingleProcess();
// cpu.PrintHardwareState();
}
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(0).GetNum() == 0);
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(1).GetNum() == 3);
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(2).GetNum() == 4);
// ---------------------------------------
}
TEST_CASE("Inst_Foreach", "[taglgp]") {
// Constants
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 13;
// Convenient aliases
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
// Create new random number generator
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
// Create new instruction library
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
// Create virtual hardware w/inst_lib
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix);
// Create new program
program_t prog(inst_lib);
/////////////////////////////////////
// Instruction testing
// InstProperty BEGIN_FLOW END_FLOW MODULE
inst_lib->AddInst("Inc", hardware_t::Inst_Inc, 1, "");
inst_lib->AddInst("Dec", hardware_t::Inst_Dec, 1, "");
inst_lib->AddInst("Nop", hardware_t::Inst_Nop, 0, "");
inst_lib->AddInst("If", hardware_t::Inst_If, 1, "", {inst_lib_t::InstProperty::BEGIN_FLOW});
inst_lib->AddInst("MakeVector", hardware_t::Inst_MakeVector, 3, "");
inst_lib->AddInst("Foreach", hardware_t::Inst_Foreach, 1, "", {inst_lib_t::InstProperty::BEGIN_FLOW});
inst_lib->AddInst("Close", hardware_t::Inst_Close, 0, "", {inst_lib_t::InstProperty::END_FLOW});
inst_lib->AddInst("Break", hardware_t::Inst_Break, 0, "");
// ---------------------------------------
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
prog.PushInst("Dec", {matrix[0]});
prog.PushInst("Dec", {matrix[1]});
prog.PushInst("Dec", {matrix[1]});
prog.PushInst("Dec", {matrix[2]});
prog.PushInst("Dec", {matrix[2]});
prog.PushInst("Dec", {matrix[2]});
prog.PushInst("Dec", {matrix[3]});
prog.PushInst("Dec", {matrix[3]});
prog.PushInst("Dec", {matrix[3]});
prog.PushInst("Dec", {matrix[3]});
prog.PushInst("MakeVector", {matrix[0], matrix[3], matrix[0]});
prog.PushInst("Inc", {matrix[1]});
prog.PushInst("Inc", {matrix[1]});
prog.PushInst("Foreach", {matrix[3], matrix[0]});
prog.PushInst("Inc", {matrix[1]});
prog.PushInst("Close", {});
prog.PushInst("Nop", {});
cpu.SetProgram(prog);
cpu.CallModule(0);
// std::cout << "\n\n---PROGRAM---\n\n";
// cpu.GetProgram().Print();
// std::cout << "\n\n--- INITIAL STATE ---" << std::endl;
// cpu.PrintHardwareState();
for (size_t i = 0; i < 27; ++i) {
// std::cout << "\n\n--- AFTER CYCLE " << i << std::endl;
cpu.SingleProcess();
// cpu.PrintHardwareState();
}
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(1).GetNum() == 4);
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(2).GetNum() == -3);
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(3).GetNum() == -4);
// ---------------------------------------
// exit(-1);
// ---------------------------------------
// - TEST: If(true) ... Close ...
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
prog.PushInst("Dec", {matrix[0]});
prog.PushInst("Dec", {matrix[1]});
prog.PushInst("Dec", {matrix[1]});
prog.PushInst("Dec", {matrix[2]});
prog.PushInst("Dec", {matrix[2]});
prog.PushInst("Dec", {matrix[2]});
prog.PushInst("Dec", {matrix[3]});
prog.PushInst("Dec", {matrix[3]});
prog.PushInst("Dec", {matrix[3]});
prog.PushInst("Dec", {matrix[3]});
prog.PushInst("MakeVector", {matrix[0], matrix[3], matrix[0]});
prog.PushInst("Inc", {matrix[1]});
prog.PushInst("Inc", {matrix[1]});
prog.PushInst("Foreach", {matrix[0], matrix[0]});
prog.PushInst("Inc", {matrix[1]});
prog.PushInst("Close", {});
prog.PushInst("Nop", {});
cpu.SetProgram(prog);
cpu.CallModule(0);
// std::cout << "\n\n---PROGRAM---\n\n";
// cpu.GetProgram().Print();
// std::cout << "\n\n--- INITIAL STATE ---" << std::endl;
// cpu.PrintHardwareState();
for (size_t i = 0; i < 18; ++i) {
// std::cout << "\n\n--- AFTER CYCLE " << i << std::endl;
cpu.SingleProcess();
// cpu.PrintHardwareState();
}
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(0).GetNum() == -1);
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(1).GetNum() == 1);
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(2).GetNum() == -3);
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(3).GetNum() == -4);
// ---------------------------------------
}
TEST_CASE("Inst_Call", "[taglgp]") {
// Constants
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 13;
// Convenient aliases
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
// Create new random number generator
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
// Create new instruction library
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
// Create virtual hardware w/inst_lib
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix);
// Create new program
program_t prog(inst_lib);
/////////////////////////////////////
// Instruction testing
// InstProperty BEGIN_FLOW END_FLOW MODULE
inst_lib->AddInst("Inc", hardware_t::Inst_Inc, 1, "");
inst_lib->AddInst("Dec", hardware_t::Inst_Dec, 1, "");
inst_lib->AddInst("Nop", hardware_t::Inst_Nop, 0, "");
inst_lib->AddInst("If", hardware_t::Inst_If, 1, "", {inst_lib_t::InstProperty::BEGIN_FLOW});
inst_lib->AddInst("Call", hardware_t::Inst_Call, 1, "");
inst_lib->AddInst("Return", hardware_t::Inst_Return, 0, "");
inst_lib->AddInst("Output", hardware_t::Inst_Output, 2, "");
inst_lib->AddInst("ModuleDef", hardware_t::Inst_Nop, 1, "", {inst_lib_t::InstProperty::MODULE});
inst_lib->AddInst("Close", hardware_t::Inst_Close, 0, "", {inst_lib_t::InstProperty::END_FLOW});
inst_lib->AddInst("Break", hardware_t::Inst_Break, 0, "");
// ---------------------------------------
// - TEST: If(true) ... Close ...
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
prog.PushInst("Nop", {});
prog.PushInst("Return", {matrix[2]});
prog.PushInst("Output", {matrix[2], matrix[3]});
prog.PushInst("ModuleDef", {matrix[0]});
prog.PushInst("Inc", {matrix[0]});
prog.PushInst("Call", {matrix[1]});
prog.PushInst("Inc", {matrix[0]});
prog.PushInst("Call", {matrix[2]});
prog.PushInst("Nop", {matrix[2]});
prog.PushInst("ModuleDef", {matrix[1]});
prog.PushInst("Inc", {matrix[1]});
prog.PushInst("Output", {matrix[1], matrix[1]});
prog.PushInst("ModuleDef", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Output", {matrix[2], matrix[2]});
cpu.SetProgram(prog);
cpu.CallModule(0);
// std::cout << "\n\n---PROGRAM---\n\n";
// cpu.GetProgram().Print();
// std::cout << "\n\n--- INITIAL STATE ---" << std::endl;
// cpu.PrintHardwareState();
for (size_t i = 0; i < 12; ++i) {
// std::cout << "\n\n--- AFTER CYCLE " << i << std::endl;
cpu.SingleProcess();
// cpu.PrintHardwareState();
}
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(0).GetNum() == 2);
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(1).GetNum() == 1);
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(2).GetNum() == 2);
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(3).GetNum() == 0);
// ---------------------------------------
}
TEST_CASE("Inst_Routine", "[taglgp]") {
// Constants
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 13;
// Convenient aliases
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
// Create new random number generator
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
// Create new instruction library
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
// Create virtual hardware w/inst_lib
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix);
// Create new program
program_t prog(inst_lib);
/////////////////////////////////////
// Instruction testing
// InstProperty BEGIN_FLOW END_FLOW MODULE
inst_lib->AddInst("Inc", hardware_t::Inst_Inc, 1, "");
inst_lib->AddInst("Dec", hardware_t::Inst_Dec, 1, "");
inst_lib->AddInst("Nop", hardware_t::Inst_Nop, 0, "");
inst_lib->AddInst("If", hardware_t::Inst_If, 1, "", {inst_lib_t::InstProperty::BEGIN_FLOW});
inst_lib->AddInst("IfNot", hardware_t::Inst_IfNot, 1, "", {inst_lib_t::InstProperty::BEGIN_FLOW});
inst_lib->AddInst("Call", hardware_t::Inst_Call, 1, "");
inst_lib->AddInst("Routine", hardware_t::Inst_Routine, 1, "");
inst_lib->AddInst("While", hardware_t::Inst_While, 1, "");
inst_lib->AddInst("Return", hardware_t::Inst_Return, 0, "");
inst_lib->AddInst("Output", hardware_t::Inst_Output, 2, "");
inst_lib->AddInst("ModuleDef", hardware_t::Inst_Nop, 1, "", {inst_lib_t::InstProperty::MODULE});
inst_lib->AddInst("Close", hardware_t::Inst_Close, 0, "", {inst_lib_t::InstProperty::END_FLOW});
inst_lib->AddInst("Break", hardware_t::Inst_Break, 0, "");
// ---------------------------------------
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
prog.PushInst("Nop", {});
prog.PushInst("Return", {matrix[2]});
prog.PushInst("Dec", {matrix[2]});
prog.PushInst("ModuleDef", {matrix[0]});
prog.PushInst("Inc", {matrix[0]});
prog.PushInst("Routine", {matrix[1]});
prog.PushInst("Inc", {matrix[0]});
prog.PushInst("Routine", {matrix[2]});
prog.PushInst("Inc", {matrix[0]});
prog.PushInst("Nop", {matrix[2]});
prog.PushInst("ModuleDef", {matrix[1]});
prog.PushInst("Inc", {matrix[1]});
prog.PushInst("ModuleDef", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
cpu.SetProgram(prog);
cpu.CallModule(0);
// std::cout << "\n\n---PROGRAM---\n\n";
// cpu.GetProgram().Print();
// std::cout << "\n\n--- INITIAL STATE ---" << std::endl;
// cpu.PrintHardwareState();
for (size_t i = 0; i < 11; ++i) {
// std::cout << "\n\n--- AFTER CYCLE " << i << std::endl;
cpu.SingleProcess();
// cpu.PrintHardwareState();
}
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(0).GetNum() == 3);
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(1).GetNum() == 1);
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(2).GetNum() == 2);
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(3).GetNum() == 0);
// ---------------------------------------
// ---------------------------------------
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
prog.PushInst("If", {matrix[2]});
prog.PushInst("Nop", {matrix[2]});
prog.PushInst("While", {matrix[2]});
prog.PushInst("Nop", {matrix[2]});
prog.PushInst("Return", {matrix[2]});
prog.PushInst("Close", {matrix[2]});
prog.PushInst("Close", {matrix[2]});
prog.PushInst("Routine", {matrix[2]});
prog.PushInst("ModuleDef", {matrix[0]});
prog.PushInst("Inc", {matrix[0]});
prog.PushInst("Routine", {matrix[1]});
prog.PushInst("Inc", {matrix[0]});
prog.PushInst("Routine", {matrix[2]});
prog.PushInst("Inc", {matrix[0]});
prog.PushInst("Nop", {matrix[2]});
prog.PushInst("ModuleDef", {matrix[1]});
prog.PushInst("Inc", {matrix[1]});
prog.PushInst("ModuleDef", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
prog.PushInst("Inc", {matrix[2]});
cpu.SetProgram(prog);
cpu.CallModule(0);
// std::cout << "\n\n---PROGRAM---\n\n";
// cpu.GetProgram().Print();
// std::cout << "\n\n--- INITIAL STATE ---" << std::endl;
// cpu.PrintHardwareState();
for (size_t i = 0; i < 14; ++i) {
// std::cout << "\n\n--- AFTER CYCLE " << i << std::endl;
cpu.SingleProcess();
// cpu.PrintHardwareState();
}
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(0).GetNum() == 3);
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(1).GetNum() == 1);
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(2).GetNum() == 2);
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(3).GetNum() == 0);
// ---------------------------------------
// ---------------------------------------
cpu.Reset(); // Hard reset on virtual CPU
prog.Clear();
prog.PushInst("IfNot", {matrix[3]});
prog.PushInst("Return", {});
prog.PushInst("Close", {matrix[0]});
prog.PushInst("Dec", {matrix[3]});
prog.PushInst("Close", {matrix[0]});
prog.PushInst("Nop", {matrix[0]});
prog.PushInst("Routine", {matrix[1]});
prog.PushInst("ModuleDef", {matrix[0]});
prog.PushInst("Inc", {matrix[3]});
prog.PushInst("Inc", {matrix[3]});
prog.PushInst("Inc", {matrix[3]});
prog.PushInst("Inc", {matrix[3]});
prog.PushInst("Inc", {matrix[3]});
prog.PushInst("Routine", {matrix[1]});
prog.PushInst("Inc", {matrix[0]});
prog.PushInst("Nop", {matrix[0]});
prog.PushInst("ModuleDef", {matrix[1]});
prog.PushInst("Inc", {matrix[1]});
prog.PushInst("If", {matrix[3]});
cpu.SetProgram(prog);
cpu.CallModule(0);
// std::cout << "\n\n---PROGRAM---\n\n";
// cpu.GetProgram().Print();
// std::cout << "\n\n--- INITIAL STATE ---" << std::endl;
// cpu.PrintHardwareState();
for (size_t i = 0; i < 47; ++i) {
// std::cout << "\n\n--- AFTER CYCLE " << i << std::endl;
cpu.SingleProcess();
// cpu.PrintHardwareState();
}
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(0).GetNum() == 1);
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(1).GetNum() == 6);
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(2).GetNum() == 0);
REQUIRE(cpu.GetCurCallState().GetWorkingMem().AccessVal(3).GetNum() == 0);
// ---------------------------------------
}
TEST_CASE("RandomPrograms", "[taglgp]") {
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 2;
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_t = typename hardware_t::inst_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix);
std::cout << "Empty instruction library:" << std::endl;
inst_lib->Print(); std::cout << std::endl;
inst_lib->AddInst("Add", hardware_t::Inst_Add, 3, "");
inst_lib->AddInst("Sub", hardware_t::Inst_Sub, 3, "");
inst_lib->AddInst("Mult", hardware_t::Inst_Mult, 3, "");
inst_lib->AddInst("Inc", hardware_t::Inst_Inc, 1, "");
inst_lib->AddInst("Dec", hardware_t::Inst_Dec, 1, "");
inst_lib->AddInst("Div", hardware_t::Inst_Div, 3, "");
inst_lib->AddInst("Mod", hardware_t::Inst_Mod, 3, "");
inst_lib->AddInst("Not", hardware_t::Inst_Not, 3, "");
inst_lib->AddInst("TestNumEqu", hardware_t::Inst_TestNumEqu, 3, "");
inst_lib->AddInst("TestNumNEqu", hardware_t::Inst_TestNumNEqu, 3, "");
inst_lib->AddInst("TestNumLess", hardware_t::Inst_TestNumLess, 3, "");
inst_lib->AddInst("Floor", hardware_t::Inst_Floor, 3, "");
inst_lib->AddInst("CopyMem", hardware_t::Inst_CopyMem, 3, "");
inst_lib->AddInst("SwapMem", hardware_t::Inst_SwapMem, 3, "");
inst_lib->AddInst("Input", hardware_t::Inst_Input, 3, "");
inst_lib->AddInst("Output", hardware_t::Inst_Output, 3, "");
inst_lib->AddInst("CommitGlobal", hardware_t::Inst_CommitGlobal, 3, "");
inst_lib->AddInst("PullGlobal", hardware_t::Inst_PullGlobal, 3, "");
inst_lib->AddInst("TestMemEqu", hardware_t::Inst_TestMemEqu, 3, "");
inst_lib->AddInst("TestMemNEqu", hardware_t::Inst_TestMemNEqu, 3, "");
inst_lib->AddInst("MakeVector", hardware_t::Inst_MakeVector, 3, "");
inst_lib->AddInst("VecGet", hardware_t::Inst_VecGet, 3, "");
inst_lib->AddInst("VecSet", hardware_t::Inst_VecSet, 3, "");
inst_lib->AddInst("VecLen", hardware_t::Inst_VecLen, 3, "");
inst_lib->AddInst("VecAppend", hardware_t::Inst_VecAppend, 3, "");
inst_lib->AddInst("VecPop", hardware_t::Inst_VecPop, 3, "");
inst_lib->AddInst("VecRemove", hardware_t::Inst_VecRemove, 3, "");
inst_lib->AddInst("VecReplaceAll", hardware_t::Inst_VecReplaceAll, 3, "");
inst_lib->AddInst("VecIndexOf", hardware_t::Inst_VecIndexOf, 3, "");
inst_lib->AddInst("VecOccurrencesOf", hardware_t::Inst_VecOccurrencesOf, 3, "");
inst_lib->AddInst("VecReverse", hardware_t::Inst_VecReverse, 3, "");
inst_lib->AddInst("VecSwapIfLess", hardware_t::Inst_VecSwapIfLess, 3, "");
inst_lib->AddInst("VecGetFront", hardware_t::Inst_VecGetFront, 3, "");
inst_lib->AddInst("VecGetBack", hardware_t::Inst_VecGetBack, 3, "");
inst_lib->AddInst("IsStr", hardware_t::Inst_IsStr, 3, "");
inst_lib->AddInst("IsNum", hardware_t::Inst_IsNum, 3, "");
inst_lib->AddInst("IsVec", hardware_t::Inst_IsVec, 3, "");
inst_lib->AddInst("If", hardware_t::Inst_If, 3, "", {inst_lib_t::InstProperty::BEGIN_FLOW});
inst_lib->AddInst("IfNot", hardware_t::Inst_IfNot, 3, "", {inst_lib_t::InstProperty::BEGIN_FLOW});
inst_lib->AddInst("While", hardware_t::Inst_While, 3, "", {inst_lib_t::InstProperty::BEGIN_FLOW});
inst_lib->AddInst("Countdown", hardware_t::Inst_Countdown, 3, "", {inst_lib_t::InstProperty::BEGIN_FLOW});
inst_lib->AddInst("Foreach", hardware_t::Inst_Foreach, 3, "", {inst_lib_t::InstProperty::BEGIN_FLOW});
inst_lib->AddInst("Close", hardware_t::Inst_Close, 3, "", {inst_lib_t::InstProperty::END_FLOW});
inst_lib->AddInst("Break", hardware_t::Inst_Break, 3, "");
inst_lib->AddInst("Call", hardware_t::Inst_Call, 3, "");
inst_lib->AddInst("Routine", hardware_t::Inst_Routine, 3, "");
inst_lib->AddInst("Return", hardware_t::Inst_Return, 3, "");
inst_lib->AddInst("ModuleDef", hardware_t::Inst_Nop, 3, "", {inst_lib_t::InstProperty::MODULE});
inst_lib->AddInst("Nop", hardware_t::Inst_Nop, 3, "");
// Add Terminals
for (size_t i = 0; i <= 16; ++i) {
inst_lib->AddInst("Set-" + emp::to_string(i),
[i](hardware_t & hw, const inst_t & inst) {
hardware_t::CallState & state = hw.GetCurCallState();
hardware_t::Memory & wmem = state.GetWorkingMem();
size_t posA = hw.FindBestMemoryMatch(wmem, inst.arg_tags[0], hw.GetMinTagSpecificity());
if (!hw.IsValidMemPos(posA)) return; // Do nothing
wmem.Set(posA, (double)i);
});
}
inst_lib->AddInst("Set-A",
[](hardware_t & hw, const inst_t & inst) {
hardware_t::CallState & state = hw.GetCurCallState();
hardware_t::Memory & wmem = state.GetWorkingMem();
size_t posA = hw.FindBestMemoryMatch(wmem, inst.arg_tags[0], hw.GetMinTagSpecificity());
if (!hw.IsValidMemPos(posA)) return; // Do nothing
wmem.Set(posA, "A");
});
inst_lib->AddInst("Set-B",
[](hardware_t & hw, const inst_t & inst) {
hardware_t::CallState & state = hw.GetCurCallState();
hardware_t::Memory & wmem = state.GetWorkingMem();
size_t posA = hw.FindBestMemoryMatch(wmem, inst.arg_tags[0], hw.GetMinTagSpecificity());
if (!hw.IsValidMemPos(posA)) return; // Do nothing
wmem.Set(posA, "A");
});
inst_lib->AddInst("Set-C",
[](hardware_t & hw, const inst_t & inst) {
hardware_t::CallState & state = hw.GetCurCallState();
hardware_t::Memory & wmem = state.GetWorkingMem();
size_t posA = hw.FindBestMemoryMatch(wmem, inst.arg_tags[0], hw.GetMinTagSpecificity());
if (!hw.IsValidMemPos(posA)) return; // Do nothing
wmem.Set(posA, "A");
});
// Print populated instruction library
// std::cout << "Populated instruction library:" << std::endl;
// inst_lib->Print(); std::cout << std::endl;
// Run a bunch of randomly generated programs for 1024 updates
for (size_t p = 0; p < 100; ++p) {
cpu.Reset(); // Hard reset on virtual CPU
std::cout << "Testing random program #" << p << "..." << std::endl;
program_t prg(inst_lib);
size_t N = random->GetUInt(512, 2046);
for (size_t i = 0; i < N; ++i) {
prg.PushInst(TagLGP::GenRandTagGPInst(*random, *inst_lib));
}
cpu.SetProgram(prg);
cpu.CallModule(0);
// if (p==252) {
// std::cout << "\n\n----- PROGRAM ----" << std::endl;
// cpu.GetProgram().Print();
// std::cout << "\n\n----- PROGRAM (by modules) ----" << std::endl;
// cpu.PrintModuleSequences();
// }
for (size_t i = 0; i < 4096; ++i) {
// std::cout << ">> Cycle: " << i << std::endl;
cpu.SingleProcess();
}
std::cout << " ...Done." << std::endl;
}
cpu.GetProgram().Print();
}
TEST_CASE("RandomProgramsNumericArgs", "[taglgp]") {
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 2;
// Not going to use tags, but still have to define TagLinearGP virtual hardware with tag width.
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_t = typename hardware_t::inst_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix); // Not going to use these here, but no harm in setting them up.
// Add some garbage instructions to instruction set
for (size_t i = 0; i <= 16; ++i) {
inst_lib->AddInst("Nop-" + emp::to_string(i), [](hardware_t & hw, const inst_t & inst) { } );
}
for (size_t p = 0; p < 10; ++p) {
std::cout << "=========================" << std::endl;
std::cout << "Random program with NUMERIC ARGUMENTS #" << p << "..." << std::endl;
program_t prg(inst_lib);
size_t N = random->GetUInt(8, 32);
for (size_t i = 0; i < N; ++i) {
prg.PushInst(TagLGP::GenRandTagGPInst_NumArgs(*random, *inst_lib, cpu.GetMemSize()-1));
}
prg.Print();
}
for (size_t p = 0; p < 10; ++p) {
std::cout << "=========================" << std::endl;
std::cout << "Random program with TAG ARGUMENTS #" << p << "..." << std::endl;
program_t prg(inst_lib);
size_t N = random->GetUInt(8, 32);
for (size_t i = 0; i < N; ++i) {
prg.PushInst(TagLGP::GenRandTagGPInst(*random, *inst_lib));
}
prg.Print();
}
for (size_t p = 0; p < 10; ++p) {
std::cout << "=========================" << std::endl;
std::cout << "Random program with NUMERIC AND TAG ARGUMENTS #" << p << "..." << std::endl;
program_t prg(inst_lib);
size_t N = random->GetUInt(8, 32);
for (size_t i = 0; i < N; ++i) {
prg.PushInst(TagLGP::GenRandTagGPInst_TagAndNumArgs(*random, *inst_lib, cpu.GetMemSize()-1));
}
prg.Print();
}
}
*/
TEST_CASE("FindBestMatch (DIRECT INDEX)", "[taglgp]") {
constexpr size_t TAG_WIDTH = 4;
constexpr int seed = 2;
// Not going to use tags, but still have to define TagLinearGP virtual hardware with tag width.
using hardware_t = TagLGP::TagLinearGP_TW<TAG_WIDTH>;
using program_t = typename hardware_t::program_t;
using inst_t = typename hardware_t::inst_t;
using inst_lib_t = TagLGP::InstLib<hardware_t>;
using memory_t = typename hardware_t::memory_t;
emp::Ptr<emp::Random> random = emp::NewPtr<emp::Random>(seed);
emp::Ptr<inst_lib_t> inst_lib = emp::NewPtr<inst_lib_t>();
hardware_t cpu(inst_lib, random);
// Configure CPU
emp::vector<emp::BitSet<TAG_WIDTH>> matrix = GenHadamardMatrix<TAG_WIDTH>();
cpu.SetMemSize(TAG_WIDTH);
cpu.SetMemTags(matrix); // Not going to use these here, but no harm in setting them up.
inst_lib->AddInst("Nop", hardware_t::Inst_Nop, 0, "");
program_t prog(inst_lib);
prog.PushInst("Nop", {0,0,0});
prog.PushInst("Nop", {0,0,0});
prog.PushInst("Nop", {0,0,0});
prog.PushInst("Nop", {0,0,0});
prog.PushInst("Nop", {0,0,0});
cpu.SetProgram(prog);
cpu.CallModule(0);
auto & state = cpu.GetCurCallState();
memory_t & wmem = state.GetWorkingMem();
std::cout << "--------- initial hardware state ---------" << std::endl;
cpu.PrintHardwareState();
size_t mem_index = 2;
hardware_t::MemPosType mem_type = hardware_t::MemPosType::NUM;
std::cout << "Search for NUM @ index " << mem_index << ": " << cpu.FindBestMemoryMatch(wmem, mem_index, mem_type) << std::endl;
mem_index = 2;
mem_type = hardware_t::MemPosType::ANY;
std::cout << "Search for ANY @ index " << mem_index << ": " << cpu.FindBestMemoryMatch(wmem, mem_index, mem_type) << std::endl;
mem_index = 2;
mem_type = hardware_t::MemPosType::VEC;
std::cout << "Search for VEC @ index " << mem_index << ": " << cpu.FindBestMemoryMatch(wmem, mem_index, mem_type) << std::endl;
mem_index = 2;
mem_type = hardware_t::MemPosType::STR;
std::cout << "Search for STR @ index " << mem_index << ": " << cpu.FindBestMemoryMatch(wmem, mem_index, mem_type) << std::endl;
wmem.Set(0, "Hello");
wmem.Set(1, {"hello", "there", "again"});
cpu.PrintHardwareState();
mem_index = 2;
mem_type = hardware_t::MemPosType::VEC;
std::cout << "Search for VEC @ index " << mem_index << ": " << cpu.FindBestMemoryMatch(wmem, mem_index, mem_type) << std::endl;
mem_index = 2;
mem_type = hardware_t::MemPosType::STR;
std::cout << "Search for STR @ index " << mem_index << ": " << cpu.FindBestMemoryMatch(wmem, mem_index, mem_type) << std::endl;
mem_index = 2;
std::cout << "Search for STR/VEC @ index " << mem_index << ": " << cpu.FindBestMemoryMatch(wmem, mem_index, {hardware_t::MemPosType::VEC, hardware_t::MemPosType::STR}) << std::endl;
}
| [
"amlalejini@gmail.com"
] | amlalejini@gmail.com |
5be51bdb14490db4b93915ae4cf5a80ca1b6e53e | c8d324a7368890d50f2ac9b953b78336b2079b60 | /RecoBTag/LWTNN/src/NanReplacer.cc | f13e31d123b30ace0f93af55f087df57b4099668 | [] | no_license | vhbb/cmssw | 73345541bb62951f2303ccbff18a32a7b46156a5 | 81148c34bb3b546425be61af523c4a7847253484 | refs/heads/vhbbHeppy80X | 2021-01-18T19:45:44.179241 | 2017-03-29T15:21:44 | 2017-03-29T15:21:44 | 11,608,804 | 7 | 11 | null | 2023-02-09T09:10:52 | 2013-07-23T13:22:20 | C++ | UTF-8 | C++ | false | false | 1,231 | cc | #include "RecoBTag/LWTNN/interface/NanReplacer.h"
#include <cmath> // NAN
#include <limits> // check for NAN
static_assert(std::numeric_limits<double>::has_quiet_NaN,
"no NaN defined, but we require one");
namespace lwt {
NanReplacer::NanReplacer(const NanReplacer::ValueMap& defaults, int fg):
_defaults(defaults),
_do_nan(fg & rep::nan),
_do_inf(fg & rep::inf),
_do_ninf(fg & rep::ninf)
{
}
NanReplacer::ValueMap
NanReplacer::replace(const NanReplacer::ValueMap& inputs) const {
// return a new map with the NaN values replaced where possible.
ValueMap outputs;
// loop over all inputs
for (const auto& in: inputs) {
double val = in.second;
// figure out if this value should be replaced
bool is_nan = _do_nan && std::isnan(val);
bool is_inf = _do_inf && std::isinf(val) && !std::signbit(val);
bool is_ninf = _do_ninf && std::isinf(val) && std::signbit(val);
bool is_bad = is_nan || is_inf || is_ninf;
bool in_defaults = _defaults.count(in.first);
if (is_bad && in_defaults) {
outputs[in.first] = _defaults.at(in.first);
} else {
outputs[in.first] = val;
}
}
return outputs;
}
}
| [
"mverzett@cern.ch"
] | mverzett@cern.ch |
2d789e890ec18e8848337011cfabb68d66b2d49f | 6782ad738a872d79a01144e3461cba4d26136462 | /ncbi-blast-2.2.27+-src/c++/src/algo/blast/api/deltablast.cpp | 0be44b83374d60e6639410ed321432b40aab3f31 | [
"MIT"
] | permissive | kenongit/sequencing | 0ecc5a7d0fb9ef87294feb7cf37e695ef9849b4d | 7eb738cab66c4afda678f3d07b2c0756f4d26183 | refs/heads/master | 2020-12-25T09:38:04.815956 | 2013-05-14T23:06:43 | 2013-05-14T23:06:43 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,896 | cpp | #ifndef SKIP_DOXYGEN_PROCESSING
static char const rcsid[] =
"";
#endif /* SKIP_DOXYGEN_PROCESSING */
/* ===========================================================================
*
* PUBLIC DOMAIN NOTICE
* National Center for Biotechnology Information
*
* This software/database is a "United States Government Work" under the
* terms of the United States Copyright Act. It was written as part of
* the author's official duties as a United States Government employee and
* thus cannot be copyrighted. This software/database is freely available
* to the public for use. The National Library of Medicine and the U.S.
* Government have not placed any restriction on its use or reproduction.
*
* Although all reasonable efforts have been taken to ensure the accuracy
* and reliability of the software and data, the NLM and the U.S.
* Government do not and cannot warrant the performance or results that
* may be obtained by using this software or data. The NLM and the U.S.
* Government disclaim all warranties, express or implied, including
* warranties of performance, merchantability or fitness for any particular
* purpose.
*
* Please cite the author in any work or product based on this material.
*
* ===========================================================================
*
* Author: Greg Boratyn
*
*/
/** @file deltablast.cpp
* Implementation of CDeltaBlast.
*/
#include <ncbi_pch.hpp>
#include <algo/blast/api/psiblast.hpp>
// PSSM Engine includes
#include <algo/blast/api/pssm_engine.hpp>
#include <objects/scoremat/PssmWithParameters.hpp>
#include <objects/scoremat/Pssm.hpp>
#include <algo/blast/api/local_blast.hpp>
#include <algo/blast/api/deltablast.hpp>
/** @addtogroup AlgoBlast
*
* @{
*/
BEGIN_NCBI_SCOPE
USING_SCOPE(objects);
BEGIN_SCOPE(blast);
CDeltaBlast::CDeltaBlast(CRef<IQueryFactory> query_factory,
CRef<CLocalDbAdapter> blastdb,
CRef<CLocalDbAdapter> domain_db,
CConstRef<CDeltaBlastOptionsHandle> options)
: m_Queries(query_factory),
m_Subject(blastdb),
m_DomainDb(domain_db),
m_Options(options)
{
x_Validate();
}
CRef<CSearchResultSet> CDeltaBlast::Run(void)
{
CPSIBlastOptions opts;
PSIBlastOptionsNew(&opts);
opts->inclusion_ethresh = m_Options->GetDomainInclusionThreshold();
// Make domain search
m_DomainResults = x_FindDomainHits();
CRef<ILocalQueryData> query_data =
m_Queries->MakeLocalQueryData(&m_Options->GetOptions());
// get query sequences
BLAST_SequenceBlk* seq_blk = query_data->GetSequenceBlk();
BlastQueryInfo* query_info = query_data->GetQueryInfo();
vector<Uint1*> query_seq(query_data->GetNumQueries(), NULL);
vector<size_t> query_lens(query_data->GetNumQueries(), 0);
for (size_t i=0;i < query_data->GetNumQueries();i++) {
query_seq[i] =
seq_blk->sequence_start + query_info->contexts[i].query_offset + 1;
query_lens[i] = query_info->contexts[i].query_length;
}
_ASSERT(m_DomainResults->size() == query_seq.size());
// TO DO: Allow for more information in diagnostics
CPSIDiagnosticsRequest diags;
diags.Reset(PSIDiagnosticsRequestNewEx(false));
// for each results from single query
for (size_t i=0;i < m_DomainResults->size();i++) {
CRef<CCddInputData> pssm_input(
new CCddInputData(query_seq[i],
query_lens[i],
(*m_DomainResults)[i].GetSeqAlign(),
*opts.Get(),
m_DomainDb->GetDatabaseName(),
m_Options->GetMatrixName(),
m_Options->GetGapOpeningCost(),
m_Options->GetGapExtensionCost(),
diags));
CRef<CPssmEngine> pssm_engine;
pssm_engine.Reset(new CPssmEngine(pssm_input.GetNonNullPointer()));
// compute pssm
m_Pssm.push_back(pssm_engine->Run());
// pssm may not have query id set if there were no CDD hits
// in such case set query id in the PSSM
if (!m_Pssm.back()->GetPssm().GetQuery().GetSeq().GetFirstId()) {
CRef<CSeq_id> query_id(const_cast<CSeq_id*>(
query_data->GetSeq_loc(i)->GetId()));
m_Pssm.back()->SetPssm().SetQuery().SetSeq().SetId().push_back(
query_id);
}
// Run psiblast with computed pssm
CConstRef<CPSIBlastOptionsHandle> psi_opts(
m_Options.GetNonNullPointer());
CPsiBlast psiblast(m_Pssm.back(), m_Subject, psi_opts);
psiblast.SetNumberOfThreads(GetNumberOfThreads());
CRef<CSearchResultSet> results = psiblast.Run();
if (m_Results.Empty()) {
m_Results = results;
}
else {
NON_CONST_ITERATE (CSearchResultSet, res, *results) {
m_Results->push_back(*res);
}
}
}
// return search results
return m_Results;
}
CConstRef<CPssmWithParameters> CDeltaBlast::GetPssm(int index) const
{
if (index >= (int)m_Pssm.size()) {
NCBI_THROW(CBlastException, eInvalidArgument, "PSSM index too large");
}
CConstRef<CPssmWithParameters> pssm(m_Pssm[index].GetNonNullPointer());
return pssm;
}
CRef<CPssmWithParameters> CDeltaBlast::GetPssm(int index)
{
if (index >= (int)m_Pssm.size()) {
NCBI_THROW(CBlastException, eInvalidArgument, "PSSM index too large");
}
CRef<CPssmWithParameters> pssm(m_Pssm[index].GetNonNullPointer());
return pssm;
}
CRef<CSearchResultSet> CDeltaBlast::x_FindDomainHits(void)
{
CRef<CBlastOptionsHandle> opts(CBlastOptionsFactory::Create(eRPSBlast));
opts->SetEvalueThreshold(m_Options->GetDomainInclusionThreshold());
opts->SetFilterString("F");
CLocalBlast blaster(m_Queries, opts, m_DomainDb);
return blaster.Run();
}
void CDeltaBlast::x_Validate(void)
{
if (m_Options.Empty()) {
NCBI_THROW(CBlastException, eInvalidArgument, "Missing options");
}
if (m_Queries.Empty()) {
NCBI_THROW(CBlastException, eInvalidArgument, "Missing query");
}
if (m_Subject.Empty()) {
NCBI_THROW(CBlastException, eInvalidArgument,
"Missing database or subject sequences");
}
if (m_DomainDb.Empty()) {
NCBI_THROW(CBlastException, eInvalidArgument, "Missing domain database");
}
}
END_SCOPE(blast)
END_NCBI_SCOPE
/* @} */
| [
"github@jakewendt.com"
] | github@jakewendt.com |
7cdb18e833e36f1fea57ad541695d0e8db35773f | d0651793397ff497c7cde2b23ba0edef7b343c41 | /source/polyvec/polygon-tracer/error-metrics.cpp | e3768998a0d14d8af6c89f0a929641eac5618d35 | [
"MIT"
] | permissive | lianzhouhui/polyfit | 75e50ad0e39d71098bd81ba37dac40528126d445 | e94d7410862571efb8bdd01502004f3e18f32717 | refs/heads/master | 2022-12-13T02:56:40.914634 | 2020-08-25T01:17:15 | 2020-08-25T01:17:15 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,054 | cpp | #include <polyvec/polygon-tracer/error-metrics.hpp>
// polyfit
#include <polyvec/api.hpp>
#include <polyvec/geom.hpp>
#include <polyvec/geometry/path.hpp>
#include <polyvec/core/options.hpp>
#include <polyvec/debug.hpp>
#include <polyvec/geometry/angle.hpp>
#include <polyvec/core/options.hpp>
// c++ stl
#include <algorithm>
// Eigen
#include <Eigen/Geometry>
#define TEST_PARAM_DEFAULT(v) (v)
#define TEST_PARAM_20_UP(v) ((v) + (.1 * (v)))
#define TEST_PARAM_20_DOWN(v) ((v) - (.1 * (v)))
// 1.
#define SMOOTHNESS_LIMIT TEST_PARAM_DEFAULT(VectorOptions::get()->error_smoothness_limit)
// 2.
#define CONTINUITY_LIMIT TEST_PARAM_DEFAULT(VectorOptions::get()->error_continuity_limit)
// 3.
#define INFLECTION_LIMIT TEST_PARAM_DEFAULT(VectorOptions::get()->error_inflection_limit)
// 4.
#define INFLECTION_PENALTY TEST_PARAM_DEFAULT(VectorOptions::get()->error_inflection_penalty)
// unit weight
#define SMOOTHNESS_WEIGHT VectorOptions::get()->error_smoothness_weight
#define ACCURACY_WEIGHT VectorOptions::get()->error_accuracy_weight
// 5.
#define CONTINUITY_WEIGHT TEST_PARAM_DEFAULT(VectorOptions::get()->error_continuity_weight)
using namespace polyvec;
using namespace std;
namespace polyfit {
namespace ErrorMetrics {
double smoothness(const double rad0, const double rad1, const int flags) {
const bool is_first = flags & EDGE_FIRST_IN_PATH;
const bool is_last = flags & EDGE_LAST_IN_PATH;
double e = 0.;
e += .5 * (!(is_first) ? smoothness(rad0) : 0.);
e += .5 * (!(is_last) ? smoothness(rad1) : 0.);
return e;
}
double smoothness(const double rad0) {
return SMOOTHNESS_WEIGHT * min((M_PI - rad0) / SMOOTHNESS_LIMIT, 1.0);
}
double accuracy(const double d_min, const double d_max, const int flags) {
const double overflow = max(d_max - 1., 0.) + max(d_min - .5, 0.);
return ACCURACY_WEIGHT * d_min + max(d_max - .5, 0.) + overflow;
}
double accuracy_implicit(const double d_min, const double d_max, const int flags) {
return ACCURACY_WEIGHT * 2 * max(0., d_max - .5);
}
double continuity(const double rad0, const double rad1, const int flags) {
if ((flags & EDGE_LAST_IN_PATH) || (flags & EDGE_FIRST_IN_PATH)) {
return 0.;
}
if (flags & EDGE_HAS_INFLECTION) {
return CONTINUITY_WEIGHT * min(1., INFLECTION_PENALTY + (M_PI - min(rad0, rad1)) / INFLECTION_LIMIT * (1. - INFLECTION_PENALTY));
//const double a = min(2 * M_PI - rad0 - rad1, CONTINUITY_LIMIT);
//return CONTINUITY_WEIGHT * a / CONTINUITY_LIMIT;
}
else {
return CONTINUITY_WEIGHT * min(abs(rad0 - rad1) / CONTINUITY_LIMIT, 1.0);
}
}
bool accuracy_within_bounds(const double d_min, const double d_max, const vec2& edge_dir) {
// This is only checking the distance measures, not the error
const double phi = atan2(edge_dir.cwiseAbs().minCoeff(), edge_dir.cwiseAbs().maxCoeff());
const double d_eps = .1;
// adaptive accuracy
const double max_threshold = std::min(1.0, 0.5 + (.5 + d_eps) * cos(phi) - .5 * sin(phi));
return (d_min <= .5 + PF_EPS && d_max <= max_threshold - PF_EPS);
//return (d_min <= (.5 + PF_EPS) && d_max <= (1. - PF_EPS));
}
bool accuracy_within_bounds_relaxed(const double d_min, const double d_max) {
return d_min < 1. - PF_EPS && d_max < 1. - PF_EPS;
}
vec3 calculate_at_edge(const mat2x& points, const mat24& p, const vec4i& v, int flags) {
#if 0
assert_break(p.cols() == 4);
const double rad0 = PathUtils::shortest_angle_spanned(p.col(0), p.col(1), p.col(2));
const double rad1 = PathUtils::shortest_angle_spanned(p.col(1), p.col(2), p.col(3));
flags |= PathUtils::are_consecutive_angles_opposite(p.col(0), p.col(1), p.col(2), p.col(3)) ? EDGE_HAS_INFLECTION : 0x0;
#if 1
dbg::info(FMT("error-metric - angles:(%.3f %.3f) inflection: %d", geom::degrees(rad0), geom::degrees(rad1), flags & EDGE_HAS_INFLECTION));
#endif
const vec2 d_err = PathUtils::distance_bounds_from_points(points, p.block(0, 1, 2, 2), v.segment(1, 2), );
vec3 error;
error(0) = smoothness(rad0, rad1, flags);
error(1) = accuracy(d_err.x(), d_err.y(), flags);
error(2) = continuity(rad0, rad1, flags);
return error;
#endif
return vec3(0., 0., 0.);
}
vec3 calculate_inner_sep(double d_min, double d_max, const vec2 p0, const vec2 p1, const vec2 p2, const vec2 p3) {
const int flags = AngleUtils::have_opposite_convexity(p0, p1, p2, p3) ? EDGE_HAS_INFLECTION : 0x0;
const double rad0 = AngleUtils::spanned_shortest(p0, p1, p2);
const double rad1 = AngleUtils::spanned_shortest(p1, p2, p3);
vec3 e;
e(SMOOTHNESS) = ErrorMetrics::smoothness(rad0, rad1, flags);
e(CONTINUITY) = ErrorMetrics::continuity(rad0, rad1, flags);
if (VectorOptions::get()->accuracy_metric == AccuracyMetric::OneSided) {
e(ACCURACY) = ErrorMetrics::accuracy(d_min, d_max, flags);
}
else if (VectorOptions::get()->accuracy_metric == AccuracyMetric::Implicit) {
e(ACCURACY) = ErrorMetrics::accuracy_implicit(d_min, d_max, flags);
}
else {
PF_ABORT;
}
return e;
}
vec3 calculate_first_sep(double d_min, double d_max, const vec2 p1, const vec2 p2, const vec2 p3) {
const int flags = EDGE_FIRST_IN_PATH;
const double rad1 = AngleUtils::spanned_shortest(p1, p2, p3);
vec3 e;
e(SMOOTHNESS) = ErrorMetrics::smoothness(M_PI, rad1, flags);
e(CONTINUITY) = ErrorMetrics::continuity(M_PI, rad1, flags);
if (VectorOptions::get()->accuracy_metric == AccuracyMetric::OneSided) {
e(ACCURACY) = ErrorMetrics::accuracy(d_min, d_max, flags);
}
else if (VectorOptions::get()->accuracy_metric == AccuracyMetric::Implicit) {
e(ACCURACY) = ErrorMetrics::accuracy_implicit(d_min, d_max, flags);
}
else {
PF_ABORT;
}
return e;
}
vec3 calculate_last_sep(double d_min, double d_max, const vec2 p1, const vec2 p2, const vec2 p3) {
const int flags = EDGE_FIRST_IN_PATH;
const double rad1 = AngleUtils::spanned_shortest(p1, p2, p3);
vec3 e;
e(SMOOTHNESS) = ErrorMetrics::smoothness(M_PI, rad1, flags);
e(CONTINUITY) = ErrorMetrics::continuity(M_PI, rad1, flags);
if (VectorOptions::get()->accuracy_metric == AccuracyMetric::OneSided) {
e(ACCURACY) = ErrorMetrics::accuracy(d_min, d_max, flags);
}
else if (VectorOptions::get()->accuracy_metric == AccuracyMetric::Implicit) {
e(ACCURACY) = ErrorMetrics::accuracy_implicit(d_min, d_max, flags);
}
else {
PF_ABORT;
}
return e;
}
double calculate_inner(double d_min, double d_max, const vec2 p0, const vec2 p1, const vec2 p2, const vec2 p3) {
const vec3 e = calculate_inner_sep(d_min, d_max, p0, p1, p2, p3);
return e.sum();
}
double calculate_first(double d_min, double d_max, const vec2 p1, const vec2 p2, const vec2 p3) {
const vec3 e = calculate_first_sep(d_min, d_max, p1, p2, p3);
return e.sum();
}
double calculate_last(double d_min, double d_max, const vec2 p1, const vec2 p2, const vec2 p3) {
const vec3 e = calculate_last_sep(d_min, d_max, p1, p2, p3);
return e.sum();
}
}
} | [
"edoaramis@gmail.com"
] | edoaramis@gmail.com |
c6f36a34ec764d93733c6edc1dc6c8b0b641f36d | e0818dd68188d2a8db6be31944745cc6d22f27f0 | /extensions/sdktools/vnatives.cpp | b2f382d8068477ad7156d5a8248c1e22acf79432 | [] | no_license | PMArkive/simillimum | 4f36d329fa93dd3be6a034680c8a4678842c8acd | 08757300821ac9b4511873416475a20615e08956 | refs/heads/master | 2023-03-28T07:26:57.123535 | 2013-07-04T23:02:54 | 2013-07-04T23:02:54 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 36,800 | cpp | /**
* vim: set ts=4 :
* =============================================================================
* Simillimum SDKTools Extension
* Copyright (C) 2004-2010 AlliedModders LLC. All rights reserved.
* =============================================================================
*
* This program is free software; you can redistribute it and/or modify it under
* the terms of the GNU General Public License, version 3.0, as published by the
* Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
* details.
*
* You should have received a copy of the GNU General Public License along with
* this program. If not, see <http://www.gnu.org/licenses/>.
*
* As a special exception, AlliedModders LLC gives you permission to link the
* code of this program (as well as its derivative works) to "Half-Life 2," the
* "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
* by the Valve Corporation. You must obey the GNU General Public License in
* all respects for all other code used. Additionally, AlliedModders LLC grants
* this exception to all derivative works. AlliedModders LLC defines further
* exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
* or <http://www.simillimum.net/license.php>.
*
* Version: $Id$
*/
#include <stdlib.h>
#include <sh_string.h>
#include "extension.h"
#include "vcallbuilder.h"
#include "vnatives.h"
#include "vhelpers.h"
#include "vglobals.h"
#include "CellRecipientFilter.h"
#include <inetchannel.h>
#include <iclient.h>
#include "iserver.h"
SourceHook::List<ValveCall *> g_RegCalls;
SourceHook::List<ICallWrapper *> g_CallWraps;
inline void InitPass(ValvePassInfo &info, ValveType vtype, PassType type, unsigned int flags, unsigned int decflags=0)
{
info.decflags = decflags;
info.encflags = 0;
info.flags = flags;
info.type = type;
info.vtype = vtype;
}
#define START_CALL() \
unsigned char *vptr = pCall->stk_get();
#define FINISH_CALL_SIMPLE(vret) \
pCall->call->Execute(vptr, vret); \
pCall->stk_put(vptr);
#define ENCODE_VALVE_PARAM(num, which, vnum) \
if (EncodeValveParam(pContext, \
params[num], \
pCall, \
&pCall->which[vnum], \
vptr) \
== Data_Fail) \
{ \
return 0; \
}
#define DECODE_VALVE_PARAM(num, which, vnum) \
if (DecodeValveParam(pContext, \
params[num], \
pCall, \
&pCall->which[vnum], \
vptr) \
== Data_Fail) \
{ \
return 0; \
}
bool CreateBaseCall(const char *name,
ValveCallType vcalltype,
const ValvePassInfo *retinfo,
const ValvePassInfo params[],
unsigned int numParams,
ValveCall **vaddr)
{
int offset;
ValveCall *call;
if (g_pGameConf->GetOffset(name, &offset))
{
call = CreateValveVCall(offset, vcalltype, retinfo, params, numParams);
if (call)
{
g_RegCalls.push_back(call);
}
*vaddr = call;
return true;
} else {
void *addr = NULL;
if (g_pGameConf->GetMemSig(name, &addr) && addr != NULL)
{
call = CreateValveCall(addr, vcalltype, retinfo, params, numParams);
if (call)
{
g_RegCalls.push_back(call);
}
*vaddr = call;
return true;
}
}
return false;
}
static cell_t RemovePlayerItem(IPluginContext *pContext, const cell_t *params)
{
static ValveCall *pCall = NULL;
if (!pCall)
{
ValvePassInfo pass[2];
InitPass(pass[0], Valve_CBaseEntity, PassType_Basic, PASSFLAG_BYVAL);
InitPass(pass[1], Valve_Bool, PassType_Basic, PASSFLAG_BYVAL);
if (!CreateBaseCall("RemovePlayerItem", ValveCall_Player, &pass[1], pass, 1, &pCall))
{
return pContext->ThrowNativeError("\"RemovePlayerItem\" not supported by this mod");
} else if (!pCall) {
return pContext->ThrowNativeError("\"RemovePlayerItem\" wrapper failed to initialize");
}
}
bool ret;
START_CALL();
DECODE_VALVE_PARAM(1, thisinfo, 0);
DECODE_VALVE_PARAM(2, vparams, 0);
FINISH_CALL_SIMPLE(&ret);
return ret ? 1 : 0;
}
static cell_t GiveNamedItem(IPluginContext *pContext, const cell_t *params)
{
static ValveCall *pCall = NULL;
if (!pCall)
{
ValvePassInfo pass[3];
InitPass(pass[0], Valve_String, PassType_Basic, PASSFLAG_BYVAL);
InitPass(pass[1], Valve_POD, PassType_Basic, PASSFLAG_BYVAL);
InitPass(pass[2], Valve_CBaseEntity, PassType_Basic, PASSFLAG_BYVAL);
if (!CreateBaseCall("GiveNamedItem", ValveCall_Player, &pass[2], pass, 2, &pCall))
{
return pContext->ThrowNativeError("\"GiveNamedItem\" not supported by this mod");
} else if (!pCall) {
return pContext->ThrowNativeError("\"GiveNamedItem\" wrapper failed to initialize");
}
}
CBaseEntity *pEntity = NULL;
START_CALL();
DECODE_VALVE_PARAM(1, thisinfo, 0);
DECODE_VALVE_PARAM(2, vparams, 0);
DECODE_VALVE_PARAM(3, vparams, 1);
FINISH_CALL_SIMPLE(&pEntity);
return gamehelpers->EntityToBCompatRef(pEntity);
}
static cell_t GetPlayerWeaponSlot(IPluginContext *pContext, const cell_t *params)
{
static ValveCall *pCall = NULL;
if (!pCall)
{
ValvePassInfo pass[2];
InitPass(pass[0], Valve_POD, PassType_Basic, PASSFLAG_BYVAL);
InitPass(pass[1], Valve_CBaseEntity, PassType_Basic, PASSFLAG_BYVAL);
if (!CreateBaseCall("Weapon_GetSlot", ValveCall_Player, &pass[1], pass, 1, &pCall))
{
return pContext->ThrowNativeError("\"Weapon_GetSlot\" not supported by this mod");
} else if (!pCall) {
return pContext->ThrowNativeError("\"Weapon_GetSlot\" wrapper failed to initialize");
}
}
CBaseEntity *pEntity;
START_CALL();
DECODE_VALVE_PARAM(1, thisinfo, 0);
DECODE_VALVE_PARAM(2, vparams, 0);
FINISH_CALL_SIMPLE(&pEntity);
return gamehelpers->EntityToBCompatRef(pEntity);
}
#if SOURCE_ENGINE != SE_DARKMESSIAH
static cell_t IgniteEntity(IPluginContext *pContext, const cell_t *params)
{
static ValveCall *pCall = NULL;
if (!pCall)
{
ValvePassInfo pass[4];
InitPass(pass[0], Valve_Float, PassType_Float, PASSFLAG_BYVAL);
InitPass(pass[1], Valve_Bool, PassType_Basic, PASSFLAG_BYVAL);
InitPass(pass[2], Valve_Float, PassType_Float, PASSFLAG_BYVAL);
InitPass(pass[3], Valve_Bool, PassType_Basic, PASSFLAG_BYVAL);
if (!CreateBaseCall("Ignite", ValveCall_Entity, NULL, pass, 4, &pCall))
{
return pContext->ThrowNativeError("\"Ignite\" not supported by this mod");
} else if (!pCall) {
return pContext->ThrowNativeError("\"Ignite\" wrapper failed to initialize");
}
}
START_CALL();
DECODE_VALVE_PARAM(1, thisinfo, 0);
DECODE_VALVE_PARAM(2, vparams, 0);
DECODE_VALVE_PARAM(3, vparams, 1);
DECODE_VALVE_PARAM(4, vparams, 2);
DECODE_VALVE_PARAM(5, vparams, 3);
FINISH_CALL_SIMPLE(NULL);
return 1;
}
#else
/* Dark Messiah specific version */
static cell_t IgniteEntity(IPluginContext *pContext, const cell_t *params)
{
static ValveCall *pCall = NULL;
if (!pCall)
{
ValvePassInfo pass[6];
InitPass(pass[0], Valve_Float, PassType_Float, PASSFLAG_BYVAL);
InitPass(pass[1], Valve_Bool, PassType_Basic, PASSFLAG_BYVAL);
InitPass(pass[2], Valve_Float, PassType_Float, PASSFLAG_BYVAL);
InitPass(pass[3], Valve_Bool, PassType_Basic, PASSFLAG_BYVAL);
InitPass(pass[4], Valve_POD, PassType_Basic, PASSFLAG_BYVAL);
InitPass(pass[5], Valve_POD, PassType_Basic, PASSFLAG_BYVAL);
if (!CreateBaseCall("Ignite", ValveCall_Entity, NULL, pass, 6, &pCall))
{
return pContext->ThrowNativeError("\"Ignite\" not supported by this mod");
} else if (!pCall) {
return pContext->ThrowNativeError("\"Ignite\" wrapper failed to initialize");
}
}
START_CALL();
DECODE_VALVE_PARAM(1, thisinfo, 0);
DECODE_VALVE_PARAM(2, vparams, 0);
DECODE_VALVE_PARAM(3, vparams, 1);
DECODE_VALVE_PARAM(4, vparams, 2);
DECODE_VALVE_PARAM(5, vparams, 3);
/* Not sure what these params do, but they appear to be the default values */
*(int *)(vptr + 14) = 3;
*(int *)(vptr + 18) = 0;
FINISH_CALL_SIMPLE(NULL);
return 1;
}
#endif
static cell_t ExtinguishEntity(IPluginContext *pContext, const cell_t *params)
{
#if SOURCE_ENGINE == SE_CSS
if(params[1] <= gpGlobals->maxClients)
{
IGamePlayer *player = playerhelpers->GetGamePlayer(params[1]);
if (player == NULL)
{
return pContext->ThrowNativeError("Invalid client index %d", params[1]);
}
if (!player->IsInGame())
{
return pContext->ThrowNativeError("Client %d is not in game", params[1]);
}
edict_t *pEdict = PEntityOfEntIndex(gamehelpers->ReferenceToIndex(params[2]));
if (!pEdict || pEdict->IsFree())
{
return pContext->ThrowNativeError("Entity %d is not valid", params[2]);
}
CBaseEntity *pEntity = g_pGameHelpers->ReferenceToEntity(params[1]);
datamap_t * m_Datamap = g_pGameHelpers->GetDataMap(pEntity);
if(!m_Datamap)
{
return pContext->ThrowNativeError("Cannot find datamap for entity %d", params[1]);
}
typedescription_t *m_hEffectEntity = g_pGameHelpers->FindInDataMap(m_Datamap, "m_hEffectEntity");
if(!m_hEffectEntity)
{
return pContext->ThrowNativeError("Cannot find m_hEffectEntity offset for entity %d", params[1]);
}
CBaseHandle &hndl = *(CBaseHandle *)((uint8_t *)pEntity + GetTypeDescOffs(m_hEffectEntity));
CBaseEntity *pHandleEntity = g_pGameHelpers->ReferenceToEntity(hndl.GetEntryIndex());
if (!pHandleEntity || hndl != reinterpret_cast<IHandleEntity *>(pHandleEntity)->GetRefEHandle())
return 1;
m_Datamap = g_pGameHelpers->GetDataMap(pHandleEntity);
if(!m_Datamap)
{
return pContext->ThrowNativeError("Cannot find datamap for entity %d", g_pGameHelpers->EntityToBCompatRef(pHandleEntity));
}
typedescription_t *m_flLifetime = g_pGameHelpers->FindInDataMap(m_Datamap, "m_flLifetime");
if(!m_flLifetime)
{
return pContext->ThrowNativeError("Cannot find m_flLifetime offset for entity %d", g_pGameHelpers->EntityToBCompatRef(pHandleEntity));
}
*(float*)((uint8_t *)pHandleEntity + GetTypeDescOffs(m_flLifetime)) = 0.0f;
}
else
{
#endif
static ValveCall *pCall = NULL;
if (!pCall)
{
if (!CreateBaseCall("Extinguish", ValveCall_Entity, NULL, NULL, 0, &pCall))
{
return pContext->ThrowNativeError("\"Extinguish\" not supported by this mod");
} else if (!pCall) {
return pContext->ThrowNativeError("\"Extinguish\" wrapper failed to initialize");
}
}
START_CALL();
DECODE_VALVE_PARAM(1, thisinfo, 0);
FINISH_CALL_SIMPLE(NULL);
#if SOURCE_ENGINE == SE_CSS
}
#endif
return 1;
}
static cell_t TeleportEntity(IPluginContext *pContext, const cell_t *params)
{
static ValveCall *pCall = NULL;
if (!pCall)
{
ValvePassInfo pass[3];
InitPass(pass[0], Valve_Vector, PassType_Basic, PASSFLAG_BYVAL, VDECODE_FLAG_ALLOWNULL);
InitPass(pass[1], Valve_QAngle, PassType_Basic, PASSFLAG_BYVAL, VDECODE_FLAG_ALLOWNULL);
InitPass(pass[2], Valve_Vector, PassType_Basic, PASSFLAG_BYVAL, VDECODE_FLAG_ALLOWNULL);
if (!CreateBaseCall("Teleport", ValveCall_Entity, NULL, pass, 3, &pCall))
{
return pContext->ThrowNativeError("\"Teleport\" not supported by this mod");
} else if (!pCall) {
return pContext->ThrowNativeError("\"Teleport\" wrapper failed to initialize");
}
}
START_CALL();
DECODE_VALVE_PARAM(1, thisinfo, 0);
DECODE_VALVE_PARAM(2, vparams, 0);
DECODE_VALVE_PARAM(3, vparams, 1);
DECODE_VALVE_PARAM(4, vparams, 2);
FINISH_CALL_SIMPLE(NULL);
return 1;
}
#if SOURCE_ENGINE >= SE_ORANGEBOX
/* :TODO: This is Team Fortress 2 specific */
static cell_t ForcePlayerSuicide(IPluginContext *pContext, const cell_t *params)
{
static ValveCall *pCall = NULL;
if (!pCall)
{
ValvePassInfo pass[2];
InitPass(pass[0], Valve_Bool, PassType_Basic, PASSFLAG_BYVAL);
InitPass(pass[1], Valve_Bool, PassType_Basic, PASSFLAG_BYVAL);
if (!CreateBaseCall("CommitSuicide", ValveCall_Player, NULL, pass, 2, &pCall))
{
return pContext->ThrowNativeError("\"CommitSuicide\" not supported by this mod");
}
else if (!pCall)
{
return pContext->ThrowNativeError("\"CommitSuicide\" wrapper failed to initialize");
}
}
START_CALL();
DECODE_VALVE_PARAM(1, thisinfo, 0);
*(bool *)(vptr + 4) = false;
*(bool *)(vptr + 5) = false;
FINISH_CALL_SIMPLE(NULL);
return 1;
}
#else
static cell_t ForcePlayerSuicide(IPluginContext *pContext, const cell_t *params)
{
static ValveCall *pCall = NULL;
if (!pCall)
{
if (!CreateBaseCall("CommitSuicide", ValveCall_Player, NULL, NULL, 0, &pCall))
{
return pContext->ThrowNativeError("\"CommitSuicide\" not supported by this mod");
} else if (!pCall) {
return pContext->ThrowNativeError("\"CommitSuicide\" wrapper failed to initialize");
}
}
START_CALL();
DECODE_VALVE_PARAM(1, thisinfo, 0);
FINISH_CALL_SIMPLE(NULL);
return 1;
}
#endif
static cell_t SetClientViewEntity(IPluginContext *pContext, const cell_t *params)
{
IGamePlayer *player = playerhelpers->GetGamePlayer(params[1]);
if (player == NULL)
{
return pContext->ThrowNativeError("Invalid client index %d", params[1]);
}
if (!player->IsInGame())
{
return pContext->ThrowNativeError("Client %d is not in game", params[1]);
}
edict_t *pEdict = PEntityOfEntIndex(gamehelpers->ReferenceToIndex(params[2]));
if (!pEdict || pEdict->IsFree())
{
return pContext->ThrowNativeError("Entity %d is not valid", params[2]);
}
#if SOURCE_ENGINE == SE_DOTA
engine->SetView(params[1], params[2]);
#else
engine->SetView(player->GetEdict(), pEdict);
#endif
return 1;
}
static SourceHook::String *g_lightstyle[MAX_LIGHTSTYLES] = {NULL};
static cell_t SetLightStyle(IPluginContext *pContext, const cell_t *params)
{
int style = params[1];
if (style >= MAX_LIGHTSTYLES)
{
return pContext->ThrowNativeError("Light style %d is invalid (range: 0-%d)", style, MAX_LIGHTSTYLES - 1);
}
if (g_lightstyle[style] == NULL)
{
/* We allocate and never free this because the Engine wants to hold onto it :\
* in theory we could hook light style and know whether we're supposed to free
* this or not on shutdown, but for ~4K of memory MAX, it doesn't seem worth it yet.
* So, it's a :TODO:!
*/
g_lightstyle[style] = new SourceHook::String();
}
char *str;
pContext->LocalToString(params[2], &str);
g_lightstyle[style]->assign(str);
engine->LightStyle(style, g_lightstyle[style]->c_str());
return 1;
}
static cell_t SlapPlayer(IPluginContext *pContext, const cell_t *params)
{
static bool s_slap_supported = false;
static bool s_slap_setup = false;
static ICallWrapper *s_teleport = NULL;
static int s_health_offs = 0;
static int s_sound_count = 0;
static int s_frag_offs = 0;
if (!s_slap_setup)
{
int tries = 0;
s_slap_setup = true;
if (IsTeleportSupported())
{
tries++;
}
if (IsGetVelocitySupported())
{
tries++;
}
/* Setup health */
if (g_pGameConf->GetOffset("m_iHealth", &s_health_offs) && s_health_offs)
{
tries++;
}
if (tries == 3)
{
s_slap_supported = true;
const char *key;
if ((key = g_pGameConf->GetKeyValue("SlapSoundCount")) != NULL)
{
s_sound_count = atoi(key);
}
}
}
if (!s_slap_supported)
{
return pContext->ThrowNativeError("This function is not supported on this mod");
}
/* First check if the client is valid */
IGamePlayer *player = playerhelpers->GetGamePlayer(params[1]);
if (!player)
{
return pContext->ThrowNativeError("Client %d is not valid", params[1]);
} else if (!player->IsInGame()) {
return pContext->ThrowNativeError("Client %d is not in game", params[1]);
}
edict_t *pEdict = player->GetEdict();
CBaseEntity *pEntity = pEdict->GetUnknown()->GetBaseEntity();
/* See if we should be taking away health */
bool should_slay = false;
if (params[2])
{
#if SOURCE_ENGINE != SE_DARKMESSIAH
int *health = (int *)((char *)pEntity + s_health_offs);
if (*health - params[2] <= 0)
{
*health = 1;
should_slay = true;
} else {
*health -= params[2];
}
#else
float *health = (float *)((char *)pEntity + s_health_offs);
if (*health - (float)params[2] <= 0)
{
*health = 1.0f;
should_slay = true;
} else {
*health -= (float)params[2];
}
#endif
}
/* Teleport in a random direction - thank you, Mani!*/
Vector velocity;
GetVelocity(pEntity, &velocity, NULL);
velocity.x += ((rand() % 180) + 50) * (((rand() % 2) == 1) ? -1 : 1);
velocity.y += ((rand() % 180) + 50) * (((rand() % 2) == 1) ? -1 : 1);
velocity.z += rand() % 200 + 100;
Teleport(pEntity, NULL, NULL, &velocity);
/* Play a random sound */
if (params[3] && s_sound_count > 0)
{
char name[48];
const char *sound_name;
cell_t player_list[256], total_players = 0;
int maxClients = playerhelpers->GetMaxClients();
int r = (rand() % s_sound_count) + 1;
snprintf(name, sizeof(name), "SlapSound%d", r);
if ((sound_name = g_pGameConf->GetKeyValue(name)) != NULL)
{
IGamePlayer *other;
for (int i=1; i<=maxClients; i++)
{
other = playerhelpers->GetGamePlayer(i);
if (other->IsInGame())
{
player_list[total_players++] = i;
}
}
const Vector & pos = pEdict->GetCollideable()->GetCollisionOrigin();
CellRecipientFilter rf;
rf.SetToReliable(true);
rf.Initialize(player_list, total_players);
#if SOURCE_ENGINE == SE_ORANGEBOXVALVE || SOURCE_ENGINE == SE_CSS
engsound->EmitSound(rf, params[1], CHAN_AUTO, sound_name, VOL_NORM, ATTN_NORM, 0, PITCH_NORM, 0, &pos);
#elif SOURCE_ENGINE < SE_PORTAL2
engsound->EmitSound(rf, params[1], CHAN_AUTO, sound_name, VOL_NORM, ATTN_NORM, 0, PITCH_NORM, &pos);
#else
engsound->EmitSound(rf, params[1], CHAN_AUTO, sound_name, -1, sound_name, VOL_NORM, ATTN_NORM, 0, 0, PITCH_NORM, &pos);
#endif
}
}
if (!s_frag_offs)
{
const char *frag_prop = g_pGameConf->GetKeyValue("m_iFrags");
if (frag_prop)
{
datamap_t *pMap = gamehelpers->GetDataMap(pEntity);
typedescription_t *pType = gamehelpers->FindInDataMap(pMap, frag_prop);
if (pType != NULL)
{
s_frag_offs = GetTypeDescOffs(pType);
}
}
if (!s_frag_offs)
{
s_frag_offs = -1;
}
}
int old_frags = 0;
if (s_frag_offs > 0)
{
old_frags = *(int *)((char *)pEntity + s_frag_offs);
}
/* Force suicide */
if (should_slay)
{
#if SOURCE_ENGINE == SE_DOTA
engine->ClientCommand(params[1], "kill\n");
#else
pluginhelpers->ClientCommand(pEdict, "kill\n");
#endif
}
if (s_frag_offs > 0)
{
*(int *)((char *)pEntity + s_frag_offs) = old_frags;
}
return 1;
}
static cell_t GetClientEyePosition(IPluginContext *pContext, const cell_t *params)
{
IGamePlayer *player = playerhelpers->GetGamePlayer(params[1]);
if (player == NULL)
{
return pContext->ThrowNativeError("Invalid client index %d", params[1]);
}
if (!player->IsInGame())
{
return pContext->ThrowNativeError("Client %d is not in game", params[1]);
}
Vector pos;
#if SOURCE_ENGINE == SE_DOTA
serverClients->ClientEarPosition(params[1], &pos);
#else
serverClients->ClientEarPosition(player->GetEdict(), &pos);
#endif
cell_t *addr;
pContext->LocalToPhysAddr(params[2], &addr);
addr[0] = sp_ftoc(pos.x);
addr[1] = sp_ftoc(pos.y);
addr[2] = sp_ftoc(pos.z);
return 1;
}
static cell_t GetClientEyeAngles(IPluginContext *pContext, const cell_t *params)
{
IGamePlayer *pPlayer = playerhelpers->GetGamePlayer(params[1]);
if (!pPlayer)
{
return pContext->ThrowNativeError("Invalid client index %d", params[1]);
}
else if (!pPlayer->IsInGame())
{
return pContext->ThrowNativeError("Client %d is not in game", params[1]);
}
edict_t *pEdict = pPlayer->GetEdict();
CBaseEntity *pEntity = pEdict->GetUnknown() ? pEdict->GetUnknown()->GetBaseEntity() : NULL;
/* We always set the angles for backwards compatibility --
* The original function had no return value.
*/
QAngle angles;
bool got_angles = false;
if (pEntity != NULL)
{
got_angles = GetEyeAngles(pEntity, &angles);
}
cell_t *addr;
pContext->LocalToPhysAddr(params[2], &addr);
addr[0] = sp_ftoc(angles.x);
addr[1] = sp_ftoc(angles.y);
addr[2] = sp_ftoc(angles.z);
return got_angles ? 1 : 0;
}
#if SOURCE_ENGINE >= SE_ORANGEBOX
static cell_t NativeFindEntityByClassname(IPluginContext *pContext, const cell_t *params)
{
char *searchname;
CBaseEntity *pEntity;
if (params[1] == -1)
{
pEntity = (CBaseEntity *)servertools->FirstEntity();
}
else
{
pEntity = gamehelpers->ReferenceToEntity(params[1]);
if (!pEntity)
{
return pContext->ThrowNativeError("Entity %d (%d) is invalid",
gamehelpers->ReferenceToIndex(params[1]),
params[1]);
}
pEntity = (CBaseEntity *)servertools->NextEntity(pEntity);
}
// it's tough to find a good ent these days
if (!pEntity)
{
return -1;
}
pContext->LocalToString(params[2], &searchname);
const char *classname;
int lastletterpos;
static int offset = -1;
if (offset == -1)
{
offset = GetTypeDescOffs(
gamehelpers->FindInDataMap(gamehelpers->GetDataMap(pEntity),
"m_iClassname")
);
}
string_t s;
while (pEntity)
{
if ((s = *(string_t *)((uint8_t *)pEntity + offset)) == NULL_STRING)
{
pEntity = (CBaseEntity *)servertools->NextEntity(pEntity);
continue;
}
classname = STRING(s);
lastletterpos = strlen(searchname) - 1;
if (searchname[lastletterpos] == '*')
{
if (strncasecmp(searchname, classname, lastletterpos) == 0)
{
return gamehelpers->EntityToBCompatRef(pEntity);
}
}
else if (strcasecmp(searchname, classname) == 0)
{
return gamehelpers->EntityToBCompatRef(pEntity);
}
pEntity = (CBaseEntity *)servertools->NextEntity(pEntity);
}
return -1;
}
#endif
static cell_t FindEntityByClassname(IPluginContext *pContext, const cell_t *params)
{
static ValveCall *pCall = NULL;
static bool bProbablyNoFEBC = false;
#if SOURCE_ENGINE >= SE_ORANGEBOX
if (bProbablyNoFEBC)
{
return NativeFindEntityByClassname(pContext, params);
}
#endif
if (!pCall)
{
ValvePassInfo pass[3];
InitPass(pass[0], Valve_CBaseEntity, PassType_Basic, PASSFLAG_BYVAL, VDECODE_FLAG_ALLOWNULL|VDECODE_FLAG_ALLOWWORLD);
InitPass(pass[1], Valve_String, PassType_Basic, PASSFLAG_BYVAL);
InitPass(pass[2], Valve_CBaseEntity, PassType_Basic, PASSFLAG_BYVAL);
char error[256];
error[0] = '\0';
if (!CreateBaseCall("FindEntityByClassname", ValveCall_EntityList, &pass[2], pass, 2, &pCall))
{
g_pSM->Format(error, sizeof(error), "\"FindEntityByClassname\" not supported by this mod");
} else if (!pCall) {
g_pSM->Format(error, sizeof(error), "\"FindEntityByClassname\" wrapper failed to initialize");
}
if (error[0] != '\0')
{
#if SOURCE_ENGINE >= SE_ORANGEBOX
if (!bProbablyNoFEBC)
{
bProbablyNoFEBC = true;
g_pSM->LogError(myself, "%s, falling back to IServerTools method.", error);
}
return NativeFindEntityByClassname(pContext, params);
#else
return pContext->ThrowNativeError("%s", error);
#endif
}
}
CBaseEntity *pEntity;
START_CALL();
*(void **)vptr = g_EntList;
DECODE_VALVE_PARAM(1, vparams, 0);
DECODE_VALVE_PARAM(2, vparams, 1);
FINISH_CALL_SIMPLE(&pEntity);
return gamehelpers->EntityToBCompatRef(pEntity);
}
#if SOURCE_ENGINE >= SE_ORANGEBOX
static cell_t CreateEntityByName(IPluginContext *pContext, const cell_t *params)
{
if (!g_pSM->IsMapRunning())
{
return pContext->ThrowNativeError("Cannot create new entity when no map is running");
}
char *classname;
pContext->LocalToString(params[1], &classname);
CBaseEntity *pEntity = (CBaseEntity *)servertools->CreateEntityByName(classname);
return gamehelpers->EntityToBCompatRef(pEntity);
}
#else
static cell_t CreateEntityByName(IPluginContext *pContext, const cell_t *params)
{
if (!g_pSM->IsMapRunning())
{
return pContext->ThrowNativeError("Cannot create new entity when no map is running");
}
static ValveCall *pCall = NULL;
if (!pCall)
{
ValvePassInfo pass[3];
InitPass(pass[0], Valve_String, PassType_Basic, PASSFLAG_BYVAL);
InitPass(pass[1], Valve_POD, PassType_Basic, PASSFLAG_BYVAL);
InitPass(pass[2], Valve_CBaseEntity, PassType_Basic, PASSFLAG_BYVAL);
if (!CreateBaseCall("CreateEntityByName", ValveCall_Static, &pass[2], pass, 2, &pCall))
{
return pContext->ThrowNativeError("\"CreateEntityByName\" not supported by this mod");
} else if (!pCall) {
return pContext->ThrowNativeError("\"CreateEntityByName\" wrapper failed to initialize");
}
}
CBaseEntity *pEntity = NULL;
START_CALL();
DECODE_VALVE_PARAM(1, vparams, 0);
DECODE_VALVE_PARAM(2, vparams, 1);
FINISH_CALL_SIMPLE(&pEntity);
return gamehelpers->EntityToBCompatRef(pEntity);
}
#endif
#if SOURCE_ENGINE >= SE_ORANGEBOX
static cell_t DispatchSpawn(IPluginContext *pContext, const cell_t *params)
{
CBaseEntity *pEntity = gamehelpers->ReferenceToEntity(params[1]);
if (!pEntity)
{
return pContext->ThrowNativeError("Entity %d (%d) is invalid", gamehelpers->ReferenceToIndex(params[1]), params[1]);
}
servertools->DispatchSpawn(pEntity);
return 1;
}
#else
static cell_t DispatchSpawn(IPluginContext *pContext, const cell_t *params)
{
static ValveCall *pCall = NULL;
if (!pCall)
{
ValvePassInfo pass[2];
InitPass(pass[0], Valve_CBaseEntity, PassType_Basic, PASSFLAG_BYVAL);
InitPass(pass[1], Valve_POD, PassType_Basic, PASSFLAG_BYVAL);
if (!CreateBaseCall("DispatchSpawn", ValveCall_Static, &pass[1], pass, 1, &pCall))
{
return pContext->ThrowNativeError("\"DispatchSpawn\" not supported by this mod");
} else if (!pCall) {
return pContext->ThrowNativeError("\"DispatchSpawn\" wrapper failed to initialize");
}
}
int ret;
START_CALL();
DECODE_VALVE_PARAM(1, vparams, 0);
FINISH_CALL_SIMPLE(&ret);
return (ret == -1) ? 0 : 1;
}
#endif
#if SOURCE_ENGINE >= SE_ORANGEBOX
static cell_t DispatchKeyValue(IPluginContext *pContext, const cell_t *params)
{
CBaseEntity *pEntity = gamehelpers->ReferenceToEntity(params[1]);
if (!pEntity)
{
return pContext->ThrowNativeError("Entity %d (%d) is invalid", gamehelpers->ReferenceToIndex(params[1]), params[1]);
}
char *key;
char *value;
pContext->LocalToString(params[2], &key);
pContext->LocalToString(params[3], &value);
return (servertools->SetKeyValue(pEntity, key, value) ? 1 : 0);
}
#else
static cell_t DispatchKeyValue(IPluginContext *pContext, const cell_t *params)
{
static ValveCall *pCall = NULL;
if (!pCall)
{
ValvePassInfo pass[3];
InitPass(pass[0], Valve_String, PassType_Basic, PASSFLAG_BYVAL);
InitPass(pass[1], Valve_String, PassType_Basic, PASSFLAG_BYVAL);
InitPass(pass[2], Valve_Bool, PassType_Basic, PASSFLAG_BYVAL);
if (!CreateBaseCall("DispatchKeyValue", ValveCall_Entity, &pass[2], pass, 2, &pCall))
{
return pContext->ThrowNativeError("\"DispatchKeyValue\" not supported by this mod");
} else if (!pCall) {
return pContext->ThrowNativeError("\"DispatchKeyValue\" wrapper failed to initialize");
}
}
bool ret;
START_CALL();
DECODE_VALVE_PARAM(1, thisinfo, 0);
DECODE_VALVE_PARAM(2, vparams, 0);
DECODE_VALVE_PARAM(3, vparams, 1);
FINISH_CALL_SIMPLE(&ret);
return ret ? 1 : 0;
}
#endif
#if SOURCE_ENGINE >= SE_ORANGEBOX
static cell_t DispatchKeyValueFloat(IPluginContext *pContext, const cell_t *params)
{
CBaseEntity *pEntity = gamehelpers->ReferenceToEntity(params[1]);
if (!pEntity)
{
return pContext->ThrowNativeError("Entity %d (%d) is invalid", gamehelpers->ReferenceToIndex(params[1]), params[1]);
}
char *key;
pContext->LocalToString(params[2], &key);
float value = sp_ctof(params[3]);
return (servertools->SetKeyValue(pEntity, key, value) ? 1 : 0);
}
#else
static cell_t DispatchKeyValueFloat(IPluginContext *pContext, const cell_t *params)
{
static ValveCall *pCall = NULL;
if (!pCall)
{
ValvePassInfo pass[3];
InitPass(pass[0], Valve_String, PassType_Basic, PASSFLAG_BYVAL);
InitPass(pass[1], Valve_Float, PassType_Float, PASSFLAG_BYVAL);
InitPass(pass[2], Valve_Bool, PassType_Basic, PASSFLAG_BYVAL);
if (!CreateBaseCall("DispatchKeyValueFloat", ValveCall_Entity, &pass[2], pass, 2, &pCall))
{
return pContext->ThrowNativeError("\"DispatchKeyValueFloat\" not supported by this mod");
} else if (!pCall) {
return pContext->ThrowNativeError("\"DispatchKeyValueFloat\" wrapper failed to initialize");
}
}
bool ret;
START_CALL();
DECODE_VALVE_PARAM(1, thisinfo, 0);
DECODE_VALVE_PARAM(2, vparams, 0);
DECODE_VALVE_PARAM(3, vparams, 1);
FINISH_CALL_SIMPLE(&ret);
return ret ? 1 : 0;
}
#endif
#if SOURCE_ENGINE >= SE_ORANGEBOX
static cell_t DispatchKeyValueVector(IPluginContext *pContext, const cell_t *params)
{
CBaseEntity *pEntity = gamehelpers->ReferenceToEntity(params[1]);
if (!pEntity)
{
return pContext->ThrowNativeError("Entity %d (%d) is invalid", gamehelpers->ReferenceToIndex(params[1]), params[1]);
}
char *key;
pContext->LocalToString(params[2], &key);
cell_t *vec;
pContext->LocalToPhysAddr(params[3], &vec);
const Vector *v = new Vector(
sp_ctof(vec[0]),
sp_ctof(vec[1]),
sp_ctof(vec[2]));
return (servertools->SetKeyValue(pEntity, key, *v) ? 1 : 0);
}
#else
static cell_t DispatchKeyValueVector(IPluginContext *pContext, const cell_t *params)
{
static ValveCall *pCall = NULL;
if (!pCall)
{
ValvePassInfo pass[3];
InitPass(pass[0], Valve_String, PassType_Basic, PASSFLAG_BYVAL);
#if SOURCE_ENGINE >= SE_ORANGEBOX
InitPass(pass[1], Valve_Vector, PassType_Basic, PASSFLAG_BYVAL);
#else
InitPass(pass[1], Valve_Vector, PassType_Object, PASSFLAG_BYVAL|PASSFLAG_OCTOR|PASSFLAG_OASSIGNOP);
#endif
InitPass(pass[2], Valve_Bool, PassType_Basic, PASSFLAG_BYVAL);
if (!CreateBaseCall("DispatchKeyValueVector", ValveCall_Entity, &pass[2], pass, 2, &pCall))
{
return pContext->ThrowNativeError("\"DispatchKeyValueVector\" not supported by this mod");
} else if (!pCall) {
return pContext->ThrowNativeError("\"DispatchKeyValueVector\" wrapper failed to initialize");
}
}
bool ret;
START_CALL();
DECODE_VALVE_PARAM(1, thisinfo, 0);
DECODE_VALVE_PARAM(2, vparams, 0);
DECODE_VALVE_PARAM(3, vparams, 1);
FINISH_CALL_SIMPLE(&ret);
return ret ? 1 : 0;
}
#endif
static cell_t sm_GetClientAimTarget(IPluginContext *pContext, const cell_t *params)
{
IGamePlayer *pPlayer = playerhelpers->GetGamePlayer(params[1]);
if (!pPlayer)
{
return pContext->ThrowNativeError("Invalid client index %d", params[1]);
}
else if (!pPlayer->IsInGame())
{
return pContext->ThrowNativeError("Client %d is not in game", params[1]);
}
return GetClientAimTarget(pPlayer->GetEdict(), params[2] ? true : false);
}
static cell_t sm_SetEntityModel(IPluginContext *pContext, const cell_t *params)
{
static ValveCall *pCall = NULL;
if (!pCall)
{
ValvePassInfo pass[1];
InitPass(pass[0], Valve_String, PassType_Basic, PASSFLAG_BYVAL);
if (!CreateBaseCall("SetEntityModel", ValveCall_Entity, NULL, pass, 1, &pCall))
{
return pContext->ThrowNativeError("\"SetEntityModel\" not supported by this mod");
} else if (!pCall) {
return pContext->ThrowNativeError("\"SetEntityModel\" wrapper failed to initialize");
}
}
START_CALL();
DECODE_VALVE_PARAM(1, thisinfo, 0);
DECODE_VALVE_PARAM(2, vparams, 0);
FINISH_CALL_SIMPLE(NULL);
return 1;
}
static cell_t GetPlayerDecalFile(IPluginContext *pContext, const cell_t *params)
{
IGamePlayer *player = playerhelpers->GetGamePlayer(params[1]);
if (player == NULL)
{
return pContext->ThrowNativeError("Invalid client index %d", params[1]);
}
if (!player->IsInGame())
{
return pContext->ThrowNativeError("Client %d is not in game", params[1]);
}
player_info_t info;
char *buffer;
if (!GetPlayerInfo(params[1], &info) || !info.customFiles[0])
{
return 0;
}
pContext->LocalToString(params[2], &buffer);
Q_binarytohex((byte *)&info.customFiles[0], sizeof(info.customFiles[0]), buffer, params[3]);
return 1;
}
static cell_t GetServerNetStats(IPluginContext *pContext, const cell_t *params)
{
if (iserver == NULL)
{
return pContext->ThrowNativeError("IServer interface not supported, file a bug report.");
}
float in, out;
cell_t *pIn, *pOut;
pContext->LocalToPhysAddr(params[1], &pIn);
pContext->LocalToPhysAddr(params[2], &pOut);
iserver->GetNetStats(in, out);
*pIn = sp_ftoc(in);
*pOut = sp_ftoc(out);
return 1;
}
static cell_t WeaponEquip(IPluginContext *pContext, const cell_t *params)
{
static ValveCall *pCall = NULL;
if (!pCall)
{
ValvePassInfo pass[1];
InitPass(pass[0], Valve_CBaseEntity, PassType_Basic, PASSFLAG_BYVAL);
if (!CreateBaseCall("WeaponEquip", ValveCall_Player, NULL, pass, 1, &pCall))
{
return pContext->ThrowNativeError("\"WeaponEquip\" not supported by this mod");
} else if (!pCall) {
return pContext->ThrowNativeError("\"WeaponEquip\" wrapper failed to initialize");
}
}
START_CALL();
DECODE_VALVE_PARAM(1, thisinfo, 0);
DECODE_VALVE_PARAM(2, vparams, 0);
FINISH_CALL_SIMPLE(NULL);
return 1;
}
static cell_t ActivateEntity(IPluginContext *pContext, const cell_t *params)
{
static ValveCall *pCall = NULL;
if (!pCall)
{
if (!CreateBaseCall("Activate", ValveCall_Entity, NULL, NULL, 0, &pCall))
{
return pContext->ThrowNativeError("\"Activate\" not supported by this mod");
}
else if (!pCall)
{
return pContext->ThrowNativeError("\"Activate\" wrapper failed to initialize");
}
}
START_CALL();
DECODE_VALVE_PARAM(1, thisinfo, 0);
FINISH_CALL_SIMPLE(NULL);
return 1;
}
static cell_t SetClientInfo(IPluginContext *pContext, const cell_t *params)
{
if (iserver == NULL)
{
return pContext->ThrowNativeError("IServer interface not supported, file a bug report.");
}
IGamePlayer *player = playerhelpers->GetGamePlayer(params[1]);
IClient *pClient = iserver->GetClient(params[1] - 1);
if (player == NULL || pClient == NULL)
{
return pContext->ThrowNativeError("Invalid client index %d", params[1]);
}
if (!player->IsConnected())
{
return pContext->ThrowNativeError("Client %d is not connected", params[1]);
}
static ValveCall *pCall = NULL;
if (!pCall)
{
ValvePassInfo params[2];
InitPass(params[0], Valve_String, PassType_Basic, PASSFLAG_BYVAL);
InitPass(params[1], Valve_String, PassType_Basic, PASSFLAG_BYVAL);
if (!CreateBaseCall("SetUserCvar", ValveCall_Entity, NULL, params, 2, &pCall))
{
return pContext->ThrowNativeError("\"SetUserCvar\" not supported by this mod");
}
else if (!pCall)
{
return pContext->ThrowNativeError("\"SetUserCvar\" wrapper failed to initialize");
}
}
/* TODO: Use UpdateUserSettings function for all engines */
#if SOURCE_ENGINE == SE_DARKMESSIAH
static ValveCall *pUpdateSettings = NULL;
if (!pUpdateSettings)
{
if (!CreateBaseCall("UpdateUserSettings", ValveCall_Entity, NULL, NULL, 0, &pUpdateSettings))
{
return pContext->ThrowNativeError("\"SetUserCvar\" not supported by this mod");
}
else if (!pUpdateSettings)
{
return pContext->ThrowNativeError("\"SetUserCvar\" wrapper failed to initialize");
}
}
#else
static int changedOffset = -1;
if (changedOffset == -1)
{
if (!g_pGameConf->GetOffset("InfoChanged", &changedOffset))
{
return pContext->ThrowNativeError("\"SetUserCvar\" not supported by this mod");
}
}
#endif
unsigned char *CGameClient = (unsigned char *)pClient - 4;
START_CALL();
/* Not really a CBaseEntity* but this works */
CBaseEntity **ebuf = (CBaseEntity **)vptr;
*ebuf = (CBaseEntity *)CGameClient;
DECODE_VALVE_PARAM(2, vparams, 0);
DECODE_VALVE_PARAM(3, vparams, 1);
FINISH_CALL_SIMPLE(NULL);
#if SOURCE_ENGINE == SE_DARKMESSIAH
unsigned char *args = pUpdateSettings->stk_get();
*(void **)args = CGameClient;
pUpdateSettings->call->Execute(args, NULL);
pUpdateSettings->stk_put(args);
#else
uint8_t* changed = (uint8_t *)(CGameClient + changedOffset);
*changed = 1;
#endif
return 1;
}
static cell_t GetPlayerResourceEntity(IPluginContext *pContext, const cell_t *params)
{
if (gamehelpers->GetHandleEntity(g_ResourceEntity) != NULL)
{
return g_ResourceEntity.GetEntryIndex();
}
return -1;
}
sp_nativeinfo_t g_Natives[] =
{
{"ExtinguishEntity", ExtinguishEntity},
{"ForcePlayerSuicide", ForcePlayerSuicide},
{"GivePlayerItem", GiveNamedItem},
{"GetPlayerWeaponSlot", GetPlayerWeaponSlot},
{"IgniteEntity", IgniteEntity},
{"RemovePlayerItem", RemovePlayerItem},
{"TeleportEntity", TeleportEntity},
{"SetClientViewEntity", SetClientViewEntity},
{"SetLightStyle", SetLightStyle},
{"SlapPlayer", SlapPlayer},
{"GetClientEyePosition", GetClientEyePosition},
{"GetClientEyeAngles", GetClientEyeAngles},
{"FindEntityByClassname", FindEntityByClassname},
{"CreateEntityByName", CreateEntityByName},
{"DispatchSpawn", DispatchSpawn},
{"DispatchKeyValue", DispatchKeyValue},
{"DispatchKeyValueFloat", DispatchKeyValueFloat},
{"DispatchKeyValueVector", DispatchKeyValueVector},
{"GetClientAimTarget", sm_GetClientAimTarget},
{"SetEntityModel", sm_SetEntityModel},
{"GetPlayerDecalFile", GetPlayerDecalFile},
{"GetServerNetStats", GetServerNetStats},
{"EquipPlayerWeapon", WeaponEquip},
{"ActivateEntity", ActivateEntity},
{"SetClientInfo", SetClientInfo},
{"GetPlayerResourceEntity", GetPlayerResourceEntity},
{NULL, NULL},
};
| [
"dvarnai@gmail.com"
] | dvarnai@gmail.com |
3b1f3ea592de8303ddeed87ea8b2e0129ddc1872 | ce80d0da332985ea3aecd0381feae9ea65649a51 | /Judges/Rosalind/Counting DNA Nucleotides/count.cpp | fdf2ce0fca3bf3d5b1be88e1eb2952262b769396 | [] | no_license | EstebanFS/Competitive-Programming | e3c1e35073b5a713ba553c2c0548433f7c41aa3c | b154c833098086f69177883c4f38bf58f428186f | refs/heads/master | 2022-09-29T22:01:22.692452 | 2022-09-13T16:15:20 | 2022-09-13T16:15:20 | 10,339,018 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 752 | cpp | //Esteban Foronda Sierra
using namespace std;
#include <algorithm>
#include <iostream>
#include <iterator>
#include <numeric>
#include <sstream>
#include <fstream>
#include <cassert>
#include <climits>
#include <cstdlib>
#include <cstring>
#include <string>
#include <cstdio>
#include <vector>
#include <cmath>
#include <queue>
#include <deque>
#include <stack>
#include <list>
#include <map>
#include <set>
#define D(x) cout << #x " is " << x << endl
int main(){
string s; cin >> s;
int a,c,g,t;a=c=g=t=0;
for(int i=0; i<s.size(); i++){
if(s[i]=='A')a++;
if(s[i]=='C')c++;
if(s[i]=='G')g++;
if(s[i]=='T')t++;
}
printf("%d %d %d %d\n",a,c,g,t);
return 0;
}
| [
"estebanforondasierra@Estebans-MacBook-Air.local"
] | estebanforondasierra@Estebans-MacBook-Air.local |
43955ea8cf6525249e2ffb8b51f73bc9813fe995 | c492a2eea222532e9c6b17b06e2dce9224e79c2d | /Archs/MIPS/MipsMacros.cpp | 566639ee22b03c2d740ae5e5c25176ab224c56a9 | [] | no_license | Normmatt/armips | 7f9afd8fbec17fbfa12af85752a8ed2b819eb352 | 45ef0fb9f6cfe3b042b63749a8512b8c516b9461 | refs/heads/master | 2021-01-18T08:04:45.984266 | 2013-11-15T08:43:40 | 2013-11-15T08:43:40 | 13,533,243 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 14,860 | cpp | #include "stdafx.h"
#include "MipsMacros.h"
#include "CMipsInstruction.h"
#include "Core/Common.h"
#include "Mips.h"
#include "MipsOpcodes.h"
#include "CMipsMacro.h"
void MipsMacroLoadOpcode(CMipsInstruction& Opcode, char* name, char* argformat, ...)
{
char str[1024];
va_list args;
va_start(args,argformat);
vsprintf(str,argformat,args);
va_end (args);
Opcode.Load(name,str);
}
int MipsMacroLi(tMipsMacroValues& Values, int Flags, CMipsInstruction* Opcodes)
{
int OpcodeCount = 0;
bool upper = (Flags & MIPSM_UPPER) != 0;
bool lower = (Flags & MIPSM_LOWER) != 0;
if ((unsigned)Values.i2 > 0xFFFF) // may not fit into one opcode
{
if ((Values.i2 & 0xFFFF8000) == 0xFFFF8000)
{
if (!upper)
{
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"addiu","%s,r0,0x%04X",
Values.rs.name,Values.i2 & 0xFFFF);
}
} else if ((Values.i2 & 0xFFFF) == 0)
{
if (lower)
{
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"nop","");
} else {
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"lui","%s,0x%04X",
Values.rs.name,Values.i2 >> 16);
}
} else { // lui+addiu
if (Values.i2 & 0x8000) Values.i2 += 0x10000;
if (upper == false && lower == false)
{
upper = lower = true;
}
if (upper)
{
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"lui","%s,0x%04X",
Values.rs.name,Values.i2 >> 16);
}
if (lower)
{
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"addiu","%s,%s,0x%04X",
Values.rs.name,Values.rs.name,Values.i2 & 0xFFFF);
}
}
} else { // definitely fits into one opcode
if (upper)
{
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"nop","");
} else {
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"ori","%s,r0,0x%04X",Values.rs.name,Values.i2);
}
}
return OpcodeCount;
}
int MipsMacroLoad(tMipsMacroValues& Values, int Flags, CMipsInstruction* Opcodes)
{
int OpcodeCount = 0;
if (Values.i2 & 0x8000) Values.i2 += 0x10000;
if (Flags & MIPSM_UPPER)
{
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"lui","%s,0x%04X",Values.rs.name,Values.i2 >> 16);
}
if (Flags & MIPSM_LOWER)
{
if (Flags & MIPSM_B) MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"lb","%s,0x%04X(%s)",
Values.rs.name,Values.i2 & 0xFFFF,Values.rs.name);
else if (Flags & MIPSM_BU) MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"lbu","%s,0x%04X(%s)",
Values.rs.name,Values.i2 & 0xFFFF,Values.rs.name);
else if (Flags & MIPSM_HW) MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"lh","%s,0x%04X(%s)",
Values.rs.name,Values.i2 & 0xFFFF,Values.rs.name);
else if (Flags & MIPSM_HWU) MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"lhu","%s,0x%04X(%s)",
Values.rs.name,Values.i2 & 0xFFFF,Values.rs.name);
else if (Flags & MIPSM_W) MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"lw","%s,0x%04X(%s)",
Values.rs.name,Values.i2 & 0xFFFF,Values.rs.name);
else Logger::printError(Logger::Error,L"Invalid Load macro");
}
return OpcodeCount;
}
int MipsMacroStore(tMipsMacroValues& Values, int Flags, CMipsInstruction* Opcodes)
{
int OpcodeCount = 0;
if (Values.i2 & 0x8000) Values.i2 += 0x10000;
if (Flags & MIPSM_UPPER)
{
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"lui","r1,0x%04X",Values.i2 >> 16);
}
if (Flags & MIPSM_LOWER)
{
if (Flags & MIPSM_B) MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"sb","%s,0x%04X(r1)",
Values.rs.name,Values.i2 & 0xFFFF);
else if (Flags & MIPSM_HW) MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"sh","%s,0x%04X(r1)",
Values.rs.name,Values.i2 & 0xFFFF);
else if (Flags & MIPSM_W) MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"sw","%s,0x%04X(r1)",
Values.rs.name,Values.i2 & 0xFFFF);
else Logger::printError(Logger::Error,L"Invalid Store macro");
}
return OpcodeCount;
}
int MipsMacroLoadUnaligned(tMipsMacroValues& Values, int Flags, CMipsInstruction* Opcodes)
{
int OpcodeCount = 0;
if (!(Flags & MIPSM_IMM)) Values.i1 = 0;
if (Flags & MIPSM_HW)
{
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"lb","r1,0x%04X(%s)",
Values.i1+1,Values.rs.name);
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"lb","%s,0x%04X(%s)",
Values.rd.name,Values.i1,Values.rs.name);
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"sll","r1,8");
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"or","%s,r1",
Values.rd.name );
} else if (Flags & MIPSM_HWU)
{
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"lbu","r1,0x%04X(%s)",
Values.i1+1,Values.rs.name);
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"lbu","%s,0x%04X(%s)",
Values.rd.name,Values.i1,Values.rs.name);
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"sll","r1,8");
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"or","%s,r1",
Values.rd.name );
} else if (Flags & MIPSM_W)
{
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"lwl","%s,0x%04X(%s)",
Values.rd.name,Values.i1+3,Values.rs.name);
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"lwr","%s,0x%04X(%s)",
Values.rd.name,Values.i1,Values.rs.name);
} else {
Logger::printError(Logger::Error,L"Invalid Store Unaligned macro");
}
return OpcodeCount;
}
int MipsMacroStoreUnaligned(tMipsMacroValues& Values, int Flags, CMipsInstruction* Opcodes)
{
int OpcodeCount = 0;
if (!(Flags & MIPSM_IMM)) Values.i1 = 0;
if (Flags & MIPSM_HW)
{
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"sb","%s,0x%04X(%s)",
Values.rd.name,Values.i1,Values.rs.name);
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"srl","r1,%s,8",
Values.rd.name);
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"sb","r1,0x%04X(%s)",
Values.i1+1,Values.rs.name);
} else if (Flags & MIPSM_W)
{
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"swl","%s,0x%04X(%s)",
Values.rd.name,Values.i1+3,Values.rs.name);
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"swr","%s,0x%04X(%s)",
Values.rd.name,Values.i1,Values.rs.name);
} else {
Logger::printError(Logger::Error,L"Invalid Store Unaligned macro");
}
return OpcodeCount;
}
int MipsMacroBranch(tMipsMacroValues& Values, int Flags, CMipsInstruction* Opcodes)
{
int OpcodeCount = 0;
tMipsMacroValues NewValues;
bool LoadedImmediate = false;
if (((Flags & MIPSM_IMM) && (unsigned) Values.i1 > 0xFFFF) ||
(Flags & MIPSM_NE) || (Flags & MIPSM_EQ)) // has to be loaded into r1
{
strcpy(NewValues.rs.name,"r1");
NewValues.i2 = Values.i1;
OpcodeCount = MipsMacroLi(NewValues,0,Opcodes);
LoadedImmediate = true;
}
if (Flags & MIPSM_NE)
{
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"bne","%s,r1,0x%08X",
Values.rs.name,Values.i2);
} else if (Flags & MIPSM_EQ)
{
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"beq","%s,r1,0x%08X",
Values.rs.name,Values.i2);
} else {
if (LoadedImmediate == true)
{
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"slt","r1,%s,r1",
Values.rs.name);
} else {
if (Flags & MIPSM_IMM)
{
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"slti","r1,%s,0x%04X",
Values.rs.name,Values.i1);
} else {
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"slt","r1,%s,%s",
Values.rs.name,Values.rt.name);
}
}
if (Flags & MIPSM_GE)
{
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"beqz","r1,0x%08X",
Values.i2);
} else if (Flags & MIPSM_LT)
{
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"bnez","r1,0x%08X",
Values.i2);
} else {
Logger::printError(Logger::Error,L"Invalid Branch macro");
}
}
return OpcodeCount;
}
int MipsMacroRotate(tMipsMacroValues& Values, int Flags, CMipsInstruction* Opcodes)
{
int OpcodeCount = 0;
// PSP has its own rotate opcodes, use those
if (Mips.GetVersion() & MARCH_PSP)
{
if (Flags & MIPSM_IMM)
{
if (Flags & MIPSM_LEFT)
{
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"rotr","%s,%s,32-0x%02X",
Values.rd.name,Values.rs.name,Values.i1);
} else {
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"rotr","%s,%s,0x%02X",
Values.rd.name,Values.rs.name,Values.i1);
}
} else {
if (Flags & MIPSM_LEFT)
{
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"subu","r1,r0,%s",
Values.rt.name);
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"rotrv","%s,%s,r1",
Values.rd.name,Values.rs.name);
} else {
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"rotrv","%s,%s,%s",
Values.rd.name,Values.rs.name,Values.rt.name);
}
}
return OpcodeCount;
}
if (Flags & MIPSM_IMM)
{
if (Flags & MIPSM_LEFT)
{
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"srl","r1,%s,0x%02X",
Values.rs.name,32-Values.i1);
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"sll","%s,%s,0x%02X",
Values.rd.name,Values.rs.name,Values.i1);
} else {
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"sll","r1,%s,0x%02X",
Values.rs.name,32-Values.i1);
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"srl","%s,%s,0x%02X",
Values.rd.name,Values.rs.name,Values.i1);
}
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"or","%s,r1",
Values.rd.name);
} else {
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"subu","r1,r0,%s",
Values.rt.name);
if (Flags & MIPSM_LEFT)
{
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"srlv","r1,%s,r1",
Values.rs.name);
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"sllv","%s,%s,%s",
Values.rd.name,Values.rs.name,Values.rt.name);
} else {
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"sllv","r1,%s,r1",
Values.rs.name);
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"srlv","%s,%s,%s",
Values.rd.name,Values.rs.name,Values.rt.name);
}
MipsMacroLoadOpcode(Opcodes[OpcodeCount++],"or","%s,r1",
Values.rd.name);
}
return OpcodeCount;
}
/* Placeholders
i = i1 = 16 bit immediate
I = i2 = 32 bit immediate
s,t,d = registers */
const tMipsMacro MipsMacros[] = {
{ "li", "s,I", 2, &MipsMacroLi, MIPSM_IMM },
{ "li.u", "s,I", 2, &MipsMacroLi, MIPSM_IMM|MIPSM_UPPER },
{ "li.l", "s,I", 2, &MipsMacroLi, MIPSM_IMM|MIPSM_LOWER },
{ "la", "s,I", 2, &MipsMacroLi, MIPSM_IMM },
{ "lb", "s,I", 2, &MipsMacroLoad, MIPSM_B|MIPSM_UPPER|MIPSM_LOWER },
{ "lbu", "s,I", 2, &MipsMacroLoad, MIPSM_BU|MIPSM_UPPER|MIPSM_LOWER },
{ "lh", "s,I", 2, &MipsMacroLoad, MIPSM_HW|MIPSM_UPPER|MIPSM_LOWER },
{ "lhu", "s,I", 2, &MipsMacroLoad, MIPSM_HWU|MIPSM_UPPER|MIPSM_LOWER },
{ "lw", "s,I", 2, &MipsMacroLoad, MIPSM_W|MIPSM_UPPER|MIPSM_LOWER },
{ "lb.u", "s,I", 2, &MipsMacroLoad, MIPSM_B|MIPSM_UPPER },
{ "lbu.u", "s,I", 2, &MipsMacroLoad, MIPSM_BU|MIPSM_UPPER },
{ "lh.u", "s,I", 2, &MipsMacroLoad, MIPSM_HW|MIPSM_UPPER },
{ "lhu.u", "s,I", 2, &MipsMacroLoad, MIPSM_HWU|MIPSM_UPPER },
{ "lw.u", "s,I", 2, &MipsMacroLoad, MIPSM_W|MIPSM_UPPER },
{ "lb.l", "s,I", 2, &MipsMacroLoad, MIPSM_B|MIPSM_LOWER },
{ "lbu.l", "s,I", 2, &MipsMacroLoad, MIPSM_BU|MIPSM_LOWER },
{ "lh.l", "s,I", 2, &MipsMacroLoad, MIPSM_HW|MIPSM_LOWER },
{ "lhu.l", "s,I", 2, &MipsMacroLoad, MIPSM_HWU|MIPSM_LOWER },
{ "lw.l", "s,I", 2, &MipsMacroLoad, MIPSM_W|MIPSM_LOWER },
{ "ulh", "d,i(s)", 4, &MipsMacroLoadUnaligned, MIPSM_HW|MIPSM_IMM },
{ "ulh", "d,(s)", 4, &MipsMacroLoadUnaligned, MIPSM_HW },
{ "ulhu", "d,i(s)", 4, &MipsMacroLoadUnaligned, MIPSM_HWU|MIPSM_IMM },
{ "ulhu", "d,(s)", 4, &MipsMacroLoadUnaligned, MIPSM_HWU },
{ "ulw", "d,i(s)", 4, &MipsMacroLoadUnaligned, MIPSM_W|MIPSM_IMM },
{ "ulw", "d,(s)", 4, &MipsMacroLoadUnaligned, MIPSM_W },
{ "sb", "s,I", 2, &MipsMacroStore, MIPSM_B|MIPSM_UPPER|MIPSM_LOWER },
{ "sh", "s,I", 2, &MipsMacroStore, MIPSM_HW|MIPSM_UPPER|MIPSM_LOWER },
{ "sw", "s,I", 2, &MipsMacroStore, MIPSM_W|MIPSM_UPPER|MIPSM_LOWER },
{ "sb.u", "s,I", 2, &MipsMacroStore, MIPSM_B|MIPSM_UPPER },
{ "sh.u", "s,I", 2, &MipsMacroStore, MIPSM_HW|MIPSM_UPPER },
{ "sw.u", "s,I", 2, &MipsMacroStore, MIPSM_W|MIPSM_UPPER },
{ "sb.l", "s,I", 2, &MipsMacroStore, MIPSM_B|MIPSM_LOWER },
{ "sh.l", "s,I", 2, &MipsMacroStore, MIPSM_HW|MIPSM_LOWER },
{ "sw.l", "s,I", 2, &MipsMacroStore, MIPSM_W|MIPSM_LOWER },
{ "ush", "d,i(s)", 3, &MipsMacroStoreUnaligned, MIPSM_HW|MIPSM_IMM },
{ "ush", "d,(s)", 3, &MipsMacroStoreUnaligned, MIPSM_HW },
{ "usw", "d,i(s)", 3, &MipsMacroStoreUnaligned, MIPSM_W|MIPSM_IMM },
{ "usw", "d,(s)", 3, &MipsMacroStoreUnaligned, MIPSM_W },
{ "blt", "s,t,I", 4, &MipsMacroBranch, MIPSM_LT|MIPSM_DONTWARNDELAYSLOT },
{ "blt", "s,i,I", 4, &MipsMacroBranch, MIPSM_LT|MIPSM_IMM|MIPSM_DONTWARNDELAYSLOT },
{ "bge", "s,t,I", 4, &MipsMacroBranch, MIPSM_GE|MIPSM_DONTWARNDELAYSLOT },
{ "bge", "s,i,I", 4, &MipsMacroBranch, MIPSM_GE|MIPSM_IMM|MIPSM_DONTWARNDELAYSLOT },
{ "bne", "s,i,I", 4, &MipsMacroBranch, MIPSM_NE|MIPSM_IMM|MIPSM_DONTWARNDELAYSLOT },
{ "beq", "s,i,I", 4, &MipsMacroBranch, MIPSM_EQ|MIPSM_IMM|MIPSM_DONTWARNDELAYSLOT },
{ "rol", "d,s,t", 4, &MipsMacroRotate, MIPSM_LEFT },
{ "rol", "d,s,i", 4, &MipsMacroRotate, MIPSM_LEFT|MIPSM_IMM },
{ "ror", "d,s,t", 4, &MipsMacroRotate, MIPSM_RIGHT },
{ "ror", "d,s,i", 4, &MipsMacroRotate, MIPSM_RIGHT|MIPSM_IMM },
{ NULL, NULL, NULL, 0 }
};
bool MipsCheckMacroParsing(char* Opcode, char* Arguments, tMipsMacroVars& Vars)
{
int RetLen;
while (*Arguments == ' ' || *Arguments == '\t') Arguments++;
if (*Opcode == 0 && *Arguments == 0) return true;
while (*Opcode != NULL)
{
while (*Arguments == ' ' || *Arguments == '\t') Arguments++;
if (*Arguments == 0) return false;
switch (*Opcode)
{
case 's':
if (MipsGetRegister(Arguments,RetLen,Vars.rs) == false) return false;
Arguments += RetLen;
Opcode++;
break;
case 'd':
if (MipsGetRegister(Arguments,RetLen,Vars.rd) == false) return false;
Arguments += RetLen;
Opcode++;
break;
case 't':
if (MipsGetRegister(Arguments,RetLen,Vars.rt) == false) return false;
Arguments += RetLen;
Opcode++;
break;
case 'i':
if (MipsCheckImmediate(Arguments,Vars.i1,RetLen) == false) return false;
Arguments += RetLen;
Opcode++;
break;
case 'I':
if (MipsCheckImmediate(Arguments,Vars.i2,RetLen) == false) return false;
Arguments += RetLen;
Opcode++;
break;
default:
if (*Opcode++ != *Arguments++) return false;
break;
}
}
while (*Arguments == ' ' || *Arguments == '\t') Arguments++;
if (*Arguments != 0) return false; // there's something else, bad
if (Vars.i1.isLoaded())
{
if (Vars.i1.check() == false)
{
Vars.NoCheckError = true;
return false;
}
}
if (Vars.i2.isLoaded())
{
if (Vars.i2.check() == false)
{
Vars.NoCheckError = true;
return false;
}
}
return true;
}
bool MipsCheckMacro(char* Opcode, char* Arguments)
{
tMipsMacroVars Vars;
Vars.NoCheckError = false;
bool ParamFail = false;
for (int y = 0; MipsMacros[y].name != NULL; y++)
{
if (strcmp(Opcode,MipsMacros[y].name) == 0)
{
if (MipsCheckMacroParsing(MipsMacros[y].args,Arguments,Vars) == true)
{
CMipsMacro* Macro = new CMipsMacro(y,Vars);
AddAssemblerCommand(Macro);
return true;
} else {
ParamFail = true;
}
}
}
if (ParamFail == true)
{
return false;
}
return false;
} | [
"sorgts@googlemail.com"
] | sorgts@googlemail.com |
ef55d03c4770b4f9860d9f941943e6965e656bb0 | 999c9b49caf48e6653147f761e438ece405cb515 | /include/fruit/impl/injector/injector_accessor_for_tests.h | cf7517a22f90e2173d0ffef0792cc95f4096826c | [
"Apache-2.0"
] | permissive | google/fruit | 34bb2481855d35167cc715f510f1c294e4158e38 | 570eb41e8ba7cb64837af57e5d50a94e45f02446 | refs/heads/master | 2023-08-29T15:34:03.496802 | 2023-01-29T23:16:31 | 2023-01-30T00:43:24 | 20,900,043 | 1,824 | 269 | Apache-2.0 | 2023-01-30T00:43:25 | 2014-06-16T20:43:26 | C++ | UTF-8 | C++ | false | false | 2,255 | h | /*
* Copyright 2014 Google Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef FRUIT_INJECTOR_ACCESSOR_FOR_TESTS_H
#define FRUIT_INJECTOR_ACCESSOR_FOR_TESTS_H
#include <fruit/fruit.h>
namespace fruit {
namespace impl {
/**
* A class used to access Injector's internals in Fruit's own tests. Note that this is *not* meant to be used outside
* of Fruit.
*/
struct InjectorAccessorForTests {
/**
* If C was bound (directly or indirectly) in the component used to create this injector, returns a pointer to the
* instance of C (constructing it if necessary). Otherwise returns nullptr.
*
* This supports annotated injection, just use Annotated<Annotation, C> instead of just C.
* With a non-annotated parameter C, this returns a C*.
* With an annotated parameter C=Annotated<Annotation, SomeClass>, this returns a const SomeClass*.
*
* Note that this doesn't trigger auto-bindings: so even if the constructor of C was visible to some get*Component
* function (or to the place where unsafeGet is called), in order to successfully get an instance with this method
* you need all the following to be true:
* * C was explicitly bound in a component, or C was a dependency (direct or indirect) of a type that was explicitly
* bound
* * C was not bound to any interface (note however that if C was bound to I, you can do unsafeGet<I>() instead).
*
* Otherwise this method will return nullptr.
*/
template <typename C, typename... Params>
static const fruit::impl::RemoveAnnotations<C>*
unsafeGet(fruit::Injector<Params...>& injector);
};
}
}
#include <fruit/impl/injector/injector_accessor_for_tests.defn.h>
#endif // FRUIT_INJECTOR_ACCESSOR_FOR_TESTS_H
| [
"poletti.marco@gmail.com"
] | poletti.marco@gmail.com |
aca6fb33819970183e0427d3e286e49cfab5c425 | 4352b5c9e6719d762e6a80e7a7799630d819bca3 | /tutorials/eulerVortex.twitch/eulerVortex.cyclic.twitch.test.test/processor2/1.49/e | 5a6138a559f6a915ae6c75400c4e648aafa31e6d | [] | no_license | dashqua/epicProject | d6214b57c545110d08ad053e68bc095f1d4dc725 | 54afca50a61c20c541ef43e3d96408ef72f0bcbc | refs/heads/master | 2022-02-28T17:20:20.291864 | 2019-10-28T13:33:16 | 2019-10-28T13:33:16 | 184,294,390 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 48,995 | /*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: 6
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
location "1.49";
object e;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 2 -2 0 0 0 0];
internalField nonuniform List<scalar>
5625
(
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.28
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.28
1006.28
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.28
1006.28
1006.28
1006.28
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.28
1006.28
1006.28
1006.28
1006.28
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.28
1006.28
1006.28
1006.28
1006.28
1006.28
1006.27
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.28
1006.28
1006.28
1006.28
1006.28
1006.27
1006.26
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.28
1006.28
1006.28
1006.28
1006.27
1006.26
1006.24
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.28
1006.28
1006.28
1006.27
1006.26
1006.24
1006.21
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.28
1006.28
1006.28
1006.27
1006.26
1006.24
1006.21
1006.16
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.28
1006.28
1006.28
1006.27
1006.26
1006.24
1006.21
1006.16
1006.09
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.28
1006.28
1006.28
1006.26
1006.24
1006.21
1006.16
1006.09
1005.98
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.28
1006.28
1006.27
1006.25
1006.22
1006.17
1006.09
1005.97
1005.81
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.28
1006.28
1006.27
1006.26
1006.23
1006.19
1006.11
1005.99
1005.81
1005.56
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.28
1006.28
1006.27
1006.25
1006.21
1006.14
1006.02
1005.84
1005.58
1005.21
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.28
1006.27
1006.26
1006.23
1006.17
1006.07
1005.9
1005.64
1005.25
1004.7
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.28
1006.28
1006.27
1006.25
1006.2
1006.12
1005.97
1005.73
1005.36
1004.8
1004.02
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.28
1006.28
1006.26
1006.23
1006.16
1006.05
1005.84
1005.5
1004.98
1004.19
1003.09
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.28
1006.28
1006.27
1006.25
1006.21
1006.12
1005.96
1005.67
1005.2
1004.47
1003.39
1001.87
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.28
1006.28
1006.27
1006.24
1006.18
1006.06
1005.84
1005.46
1004.82
1003.83
1002.37
1000.32
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.28
1006.28
1006.26
1006.22
1006.14
1005.98
1005.69
1005.18
1004.34
1003.02
1001.08
998.377
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.28
1006.27
1006.25
1006.2
1006.1
1005.89
1005.52
1004.85
1003.75
1002.04
999.523
996.024
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.28
1006.27
1006.24
1006.18
1006.05
1005.79
1005.31
1004.46
1003.05
1000.87
997.678
993.254
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.28
1006.28
1006.26
1006.23
1006.15
1005.99
1005.67
1005.07
1004.01
1002.25
999.531
995.563
990.091
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.28
1006.28
1006.26
1006.22
1006.12
1005.93
1005.54
1004.8
1003.5
1001.36
998.038
993.215
986.594
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.28
1006.28
1006.25
1006.2
1006.09
1005.86
1005.39
1004.52
1002.96
1000.4
996.433
990.696
982.859
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.28
1006.27
1006.25
1006.19
1006.06
1005.79
1005.25
1004.22
1002.4
999.399
994.771
988.093
979.011
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.28
1006.27
1006.24
1006.18
1006.03
1005.72
1005.1
1003.93
1001.85
998.414
993.121
985.511
975.205
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.28
1006.27
1006.24
1006.16
1006
1005.66
1004.97
1003.67
1001.34
997.489
991.565
983.069
971.609
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.28
1006.28
1006.27
1006.23
1006.15
1005.97
1005.6
1004.86
1003.44
1000.9
996.676
990.186
980.892
968.396
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.28
1006.26
1006.23
1006.14
1005.95
1005.56
1004.77
1003.26
1000.55
996.026
989.063
979.099
965.732
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.28
1006.28
1006.26
1006.23
1006.14
1005.94
1005.53
1004.71
1003.15
1000.32
995.583
988.269
977.795
963.762
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.28
1006.28
1006.26
1006.22
1006.13
1005.93
1005.52
1004.69
1003.1
1000.23
995.38
987.859
977.063
962.597
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.28
1006.28
1006.26
1006.22
1006.13
1005.93
1005.52
1004.7
1003.13
1000.28
995.431
987.862
976.955
962.316
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.28
1006.28
1006.26
1006.23
1006.14
1005.94
1005.54
1004.74
1003.23
1000.46
995.734
988.288
977.49
962.947
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.28
1006.26
1006.23
1006.14
1005.96
1005.57
1004.82
1003.38
1000.77
996.269
989.112
978.644
964.471
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.28
1006.28
1006.27
1006.23
1006.15
1005.98
1005.62
1004.91
1003.59
1001.17
996.995
990.282
980.359
966.818
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.28
1006.28
1006.27
1006.24
1006.16
1006
1005.67
1005.03
1003.82
1001.64
997.861
991.72
982.534
969.871
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.28
1006.28
1006.27
1006.24
1006.17
1006.03
1005.73
1005.16
1004.08
1002.15
998.807
993.332
985.039
973.465
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.28
1006.28
1006.27
1006.25
1006.19
1006.06
1005.8
1005.29
1004.35
1002.67
999.775
995.016
987.721
977.4
)
;
boundaryField
{
emptyPatches_empt
{
type empty;
}
top_cyc
{
type cyclic;
}
bottom_cyc
{
type cyclic;
}
inlet_cyc
{
type cyclic;
}
outlet_cyc
{
type cyclic;
}
procBoundary2to0
{
type processor;
value nonuniform List<scalar>
75
(
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.28
1006.27
1006.25
1006.2
1006.09
1005.87
1005.43
1004.62
1003.18
1000.72
996.678
990.425
981.46
)
;
}
procBoundary2to0throughtop_cyc
{
type processorCyclic;
value nonuniform List<scalar>
75
(
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
)
;
}
procBoundary2to3
{
type processor;
value nonuniform List<scalar>
75
(
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.28
1006.28
1006.28
1006.28
1006.27
1006.26
1006.25
1006.22
1006.18
1006.11
1006
1005.83
1005.59
1005.22
1004.7
1003.97
1002.97
1001.62
999.849
997.592
994.787
991.403
987.437
982.931
977.976
972.709
967.312
961.995
956.987
952.519
948.808
946.04
944.36
943.867
944.6
946.538
949.604
953.657
958.504
963.904
)
;
}
procBoundary2to3throughinlet_cyc
{
type processorCyclic;
value nonuniform List<scalar>
75
(
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
1006.29
)
;
}
}
// ************************************************************************* //
| [
"tdg@debian"
] | tdg@debian | |
ee75133b9dbd291f88b67136d83dd1badaa7d185 | 3fb85c311478a78d427f9bd8afa5a053439a3e8e | /openjudge/5.2.cpp | d8892bbb0d4dd5cb7e582ba95f61e5160fd21e28 | [] | no_license | Jinnaouc/C_programming | 87b7467983a0e2de0be0034d92ca7b7212e81930 | 38130dd362593a2ac6ce9f18b9d9ea867277786d | refs/heads/master | 2021-01-11T02:57:31.548277 | 2017-05-31T06:58:06 | 2017-05-31T06:58:06 | 70,875,040 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,371 | cpp | #include <stdio.h>
#include <iostream>
#include <vector>
using namespace std;
int main(){
int n,m = 0;
vector<int>a;
while(cin >> n){
m ++;
if (n % 3 == 0) {
if(n % 5 == 0){
if (n % 7 == 0) {
a.push_back(1);
}
else
a.push_back(2);
}
else if(n % 7 == 0)
a.push_back(3);
else
a.push_back(4);
}
else if(n % 5 == 0){
if(n % 7 == 0)
a.push_back(5);
else a.push_back(6);
}
else if( n % 7 == 0)
a.push_back(7);
else a.push_back(8);
}
for (int i = 0; i < m; i ++) {
if(a[i] == 1){
printf("3 5 7");
printf("\n");
}
if(a[i] == 2){
printf("3 5");
printf("\n");
}
if(a[i] == 3){
printf("3 7");
printf("\n");
}
if(a[i] == 4){
printf("3");
printf("\n");
}
if(a[i] == 5){
printf("5 7");
printf("\n");
}
if (a[i] == 6){
printf("5");
printf("\n");
}
if(a[i] == 7){
printf("7");
printf("\n");
}
if(a[i] == 8){
printf("n");
printf("\n");}
}
return 0;
}
| [
"Jinna_ouc@163.com"
] | Jinna_ouc@163.com |
b04ac660a0d467db5373c36e53ec56984e9a19a4 | 24146e5b09a792692d9acb9e82ba4fbd12af20ad | /src/apps/mplayerc/MiniDump.h | db6ec13b3ea7f49f6bdefb6b677b2f8d79bbfb33 | [] | no_license | RocherKong/MPCBE | 846a0bdeaa92d37f93526b0be4d5325e0f360312 | 3a3a879aa4d71cfd23cab36d2e30b67f82e7b04e | refs/heads/master | 2020-06-10T07:39:51.502548 | 2017-11-29T05:35:40 | 2017-11-29T05:35:40 | 75,987,960 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,040 | h | /*
* (C) 2006-2014 see Authors.txt
*
* This file is part of MPC-BE.
*
* MPC-BE is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* MPC-BE is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
#pragma once
class CMiniDump
{
public:
CMiniDump();
static void SetState(bool bState) {
m_bMiniDumpEnabled = bState;
}
private :
static LONG WINAPI UnhandledExceptionFilter( _EXCEPTION_POINTERS *lpTopLevelExceptionFilter );
static BOOL PreventSetUnhandledExceptionFilter();
static bool m_bMiniDumpEnabled;
};
| [
"rocher@126.com"
] | rocher@126.com |
6d5f3578a95781fe34f73f2c0241cf06f901aa1e | 46e8533f8a02b3a5b87c4a0a3d0869a0470b9d14 | /src/Communication/Write/WritePolicy.cpp | d5fe24ceaa23d8e24781617cb7936349f0881eb8 | [] | no_license | verxirtam/ReinforcementLearning | be5c480a1362ee2a1ec21525669b175440739968 | 78a7f24414f88185934a5f97ddc187e4d4f824f2 | refs/heads/master | 2021-01-15T21:44:29.362076 | 2015-12-15T15:40:49 | 2015-12-15T15:40:49 | 25,928,479 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 379 | cpp | /*
* WriteRegularPolicy.cpp
*
* Created on: 2015/08/16
* Author: daisuke
*/
#include "WritePolicy.h"
namespace RL
{
void WritePolicy::process(OutputContext& output)
{
idx state_count = policy.getStateCount();
RL::WriteSinglePolicy wsp(policy,0);
for(idx i = 0; i < state_count; i++)
{
wsp.setStateIndex(i);
wsp.process(output);
}
}
} /* namespace RL */
| [
"d-kosuga@jcom.home.ne.jp"
] | d-kosuga@jcom.home.ne.jp |
223b188212b601e57734f0cec521d634f5c87b9f | 25b36236d90aa38deb0e28db06f5f5ee5264d931 | /Projects/S1554/macro/SiCheck4.cxx | cb75410b16857fcee93833b2aaa7a423605178db | [] | no_license | adrien-matta/nptool | 54b5ea6fe2d8c226e7422a948d3ecc94d62d1ff2 | 415ad50066f715ca1de312da1202201f9381e87e | refs/heads/NPTool.2.dev | 2021-04-18T23:52:44.645407 | 2019-09-02T12:38:49 | 2019-09-02T12:38:49 | 13,268,020 | 36 | 20 | null | 2016-12-05T11:46:35 | 2013-10-02T10:11:22 | C++ | UTF-8 | C++ | false | false | 444 | cxx | void SiCheck4(){
TFile* file = new TFile("../../Outputs/Analysis/S1554_28Si_Phy.root");
TTree* tree = (TTree*) file->FindObjectAny("PhysicsTree");
TCanvas* c = new TCanvas("Result","Result",900,900);
c->Divide(4,4);
for(unsigned int i = 0 ; i < 16 ; i++){
c->cd(i+1);
if(i+1>4)
tree->Draw(Form("Gamma_Energy/1000.>>h%i(10000,0,10)",i),Form("ELab>0 && ThetaLab>90 && Clover_Number==%i",i+1),"colz");
c->Update();
}
}
| [
"a.matta@surrey.ac.uk"
] | a.matta@surrey.ac.uk |
f8d81df5e340ae591beed427e9a0d3a77739c891 | 621aaff052be79515ea25cb6c5559ec98402fbde | /ED/Monitoria05 - Listas/Lista sequencial/day01/qx_vector.cpp | a1dafde58444c46c6ed24c263e9acc804b445fca | [] | no_license | HenrickyL/monitoria-2021.1 | bf2ba3688d30ea36fbcceb97c4af7af0373a283a | a4211eecf22908e5da976fc26f76947738e2901a | refs/heads/main | 2023-07-07T11:24:48.756459 | 2021-08-13T23:16:05 | 2021-08-13T23:16:05 | 365,626,249 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 876 | cpp | #include "qx_vector.hpp"
#include<iostream>
template<typename T>
Qx_vector<T>::Qx_vector(int capacidade){
this->_capacidade = capacidade;
this->_data = new T[_capacidade];
_size=0;
std::cout<<"Vector Criado!\n";
}
template<typename T>
Qx_vector<T>::~Qx_vector(){
delete[] _data;
}
template<typename T>
void Qx_vector<T>::add(T x){
if(_size < _capacidade){
_data[_size] = x;
_size++;
}else{
std::cout<<"atingiu a capacidade!\n";
}
}
template<typename T>
void Qx_vector<T>::pop_back(){
if(_size>0){
_size--;
}else{
std::cout<<"vetor ja está vazio!\n";
}
}
template<typename T>
int Qx_vector<T>::size(){
return _size;
}
template<typename T>
void Qx_vector<T>::print(){
std::cout<<"[ ";
for(int i=0; i< _size; i++){
std::cout<<_data[i]<<',';
}
std::cout<<"]\n";
} | [
"henrickyl1@gmail.com"
] | henrickyl1@gmail.com |
1fb4cf24613be5595541d693bcc7b0dd509c6802 | e5a75731bf787d83db939eba8b13f859fd7c8cd4 | /cppDay04/ex02/AssaultTerminator.cpp | 6d959213b9f0951e9d84e5c2eecf923f1ef4d9be | [] | no_license | ekiriche/cppPool | cf74f15534f82e86ad13e4287910e83f0a14535b | 6ed66d1be410320aaedf420f04f722624fdbecad | refs/heads/master | 2020-07-25T20:22:42.742159 | 2019-11-07T08:23:33 | 2019-11-07T08:23:33 | 208,412,631 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 901 | cpp | #include "AssaultTerminator.hpp"
AssaultTerminator::AssaultTerminator(void) {
std::cout << "* teleports from space *" << std::endl;
}
AssaultTerminator::~AssaultTerminator() {
std::cout << "I’ll be back ..." << std::endl;
}
AssaultTerminator::AssaultTerminator(AssaultTerminator const &rhs) {
*this = rhs;
}
AssaultTerminator &AssaultTerminator::operator=(AssaultTerminator const &rhs) {
if (&rhs != nullptr)
{
return *this;
}
return *this;
}
void AssaultTerminator::battleCry() const {
std::cout << "This code is unclean. PURIFY IT !" << std::endl;
}
void AssaultTerminator::rangedAttack() const {
std::cout << "* does nothing *" << std::endl;
}
void AssaultTerminator::meleeAttack() const {
std::cout << "* attacks with chainfists *" << std::endl;
}
AssaultTerminator* AssaultTerminator::clone() const {
return new AssaultTerminator();
} | [
"zheniakk@gmail.com"
] | zheniakk@gmail.com |
6d7dc8b7df2fae00a9c794773f4e0b1c9609dec5 | d312d534036de17b5dad24a26bf710c9fbf102f5 | /src/tools/voxedit/ui/editorscene/Model.cpp | 82d3c2969e27b47e452e0d7e81cace415ba8ab30 | [] | no_license | wshmaple/engine | e9f3964e7210125b71fa0294c33df35494abb9e2 | f4ae34f9600ba0004af953a7d2447fd835ad85c4 | refs/heads/master | 2021-05-04T12:27:11.545596 | 2018-01-30T17:01:05 | 2018-01-30T18:44:52 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 24,742 | cpp | /**
* @file
*/
#include "Model.h"
#include "voxel/polyvox/VolumeMerger.h"
#include "voxel/polyvox/VolumeCropper.h"
#include "voxel/polyvox/VolumeRotator.h"
#include "voxel/polyvox/VolumeMover.h"
#include "voxel/polyvox/VolumeRescaler.h"
#include "voxel/polyvox//RawVolumeWrapper.h"
#include "voxel/polyvox//RawVolumeMoveWrapper.h"
#include "voxel/generator/WorldGenerator.h"
#include "voxel/generator/CloudGenerator.h"
#include "voxel/generator/CactusGenerator.h"
#include "voxel/generator/BuildingGenerator.h"
#include "voxel/generator/PlantGenerator.h"
#include "voxel/model/VoxFormat.h"
#include "voxel/model/QBTFormat.h"
#include "voxel/model/QBFormat.h"
#include "video/ScopedPolygonMode.h"
#include "video/ScopedLineWidth.h"
#include "math/Random.h"
#include "core/Array.h"
#include "core/App.h"
#include "io/Filesystem.h"
#include "voxedit-util/tool/Crop.h"
#include "voxedit-util/tool/Expand.h"
#include "voxedit-util/tool/Fill.h"
#include "voxedit-util/ImportHeightmap.h"
#include "core/GLM.h"
#include <set>
namespace voxedit {
const int leafSize = 8;
Model::Model() :
_gridRenderer(true, true) {
}
Model::~Model() {
shutdown();
}
bool Model::importHeightmap(const std::string& file) {
voxel::RawVolume* v = modelVolume();
if (v == nullptr) {
return false;
}
const image::ImagePtr& img = image::loadImage(file, false);
if (!img->isLoaded()) {
return false;
}
voxedit::importHeightmap(*v, img);
modified(v->region());
return true;
}
bool Model::save(const std::string& file) {
if (modelVolume() == nullptr) {
return false;
}
const io::FilePtr& filePtr = core::App::getInstance()->filesystem()->open(std::string(file), io::FileMode::Write);
if (filePtr->extension() == "qbt") {
voxel::QBTFormat f;
if (f.save(modelVolume(), filePtr)) {
_dirty = false;
return true;
}
} else if (filePtr->extension() == "vox") {
voxel::VoxFormat f;
if (f.save(modelVolume(), filePtr)) {
_dirty = false;
return true;
}
} else if (filePtr->extension() == "qb") {
voxel::QBFormat f;
if (f.save(modelVolume(), filePtr)) {
_dirty = false;
return true;
}
}
return false;
}
bool Model::load(const std::string& file) {
const io::FilePtr& filePtr = core::App::getInstance()->filesystem()->open(file);
if (!(bool)filePtr) {
Log::error("Failed to open model file %s", file.data());
return false;
}
voxel::RawVolume* newVolume;
if (filePtr->extension() == "qbt") {
voxel::QBTFormat f;
newVolume = f.load(filePtr);
} else if (filePtr->extension() == "vox") {
voxel::VoxFormat f;
newVolume = f.load(filePtr);
} else if (filePtr->extension() == "qb") {
voxel::QBFormat f;
newVolume = f.load(filePtr);
} else {
newVolume = nullptr;
}
if (newVolume == nullptr) {
Log::error("Failed to load model file %s", file.c_str());
return false;
}
Log::info("Loaded model file %s", file.c_str());
undoHandler().clearUndoStates();
setNewVolume(newVolume);
modified(newVolume->region());
_dirty = false;
return true;
}
void Model::select(const glm::ivec3& pos) {
voxel::RawVolume* selectionVolume = _rawVolumeSelectionRenderer.volume(SelectionVolumeIndex);
_extractSelection |= _selectionHandler.select(modelVolume(), selectionVolume, pos);
}
void Model::unselectAll() {
_selectionHandler.unselectAll();
_rawVolumeSelectionRenderer.volume(SelectionVolumeIndex)->clear();
_extractSelection = true;
}
void Model::setMousePos(int x, int y) {
_mouseX = x;
_mouseY = y;
}
void Model::modified(const voxel::Region& modifiedRegion, bool markUndo) {
if (markUndo) {
undoHandler().markUndo(modelVolume());
}
// TODO: handle the region
_dirty = true;
markExtract();
}
void Model::crop() {
if (_empty) {
Log::info("Empty volumes can't be cropped");
return;
}
voxel::RawVolume* newVolume = voxedit::tool::crop(modelVolume());
if (newVolume == nullptr) {
return;
}
setNewVolume(newVolume);
modified(newVolume->region());
}
void Model::extend(const glm::ivec3& size) {
voxel::RawVolume* newVolume = voxedit::tool::expand(modelVolume(), size);
if (newVolume == nullptr) {
return;
}
setNewVolume(newVolume);
modified(newVolume->region());
}
void Model::scale() {
// TODO: check that src region boundaries are even
const voxel::Region& srcRegion = modelVolume()->region();
const int w = srcRegion.getWidthInVoxels();
const int h = srcRegion.getHeightInVoxels();
const int d = srcRegion.getDepthInVoxels();
const glm::ivec3 maxs(w / 2, h / 2, d / 2);
voxel::Region region(glm::zero<glm::ivec3>(), maxs);
voxel::RawVolume* newVolume = new voxel::RawVolume(region);
voxel::RawVolumeWrapper wrapper(newVolume);
voxel::rescaleVolume(*modelVolume(), *newVolume);
setNewVolume(newVolume);
modified(newVolume->region());
}
void Model::fill(int x, int y, int z) {
const bool overwrite = evalAction() == Action::OverrideVoxel;
voxel::Region modifiedRegion;
if (voxedit::tool::fill(*modelVolume(), glm::ivec3(x, y, z), _lockedAxis, _shapeHandler.currentVoxel(), overwrite, &modifiedRegion)) {
modified(modifiedRegion);
}
}
bool Model::place() {
voxel::Region modifiedRegion;
const bool extract = placeCursor(&modifiedRegion);
if (extract) {
modified(modifiedRegion);
}
return extract;
}
// TODO: delete selected volume from model volume
bool Model::remove() {
const bool extract = setVoxel(_cursorPos, voxel::Voxel());
if (extract) {
const voxel::Region modifiedRegion(_cursorPos, _cursorPos);
modified(modifiedRegion);
}
return extract;
}
void Model::vertices(float* vertices, size_t vertexSize, size_t verticesSize, uint32_t* indices, size_t indicesSize) {
glm::ivec3 mins(std::numeric_limits<glm::ivec3::value_type>::max());
glm::ivec3 maxs(std::numeric_limits<glm::ivec3::value_type>::min());
// TODO: add uv support and apply colored voxels from the texture
const voxel::Voxel& voxel = voxel::createColorVoxel(voxel::VoxelType::Generic, 0);
for (size_t idx = 0u; idx < indicesSize; ++idx) {
const uint32_t vertexIndex = indices[idx];
const float* vertex = &vertices[vertexIndex * vertexSize];
const glm::ivec3 pos(_cursorPos.x + vertex[0], _cursorPos.y + vertex[1], _cursorPos.z + vertex[2]);
setVoxel(pos, voxel);
mins = glm::min(mins, pos);
maxs = glm::max(maxs, pos);
}
const voxel::Region modifiedRegion(mins, maxs);
modified(modifiedRegion);
}
void Model::executeAction(uint64_t now) {
const Action execAction = evalAction();
if (execAction == Action::None) {
Log::warn("Nothing to execute");
return;
}
core_trace_scoped(EditorSceneExecuteAction);
if (_lastAction == execAction) {
if (now - _lastActionExecution < _actionExecutionDelay) {
return;
}
}
_lastAction = execAction;
_lastActionExecution = now;
bool extract = false;
const bool didHit = _result.didHit;
voxel::Region modifiedRegion;
if (didHit && execAction == Action::CopyVoxel) {
shapeHandler().setVoxel(getVoxel(_cursorPos));
} else if (didHit && execAction == Action::SelectVoxels) {
select(_cursorPos);
} else if (didHit && execAction == Action::OverrideVoxel) {
extract = placeCursor(&modifiedRegion);
} else if (didHit && execAction == Action::DeleteVoxel) {
extract = setVoxel(_cursorPos, voxel::Voxel());
if (extract) {
modifiedRegion.setLowerCorner(_cursorPos);
modifiedRegion.setUpperCorner(_cursorPos);
}
} else if (_result.validPreviousPosition && execAction == Action::PlaceVoxel) {
extract = placeCursor(&modifiedRegion);
} else if (didHit && execAction == Action::PlaceVoxel) {
extract = placeCursor(&modifiedRegion);
}
if (!extract) {
return;
}
resetLastTrace();
modified(modifiedRegion);
}
void Model::undo() {
voxel::RawVolume* v = undoHandler().undo();
if (v == nullptr) {
return;
}
setNewVolume(v);
modified(v->region(), false);
}
void Model::redo() {
voxel::RawVolume* v = undoHandler().redo();
if (v == nullptr) {
return;
}
setNewVolume(v);
modified(v->region(), false);
}
bool Model::placeCursor(voxel::Region* modifiedRegion) {
const glm::ivec3& pos = _cursorPos;
const voxel::RawVolume* cursorVolume = cursorPositionVolume();
const voxel::Region& cursorRegion = cursorVolume->region();
const glm::ivec3 mins = -cursorRegion.getCentre() + pos;
const glm::ivec3 maxs = mins + cursorRegion.getDimensionsInCells();
const voxel::Region destReg(mins, maxs);
int cnt = 0;
for (int32_t z = cursorRegion.getLowerZ(); z <= cursorRegion.getUpperZ(); ++z) {
const int destZ = destReg.getLowerZ() + z - cursorRegion.getLowerZ();
for (int32_t y = cursorRegion.getLowerY(); y <= cursorRegion.getUpperY(); ++y) {
const int destY = destReg.getLowerY() + y - cursorRegion.getLowerY();
for (int32_t x = cursorRegion.getLowerX(); x <= cursorRegion.getUpperX(); ++x) {
const voxel::Voxel& voxel = cursorVolume->voxel(x, y, z);
if (isAir(voxel.getMaterial())) {
continue;
}
const int destX = destReg.getLowerX() + x - cursorRegion.getLowerX();
if (setVoxel(glm::ivec3(destX, destY, destZ), voxel)) {
++cnt;
}
}
}
}
if (cnt <= 0) {
return false;
}
if (modifiedRegion != nullptr) {
*modifiedRegion = destReg;
}
return true;
}
void Model::resetLastTrace() {
_lastRaytraceX = _lastRaytraceY = -1;
}
void Model::setNewVolume(voxel::RawVolume* volume) {
const voxel::Region& region = volume->region();
delete _rawVolumeSelectionRenderer.setVolume(SelectionVolumeIndex, new voxel::RawVolume(region));
delete _rawVolumeRenderer.setVolume(ModelVolumeIndex, volume);
delete _rawVolumeRenderer.setVolume(CursorVolumeIndex, new voxel::RawVolume(region));
#if 0
if (_spaceColonizationTree != nullptr) {
delete _spaceColonizationTree;
_spaceColonizationTree = nullptr;
}
#endif
if (volume != nullptr) {
const voxel::Region& region = volume->region();
_gridRenderer.update(region);
} else {
_gridRenderer.clear();
}
setCursorShape(_shapeHandler.cursorShape());
_dirty = false;
_lastPlacement = glm::ivec3(-1);
_result = voxel::PickResult();
const glm::ivec3 pos = _cursorPos;
_cursorPos = pos * 10 + 10;
setCursorPosition(pos);
const glm::ivec3 refPos(region.getCentreX(), 0, region.getCentreZ());
setReferencePosition(refPos);
resetLastTrace();
}
bool Model::newVolume(bool force) {
if (dirty() && !force) {
return false;
}
const voxel::Region region(glm::ivec3(0), glm::ivec3(size() - 1));
undoHandler().clearUndoStates();
setNewVolume(new voxel::RawVolume(region));
modified(region);
_dirty = false;
return true;
}
void Model::rotate(int angleX, int angleY, int angleZ) {
const voxel::RawVolume* model = modelVolume();
voxel::RawVolume* newVolume = voxel::rotateVolume(model, glm::vec3(angleX, angleY, angleZ), voxel::Voxel(), false);
setNewVolume(newVolume);
modified(newVolume->region());
}
void Model::move(int x, int y, int z) {
const voxel::RawVolume* model = modelVolume();
voxel::RawVolume* newVolume = new voxel::RawVolume(model->region());
voxel::RawVolumeMoveWrapper wrapper(newVolume);
voxel::moveVolume(&wrapper, model, glm::ivec3(x, y, z), voxel::Voxel());
setNewVolume(newVolume);
modified(newVolume->region());
}
const voxel::Voxel& Model::getVoxel(const glm::ivec3& pos) const {
return modelVolume()->voxel(pos);
}
bool Model::setVoxel(const glm::ivec3& pos, const voxel::Voxel& voxel) {
voxel::RawVolumeWrapper wrapper(modelVolume());
const bool placed = wrapper.setVoxel(pos, voxel);
if (!placed) {
return false;
}
_lastPlacement = pos;
if (_mirrorAxis == math::Axis::None) {
return true;
}
const int index = getIndexForMirrorAxis(_mirrorAxis);
const int delta = _mirrorPos[index] - pos[index] - 1;
if (delta == 0) {
return true;
}
glm::ivec3 mirror;
for (int i = 0; i < 3; ++i) {
if (i == index) {
mirror[i] = _mirrorPos[i] + delta;
} else {
mirror[i] = pos[i];
}
}
wrapper.setVoxel(mirror, voxel);
return true;
}
void Model::copy() {
voxel::mergeRawVolumesSameDimension(cursorPositionVolume(), _rawVolumeSelectionRenderer.volume());
markCursorExtract();
}
void Model::paste() {
voxel::RawVolume* cursorVolume = cursorPositionVolume();
const voxel::Region& srcRegion = cursorVolume->region();
const voxel::Region destRegion = srcRegion + _cursorPos;
voxel::RawVolumeWrapper wrapper(modelVolume());
voxel::mergeVolumes(&wrapper, cursorVolume, destRegion, srcRegion);
}
void Model::cut() {
voxel::RawVolume* cursorVolume = cursorPositionVolume();
voxel::mergeRawVolumesSameDimension(cursorVolume, _rawVolumeSelectionRenderer.volume(SelectionVolumeIndex));
// TODO: see remove
// TODO: delete selected volume from model volume
}
void Model::render(const video::Camera& camera) {
const voxel::Mesh* mesh = _rawVolumeRenderer.mesh(ModelVolumeIndex);
_empty = mesh != nullptr ? mesh->getNoOfIndices() == 0 : true;
_gridRenderer.render(camera, modelVolume()->region());
_rawVolumeRenderer.render(camera);
// TODO: render error if rendered last - but be before grid renderer to get transparency.
if (_renderLockAxis) {
for (int i = 0; i < lengthof(_planeMeshIndex); ++i) {
_shapeRenderer.render(_planeMeshIndex[i], camera);
}
}
_shapeRenderer.render(_mirrorMeshIndex, camera);
renderSelection(camera);
}
void Model::renderSelection(const video::Camera& camera) {
const voxel::Mesh* mesh = _rawVolumeSelectionRenderer.mesh(SelectionVolumeIndex);
if (mesh == nullptr || mesh->getNoOfIndices() == 0) {
return;
}
video::ScopedPolygonMode polygonMode(video::PolygonMode::WireFrame, glm::vec2(-2.0f));
video::ScopedLineWidth lineWidth(3.0f);
video::enable(video::State::Blend);
video::blendFunc(video::BlendMode::One, video::BlendMode::One);
_rawVolumeSelectionRenderer.render(camera);
video::blendFunc(video::BlendMode::SourceAlpha, video::BlendMode::OneMinusSourceAlpha);
}
void Model::onResize(const glm::ivec2& size) {
_rawVolumeRenderer.onResize(glm::ivec2(0), size);
_rawVolumeSelectionRenderer.onResize(glm::ivec2(0), size);
}
void Model::init() {
if (_initialized > 0) {
return;
}
++_initialized;
_rawVolumeRenderer.init();
_rawVolumeSelectionRenderer.init();
_shapeRenderer.init();
_gridRenderer.init();
_mirrorMeshIndex = -1;
for (int i = 0; i < lengthof(_planeMeshIndex); ++i) {
_planeMeshIndex[i] = -1;
}
_lastAction = Action::None;
_action = Action::None;
_lockedAxis = math::Axis::None;
_mirrorAxis = math::Axis::None;
}
void Model::update() {
const uint64_t ms = core::App::getInstance()->systemMillis();
if (_spaceColonizationTree != nullptr && ms - _lastGrow > 1000L) {
const bool growing = _spaceColonizationTree->step();
_lastGrow = ms;
voxel::RawVolumeWrapper wrapper(modelVolume());
math::Random random;
const voxel::RandomVoxel woodRandomVoxel(voxel::VoxelType::Wood, random);
_spaceColonizationTree->generate(wrapper, woodRandomVoxel);
modified(modelVolume()->region());
if (!growing) {
const voxel::RandomVoxel leavesRandomVoxel(voxel::VoxelType::Leaf, random);
_spaceColonizationTree->generateLeaves(wrapper, leavesRandomVoxel, glm::ivec3(leafSize));
delete _spaceColonizationTree;
_spaceColonizationTree = nullptr;
}
}
extractVolume();
extractCursorVolume();
extractSelectionVolume();
}
void Model::shutdown() {
--_initialized;
if (_initialized > 0) {
return;
} else if (_initialized < 0) {
_initialized = 0;
return;
}
_initialized = 0;
{
const std::vector<voxel::RawVolume*>& old = _rawVolumeRenderer.shutdown();
for (voxel::RawVolume* v : old) {
delete v;
}
}
{
const std::vector<voxel::RawVolume*>& old = _rawVolumeSelectionRenderer.shutdown();
for (voxel::RawVolume* v : old) {
delete v;
}
}
if (_spaceColonizationTree != nullptr) {
delete _spaceColonizationTree;
_spaceColonizationTree = nullptr;
}
_shapeRenderer.shutdown();
_shapeBuilder.shutdown();
_gridRenderer.shutdown();
undoHandler().clearUndoStates();
}
bool Model::extractSelectionVolume() {
if (_extractSelection) {
_extractSelection = false;
_rawVolumeSelectionRenderer.extract(SelectionVolumeIndex);
return true;
}
return false;
}
bool Model::extractVolume() {
if (_extract) {
_extract = false;
_rawVolumeRenderer.extract(ModelVolumeIndex);
return true;
}
return false;
}
bool Model::extractCursorVolume() {
if (_extractCursor) {
_extractCursor = false;
_rawVolumeRenderer.extract(CursorVolumeIndex);
return true;
}
return false;
}
void Model::noise(int octaves, float lacunarity, float frequency, float gain, voxel::noise::NoiseType type) {
math::Random random;
voxel::RawVolumeWrapper wrapper(modelVolume());
voxel::noise::generate(wrapper, octaves, lacunarity, frequency, gain, type, random);
modified(modelVolume()->region());
}
void Model::spaceColonization() {
const voxel::Region& region = modelVolume()->region();
const math::AABB<int>& aabb = region.aabb();
const int trunkHeight = aabb.getWidthY() / 2;
_lastGrow = core::App::getInstance()->systemMillis();
_spaceColonizationTree = new voxel::tree::Tree(referencePosition(), trunkHeight, 6,
aabb.getWidthX() - leafSize, aabb.getWidthY() - trunkHeight - leafSize, aabb.getWidthZ() - leafSize, 4.0f, _lastGrow);
}
void Model::lsystem(const voxel::lsystem::LSystemContext& lsystemCtx) {
math::Random random;
voxel::RawVolumeWrapper wrapper(modelVolume());
if (voxel::lsystem::generate(wrapper, lsystemCtx, random)) {
modified(modelVolume()->region());
}
}
void Model::bezier(const glm::ivec3& start, const glm::ivec3& end, const glm::ivec3& control) {
voxel::RawVolumeWrapper wrapper(modelVolume());
const int steps = glm::distance2(glm::vec3(start), glm::vec3(end)) * 10;
voxel::shape::createBezier(wrapper,start, end, control, _shapeHandler.currentVoxel(), steps);
const glm::ivec3 mins = glm::min(start, end);
const glm::ivec3 maxs = glm::max(start, end);
modified(voxel::Region(mins, maxs));
}
void Model::world(const voxel::WorldContext& ctx) {
const voxel::Region region(glm::ivec3(0), glm::ivec3(127, 63, 127));
setNewVolume(new voxel::RawVolume(region));
voxel::BiomeManager mgr;
const io::FilesystemPtr& filesystem = core::App::getInstance()->filesystem();
mgr.init(filesystem->load("biomes.lua"));
voxel::RawVolumeWrapper wrapper(modelVolume());
voxel::world::WorldGenerator gen(mgr, 1L);
gen.createWorld(ctx, wrapper, 0.0f, 0.0f);
voxel::cloud::CloudContext cloudCtx;
gen.createClouds(wrapper, cloudCtx);
gen.createTrees(wrapper);
modified(modelVolume()->region());
}
void Model::createCactus() {
math::Random random;
voxel::RawVolumeWrapper wrapper(modelVolume());
voxel::cactus::createCactus(wrapper, _referencePos, 18, 2, random);
modified(modelVolume()->region());
}
void Model::createCloud() {
voxel::RawVolumeWrapper wrapper(modelVolume());
struct HasClouds {
glm::vec2 pos;
void getCloudPositions(const voxel::Region& region, std::vector<glm::vec2>& positions, math::Random& random, int border) const {
positions.push_back(pos);
}
};
HasClouds hasClouds;
hasClouds.pos = glm::vec2(_referencePos.x, _referencePos.z);
voxel::cloud::CloudContext cloudCtx;
if (voxel::cloud::createClouds(wrapper, wrapper.region(), hasClouds, cloudCtx)) {
modified(modelVolume()->region());
}
}
void Model::createPlant(voxel::PlantType type) {
voxel::PlantGenerator g;
voxel::RawVolumeWrapper wrapper(modelVolume());
if (type == voxel::PlantType::Flower) {
g.createFlower(5, _referencePos, wrapper);
} else if (type == voxel::PlantType::Grass) {
g.createGrass(10, _referencePos, wrapper);
} else if (type == voxel::PlantType::Mushroom) {
g.createMushroom(7, _referencePos, wrapper);
}
g.shutdown();
modified(modelVolume()->region());
}
void Model::createBuilding(voxel::BuildingType type, const voxel::BuildingContext& ctx) {
voxel::RawVolumeWrapper wrapper(modelVolume());
voxel::building::createBuilding(wrapper, _referencePos, type);
modified(modelVolume()->region());
}
void Model::createTree(voxel::TreeContext ctx) {
math::Random random;
voxel::RawVolumeWrapper wrapper(modelVolume());
ctx.pos = _referencePos;
voxel::tree::createTree(wrapper, ctx, random);
modified(modelVolume()->region());
}
void Model::setReferencePosition(const glm::ivec3& pos) {
_referencePos = pos;
}
void Model::setCursorPosition(glm::ivec3 pos, bool force) {
if (!force) {
if ((_lockedAxis & math::Axis::X) != math::Axis::None) {
pos.x = _cursorPos.x;
}
if ((_lockedAxis & math::Axis::Y) != math::Axis::None) {
pos.y = _cursorPos.y;
}
if ((_lockedAxis & math::Axis::Z) != math::Axis::None) {
pos.z = _cursorPos.z;
}
}
const voxel::Region& region = modelVolume()->region();
if (!region.containsPoint(pos)) {
pos = region.moveInto(pos.x, pos.y, pos.z);
}
if (_cursorPos == pos) {
return;
}
_cursorPos = pos;
const voxel::Region& cursorRegion = cursorPositionVolume()->region();
_rawVolumeRenderer.setOffset(CursorVolumeIndex, -cursorRegion.getCentre() + _cursorPos);
updateLockedPlane(math::Axis::X);
updateLockedPlane(math::Axis::Y);
updateLockedPlane(math::Axis::Z);
}
void Model::markCursorExtract() {
_extractCursor = true;
}
void Model::markExtract() {
_extract = true;
}
bool Model::trace(const video::Camera& camera) {
if (modelVolume() == nullptr) {
return false;
}
if (_lastRaytraceX != _mouseX || _lastRaytraceY != _mouseY) {
core_trace_scoped(EditorSceneOnProcessUpdateRay);
_lastRaytraceX = _mouseX;
_lastRaytraceY = _mouseY;
const video::Ray& ray = camera.mouseRay(glm::ivec2(_mouseX, _mouseY));
const glm::vec3& dirWithLength = ray.direction * camera.farPlane();
static constexpr voxel::Voxel air;
_result = voxel::pickVoxel(modelVolume(), ray.origin, dirWithLength, air);
if (actionRequiresExistingVoxel(evalAction())) {
if (_result.didHit) {
setCursorPosition(_result.hitVoxel);
} else if (_result.validPreviousPosition) {
setCursorPosition(_result.previousPosition);
}
} else if (_result.validPreviousPosition) {
setCursorPosition(_result.previousPosition);
}
}
return true;
}
int Model::getIndexForAxis(math::Axis axis) const {
if (axis == math::Axis::X) {
return 0;
} else if (axis == math::Axis::Y) {
return 1;
}
return 2;
}
int Model::getIndexForMirrorAxis(math::Axis axis) const {
if (axis == math::Axis::X) {
return 2;
} else if (axis == math::Axis::Y) {
return 1;
}
return 0;
}
void Model::updateShapeBuilderForPlane(bool mirror, const glm::ivec3& pos, math::Axis axis, const glm::vec4& color) {
const voxel::Region& region = modelVolume()->region();
const int index = mirror ? getIndexForMirrorAxis(axis) : getIndexForAxis(axis);
glm::vec3 mins = region.getLowerCorner();
glm::vec3 maxs = region.getUpperCorner();
mins[index] = maxs[index] = pos[index];
const glm::vec3& ll = mins;
const glm::vec3& ur = maxs;
glm::vec3 ul;
glm::vec3 lr;
if (axis == math::Axis::Y) {
ul = glm::vec3(mins.x, mins.y, maxs.z);
lr = glm::vec3(maxs.x, maxs.y, mins.z);
} else {
ul = glm::vec3(mins.x, maxs.y, mins.z);
lr = glm::vec3(maxs.x, mins.y, maxs.z);
}
std::vector<glm::vec3> vecs({ll, ul, ur, lr});
// lower left (0), upper left (1), upper right (2)
// lower left (0), upper right (2), lower right (3)
const std::vector<uint32_t> indices { 0, 1, 2, 0, 2, 3, 2, 1, 0, 3, 2, 0 };
_shapeBuilder.clear();
_shapeBuilder.setColor(color);
_shapeBuilder.geom(vecs, indices);
}
void Model::updateLockedPlane(math::Axis axis) {
if (axis == math::Axis::None) {
return;
}
const int index = getIndexForAxis(axis);
int32_t& meshIndex = _planeMeshIndex[index];
if ((_lockedAxis & axis) == math::Axis::None) {
if (meshIndex != -1) {
_shapeRenderer.deleteMesh(meshIndex);
meshIndex = -1;
}
return;
}
const glm::vec4 colors[] = {
core::Color::LightRed,
core::Color::LightGreen,
core::Color::LightBlue
};
updateShapeBuilderForPlane(false, _cursorPos, axis, core::Color::alpha(colors[index], 0.3f));
_shapeRenderer.createOrUpdate(meshIndex, _shapeBuilder);
}
math::Axis Model::mirrorAxis() const {
return _mirrorAxis;
}
void Model::setMirrorAxis(math::Axis axis, const glm::ivec3& mirrorPos) {
if (_mirrorAxis == axis) {
if (_mirrorPos != mirrorPos) {
_mirrorPos = mirrorPos;
updateMirrorPlane();
}
return;
}
_mirrorPos = mirrorPos;
_mirrorAxis = axis;
updateMirrorPlane();
}
void Model::updateMirrorPlane() {
if (_mirrorAxis == math::Axis::None) {
if (_mirrorMeshIndex != -1) {
_shapeRenderer.deleteMesh(_mirrorMeshIndex);
_mirrorMeshIndex = -1;
}
return;
}
updateShapeBuilderForPlane(true, _mirrorPos, _mirrorAxis, core::Color::alpha(core::Color::LightGray, 0.1f));
_shapeRenderer.createOrUpdate(_mirrorMeshIndex, _shapeBuilder);
}
void Model::setLockedAxis(math::Axis axis, bool unlock) {
if (unlock) {
_lockedAxis &= ~axis;
} else {
_lockedAxis |= axis;
}
updateLockedPlane(math::Axis::X);
updateLockedPlane(math::Axis::Y);
updateLockedPlane(math::Axis::Z);
}
}
| [
"martin.gerhardy@gmail.com"
] | martin.gerhardy@gmail.com |
5fcafbff312bc0ca19911f617c58abc14afb4ea9 | 197842fefb345260d65acf62daf1956698a6747b | /iris/gameobject/GameObject.cpp | 3fe6f19ddb1868c9671d45df12134151e8438acb | [
"MIT"
] | permissive | pixelsquare/iris-engine-opengl | ede3129c912bbbac5170f59f6dab60db17849060 | 5b542333f3c3aed9a66f388a6703dc0daa06b3fb | refs/heads/master | 2023-08-19T04:13:44.230693 | 2021-09-27T05:48:39 | 2021-09-27T05:48:39 | 410,756,370 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,340 | cpp | #include "GameObject.h"
#include "transform/Transform.h"
#include "component/Component.h"
namespace IrisFramework
{
GameObject::GameObject()
: Object("new_gameobject"),
m_isActive(false),
m_hasCameraAttached(false)
{
IRIS_LOG.internalLog("GameObject Created [%s]", getName());
m_transform = addComponent<Transform>();
m_transform->setGameObject(this);
}
GameObject::GameObject(const char* p_name)
: Object(p_name),
m_isActive(false),
m_hasCameraAttached(false)
{
IRIS_LOG.internalLog("GameObject Created [%s]", getName());
m_transform = addComponent<Transform>();
m_transform->setGameObject(this);
}
GameObject::~GameObject() {}
void GameObject::awake()
{
typedef componentMap_t::const_iterator iterator_t;
for(iterator_t iterator = m_componentMap.begin(); iterator != m_componentMap.end(); ++iterator)
{
if(NULL != (*iterator).second)
{
(*iterator).second->awake();
}
}
}
void GameObject::start()
{
typedef componentMap_t::iterator iterator_t;
for(iterator_t iterator = m_componentMap.begin(); iterator != m_componentMap.end(); ++iterator)
{
if(NULL != (*iterator).second)
{
(*iterator).second->start();
}
}
m_isActive = true;
}
void GameObject::fixedUpdate()
{
typedef componentMap_t::iterator iterator_t;
for(iterator_t iterator = m_componentMap.begin(); iterator != m_componentMap.end(); ++iterator)
{
if(NULL != (*iterator).second)
{
(*iterator).second->fixedUpdate();
}
}
}
void GameObject::update()
{
typedef componentMap_t::const_iterator iterator_t;
for(iterator_t iterator = m_componentMap.begin(); iterator != m_componentMap.end(); ++iterator)
{
if(NULL != (*iterator).second)
{
(*iterator).second->update();
}
}
}
void GameObject::lateUpdate()
{
typedef componentMap_t::iterator iterator_t;
for(iterator_t iterator = m_componentMap.begin(); iterator != m_componentMap.end(); ++iterator)
{
if(NULL != (*iterator).second)
{
(*iterator).second->lateUpdate();
}
}
}
void GameObject::onPreRender()
{
typedef componentMap_t::iterator iterator_t;
for(iterator_t iterator = m_componentMap.begin(); iterator != m_componentMap.end(); ++iterator)
{
if(NULL != (*iterator).second)
{
(*iterator).second->onPreRender();
}
}
}
void GameObject::onRender()
{
typedef componentMap_t::const_iterator iterator_t;
for(iterator_t iterator = m_componentMap.begin(); iterator != m_componentMap.end(); ++iterator)
{
if(NULL != (*iterator).second)
{
(*iterator).second->onRender();
}
}
}
void GameObject::onPostRender()
{
typedef componentMap_t::iterator iterator_t;
for(iterator_t iterator = m_componentMap.begin(); iterator != m_componentMap.end(); ++iterator)
{
if(NULL != (*iterator).second)
{
(*iterator).second->onPostRender();
}
}
}
void GameObject::dispose()
{
Object::dispose();
typedef componentMap_t::const_iterator iterator_t;
for(iterator_t iterator = m_componentMap.begin(); iterator != m_componentMap.end(); ++iterator)
{
if(NULL != (*iterator).second)
{
(*iterator).second->dispose();
}
}
}
void GameObject::addChild(GameObject* p_gameObject)
{
m_transform->addChild(&p_gameObject->getTransform());
}
void GameObject::removeChild(GameObject* p_gameObject)
{
m_transform->removeChild(&p_gameObject->getTransform());
}
componentVec_t GameObject::getComponents() const
{
componentVec_t retVal;
typedef componentMap_t::const_iterator iterator_t;
for(iterator_t iterator = m_componentMap.begin(); iterator != m_componentMap.end(); ++iterator)
{
retVal.push_back((*iterator).second);
}
return retVal;
}
componentPair_t GameObject::addComponent(unsigned int p_guid, Component *p_component)
{
componentPair_t retVal(p_guid, p_component);
m_componentMap.insert(retVal);
return retVal;
}
componentPair_t GameObject::removeComponent(unsigned int p_guid, Component *p_component)
{
componentPair_t retVal(p_guid, p_component);
componentMap_t::iterator iterator;
iterator = m_componentMap.find(p_guid);
m_componentMap.erase(iterator);
return retVal;
}
}
| [
"anthony.ganzon@ymail.com"
] | anthony.ganzon@ymail.com |
2d58e89324a4fdb890acc9cf33f91db235b86f60 | 41a9fdfa2aa4479b604cff8fed4a1c3a88f9aaa8 | /Common/LProtocol/Unix/srcs/MessageLogingResult.cpp | cc871ff6175a1c4293cd1b8a1a094fc94d423443 | [] | no_license | adril/plateR | 484f8ff0a26685b2699f1c44896a67716244f6a7 | 9a1da63a80e2f3cae38296227300fbb27f4bcaf0 | refs/heads/master | 2021-01-10T19:34:29.023065 | 2012-11-15T00:57:04 | 2012-11-15T00:57:04 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,023 | cpp | #include "../include/MessageLoginResult.hh"
MessageLoginResult::MessageLoginResult(Message &other, char type, char state)
: Message(other) {
this->_loginResult.type = type;
this->_loginResult.state = state;
}
MessageLoginResult::MessageLoginResult(Message &other) {
std::cout << "[MessageLoginResult] ------ (Message const& other)" << std::endl;
/* copy of data */
this->header_ = new char[other.getHeaderLength()];
this->copyString(other.getHeader(), this->getHeader(), other.getHeaderLength());
// std::memset(this->header_, '\0', other.getHeaderLength());
// std::memcpy(this->header_, other.getHeader(), other.getHeaderLength());
this->body_ = new char[other.getBodyLength()];
this->copyString(other.getBody(), this->getBody(), other.getBodyLength());
// std::memset(this->body_, '\0', other.getBodyLength());
// std::memcpy(this->body_, other.getBody(), other.getBodyLength());
/* copy of header infos */
this->_type = other.getType();
this->_bodyLength = other.getBodyLength();
}
MessageLoginResult::~MessageLoginResult() {}
void MessageLoginResult::encodeBody() {
std::cout << "MessageLoginResult::encodeBody()" << std::endl;
std::memcpy(this->body_, &_loginResult, sizeof(this->_loginResult));
}
void MessageLoginResult::encodeBodyWithError(char error) {
this->_loginResult.error = error;
encodeBody();
}
void MessageLoginResult::decodeBody() {
this->_loginResult.command = reinterpret_cast<VSP::Game *>(this->body_)->command;
std::memset(this->_loginResult.file, '\0', VSP::NAME_SIZE);
std::strcpy(this->_loginResult.file, reinterpret_cast<VSP::Game *>(this->body_)->file);
this->_loginResult.x = reinterpret_cast<VSP::Game *>(this->body_)->x;
this->_loginResult.y = reinterpret_cast<VSP::Game *>(this->body_)->y;
this->_loginResult.type = reinterpret_cast<VSP::Game *>(this->body_)->type;
this->_loginResult.id = reinterpret_cast<VSP::Game *>(this->body_)->id;
this->_loginResult.error = reinterpret_cast<VSP::Game *>(this->body_)->error;
}
| [
"adrien.guffens@epitech.eu"
] | adrien.guffens@epitech.eu |
5a99ca9da44afa6b6d91c7a30254c5c4004575d0 | 6474e1ce6fdc13d514e59da2a7025a35d7908218 | /week-06/ToDoApp_Factory/Command_l.cpp | c60dcfa5a9d3c09d264ef9bea7bccf3c4e658e28 | [] | no_license | green-fox-academy/ImreCsete | 1cc62af0e9dfa7f8005c214d3be13bb5db33cf69 | f5fc58a4793f17efec0249eca1b0f192d1860ff8 | refs/heads/master | 2021-09-06T09:23:06.177864 | 2018-02-05T00:53:20 | 2018-02-05T00:53:20 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 104 | cpp | #include "Command_l.h"
#include <iostream>
using namespace std;
Command_l::Command_l()
{
//ctor
}
| [
"csete_imre@hotmail.com"
] | csete_imre@hotmail.com |
f1bab6ae531013cb9bdd43d2003747acaf462ba3 | 440f814f122cfec91152f7889f1f72e2865686ce | /src/game_server/server/extension/buff/buff_pool.h | d01e4297b691e0ee3573bc7f0136c09fa15cdfc2 | [] | no_license | hackerlank/buzz-server | af329efc839634d19686be2fbeb700b6562493b9 | f76de1d9718b31c95c0627fd728aba89c641eb1c | refs/heads/master | 2020-06-12T11:56:06.469620 | 2015-12-05T08:03:25 | 2015-12-05T08:03:25 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 912 | h | //
// Summary: buzz source code.
//
// Author: Tony.
// Email: tonyjobmails@gmail.com.
// Last modify: 2013-04-02 22:27:54.
// File name: buff_pool.h
//
// Description:
// Define class BuffPool.
//
#ifndef __GAME__SERVER__BUFF__BUFF__POOL__H
#define __GAME__SERVER__BUFF__BUFF__POOL__H
#include "global/pool_template.h"
#include "global/singleton_factory.h"
namespace game {
namespace server {
namespace buff {
class Buff;
class BuffPool : public global::SingletonFactory<BuffPool> {
friend class global::SingletonFactory<BuffPool>;
public:
bool Initialize(size_t initial_number, size_t extend_number);
void Finalize();
Buff *Allocate();
void Deallocate(Buff *buff);
private:
BuffPool() {}
~BuffPool() {}
global::PoolTemplate<Buff> buffs_;
core::uint64 index_;
};
} // namespace buff
} // namespace server
} // namespace game
#endif // __GAME__SERVER__BUFF__BUFF__POOL__H
| [
"251729465@qq.com"
] | 251729465@qq.com |
922f4f74fc167c05cbc6aebeb93a7ef4835c90b9 | 06d39b42c0df00dbc334a7e41c6178303ebd2633 | /Huffman/Huffman/queue.h | b2f67d5105a1756ad4fb7912291432af9ef3c171 | [] | no_license | mszab0310/Cpp | a93bfecd314ac4bf4a6659e7f71072d6fe91b10d | 572d8065fd98793a032344ff7870dbcf849f1c73 | refs/heads/master | 2023-05-06T04:46:34.369008 | 2021-05-25T10:32:00 | 2021-05-25T10:32:00 | 309,356,434 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,754 | h | #pragma once
#include <iostream>
template <typename T>
class Node {
T val;
Node<T>* next;
public:
Node(T val, Node<T>* next = nullptr) {
this->val = val;
this->next = next;
}
Node<T>* getNext() {
return this->next;
}
T getVal() {
return this->val;
}
void setNext(Node<T>* next) {
this->next = next;
}
void setVal(int val) {
this->val = val;
}
friend std::ostream& operator<<(std::ostream& os, Node& n) {
os << n.getVal() << " -> ";
}
};
template <typename T>
class Queue {
int count;
Node<T>* first;
Node<T>* last;
protected:
void setFirst(Node<T>* first) {
this->first = first;
}
void setLast(Node<T>* last) {
this->last = last;
}
Node<T>* getFirst() {
return this->first;
}
void incCount() {
this->count++;
}
public:
Queue(int count = 0, Node<T>* first = nullptr, Node<T>* last = nullptr) {
this->count = count;
this->first = first;
this->last = last;
}
bool isEmpty() {
return (this->first == nullptr);
}
int getCount() {
return this->count;
}
T peek() {
return this->getFirst()->getVal();
}
void push(T val) {
Node<T>* a = new Node<T>(val);
if (!this->isEmpty()) {
this->last->setNext(a);
this->last = a;
}
else {
this->last = a;
this->first = this->last;
}
this->count++;
}
T pop() {
Node<T>* temp = this->first;
if (this->first == nullptr) {
throw std::exception("Empty queue");
}
else if (temp->getNext() != NULL) {
temp = temp->getNext();
T val = this->first->getVal();
delete this->first;
this->first = temp;
this->count--;
return val;
}
else {
T val = this->first->getVal();
delete this->first;
this->first = nullptr;
this->last = nullptr;
this->count--;
return val;
}
}
};
| [
"mszabi0310@gmail.com"
] | mszabi0310@gmail.com |
49cdcf8f714b569e6f6cbcde9e82bf840614842f | c6c72b7b74d0e703143c98b4cd22ffc1b513d8ad | /bot_rtb/include/TemplateBot.h | a0da5483e49bdf3ed157f96f2491cca5a1794835 | [] | no_license | javierkno/RA-bots | 8e7375530bc98104801a44e3a5bc744f88e35afe | fcfec60de320f3a30d7c859a09215f534a39e101 | refs/heads/master | 2021-01-13T02:50:57.476227 | 2014-07-14T13:11:39 | 2014-07-14T13:11:39 | 77,142,422 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,509 | h | #ifndef TEMPLATEBOT_H
#define TEMPLATEBOT_H
#include "MessageListener.h"
#include "StateMachine.h"
#include "Pathfinding.h"
class TemplateBot
{
private:
MessageListener listener;
//------------------
StateMachine<TemplateBot>* stmachine;
Pathfinding pf;
Node *sig;
vector<Node*> camino;
//+++++++++++++++++
int object;
double odistance;
double oangle;
double lodistance;
int goal;
Node coordinates[5];
double last_x;
double last_y;
//--------------------
/* ROBOT VARIABLES */
double x;
double y;
double angle;
double radarAngle;
double cannonAngle;
double speed;
double energy;
double collisionObject;
double collisionAngle;
double enemyEnergy;
bool teammate;
int robotsLeft;
/* GAME OPTIONS */
double maxRotate;
double cannonMaxRotate;
double radarMaxRotate;
double maxAcceleration;
double minAcceleration;
double startEnergy;
double maxEnergy;
double energyLevels;
double shootSpeed;
double shootMinEnergy;
double shootMaxEnergy;
double shootEnergyIncreaseSpeed;
public:
TemplateBot();
TemplateBot(const TemplateBot& orig);
virtual ~TemplateBot();
MessageListener& getListener() { return listener; }
StateMachine<TemplateBot>* getStateMachine() { return stmachine; }
Pathfinding& getPathfinding() { return pf; }
/* SETTERS */
void setX(double x) { last_x = this->x; this->x = x; }
void setY(double y) { last_y = this->y; this->y = y; }
void setAngle(double a) { this->angle = a; }
void setRadarAngle(double a) { this->radarAngle = a; }
void setCannonAngle(double a) { this->cannonAngle = a; }
void setSpeed(double s) { this->speed = s; }
void setEnergy(double e) { this->energy = e; }
void setEnemyEnergy(double e) { this->enemyEnergy = e; }
void setTeammate(bool tm) { this->teammate = tm; }
void setCollisionObject(int o) { this->collisionObject = o; }
void setCollisionAngle(double a) { this->collisionAngle = a; }
void setRobotsLeft(int rl) { this->robotsLeft = rl; }
void setMaxRotate(double mr) { maxRotate = mr; }
void setCannonMaxRotate(double cmr) { cannonMaxRotate = cmr; }
void setRadarMaxRotate(double rmr) { radarMaxRotate = rmr; }
void setMaxAcceleration(double ma) { maxAcceleration = ma; }
void setMinAcceleration(double ma) { minAcceleration = ma; }
void setStartEnergy(double se) { startEnergy = se; }
void setMaxEnergy(double me) { maxEnergy = me; }
void setEnergyLevels(double el) { energyLevels = el; }
void setShootSpeed(double ss) { shootSpeed = ss; }
void setShootMinEnergy(double sme) { shootMinEnergy = sme; }
void setShootMaxEnergy(double sme) { shootMaxEnergy = sme; }
void setShootEnergyIncreaseSpeed(double seis) { shootEnergyIncreaseSpeed = seis; }
double getMaxRotate() { return maxRotate; }
double getCannonMaxRotate() { return cannonMaxRotate; }
double getRadarMaxRotate() { return radarMaxRotate; }
double getMaxAcceleration() { return maxAcceleration; }
double getMinAcceleration() { return minAcceleration; }
double getStartEnergy() { return startEnergy; }
double getMaxEnergy() { return maxEnergy; }
double getEnergyLevels() { return energyLevels; }
double getShootSpeed() { return shootSpeed; }
double getShootMinEnergy() { return shootMinEnergy; }
double getShootMaxEnergy() { return shootMaxEnergy; }
double getShootEnergyIncreaseSpeed() { return shootEnergyIncreaseSpeed; }
double getX() { return x; }
double getY() { return y;}
double getAngle() { return angle; }
double getRadarAngle() { return radarAngle; }
double getCannonAngle() { return cannonAngle; }
double getSpeed() { return speed; }
double getEnergy() { return energy; }
double getEnemyEnergy() { return enemyEnergy; }
bool getTeammate() { return teammate; }
int getCollisionObject() { return collisionObject; }
double getCollisionAngle() { return collisionAngle; }
int getRobotsLeft() { return robotsLeft; }
Node* getSiguiente();
Node* getActual();
void getPath(int, int);
double angleTo(int, int);
int getObject() { return object; }
double getObjectDistance() { return odistance; }
double getObjectAngle() { return oangle; }
void setObject(int n) { object=n; }
void setObjectDistance(double d) { lodistance = odistance; odistance = d;}
void setObjectAngle(double a) { oangle = a; }
void cleanObject() { object=-1; }
bool changed() { return !(odistance==lodistance); }
//Node getCoords(int num) { return coordinates[num]; }
Node getGoal() { return coordinates[goal]; }
void setGoal(int g) { goal = g; }
void clearPath();
double getLastX() { return last_x; }
double getLastY() { return last_y; }
/* MESSAGES TO SERVER */
void setOption(int option, int value);
void setName(const char* name);
void setColor(int homeColor, int awayColor);
void rotate(int object, double angularVelocity);
void rotateTo(int object, double angularVelocity, double angle);
void rotateAmount(int object, double angularVelocity, double angle);
void sweep(int object, double angularVelocity, double rightAngle, double leftAngle);
void accelerate(double value);
void brake(double value);
void shoot(double energy);
};
#endif
| [
"javierkno.10@gmail.com"
] | javierkno.10@gmail.com |
85cd5fc48a69e8bda747042538fa1f5f5cefe4b4 | d227a68091e344f5f16fbec49d505ba860116d8e | /Searching/searching-15.cpp | 7c5415b71e56f677d7261f32354c7435c96c6345 | [] | no_license | ayush0997/cpp-practice | 3352dd694b7e8ef215c99573cce2263283024235 | 3691c145d256c22fda6b323a7451ac839edf2ae7 | refs/heads/master | 2023-08-29T00:24:33.769012 | 2021-10-23T11:43:20 | 2021-10-23T11:43:20 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,011 | cpp | /*You are given heights of consecutive buildings. You can move from the roof of a building
to the roof of next adjacent building. You need to find the maximum number of consecutive
steps you can put forward such that you gain an increase in altitude with each step.
For each test case, print maximum number of consecutive steps he can put forward such that
he increase in altitude, in separate lines. He initially is on the roof of the first building.
Input:
2
5
1 2 2 3 2
4
1 2 3 4
Output:
1
3
*/
#include <bits/stdc++.h>
using namespace std;
int maxStep(int A[], int N){
int maxStep = 0, currStep = 0;
for(int i=0;i<N-1;i++){
if(A[i]<A[i+1]){
currStep++;
maxStep = max(currStep,maxStep);
}else{
currStep = 0;
}
}
return maxStep;
}
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];
cout << maxStep(a, n) << endl;
}
return 0;
} | [
"57028840+adityaranjan182@users.noreply.github.com"
] | 57028840+adityaranjan182@users.noreply.github.com |
1139c035dd60edde819a336a141ba537e84738af | 235c23dc63105d901f9687f08d950ab0d3fe5ade | /bin/OVERLAPPING_DTW.cpp | cc6c769a737b08893b64a11adc12b117ae5f4c43 | [] | no_license | albertasdvirnas/hca | 4a27da2a7058d67395c6806a8f92aff3a6f81d77 | d873b350bda7b59198ebd405ae8671b9eb4cc675 | refs/heads/master | 2023-04-16T04:13:03.577907 | 2021-08-27T15:46:08 | 2021-08-27T15:46:08 | 430,676,640 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 25,339 | cpp | /***********************************************************************/
/************************* DISCLAIMER **********************************/
/***********************************************************************/
/** This UCR Suite software is copyright protected � 2012 by **/
/** Thanawin Rakthanmanon, Bilson Campana, Abdullah Mueen, **/
/** Gustavo Batista and Eamonn Keogh. **/
/** **/
/** Unless stated otherwise, all software is provided free of charge. **/
/** As well, all software is provided on an "as is" basis without **/
/** warranty of any kind, express or implied. Under no circumstances **/
/** and under no legal theory, whether in tort, contract,or otherwise,**/
/** shall Thanawin Rakthanmanon, Bilson Campana, Abdullah Mueen, **/
/** Gustavo Batista, or Eamonn Keogh be liable to you or to any other **/
/** person for any indirect, special, incidental, or consequential **/
/** damages of any character including, without limitation, damages **/
/** for loss of goodwill, work stoppage, computer failure or **/
/** malfunction, or for any and all other damages or losses. **/
/** **/
/** If you do not agree with these terms, then you you are advised to **/
/** not use this software. **/
/***********************************************************************/
/***********************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#include <iostream>
#define min(x,y) ((x)<(y)?(x):(y))
#define max(x,y) ((x)>(y)?(x):(y))
#define dist(x,y) ((x-y)*(x-y))
#define INF 1e20 //Pseudo Infitinte number for this code
using namespace std;
/// Data structure for sorting the query
typedef struct Index
{ double value;
int index;
} Index;
/// Data structure (circular array) for finding minimum and maximum for LB_Keogh envolop
struct deque
{ int *dq;
int size,capacity;
int f,r;
};
/// Sorting function for the query, sort by abs(z_norm(q[i])) from high to low
int comp(const void *a, const void* b)
{ Index* x = (Index*)a;
Index* y = (Index*)b;
return abs(y->value) - abs(x->value); // high to low
}
/// Initial the queue at the begining step of envelop calculation
void init(deque *d, int capacity)
{
d->capacity = capacity;
d->size = 0;
d->dq = (int *) malloc(sizeof(int)*d->capacity);
d->f = 0;
d->r = d->capacity-1;
}
/// Destroy the queue
void destroy(deque *d)
{
free(d->dq);
}
/// Insert to the queue at the back
void push_back(struct deque *d, int v)
{
d->dq[d->r] = v;
d->r--;
if (d->r < 0)
d->r = d->capacity-1;
d->size++;
}
/// Delete the current (front) element from queue
void pop_front(struct deque *d)
{
d->f--;
if (d->f < 0)
d->f = d->capacity-1;
d->size--;
}
/// Delete the last element from queue
void pop_back(struct deque *d)
{
d->r = (d->r+1)%d->capacity;
d->size--;
}
/// Get the value at the current position of the circular queue
int front(struct deque *d)
{
int aux = d->f - 1;
if (aux < 0)
aux = d->capacity-1;
return d->dq[aux];
}
/// Get the value at the last position of the circular queueint back(struct deque *d)
int back(struct deque *d)
{
int aux = (d->r+1)%d->capacity;
return d->dq[aux];
}
/// Check whether or not the queue is empty
int empty(struct deque *d)
{
return d->size == 0;
}
/// Finding the envelop of min and max value for LB_Keogh
/// Implementation idea is intoruduced by Danial Lemire in his paper
/// "Faster Retrieval with a Two-Pass Dynamic-Time-Warping Lower Bound", Pattern Recognition 42(9), 2009.
void lower_upper_lemire(double *t, int len, int r, double *l, double *u)
{
struct deque du, dl;
init(&du, 2*r+2);
init(&dl, 2*r+2);
push_back(&du, 0);
push_back(&dl, 0);
for (int i = 1; i < len; i++)
{
if (i > r)
{
u[i-r-1] = t[front(&du)];
l[i-r-1] = t[front(&dl)];
}
if (t[i] > t[i-1])
{
pop_back(&du);
while (!empty(&du) && t[i] > t[back(&du)])
pop_back(&du);
}
else
{
pop_back(&dl);
while (!empty(&dl) && t[i] < t[back(&dl)])
pop_back(&dl);
}
push_back(&du, i);
push_back(&dl, i);
if (i == 2 * r + 1 + front(&du))
pop_front(&du);
else if (i == 2 * r + 1 + front(&dl))
pop_front(&dl);
}
for (int i = len; i < len+r+1; i++)
{
u[i-r-1] = t[front(&du)];
l[i-r-1] = t[front(&dl)];
if (i-front(&du) >= 2 * r + 1)
pop_front(&du);
if (i-front(&dl) >= 2 * r + 1)
pop_front(&dl);
}
destroy(&du);
destroy(&dl);
}
/// Calculate quick lower bound
/// Usually, LB_Kim take time O(m) for finding top,bottom,fist and last.
/// However, because of z-normalization the top and bottom cannot give siginifant benefits.
/// And using the first and last points can be computed in constant time.
/// The prunning power of LB_Kim is non-trivial, especially when the query is not long, say in length 128.
double lb_kim_hierarchy(double *t, double *q, int j, int len, double mean, double std, double bsf = INF)
{
/// 1 point at front and back
double d, lb;
double x0 = (t[j] - mean) / std;
double y0 = (t[(len-1+j)] - mean) / std;
lb = dist(x0,q[0]) + dist(y0,q[len-1]);
if (lb >= bsf) return lb;
/// 2 points at front
double x1 = (t[(j+1)] - mean) / std;
d = min(dist(x1,q[0]), dist(x0,q[1]));
d = min(d, dist(x1,q[1]));
lb += d;
if (lb >= bsf) return lb;
/// 2 points at back
double y1 = (t[(len-2+j)] - mean) / std;
d = min(dist(y1,q[len-1]), dist(y0, q[len-2]) );
d = min(d, dist(y1,q[len-2]));
lb += d;
if (lb >= bsf) return lb;
/// 3 points at front
double x2 = (t[(j+2)] - mean) / std;
d = min(dist(x0,q[2]), dist(x1, q[2]));
d = min(d, dist(x2,q[2]));
d = min(d, dist(x2,q[1]));
d = min(d, dist(x2,q[0]));
lb += d;
if (lb >= bsf) return lb;
/// 3 points at back
double y2 = (t[(len-3+j)] - mean) / std;
d = min(dist(y0,q[len-3]), dist(y1, q[len-3]));
d = min(d, dist(y2,q[len-3]));
d = min(d, dist(y2,q[len-2]));
d = min(d, dist(y2,q[len-1]));
lb += d;
return lb;
}
/// LB_Keogh 1: Create Envelop for the query
/// Note that because the query is known, envelop can be created once at the begenining.
///
/// Variable Explanation,
/// order : sorted indices for the query.
/// uo, lo: upper and lower envelops for the query, which already sorted.
/// t : a circular array keeping the current data.
/// j : index of the starting location in t
/// cb : (output) current bound at each position. It will be used later for early abandoning in DTW.
double lb_keogh_cumulative(int* order, double *t, double *uo, double *lo, double *cb, int j, int len, double mean, double std, double best_so_far = INF)
{
double lb = 0;
double x, d;
for (int i = 0; i < len && lb < best_so_far; i++)
{
x = (t[(order[i]+j)] - mean) / std;
d = 0;
if (x > uo[i])
d = dist(x,uo[i]);
else if(x < lo[i])
d = dist(x,lo[i]);
lb += d;
cb[order[i]] = d;
}
return lb;
}
/// LB_Keogh 2: Create Envelop for the data
/// Note that the envelops have been created (in main function) when each data point has been read.
///
/// Variable Explanation,
/// tz: Z-normalized data
/// qo: sorted query
/// cb: (output) current bound at each position. Used later for early abandoning in DTW.
/// l,u: lower and upper envelop of the current data
double lb_keogh_data_cumulative(int* order, double *tz, double *qo, double *cb, double *l, double *u, int len, double mean, double std, double best_so_far = INF)
{
double lb = 0;
double uu,ll,d;
for (int i = 0; i < len && lb < best_so_far; i++)
{
uu = (u[order[i]]-mean)/std;
ll = (l[order[i]]-mean)/std;
d = 0;
if (qo[i] > uu)
d = dist(qo[i], uu);
else
{ if(qo[i] < ll)
d = dist(qo[i], ll);
}
lb += d;
cb[order[i]] = d;
}
return lb;
}
/// Calculate Dynamic Time Wrapping distance
/// A,B: data and query, respectively
/// cb : cummulative bound used for early abandoning
/// r : size of Sakoe-Chiba warpping band
double dtw(double* A, double* B, double *cb, int m, int r, double bsf = INF)
{
double *cost;
double *cost_prev;
double *cost_tmp;
int i,j,k;
double x,y,z,min_cost;
/// Instead of using matrix of size O(m^2) or O(mr), we will reuse two array of size O(r).
cost = (double*)malloc(sizeof(double)*(2*r+1));
for(k=0; k<2*r+1; k++) cost[k]=INF;
cost_prev = (double*)malloc(sizeof(double)*(2*r+1));
for(k=0; k<2*r+1; k++) cost_prev[k]=INF;
for (i=0; i<m; i++)
{
k = max(0,r-i);
min_cost = INF;
for(j=max(0,i-r); j<=min(m-1,i+r); j++, k++)
{
/// Initialize all row and column
if ((i==0)&&(j==0))
{
cost[k]=dist(A[0],B[0]);
min_cost = cost[k];
continue;
}
if ((j-1<0)||(k-1<0)) y = INF;
else y = cost[k-1];
if ((i-1<0)||(k+1>2*r)) x = INF;
else x = cost_prev[k+1];
if ((i-1<0)||(j-1<0)) z = INF;
else z = cost_prev[k];
/// Classic DTW calculation
cost[k] = min( min( x, y) , z) + dist(A[i],B[j]);
/// Find minimum cost in row for early abandoning (possibly to use column instead of row).
if (cost[k] < min_cost)
{ min_cost = cost[k];
}
}
/// We can abandon early if the current cummulative distace with lower bound together are larger than bsf
if (i+r < m-1 && min_cost + cb[i+r+1] >= bsf)
{ free(cost);
free(cost_prev);
return min_cost + cb[i+r+1];
}
/// Move current array to previous array.
cost_tmp = cost;
cost = cost_prev;
cost_prev = cost_tmp;
}
k--;
/// the DTW distance is in the last cell in the matrix of size O(m^2) or at the middle of our array.
double final_dtw = cost_prev[k];
free(cost);
free(cost_prev);
return final_dtw;
}
/// Print function for debugging
void printArray(double *x, int len)
{ for(int i=0; i<len; i++)
printf(" %6.2lf",x[i]);
printf("\n");
}
/// If expected error happens, teminated the program.
void error(int id)
{
if(id==1)
printf("ERROR : Memory can't be allocated!!!\n\n");
else if ( id == 2 )
printf("ERROR : File not Found!!!\n\n");
else if ( id == 3 )
printf("ERROR : Can't create Output File!!!\n\n");
else if ( id == 4 )
{
printf("ERROR : Invalid Number of Arguments!!!\n");
printf("Command Usage: UCR_DTW.exe data-file query-file m R\n\n");
printf("For example : UCR_DTW.exe data.txt query.txt 128 0.05\n");
}
exit(1);
}
/*
class mystream : public std::streambuf
{
protected:
virtual std::streamsize xsputn(const char *s, std::streamsize n) { mexPrintf("%.*s", n, s); return n; }
virtual int overflow(int c=EOF) { if (c != EOF) { mexPrintf("%.1s", &c); } return 1; }
};
class scoped_redirect_cout
{
public:
scoped_redirect_cout() { old_buf = std::cout.rdbuf(); std::cout.rdbuf(&mout); }
~scoped_redirect_cout() { std::cout.rdbuf(old_buf); }
private:
mystream mout;
std::streambuf *old_buf;
};
*/
/// Main Function
// void cpp_dtw()
int main( int argc , char *argv[] )
{
char *Data_File = argv[2];
char *Query_File = argv[1];
int m = atoi(argv[3]);
double R = atof(argv[4]);
// scoped_redirect_cout mycout_redirect;
FILE *fp; /// data file pointer
FILE *qp; /// query file pointer
double bsf; /// best-so-far
double *t, *q; /// data array and query array
int *order; ///new order of the query
double *u, *l, *qo, *uo, *lo,*tz,*cb, *cb1, *cb2,*u_d, *l_d;
/// name the parameters
double d;
long long i , j;
double ex , ex2 , mean, std;
int r=-1;
int loc = 0;
double t1,t2;
int kim = 0,keogh = 0, keogh2 = 0;
double dist=0, lb_kim=0, lb_k=0, lb_k2=0;
double *buffer, *u_buff, *l_buff;
Index *Q_tmp;
/// For every EPOCH points, all cummulative values, such as ex (sum), ex2 (sum square), will be restarted for reducing the floating point error.
int EPOCH = 100000;
/// Sakoe-Chiba band
if (R<=1)
r = floor(R*m);
else
r = floor(R);
/// check if the files can be opened
fp = fopen(Data_File,"r");
if( fp == NULL )
error(2);
qp = fopen(Query_File,"r");
if( qp == NULL )
error(2);
/// start the clock
t1 = clock();
/// malloc everything here
q = (double *)malloc(sizeof(double)*m);
if( q == NULL )
error(1);
qo = (double *)malloc(sizeof(double)*m);
if( qo == NULL )
error(1);
uo = (double *)malloc(sizeof(double)*m);
if( uo == NULL )
error(1);
lo = (double *)malloc(sizeof(double)*m);
if( lo == NULL )
error(1);
order = (int *)malloc(sizeof(int)*m);
if( order == NULL )
error(1);
Q_tmp = (Index *)malloc(sizeof(Index)*m);
if( Q_tmp == NULL )
error(1);
u = (double *)malloc(sizeof(double)*m);
if( u == NULL )
error(1);
l = (double *)malloc(sizeof(double)*m);
if( l == NULL )
error(1);
cb = (double *)malloc(sizeof(double)*m);
if( cb == NULL )
error(1);
cb1 = (double *)malloc(sizeof(double)*m);
if( cb1 == NULL )
error(1);
cb2 = (double *)malloc(sizeof(double)*m);
if( cb2 == NULL )
error(1);
u_d = (double *)malloc(sizeof(double)*m);
if( u == NULL )
error(1);
l_d = (double *)malloc(sizeof(double)*m);
if( l == NULL )
error(1);
t = (double *)malloc(sizeof(double)*m*2);
if( t == NULL )
error(1);
tz = (double *)malloc(sizeof(double)*m);
if( tz == NULL )
error(1);
buffer = (double *)malloc(sizeof(double)*EPOCH);
if( buffer == NULL )
error(1);
u_buff = (double *)malloc(sizeof(double)*EPOCH);
if( u_buff == NULL )
error(1);
l_buff = (double *)malloc(sizeof(double)*EPOCH);
if( l_buff == NULL )
error(1);
/// Read query file
bsf = INF; /// So this finds global solution
i = 0;
j = 0;
ex = ex2 = 0;
/// three cases. Case 1: readfull file, then m=total size of query. Done, run the code with
/// m=fullsize
/// Case 2: read only first L elements. Done, run with m=L
/// Case 3: read only last L elements
while(fscanf(qp,"%lf",&d) != EOF && i < m)
{
ex += d; /// if the numbers are very big, would have some numerical issues?
ex2 += d*d;
q[i] = d;
// printf("%f ",d);
i++;
}
fclose(qp);
/// Do z-normalize the query, keep in same array, q
mean = ex/m;
std = ex2/m;
std = sqrt(std-mean*mean);
for( i = 0 ; i < m ; i++ )
q[i] = (q[i] - mean)/std;
/// Create envelop of the query: lower envelop, l, and upper envelop, u
lower_upper_lemire(q, m, r, l, u);
/// Sort the query one time by abs(z-norm(q[i]))
for( i = 0; i<m; i++)
{
Q_tmp[i].value = q[i];
Q_tmp[i].index = i;
}
qsort(Q_tmp, m, sizeof(Index),comp);
/// also create another arrays for keeping sorted envelop
for( i=0; i<m; i++)
{ int o = Q_tmp[i].index;
order[i] = o;
qo[i] = q[o];
uo[i] = u[o];
lo[i] = l[o];
}
free(Q_tmp);
/// Initial the cummulative lower bound
for( i=0; i<m; i++)
{ cb[i]=0;
cb1[i]=0;
cb2[i]=0;
}
i = 0; /// current index of the data in current chunk of size EPOCH
j = 0; /// the starting index of the data in the circular array, t
ex = ex2 = 0;
bool done = false;
int it=0, ep=0, k=0;
long long I; /// the starting index of the data in current chunk of size EPOCH
while(!done)
{
/// Read first m-1 points
ep=0;
if (it==0)
{ for(k=0; k<m-1; k++)
if (fscanf(fp,"%lf",&d) != EOF)
buffer[k] = d;
}
else
{ for(k=0; k<m-1; k++)
buffer[k] = buffer[EPOCH-m+1+k];
}
/// Read buffer of size EPOCH or when all data has been read.
ep=m-1;
while(ep<EPOCH)
{ if (fscanf(fp,"%lf",&d) == EOF)
break;
buffer[ep] = d;
ep++;
}
/// Data are read in chunk of size EPOCH.
/// When there is nothing to read, the loop is end.
if (ep<=m-1)
{ done = true;
} else
{ lower_upper_lemire(buffer, ep, r, l_buff, u_buff);
/// Just for printing a dot for approximate a million point. Not much accurate.
if (it%(1000000/(EPOCH-m+1))==0)
fprintf(stderr,".");
/// Do main task here..
ex=0; ex2=0;
for(i=0; i<ep; i++)
{
/// A bunch of data has been read and pick one of them at a time to use
d = buffer[i];
/// Calcualte sum and sum square
ex += d;
ex2 += d*d;
/// t is a circular array for keeping current data
t[i%m] = d;
/// Double the size for avoiding using modulo "%" operator
t[(i%m)+m] = d;
/// Start the task when there are more than m-1 points in the current chunk
if( i >= m-1 )
{
mean = ex/m;
std = ex2/m;
std = sqrt(std-mean*mean);
/// compute the start location of the data in the current circular array, t
j = (i+1)%m;
/// the start location of the data in the current chunk
I = i-(m-1);
/// Use a constant lower bound to prune the obvious subsequence
lb_kim = lb_kim_hierarchy(t, q, j, m, mean, std, bsf);
if (lb_kim < bsf)
{
/// Use a linear time lower bound to prune; z_normalization of t will be computed on the fly.
/// uo, lo are envelop of the query.
lb_k = lb_keogh_cumulative(order, t, uo, lo, cb1, j, m, mean, std, bsf);
if (lb_k < bsf)
{
/// Take another linear time to compute z_normalization of t.
/// Note that for better optimization, this can merge to the previous function.
for(k=0;k<m;k++)
{ tz[k] = (t[(k+j)] - mean)/std;
}
/// Use another lb_keogh to prune
/// qo is the sorted query. tz is unsorted z_normalized data.
/// l_buff, u_buff are big envelop for all data in this chunk
lb_k2 = lb_keogh_data_cumulative(order, tz, qo, cb2, l_buff+I, u_buff+I, m, mean, std, bsf);
if (lb_k2 < bsf)
{
/// Choose better lower bound between lb_keogh and lb_keogh2 to be used in early abandoning DTW
/// Note that cb and cb2 will be cumulative summed here.
if (lb_k > lb_k2)
{
cb[m-1]=cb1[m-1];
for(k=m-2; k>=0; k--)
cb[k] = cb[k+1]+cb1[k];
}
else
{
cb[m-1]=cb2[m-1];
for(k=m-2; k>=0; k--)
cb[k] = cb[k+1]+cb2[k];
}
/// Compute DTW and early abandoning if possible
dist = dtw(tz, q, cb, m, r, bsf);
// printf("%f %f \n",tz[0],tz[1]);
// printf("%f %f\n",q[0], q[1]);
if( dist < bsf )
{ /// Update bsf
/// loc is the real starting location of the nearest neighbor in the file
bsf = dist;
loc = (it)*(EPOCH-m+1) + i-m+1;
}
} else
keogh2++;
} else
keogh++;
} else
kim++;
/// Reduce obsolute points from sum and sum square
ex -= t[j];
ex2 -= t[j]*t[j];
}
}
/// If the size of last chunk is less then EPOCH, then no more data and terminate.
if (ep<EPOCH)
done=true;
else
it++;
}
}
i = (it)*(EPOCH-m+1) + ep;
fclose(fp);
free(q);
free(u);
free(l);
free(uo);
free(lo);
free(qo);
free(cb);
free(cb1);
free(cb2);
free(tz);
free(t);
free(l_d);
free(u_d);
free(l_buff);
free(u_buff);
t2 = clock();
/// printf("\n");
/*
/// Note that loc and i are long long.
cout << "Location : " << loc << endl;
cout << "Distance : " << sqrt(bsf) << endl;
cout << "Data Scanned : " << i << endl;
cout << "Total Execution Time : " << (t2-t1)/CLOCKS_PER_SEC << " sec" << endl;
*/
// *y = loc;
// *s = sqrt(bsf);
printf("%d \n", loc);
printf("%f \n", sqrt(bsf));
/// printf is just easier for formating ;)
/*
printf("\n");
printf("Pruned by LB_Kim : %6.2f%%\n", ((double) kim / i)*100);
printf("Pruned by LB_Keogh : %6.2f%%\n", ((double) keogh / i)*100);
printf("Pruned by LB_Keogh2 : %6.2f%%\n", ((double) keogh2 / i)*100);
printf("DTW Calculation : %6.2f%%\n", 100-(((double)kim+keogh+keogh2)/i*100));
*/
return 0;
}
/* The gateway function that replaces the "main".
*plhs[] - the array of output values
*prhs[] - the array of input values*/
//
// void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
// {
// /// output location
// double *y;
// /// output score
// double *s;
//
// double R;
// /*Variable declarations as in C*/
// /// char Data_File, Query_File;
// int M;
//
//
// int L; /// length of the overlap
//
// int buflen0,status0;
// int buflen1,status1;
//
// char *input_buf0, *output_buf0;
// char *input_buf1, *output_buf1;
//
// ///
// /// Query_File = mxGetString(prhs[1]);
//
//
// /* Check for proper number of arguments. */
// if (nrhs != 4) {
// mexErrMsgTxt("Five inputs required.");
// }
// else if (nlhs > 2) {
// mexErrMsgTxt("Too many output arguments");
// }
//
// M = mxGetScalar(prhs[2]); /// overlap length
// R = mxGetScalar(prhs[3]);
//
// /* Get the length of the input string. */
// buflen0 = (mxGetM(prhs[0]) * mxGetN(prhs[0])) + 1;
// /* Allocate memory for input and output strings. */
// input_buf0 =(char *) mxCalloc(buflen0, sizeof(char));
//
// /* Copy the string data from prhs[0] into a C string
// * input_buf. */
// status0 = mxGetString(prhs[0], input_buf0, buflen0);
//
// /* Get the length of the input string. */
// buflen1 = (mxGetM(prhs[1]) * mxGetN(prhs[1])) + 1;
// /* Allocate memory for input and output strings. */
// input_buf1 =(char *) mxCalloc(buflen1, sizeof(char));
//
// /* Copy the string data from prhs[0] into a C string
// * input_buf. */
// status1 = mxGetString(prhs[1], input_buf1, buflen1);
//
// /*
// mexPrintf("Number of inputs: %d\n", nrhs);
// mexPrintf("Number of outputs: %d\n", nlhs);
// mexPrintf("M: %d\n", M);
// mexPrintf("R: %4.3f\n", R);
// mexPrintf("Data_File: %s\n", input_buf0);
// mexPrintf("Query_File: %s\n", input_buf1);
// */
//
// plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);
// y = mxGetPr(plhs[0]);
//
// plhs[1] = mxCreateDoubleMatrix(1, 1, mxREAL);
// s = mxGetPr(plhs[1]);
//
//
// cpp_dtw(input_buf0, input_buf1, M, R, y,s);
//
//
// }
| [
"albdvir@gmail.com"
] | albdvir@gmail.com |
9a678e2d2c03cdaea6c352741eab766418a160fb | d0fb46aecc3b69983e7f6244331a81dff42d9595 | /voicenavigator/src/model/EndDialogueRequest.cc | b13cd872bf8a750f9abb9c236b3853b3571a9679 | [
"Apache-2.0"
] | permissive | aliyun/aliyun-openapi-cpp-sdk | 3d8d051d44ad00753a429817dd03957614c0c66a | e862bd03c844bcb7ccaa90571bceaa2802c7f135 | refs/heads/master | 2023-08-29T11:54:00.525102 | 2023-08-29T03:32:48 | 2023-08-29T03:32:48 | 115,379,460 | 104 | 82 | NOASSERTION | 2023-09-14T06:13:33 | 2017-12-26T02:53:27 | C++ | UTF-8 | C++ | false | false | 2,047 | cc | /*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/voicenavigator/model/EndDialogueRequest.h>
using AlibabaCloud::VoiceNavigator::Model::EndDialogueRequest;
EndDialogueRequest::EndDialogueRequest()
: RpcServiceRequest("voicenavigator", "2018-06-12", "EndDialogue") {
setMethod(HttpRequest::Method::Post);
}
EndDialogueRequest::~EndDialogueRequest() {}
std::string EndDialogueRequest::getConversationId() const {
return conversationId_;
}
void EndDialogueRequest::setConversationId(const std::string &conversationId) {
conversationId_ = conversationId;
setParameter(std::string("ConversationId"), conversationId);
}
std::string EndDialogueRequest::getHangUpParams() const {
return hangUpParams_;
}
void EndDialogueRequest::setHangUpParams(const std::string &hangUpParams) {
hangUpParams_ = hangUpParams;
setParameter(std::string("HangUpParams"), hangUpParams);
}
std::string EndDialogueRequest::getInstanceId() const {
return instanceId_;
}
void EndDialogueRequest::setInstanceId(const std::string &instanceId) {
instanceId_ = instanceId;
setParameter(std::string("InstanceId"), instanceId);
}
long EndDialogueRequest::getInstanceOwnerId() const {
return instanceOwnerId_;
}
void EndDialogueRequest::setInstanceOwnerId(long instanceOwnerId) {
instanceOwnerId_ = instanceOwnerId;
setParameter(std::string("InstanceOwnerId"), std::to_string(instanceOwnerId));
}
| [
"sdk-team@alibabacloud.com"
] | sdk-team@alibabacloud.com |
875173e0beb9c2f51de50890a40d86451fec22aa | 2770af9aa3948c451bbf7fb350f33cb104031776 | /examples/clock_division/vivado_hls/test/divisor_final/solution1/.autopilot/db/counter.pragma.0.cpp | 6544b4c2adf3089a55ca91346e9e6ccc97cea471 | [] | no_license | shirishbahirat/systemC | 44939850641bd2df7fb523f3ca578a499d24e74a | 96de66a7a72f13320e809a5a4a9599f4ec2d457a | refs/heads/master | 2020-04-24T23:48:30.654958 | 2017-12-14T20:06:19 | 2017-12-14T20:06:19 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,830,797 | cpp | #1 "counter.cpp"
#1 "counter.cpp" 1
#1 "<built-in>" 1
#1 "<built-in>" 3
#155 "<built-in>" 3
#1 "<command line>" 1
#1 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/etc/autopilot_ssdm_op.h" 1
#156 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/etc/autopilot_ssdm_op.h"
extern "C" {
typedef bool _uint1_;
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));
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));
void _ssdm_op_MemShiftRead(...) __attribute__ ((nothrow));
void _ssdm_op_Wait(...) __attribute__ ((nothrow));
void _ssdm_op_Poll(...) __attribute__ ((nothrow));
void _ssdm_op_Return(...) __attribute__ ((nothrow));
void _ssdm_op_SpecSynModule(...) __attribute__ ((nothrow));
void _ssdm_op_SpecTopModule(...) __attribute__ ((nothrow));
void _ssdm_op_SpecProcessDecl(...) __attribute__ ((nothrow));
void _ssdm_op_SpecProcessDef(...) __attribute__ ((nothrow));
void _ssdm_op_SpecPort(...) __attribute__ ((nothrow));
void _ssdm_op_SpecConnection(...) __attribute__ ((nothrow));
void _ssdm_op_SpecChannel(...) __attribute__ ((nothrow));
void _ssdm_op_SpecSensitive(...) __attribute__ ((nothrow));
void _ssdm_op_SpecModuleInst(...) __attribute__ ((nothrow));
void _ssdm_op_SpecPortMap(...) __attribute__ ((nothrow));
void _ssdm_op_SpecReset(...) __attribute__ ((nothrow));
void _ssdm_op_SpecPlatform(...) __attribute__ ((nothrow));
void _ssdm_op_SpecClockDomain(...) __attribute__ ((nothrow));
void _ssdm_op_SpecPowerDomain(...) __attribute__ ((nothrow));
int _ssdm_op_SpecRegionBegin(...) __attribute__ ((nothrow));
int _ssdm_op_SpecRegionEnd(...) __attribute__ ((nothrow));
void _ssdm_op_SpecLoopName(...) __attribute__ ((nothrow));
void _ssdm_op_SpecLoopTripCount(...) __attribute__ ((nothrow));
int _ssdm_op_SpecStateBegin(...) __attribute__ ((nothrow));
int _ssdm_op_SpecStateEnd(...) __attribute__ ((nothrow));
void _ssdm_op_SpecInterface(...) __attribute__ ((nothrow));
void _ssdm_op_SpecPipeline(...) __attribute__ ((nothrow));
void _ssdm_op_SpecDataflowPipeline(...) __attribute__ ((nothrow));
void _ssdm_op_SpecLatency(...) __attribute__ ((nothrow));
void _ssdm_op_SpecParallel(...) __attribute__ ((nothrow));
void _ssdm_op_SpecProtocol(...) __attribute__ ((nothrow));
void _ssdm_op_SpecOccurrence(...) __attribute__ ((nothrow));
void _ssdm_op_SpecResource(...) __attribute__ ((nothrow));
void _ssdm_op_SpecResourceLimit(...) __attribute__ ((nothrow));
void _ssdm_op_SpecCHCore(...) __attribute__ ((nothrow));
void _ssdm_op_SpecFUCore(...) __attribute__ ((nothrow));
void _ssdm_op_SpecIFCore(...) __attribute__ ((nothrow));
void _ssdm_op_SpecIPCore(...) __attribute__ ((nothrow));
void _ssdm_op_SpecKeepValue(...) __attribute__ ((nothrow));
void _ssdm_op_SpecMemCore(...) __attribute__ ((nothrow));
void _ssdm_op_SpecExt(...) __attribute__ ((nothrow));
void _ssdm_SpecArrayDimSize(...) __attribute__ ((nothrow));
void _ssdm_RegionBegin(...) __attribute__ ((nothrow));
void _ssdm_RegionEnd(...) __attribute__ ((nothrow));
void _ssdm_Unroll(...) __attribute__ ((nothrow));
void _ssdm_UnrollRegion(...) __attribute__ ((nothrow));
void _ssdm_InlineAll(...) __attribute__ ((nothrow));
void _ssdm_InlineLoop(...) __attribute__ ((nothrow));
void _ssdm_Inline(...) __attribute__ ((nothrow));
void _ssdm_InlineSelf(...) __attribute__ ((nothrow));
void _ssdm_InlineRegion(...) __attribute__ ((nothrow));
void _ssdm_SpecArrayMap(...) __attribute__ ((nothrow));
void _ssdm_SpecArrayPartition(...) __attribute__ ((nothrow));
void _ssdm_SpecArrayReshape(...) __attribute__ ((nothrow));
void _ssdm_SpecStream(...) __attribute__ ((nothrow));
void _ssdm_SpecExpr(...) __attribute__ ((nothrow));
void _ssdm_SpecExprBalance(...) __attribute__ ((nothrow));
void _ssdm_SpecDependence(...) __attribute__ ((nothrow));
void _ssdm_SpecLoopMerge(...) __attribute__ ((nothrow));
void _ssdm_SpecLoopFlatten(...) __attribute__ ((nothrow));
void _ssdm_SpecLoopRewind(...) __attribute__ ((nothrow));
void _ssdm_SpecFuncInstantiation(...) __attribute__ ((nothrow));
void _ssdm_SpecFuncBuffer(...) __attribute__ ((nothrow));
void _ssdm_SpecFuncExtract(...) __attribute__ ((nothrow));
void _ssdm_SpecConstant(...) __attribute__ ((nothrow));
void _ssdm_DataPack(...) __attribute__ ((nothrow));
void _ssdm_SpecDataPack(...) __attribute__ ((nothrow));
void _ssdm_op_SpecBitsMap(...) __attribute__ ((nothrow));
void _ssdm_op_SpecLicense(...) __attribute__ ((nothrow));
void __xilinx_ip_top(...) __attribute__ ((nothrow));
}
#8 "<command line>" 2
#1 "<built-in>" 2
#1 "counter.cpp" 2
#12 "counter.cpp"
#1 "./counter.h" 1
#14 "./counter.h"
#1 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/systemc.h" 1
#1 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/ap_systemc.h" 1
#pragma AUTOESL_INC systemc.h begin
typedef void****** __ap_sc_begin__;
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/iostream" 1 3
#37 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/iostream" 3
#37 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/iostream" 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/c++config.h" 1 3
#153 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/c++config.h" 3
namespace std
{
typedef long unsigned int size_t;
typedef long int ptrdiff_t;
}
#393 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/c++config.h" 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/os_defines.h" 1 3
#40 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/os_defines.h" 3
#1 "/usr/include/features.h" 1 3 4
#345 "/usr/include/features.h" 3 4
#1 "/usr/include/stdc-predef.h" 1 3 4
#346 "/usr/include/features.h" 2 3 4
#375 "/usr/include/features.h" 3 4
#1 "/usr/include/sys/cdefs.h" 1 3 4
#392 "/usr/include/sys/cdefs.h" 3 4
#1 "/usr/include/bits/wordsize.h" 1 3 4
#393 "/usr/include/sys/cdefs.h" 2 3 4
#376 "/usr/include/features.h" 2 3 4
#399 "/usr/include/features.h" 3 4
#1 "/usr/include/gnu/stubs.h" 1 3 4
#10 "/usr/include/gnu/stubs.h" 3 4
#1 "/usr/include/gnu/stubs-64.h" 1 3 4
#11 "/usr/include/gnu/stubs.h" 2 3 4
#400 "/usr/include/features.h" 2 3 4
#41 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/os_defines.h" 2 3
#394 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/c++config.h" 2 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/cpu_defines.h" 1 3
#397 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/c++config.h" 2 3
#39 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/iostream" 2 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ostream" 1 3
#38 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ostream" 3
#38 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ostream" 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ios" 1 3
#37 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ios" 3
#37 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ios" 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/iosfwd" 1 3
#38 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/iosfwd" 3
#38 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/iosfwd" 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stringfwd.h" 1 3
#39 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stringfwd.h" 3
#39 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stringfwd.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Alloc>
class allocator;
template<class _CharT>
struct char_traits;
template<typename _CharT, typename _Traits = char_traits<_CharT>,
typename _Alloc = allocator<_CharT> >
class basic_string;
template<> struct char_traits<char>;
typedef basic_string<char> string;
template<> struct char_traits<wchar_t>;
typedef basic_string<wchar_t> wstring;
#85 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stringfwd.h" 3
}
#41 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/iosfwd" 2 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/postypes.h" 1 3
#40 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/postypes.h" 3
#40 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/postypes.h" 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cwchar" 1 3
#41 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cwchar" 3
#41 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cwchar" 3
#1 "/usr/include/wchar.h" 1 3 4
#36 "/usr/include/wchar.h" 3 4
#1 "/usr/include/stdio.h" 1 3 4
#44 "/usr/include/stdio.h" 3 4
struct _IO_FILE;
typedef struct _IO_FILE FILE;
#64 "/usr/include/stdio.h" 3 4
typedef struct _IO_FILE __FILE;
#37 "/usr/include/wchar.h" 2 3 4
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/clang/bin/../lib/clang/3.1/include/stdarg.h" 1 3 4
#30 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/clang/bin/../lib/clang/3.1/include/stdarg.h" 3 4
typedef __builtin_va_list va_list;
#48 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/clang/bin/../lib/clang/3.1/include/stdarg.h" 3 4
typedef __builtin_va_list __gnuc_va_list;
#40 "/usr/include/wchar.h" 2 3 4
#1 "/usr/include/bits/wchar.h" 1 3 4
#22 "/usr/include/bits/wchar.h" 3 4
#1 "/usr/include/bits/wordsize.h" 1 3 4
#23 "/usr/include/bits/wchar.h" 2 3 4
#42 "/usr/include/wchar.h" 2 3 4
#51 "/usr/include/wchar.h" 3 4
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/clang/bin/../lib/clang/3.1/include/stddef.h" 1 3 4
#31 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/clang/bin/../lib/clang/3.1/include/stddef.h" 3 4
typedef __typeof__(((int*)0)-((int*)0)) ptrdiff_t;
typedef __typeof__(sizeof(int)) size_t;
#61 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/clang/bin/../lib/clang/3.1/include/stddef.h" 3 4
typedef unsigned int wint_t;
#52 "/usr/include/wchar.h" 2 3 4
#82 "/usr/include/wchar.h" 3 4
typedef struct
{
int __count;
union
{
unsigned int __wch;
char __wchb[4];
} __value;
} __mbstate_t;
#106 "/usr/include/wchar.h" 3 4
typedef __mbstate_t mbstate_t;
#132 "/usr/include/wchar.h" 3 4
extern "C" {
struct tm;
#147 "/usr/include/wchar.h" 3 4
extern wchar_t *wcscpy (wchar_t *__restrict __dest,
const wchar_t *__restrict __src) throw ();
extern wchar_t *wcsncpy (wchar_t *__restrict __dest,
const wchar_t *__restrict __src, size_t __n)
throw ();
extern wchar_t *wcscat (wchar_t *__restrict __dest,
const wchar_t *__restrict __src) throw ();
extern wchar_t *wcsncat (wchar_t *__restrict __dest,
const wchar_t *__restrict __src, size_t __n)
throw ();
extern int wcscmp (const wchar_t *__s1, const wchar_t *__s2)
throw () __attribute__ ((__pure__));
extern int wcsncmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
throw () __attribute__ ((__pure__));
extern int wcscasecmp (const wchar_t *__s1, const wchar_t *__s2) throw ();
extern int wcsncasecmp (const wchar_t *__s1, const wchar_t *__s2,
size_t __n) throw ();
#1 "/usr/include/xlocale.h" 1 3 4
#27 "/usr/include/xlocale.h" 3 4
typedef struct __locale_struct
{
struct __locale_data *__locales[13];
const unsigned short int *__ctype_b;
const int *__ctype_tolower;
const int *__ctype_toupper;
const char *__names[13];
public :
inline __attribute__((always_inline)) __locale_struct() { _ssdm_SpecConstant(__names); }
#39 "/usr/include/xlocale.h"
} *__locale_t;
typedef __locale_t locale_t;
#181 "/usr/include/wchar.h" 2 3 4
extern int wcscasecmp_l (const wchar_t *__s1, const wchar_t *__s2,
__locale_t __loc) throw ();
extern int wcsncasecmp_l (const wchar_t *__s1, const wchar_t *__s2,
size_t __n, __locale_t __loc) throw ();
extern int wcscoll (const wchar_t *__s1, const wchar_t *__s2) throw ();
extern size_t wcsxfrm (wchar_t *__restrict __s1,
const wchar_t *__restrict __s2, size_t __n) throw ();
#206 "/usr/include/wchar.h" 3 4
extern int wcscoll_l (const wchar_t *__s1, const wchar_t *__s2,
__locale_t __loc) throw ();
extern size_t wcsxfrm_l (wchar_t *__s1, const wchar_t *__s2,
size_t __n, __locale_t __loc) throw ();
extern wchar_t *wcsdup (const wchar_t *__s) throw () __attribute__ ((__malloc__));
#227 "/usr/include/wchar.h" 3 4
extern wchar_t *wcschr (const wchar_t *__wcs, wchar_t __wc)
throw () __attribute__ ((__pure__));
#237 "/usr/include/wchar.h" 3 4
extern wchar_t *wcsrchr (const wchar_t *__wcs, wchar_t __wc)
throw () __attribute__ ((__pure__));
extern wchar_t *wcschrnul (const wchar_t *__s, wchar_t __wc)
throw () __attribute__ ((__pure__));
extern size_t wcscspn (const wchar_t *__wcs, const wchar_t *__reject)
throw () __attribute__ ((__pure__));
extern size_t wcsspn (const wchar_t *__wcs, const wchar_t *__accept)
throw () __attribute__ ((__pure__));
#266 "/usr/include/wchar.h" 3 4
extern wchar_t *wcspbrk (const wchar_t *__wcs, const wchar_t *__accept)
throw () __attribute__ ((__pure__));
#277 "/usr/include/wchar.h" 3 4
extern wchar_t *wcsstr (const wchar_t *__haystack, const wchar_t *__needle)
throw () __attribute__ ((__pure__));
extern wchar_t *wcstok (wchar_t *__restrict __s,
const wchar_t *__restrict __delim,
wchar_t **__restrict __ptr) throw ();
extern size_t wcslen (const wchar_t *__s) throw () __attribute__ ((__pure__));
#299 "/usr/include/wchar.h" 3 4
extern wchar_t *wcswcs (const wchar_t *__haystack, const wchar_t *__needle)
throw () __attribute__ ((__pure__));
extern size_t wcsnlen (const wchar_t *__s, size_t __maxlen)
throw () __attribute__ ((__pure__));
#320 "/usr/include/wchar.h" 3 4
extern wchar_t *wmemchr (const wchar_t *__s, wchar_t __c, size_t __n)
throw () __attribute__ ((__pure__));
extern int wmemcmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
throw () __attribute__ ((__pure__));
extern wchar_t *wmemcpy (wchar_t *__restrict __s1,
const wchar_t *__restrict __s2, size_t __n) throw ();
extern wchar_t *wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n)
throw ();
extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) throw ();
extern wchar_t *wmempcpy (wchar_t *__restrict __s1,
const wchar_t *__restrict __s2, size_t __n)
throw ();
extern wint_t btowc (int __c) throw ();
extern int wctob (wint_t __c) throw ();
extern int mbsinit (const mbstate_t *__ps) throw () __attribute__ ((__pure__));
extern size_t mbrtowc (wchar_t *__restrict __pwc,
const char *__restrict __s, size_t __n,
mbstate_t *__restrict __p) throw ();
extern size_t wcrtomb (char *__restrict __s, wchar_t __wc,
mbstate_t *__restrict __ps) throw ();
extern size_t __mbrlen (const char *__restrict __s, size_t __n,
mbstate_t *__restrict __ps) throw ();
extern size_t mbrlen (const char *__restrict __s, size_t __n,
mbstate_t *__restrict __ps) throw ();
#408 "/usr/include/wchar.h" 3 4
extern size_t mbsrtowcs (wchar_t *__restrict __dst,
const char **__restrict __src, size_t __len,
mbstate_t *__restrict __ps) throw ();
extern size_t wcsrtombs (char *__restrict __dst,
const wchar_t **__restrict __src, size_t __len,
mbstate_t *__restrict __ps) throw ();
extern size_t mbsnrtowcs (wchar_t *__restrict __dst,
const char **__restrict __src, size_t __nmc,
size_t __len, mbstate_t *__restrict __ps) throw ();
extern size_t wcsnrtombs (char *__restrict __dst,
const wchar_t **__restrict __src,
size_t __nwc, size_t __len,
mbstate_t *__restrict __ps) throw ();
extern int wcwidth (wchar_t __c) throw ();
extern int wcswidth (const wchar_t *__s, size_t __n) throw ();
extern double wcstod (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr) throw ();
extern float wcstof (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr) throw ();
extern long double wcstold (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr) throw ();
extern long int wcstol (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base) throw ();
extern unsigned long int wcstoul (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base)
throw ();
__extension__
extern long long int wcstoll (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base)
throw ();
__extension__
extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
int __base) throw ();
__extension__
extern long long int wcstoq (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base)
throw ();
__extension__
extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
int __base) throw ();
#530 "/usr/include/wchar.h" 3 4
extern long int wcstol_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base,
__locale_t __loc) throw ();
extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
int __base, __locale_t __loc) throw ();
__extension__
extern long long int wcstoll_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
int __base, __locale_t __loc) throw ();
__extension__
extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
int __base, __locale_t __loc)
throw ();
extern double wcstod_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, __locale_t __loc)
throw ();
extern float wcstof_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, __locale_t __loc)
throw ();
extern long double wcstold_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
__locale_t __loc) throw ();
extern wchar_t *wcpcpy (wchar_t *__restrict __dest,
const wchar_t *__restrict __src) throw ();
extern wchar_t *wcpncpy (wchar_t *__restrict __dest,
const wchar_t *__restrict __src, size_t __n)
throw ();
extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) throw ();
extern int fwide (__FILE *__fp, int __mode) throw ();
extern int fwprintf (__FILE *__restrict __stream,
const wchar_t *__restrict __format, ...)
;
extern int wprintf (const wchar_t *__restrict __format, ...)
;
extern int swprintf (wchar_t *__restrict __s, size_t __n,
const wchar_t *__restrict __format, ...)
throw () ;
extern int vfwprintf (__FILE *__restrict __s,
const wchar_t *__restrict __format,
__gnuc_va_list __arg)
;
extern int vwprintf (const wchar_t *__restrict __format,
__gnuc_va_list __arg)
;
extern int vswprintf (wchar_t *__restrict __s, size_t __n,
const wchar_t *__restrict __format,
__gnuc_va_list __arg)
throw () ;
extern int fwscanf (__FILE *__restrict __stream,
const wchar_t *__restrict __format, ...)
;
extern int wscanf (const wchar_t *__restrict __format, ...)
;
extern int swscanf (const wchar_t *__restrict __s,
const wchar_t *__restrict __format, ...)
throw () ;
#689 "/usr/include/wchar.h" 3 4
extern int vfwscanf (__FILE *__restrict __s,
const wchar_t *__restrict __format,
__gnuc_va_list __arg)
;
extern int vwscanf (const wchar_t *__restrict __format,
__gnuc_va_list __arg)
;
extern int vswscanf (const wchar_t *__restrict __s,
const wchar_t *__restrict __format,
__gnuc_va_list __arg)
throw () ;
#745 "/usr/include/wchar.h" 3 4
extern wint_t fgetwc (__FILE *__stream);
extern wint_t getwc (__FILE *__stream);
extern wint_t getwchar (void);
extern wint_t fputwc (wchar_t __wc, __FILE *__stream);
extern wint_t putwc (wchar_t __wc, __FILE *__stream);
extern wint_t putwchar (wchar_t __wc);
extern wchar_t *fgetws (wchar_t *__restrict __ws, int __n,
__FILE *__restrict __stream);
extern int fputws (const wchar_t *__restrict __ws,
__FILE *__restrict __stream);
extern wint_t ungetwc (wint_t __wc, __FILE *__stream);
#801 "/usr/include/wchar.h" 3 4
extern wint_t getwc_unlocked (__FILE *__stream);
extern wint_t getwchar_unlocked (void);
extern wint_t fgetwc_unlocked (__FILE *__stream);
extern wint_t fputwc_unlocked (wchar_t __wc, __FILE *__stream);
#827 "/usr/include/wchar.h" 3 4
extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream);
extern wint_t putwchar_unlocked (wchar_t __wc);
#837 "/usr/include/wchar.h" 3 4
extern wchar_t *fgetws_unlocked (wchar_t *__restrict __ws, int __n,
__FILE *__restrict __stream);
extern int fputws_unlocked (const wchar_t *__restrict __ws,
__FILE *__restrict __stream);
extern size_t wcsftime (wchar_t *__restrict __s, size_t __maxsize,
const wchar_t *__restrict __format,
const struct tm *__restrict __tp) throw ();
extern size_t wcsftime_l (wchar_t *__restrict __s, size_t __maxsize,
const wchar_t *__restrict __format,
const struct tm *__restrict __tp,
__locale_t __loc) throw ();
#891 "/usr/include/wchar.h" 3 4
}
#46 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cwchar" 2 3
#63 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cwchar" 3
namespace std
{
using ::mbstate_t;
}
#136 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cwchar" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
using ::wint_t;
using ::btowc;
using ::fgetwc;
using ::fgetws;
using ::fputwc;
using ::fputws;
using ::fwide;
using ::fwprintf;
using ::fwscanf;
using ::getwc;
using ::getwchar;
using ::mbrlen;
using ::mbrtowc;
using ::mbsinit;
using ::mbsrtowcs;
using ::putwc;
using ::putwchar;
using ::swprintf;
using ::swscanf;
using ::ungetwc;
using ::vfwprintf;
using ::vfwscanf;
using ::vswprintf;
using ::vswscanf;
using ::vwprintf;
using ::vwscanf;
using ::wcrtomb;
using ::wcscat;
using ::wcscmp;
using ::wcscoll;
using ::wcscpy;
using ::wcscspn;
using ::wcsftime;
using ::wcslen;
using ::wcsncat;
using ::wcsncmp;
using ::wcsncpy;
using ::wcsrtombs;
using ::wcsspn;
using ::wcstod;
using ::wcstof;
using ::wcstok;
using ::wcstol;
using ::wcstoul;
using ::wcsxfrm;
using ::wctob;
using ::wmemcmp;
using ::wmemcpy;
using ::wmemmove;
using ::wmemset;
using ::wprintf;
using ::wscanf;
using ::wcschr;
using ::wcspbrk;
using ::wcsrchr;
using ::wcsstr;
using ::wmemchr;
inline wchar_t*
wcschr(wchar_t* __p, wchar_t __c)
{ return wcschr(const_cast<const wchar_t*>(__p), __c); }
inline wchar_t*
wcspbrk(wchar_t* __s1, const wchar_t* __s2)
{ return wcspbrk(const_cast<const wchar_t*>(__s1), __s2); }
inline wchar_t*
wcsrchr(wchar_t* __p, wchar_t __c)
{ return wcsrchr(const_cast<const wchar_t*>(__p), __c); }
inline wchar_t*
wcsstr(wchar_t* __s1, const wchar_t* __s2)
{ return wcsstr(const_cast<const wchar_t*>(__s1), __s2); }
inline wchar_t*
wmemchr(wchar_t* __p, wchar_t __c, size_t __n)
{ return wmemchr(const_cast<const wchar_t*>(__p), __c, __n); }
}
namespace __gnu_cxx
{
using ::wcstold;
#258 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cwchar" 3
using ::wcstoll;
using ::wcstoull;
}
namespace std
{
using ::__gnu_cxx::wcstold;
using ::__gnu_cxx::wcstoll;
using ::__gnu_cxx::wcstoull;
}
#42 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/postypes.h" 2 3
#69 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/postypes.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
#89 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/postypes.h" 3
typedef long streamoff;
#99 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/postypes.h" 3
typedef ptrdiff_t streamsize;
#112 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/postypes.h" 3
template<typename _StateT>
class fpos
{
private:
streamoff _M_off;
_StateT _M_state;
public:
fpos()
: _M_off(0), _M_state() { }
#134 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/postypes.h" 3
fpos(streamoff __off)
: _M_off(__off), _M_state() { }
operator streamoff() const { return _M_off; }
void
state(_StateT __st)
{ _M_state = __st; }
_StateT
state() const
{ return _M_state; }
fpos&
operator+=(streamoff __off)
{
_M_off += __off;
return *this;
}
fpos&
operator-=(streamoff __off)
{
_M_off -= __off;
return *this;
}
fpos
operator+(streamoff __off) const
{
fpos __pos(*this);
__pos += __off;
return __pos;
}
fpos
operator-(streamoff __off) const
{
fpos __pos(*this);
__pos -= __off;
return __pos;
}
streamoff
operator-(const fpos& __other) const
{ return _M_off - __other._M_off; }
};
template<typename _StateT>
inline bool
operator==(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
{ return streamoff(__lhs) == streamoff(__rhs); }
template<typename _StateT>
inline bool
operator!=(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
{ return streamoff(__lhs) != streamoff(__rhs); }
typedef fpos<mbstate_t> streampos;
typedef fpos<mbstate_t> wstreampos;
#241 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/postypes.h" 3
}
#42 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/iosfwd" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
#75 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/iosfwd" 3
class ios_base;
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_ios;
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_streambuf;
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_istream;
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_ostream;
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_iostream;
template<typename _CharT, typename _Traits = char_traits<_CharT>,
typename _Alloc = allocator<_CharT> >
class basic_stringbuf;
template<typename _CharT, typename _Traits = char_traits<_CharT>,
typename _Alloc = allocator<_CharT> >
class basic_istringstream;
template<typename _CharT, typename _Traits = char_traits<_CharT>,
typename _Alloc = allocator<_CharT> >
class basic_ostringstream;
template<typename _CharT, typename _Traits = char_traits<_CharT>,
typename _Alloc = allocator<_CharT> >
class basic_stringstream;
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_filebuf;
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_ifstream;
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_ofstream;
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_fstream;
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class istreambuf_iterator;
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class ostreambuf_iterator;
typedef basic_ios<char> ios;
typedef basic_streambuf<char> streambuf;
typedef basic_istream<char> istream;
typedef basic_ostream<char> ostream;
typedef basic_iostream<char> iostream;
typedef basic_stringbuf<char> stringbuf;
typedef basic_istringstream<char> istringstream;
typedef basic_ostringstream<char> ostringstream;
typedef basic_stringstream<char> stringstream;
typedef basic_filebuf<char> filebuf;
typedef basic_ifstream<char> ifstream;
typedef basic_ofstream<char> ofstream;
typedef basic_fstream<char> fstream;
typedef basic_ios<wchar_t> wios;
typedef basic_streambuf<wchar_t> wstreambuf;
typedef basic_istream<wchar_t> wistream;
typedef basic_ostream<wchar_t> wostream;
typedef basic_iostream<wchar_t> wiostream;
typedef basic_stringbuf<wchar_t> wstringbuf;
typedef basic_istringstream<wchar_t> wistringstream;
typedef basic_ostringstream<wchar_t> wostringstream;
typedef basic_stringstream<wchar_t> wstringstream;
typedef basic_filebuf<wchar_t> wfilebuf;
typedef basic_ifstream<wchar_t> wifstream;
typedef basic_ofstream<wchar_t> wofstream;
typedef basic_fstream<wchar_t> wfstream;
}
#39 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ios" 2 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/exception" 1 3
#35 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/exception" 3
#35 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/exception" 3
#pragma GCC visibility push(default)
extern "C++" {
namespace std
{
#60 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/exception" 3
class exception
{
public:
exception() throw() { }
virtual ~exception() throw();
virtual const char* what() const throw();
};
class bad_exception : public exception
{
public:
bad_exception() throw() { }
virtual ~bad_exception() throw();
virtual const char* what() const throw();
};
typedef void (*terminate_handler) ();
typedef void (*unexpected_handler) ();
terminate_handler set_terminate(terminate_handler) throw();
void terminate() throw() __attribute__ ((__noreturn__));
unexpected_handler set_unexpected(unexpected_handler) throw();
void unexpected() __attribute__ ((__noreturn__));
#117 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/exception" 3
bool uncaught_exception() throw() __attribute__ ((__pure__));
}
namespace __gnu_cxx
{
#142 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/exception" 3
void __verbose_terminate_handler();
}
}
#pragma GCC visibility pop
#40 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ios" 2 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/char_traits.h" 1 3
#39 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/char_traits.h" 3
#39 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/char_traits.h" 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_algobase.h" 1 3
#61 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_algobase.h" 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/functexcept.h" 1 3
#41 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/functexcept.h" 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/exception_defines.h" 1 3
#42 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/functexcept.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
void
__throw_bad_exception(void) __attribute__((__noreturn__));
void
__throw_bad_alloc(void) __attribute__((__noreturn__));
void
__throw_bad_cast(void) __attribute__((__noreturn__));
void
__throw_bad_typeid(void) __attribute__((__noreturn__));
void
__throw_logic_error(const char*) __attribute__((__noreturn__));
void
__throw_domain_error(const char*) __attribute__((__noreturn__));
void
__throw_invalid_argument(const char*) __attribute__((__noreturn__));
void
__throw_length_error(const char*) __attribute__((__noreturn__));
void
__throw_out_of_range(const char*) __attribute__((__noreturn__));
void
__throw_runtime_error(const char*) __attribute__((__noreturn__));
void
__throw_range_error(const char*) __attribute__((__noreturn__));
void
__throw_overflow_error(const char*) __attribute__((__noreturn__));
void
__throw_underflow_error(const char*) __attribute__((__noreturn__));
void
__throw_ios_failure(const char*) __attribute__((__noreturn__));
void
__throw_system_error(int) __attribute__((__noreturn__));
void
__throw_future_error(int) __attribute__((__noreturn__));
void
__throw_bad_function_call() __attribute__((__noreturn__));
}
#62 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_algobase.h" 2 3
#1 "/opt/Xilinx/Vivado/2017.3/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
#36 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/cpp_type_traits.h" 3
#36 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/cpp_type_traits.h" 3
#68 "/opt/Xilinx/Vivado/2017.3/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 __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
template<typename _Iterator, typename _Container>
class __normal_iterator;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
struct __true_type { };
struct __false_type { };
template<bool>
struct __truth_type
{ typedef __false_type __type; };
template<>
struct __truth_type<true>
{ typedef __true_type __type; };
template<class _Sp, class _Tp>
struct __traitor
{
enum { __value = bool(_Sp::__value) || bool(_Tp::__value) };
typedef typename __truth_type<__value>::__type __type;
};
template<typename, typename>
struct __are_same
{
enum { __value = 0 };
typedef __false_type __type;
};
template<typename _Tp>
struct __are_same<_Tp, _Tp>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<typename _Tp>
struct __is_void
{
enum { __value = 0 };
typedef __false_type __type;
};
template<>
struct __is_void<void>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<typename _Tp>
struct __is_integer
{
enum { __value = 0 };
typedef __false_type __type;
};
template<>
struct __is_integer<bool>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<>
struct __is_integer<char>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<>
struct __is_integer<signed char>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<>
struct __is_integer<unsigned char>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<>
struct __is_integer<wchar_t>
{
enum { __value = 1 };
typedef __true_type __type;
};
#198 "/opt/Xilinx/Vivado/2017.3/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;
};
template<>
struct __is_integer<unsigned short>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<>
struct __is_integer<int>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<>
struct __is_integer<unsigned int>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<>
struct __is_integer<long>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<>
struct __is_integer<unsigned long>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<>
struct __is_integer<long long>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<>
struct __is_integer<unsigned long long>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<typename _Tp>
struct __is_floating
{
enum { __value = 0 };
typedef __false_type __type;
};
template<>
struct __is_floating<float>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<>
struct __is_floating<double>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<>
struct __is_floating<long double>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<typename _Tp>
struct __is_pointer
{
enum { __value = 0 };
typedef __false_type __type;
};
template<typename _Tp>
struct __is_pointer<_Tp*>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<typename _Tp>
struct __is_normal_iterator
{
enum { __value = 0 };
typedef __false_type __type;
};
template<typename _Iterator, typename _Container>
struct __is_normal_iterator< __gnu_cxx::__normal_iterator<_Iterator,
_Container> >
{
enum { __value = 1 };
typedef __true_type __type;
};
template<typename _Tp>
struct __is_arithmetic
: public __traitor<__is_integer<_Tp>, __is_floating<_Tp> >
{ };
template<typename _Tp>
struct __is_fundamental
: public __traitor<__is_void<_Tp>, __is_arithmetic<_Tp> >
{ };
template<typename _Tp>
struct __is_scalar
: public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> >
{ };
template<typename _Tp>
struct __is_char
{
enum { __value = 0 };
typedef __false_type __type;
};
template<>
struct __is_char<char>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<>
struct __is_char<wchar_t>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<typename _Tp>
struct __is_byte
{
enum { __value = 0 };
typedef __false_type __type;
};
template<>
struct __is_byte<char>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<>
struct __is_byte<signed char>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<>
struct __is_byte<unsigned char>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<typename _Tp>
struct __is_move_iterator
{
enum { __value = 0 };
typedef __false_type __type;
};
#422 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/cpp_type_traits.h" 3
}
#63 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_algobase.h" 2 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ext/type_traits.h" 1 3
#33 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ext/type_traits.h" 3
#33 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ext/type_traits.h" 3
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
template<bool, typename>
struct __enable_if
{ };
template<typename _Tp>
struct __enable_if<true, _Tp>
{ typedef _Tp __type; };
template<bool _Cond, typename _Iftrue, typename _Iffalse>
struct __conditional_type
{ typedef _Iftrue __type; };
template<typename _Iftrue, typename _Iffalse>
struct __conditional_type<false, _Iftrue, _Iffalse>
{ typedef _Iffalse __type; };
template<typename _Tp>
struct __add_unsigned
{
private:
typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;
public:
typedef typename __if_type::__type __type;
};
template<>
struct __add_unsigned<char>
{ typedef unsigned char __type; };
template<>
struct __add_unsigned<signed char>
{ typedef unsigned char __type; };
template<>
struct __add_unsigned<short>
{ typedef unsigned short __type; };
template<>
struct __add_unsigned<int>
{ typedef unsigned int __type; };
template<>
struct __add_unsigned<long>
{ typedef unsigned long __type; };
template<>
struct __add_unsigned<long long>
{ typedef unsigned long long __type; };
template<>
struct __add_unsigned<bool>;
template<>
struct __add_unsigned<wchar_t>;
template<typename _Tp>
struct __remove_unsigned
{
private:
typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;
public:
typedef typename __if_type::__type __type;
};
template<>
struct __remove_unsigned<char>
{ typedef signed char __type; };
template<>
struct __remove_unsigned<unsigned char>
{ typedef signed char __type; };
template<>
struct __remove_unsigned<unsigned short>
{ typedef short __type; };
template<>
struct __remove_unsigned<unsigned int>
{ typedef int __type; };
template<>
struct __remove_unsigned<unsigned long>
{ typedef long __type; };
template<>
struct __remove_unsigned<unsigned long long>
{ typedef long long __type; };
template<>
struct __remove_unsigned<bool>;
template<>
struct __remove_unsigned<wchar_t>;
template<typename _Type>
inline bool
__is_null_pointer(_Type* __ptr)
{ return __ptr == 0; }
template<typename _Type>
inline bool
__is_null_pointer(_Type)
{ return false; }
template<typename _Tp, bool = std::__is_integer<_Tp>::__value>
struct __promote
{ typedef double __type; };
template<typename _Tp>
struct __promote<_Tp, false>
{ };
template<>
struct __promote<long double>
{ typedef long double __type; };
template<>
struct __promote<double>
{ typedef double __type; };
template<>
struct __promote<float>
{ typedef float __type; };
template<typename _Tp, typename _Up,
typename _Tp2 = typename __promote<_Tp>::__type,
typename _Up2 = typename __promote<_Up>::__type>
struct __promote_2
{
typedef __typeof__(_Tp2() + _Up2()) __type;
};
template<typename _Tp, typename _Up, typename _Vp,
typename _Tp2 = typename __promote<_Tp>::__type,
typename _Up2 = typename __promote<_Up>::__type,
typename _Vp2 = typename __promote<_Vp>::__type>
struct __promote_3
{
typedef __typeof__(_Tp2() + _Up2() + _Vp2()) __type;
};
template<typename _Tp, typename _Up, typename _Vp, typename _Wp,
typename _Tp2 = typename __promote<_Tp>::__type,
typename _Up2 = typename __promote<_Up>::__type,
typename _Vp2 = typename __promote<_Vp>::__type,
typename _Wp2 = typename __promote<_Wp>::__type>
struct __promote_4
{
typedef __typeof__(_Tp2() + _Up2() + _Vp2() + _Wp2()) __type;
};
}
#64 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_algobase.h" 2 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ext/numeric_traits.h" 1 3
#32 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ext/numeric_traits.h" 3
#32 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ext/numeric_traits.h" 3
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
#53 "/opt/Xilinx/Vivado/2017.3/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
{
static const _Value __min = (((_Value)(-1) < 0) ? (_Value)1 << (sizeof(_Value) * 8 - ((_Value)(-1) < 0)) : (_Value)0);
static const _Value __max = (((_Value)(-1) < 0) ? (((((_Value)1 << ((sizeof(_Value) * 8 - ((_Value)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(_Value)0);
static const bool __is_signed = ((_Value)(-1) < 0);
static const int __digits = (sizeof(_Value) * 8 - ((_Value)(-1) < 0));
};
template<typename _Value>
const _Value __numeric_traits_integer<_Value>::__min;
template<typename _Value>
const _Value __numeric_traits_integer<_Value>::__max;
template<typename _Value>
const bool __numeric_traits_integer<_Value>::__is_signed;
template<typename _Value>
const int __numeric_traits_integer<_Value>::__digits;
#98 "/opt/Xilinx/Vivado/2017.3/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
{
static const int __max_digits10 = (2 + (std::__are_same<_Value, float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 64) * 643L / 2136);
static const bool __is_signed = true;
static const int __digits10 = (std::__are_same<_Value, float>::__value ? 6 : std::__are_same<_Value, double>::__value ? 15 : 18);
static const int __max_exponent10 = (std::__are_same<_Value, float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 4932);
};
template<typename _Value>
const int __numeric_traits_floating<_Value>::__max_digits10;
template<typename _Value>
const bool __numeric_traits_floating<_Value>::__is_signed;
template<typename _Value>
const int __numeric_traits_floating<_Value>::__digits10;
template<typename _Value>
const int __numeric_traits_floating<_Value>::__max_exponent10;
template<typename _Value>
struct __numeric_traits
: public __conditional_type<std::__is_integer<_Value>::__value,
__numeric_traits_integer<_Value>,
__numeric_traits_floating<_Value> >::__type
{ };
}
#65 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_algobase.h" 2 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_pair.h" 1 3
#60 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_pair.h" 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/move.h" 1 3
#34 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/move.h" 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/concept_check.h" 1 3
#33 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/concept_check.h" 3
#33 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/concept_check.h" 3
#35 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/move.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Tp>
inline _Tp*
__addressof(_Tp& __r)
{
return reinterpret_cast<_Tp*>
(&const_cast<char&>(reinterpret_cast<const volatile char&>(__r)));
}
}
#109 "/opt/Xilinx/Vivado/2017.3/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")))
{
#120 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/move.h" 3
template<typename _Tp>
inline void
swap(_Tp& __a, _Tp& __b)
{
_Tp __tmp = (__a);
__a = (__b);
__b = (__tmp);
}
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]);
}
}
#61 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_pair.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
#86 "/opt/Xilinx/Vivado/2017.3/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>
struct pair
{
typedef _T1 first_type;
typedef _T2 second_type;
_T1 first;
_T2 second;
pair()
: first(), second() { }
pair(const _T1& __a, const _T2& __b)
: first(__a), second(__b) { }
template<class _U1, class _U2>
pair(const pair<_U1, _U2>& __p)
: first(__p.first), second(__p.second) { }
#196 "/opt/Xilinx/Vivado/2017.3/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 bool
operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return __x.first == __y.first && __x.second == __y.second; }
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); }
template<class _T1, class _T2>
inline bool
operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return !(__x == __y); }
template<class _T1, class _T2>
inline bool
operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return __y < __x; }
template<class _T1, class _T2>
inline bool
operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return !(__y < __x); }
template<class _T1, class _T2>
inline bool
operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return !(__x < __y); }
#270 "/opt/Xilinx/Vivado/2017.3/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); }
}
#66 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_algobase.h" 2 3
#1 "/opt/Xilinx/Vivado/2017.3/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
#63 "/opt/Xilinx/Vivado/2017.3/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
#63 "/opt/Xilinx/Vivado/2017.3/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
namespace std __attribute__ ((__visibility__ ("default")))
{
#89 "/opt/Xilinx/Vivado/2017.3/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
struct input_iterator_tag { };
struct output_iterator_tag { };
struct forward_iterator_tag : public input_iterator_tag { };
struct bidirectional_iterator_tag : public forward_iterator_tag { };
struct random_access_iterator_tag : public bidirectional_iterator_tag { };
#116 "/opt/Xilinx/Vivado/2017.3/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 _Category, typename _Tp, typename _Distance = ptrdiff_t,
typename _Pointer = _Tp*, typename _Reference = _Tp&>
struct iterator
{
typedef _Category iterator_category;
typedef _Tp value_type;
typedef _Distance difference_type;
typedef _Pointer pointer;
typedef _Reference reference;
};
#162 "/opt/Xilinx/Vivado/2017.3/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;
};
template<typename _Tp>
struct iterator_traits<_Tp*>
{
typedef random_access_iterator_tag iterator_category;
typedef _Tp value_type;
typedef ptrdiff_t difference_type;
typedef _Tp* pointer;
typedef _Tp& reference;
};
template<typename _Tp>
struct iterator_traits<const _Tp*>
{
typedef random_access_iterator_tag iterator_category;
typedef _Tp value_type;
typedef ptrdiff_t difference_type;
typedef const _Tp* pointer;
typedef const _Tp& reference;
};
template<typename _Iter>
inline typename iterator_traits<_Iter>::iterator_category
__iterator_category(const _Iter&)
{ return typename iterator_traits<_Iter>::iterator_category(); }
template<typename _Iterator, bool _HasBase>
struct _Iter_base
{
typedef _Iterator iterator_type;
static iterator_type _S_base(_Iterator __it)
{ return __it; }
};
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(); }
};
}
#67 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_algobase.h" 2 3
#1 "/opt/Xilinx/Vivado/2017.3/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
#63 "/opt/Xilinx/Vivado/2017.3/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
#63 "/opt/Xilinx/Vivado/2017.3/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 std __attribute__ ((__visibility__ ("default")))
{
template<typename _InputIterator>
inline typename iterator_traits<_InputIterator>::difference_type
__distance(_InputIterator __first, _InputIterator __last,
input_iterator_tag)
{
typename iterator_traits<_InputIterator>::difference_type __n = 0;
while (__first != __last)
{
++__first;
++__n;
}
return __n;
}
template<typename _RandomAccessIterator>
inline typename iterator_traits<_RandomAccessIterator>::difference_type
__distance(_RandomAccessIterator __first, _RandomAccessIterator __last,
random_access_iterator_tag)
{
return __last - __first;
}
#110 "/opt/Xilinx/Vivado/2017.3/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
template<typename _InputIterator>
inline typename iterator_traits<_InputIterator>::difference_type
distance(_InputIterator __first, _InputIterator __last)
{
return std::__distance(__first, __last,
std::__iterator_category(__first));
}
template<typename _InputIterator, typename _Distance>
inline void
__advance(_InputIterator& __i, _Distance __n, input_iterator_tag)
{
while (__n--)
++__i;
}
template<typename _BidirectionalIterator, typename _Distance>
inline void
__advance(_BidirectionalIterator& __i, _Distance __n,
bidirectional_iterator_tag)
{
if (__n > 0)
while (__n--)
++__i;
else
while (__n++)
--__i;
}
template<typename _RandomAccessIterator, typename _Distance>
inline void
__advance(_RandomAccessIterator& __i, _Distance __n,
random_access_iterator_tag)
{
__i += __n;
}
#168 "/opt/Xilinx/Vivado/2017.3/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
template<typename _InputIterator, typename _Distance>
inline void
advance(_InputIterator& __i, _Distance __n)
{
typename iterator_traits<_InputIterator>::difference_type __d = __n;
std::__advance(__i, __d, std::__iterator_category(__i));
}
#200 "/opt/Xilinx/Vivado/2017.3/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
}
#68 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_algobase.h" 2 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_iterator.h" 1 3
#68 "/opt/Xilinx/Vivado/2017.3/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")))
{
#96 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_iterator.h" 3
template<typename _Iterator>
class reverse_iterator
: public iterator<typename iterator_traits<_Iterator>::iterator_category,
typename iterator_traits<_Iterator>::value_type,
typename iterator_traits<_Iterator>::difference_type,
typename iterator_traits<_Iterator>::pointer,
typename iterator_traits<_Iterator>::reference>
{
protected:
_Iterator current;
typedef iterator_traits<_Iterator> __traits_type;
public:
typedef _Iterator iterator_type;
typedef typename __traits_type::difference_type difference_type;
typedef typename __traits_type::pointer pointer;
typedef typename __traits_type::reference reference;
reverse_iterator() : current() { }
explicit
reverse_iterator(iterator_type __x) : current(__x) { }
reverse_iterator(const reverse_iterator& __x)
: current(__x.current) { }
template<typename _Iter>
reverse_iterator(const reverse_iterator<_Iter>& __x)
: current(__x.base()) { }
iterator_type
base() const
{ return current; }
reference
operator*() const
{
_Iterator __tmp = current;
return *--__tmp;
}
pointer
operator->() const
{ return &(operator*()); }
reverse_iterator&
operator++()
{
--current;
return *this;
}
reverse_iterator
operator++(int)
{
reverse_iterator __tmp = *this;
--current;
return __tmp;
}
reverse_iterator&
operator--()
{
++current;
return *this;
}
reverse_iterator
operator--(int)
{
reverse_iterator __tmp = *this;
++current;
return __tmp;
}
reverse_iterator
operator+(difference_type __n) const
{ return reverse_iterator(current - __n); }
reverse_iterator&
operator+=(difference_type __n)
{
current -= __n;
return *this;
}
reverse_iterator
operator-(difference_type __n) const
{ return reverse_iterator(current + __n); }
reverse_iterator&
operator-=(difference_type __n)
{
current += __n;
return *this;
}
reference
operator[](difference_type __n) const
{ return *(*this + __n); }
};
#283 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_iterator.h" 3
template<typename _Iterator>
inline bool
operator==(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
{ return __x.base() == __y.base(); }
template<typename _Iterator>
inline bool
operator<(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
{ return __y.base() < __x.base(); }
template<typename _Iterator>
inline bool
operator!=(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
{ return !(__x == __y); }
template<typename _Iterator>
inline bool
operator>(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
{ return __y < __x; }
template<typename _Iterator>
inline bool
operator<=(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
{ return !(__y < __x); }
template<typename _Iterator>
inline bool
operator>=(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
{ return !(__x < __y); }
template<typename _Iterator>
inline typename reverse_iterator<_Iterator>::difference_type
operator-(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
{ return __y.base() - __x.base(); }
template<typename _Iterator>
inline reverse_iterator<_Iterator>
operator+(typename reverse_iterator<_Iterator>::difference_type __n,
const reverse_iterator<_Iterator>& __x)
{ return reverse_iterator<_Iterator>(__x.base() - __n); }
template<typename _IteratorL, typename _IteratorR>
inline bool
operator==(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
{ return __x.base() == __y.base(); }
template<typename _IteratorL, typename _IteratorR>
inline bool
operator<(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
{ return __y.base() < __x.base(); }
template<typename _IteratorL, typename _IteratorR>
inline bool
operator!=(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
{ return !(__x == __y); }
template<typename _IteratorL, typename _IteratorR>
inline bool
operator>(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
{ return __y < __x; }
template<typename _IteratorL, typename _IteratorR>
inline bool
operator<=(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
{ return !(__y < __x); }
template<typename _IteratorL, typename _IteratorR>
inline bool
operator>=(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
{ return !(__x < __y); }
template<typename _IteratorL, typename _IteratorR>
inline typename reverse_iterator<_IteratorL>::difference_type
operator-(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
{ return __y.base() - __x.base(); }
#395 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_iterator.h" 3
template<typename _Container>
class back_insert_iterator
: public iterator<output_iterator_tag, void, void, void, void>
{
protected:
_Container* container;
public:
typedef _Container container_type;
explicit
back_insert_iterator(_Container& __x) : container(&__x) { }
#422 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_iterator.h" 3
back_insert_iterator&
operator=(typename _Container::const_reference __value)
{
container->push_back(__value);
return *this;
}
#445 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_iterator.h" 3
back_insert_iterator&
operator*()
{ return *this; }
back_insert_iterator&
operator++()
{ return *this; }
back_insert_iterator
operator++(int)
{ return *this; }
};
#471 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_iterator.h" 3
template<typename _Container>
inline back_insert_iterator<_Container>
back_inserter(_Container& __x)
{ return back_insert_iterator<_Container>(__x); }
#486 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_iterator.h" 3
template<typename _Container>
class front_insert_iterator
: public iterator<output_iterator_tag, void, void, void, void>
{
protected:
_Container* container;
public:
typedef _Container container_type;
explicit front_insert_iterator(_Container& __x) : container(&__x) { }
#512 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_iterator.h" 3
front_insert_iterator&
operator=(typename _Container::const_reference __value)
{
container->push_front(__value);
return *this;
}
#535 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_iterator.h" 3
front_insert_iterator&
operator*()
{ return *this; }
front_insert_iterator&
operator++()
{ return *this; }
front_insert_iterator
operator++(int)
{ return *this; }
};
#561 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_iterator.h" 3
template<typename _Container>
inline front_insert_iterator<_Container>
front_inserter(_Container& __x)
{ return front_insert_iterator<_Container>(__x); }
#580 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_iterator.h" 3
template<typename _Container>
class insert_iterator
: public iterator<output_iterator_tag, void, void, void, void>
{
protected:
_Container* container;
typename _Container::iterator iter;
public:
typedef _Container container_type;
insert_iterator(_Container& __x, typename _Container::iterator __i)
: container(&__x), iter(__i) {}
#623 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_iterator.h" 3
insert_iterator&
operator=(typename _Container::const_reference __value)
{
iter = container->insert(iter, __value);
++iter;
return *this;
}
#649 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_iterator.h" 3
insert_iterator&
operator*()
{ return *this; }
insert_iterator&
operator++()
{ return *this; }
insert_iterator&
operator++(int)
{ return *this; }
};
#675 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_iterator.h" 3
template<typename _Container, typename _Iterator>
inline insert_iterator<_Container>
inserter(_Container& __x, _Iterator __i)
{
return insert_iterator<_Container>(__x,
typename _Container::iterator(__i));
}
}
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
#699 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_iterator.h" 3
using std::iterator_traits;
using std::iterator;
template<typename _Iterator, typename _Container>
class __normal_iterator
{
protected:
_Iterator _M_current;
typedef iterator_traits<_Iterator> __traits_type;
public:
typedef _Iterator iterator_type;
typedef typename __traits_type::iterator_category iterator_category;
typedef typename __traits_type::value_type value_type;
typedef typename __traits_type::difference_type difference_type;
typedef typename __traits_type::reference reference;
typedef typename __traits_type::pointer pointer;
__normal_iterator() : _M_current(_Iterator()) { }
explicit
__normal_iterator(const _Iterator& __i) : _M_current(__i) { }
template<typename _Iter>
__normal_iterator(const __normal_iterator<_Iter,
typename __enable_if<
(std::__are_same<_Iter, typename _Container::pointer>::__value),
_Container>::__type>& __i)
: _M_current(__i.base()) { }
reference
operator*() const
{ return *_M_current; }
pointer
operator->() const
{ return _M_current; }
__normal_iterator&
operator++()
{
++_M_current;
return *this;
}
__normal_iterator
operator++(int)
{ return __normal_iterator(_M_current++); }
__normal_iterator&
operator--()
{
--_M_current;
return *this;
}
__normal_iterator
operator--(int)
{ return __normal_iterator(_M_current--); }
reference
operator[](const difference_type& __n) const
{ return _M_current[__n]; }
__normal_iterator&
operator+=(const difference_type& __n)
{ _M_current += __n; return *this; }
__normal_iterator
operator+(const difference_type& __n) const
{ return __normal_iterator(_M_current + __n); }
__normal_iterator&
operator-=(const difference_type& __n)
{ _M_current -= __n; return *this; }
__normal_iterator
operator-(const difference_type& __n) const
{ return __normal_iterator(_M_current - __n); }
const _Iterator&
base() const
{ return _M_current; }
};
#797 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_iterator.h" 3
template<typename _IteratorL, typename _IteratorR, typename _Container>
inline bool
operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs)
{ return __lhs.base() == __rhs.base(); }
template<typename _Iterator, typename _Container>
inline bool
operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
const __normal_iterator<_Iterator, _Container>& __rhs)
{ return __lhs.base() == __rhs.base(); }
template<typename _IteratorL, typename _IteratorR, typename _Container>
inline bool
operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs)
{ return __lhs.base() != __rhs.base(); }
template<typename _Iterator, typename _Container>
inline bool
operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
const __normal_iterator<_Iterator, _Container>& __rhs)
{ return __lhs.base() != __rhs.base(); }
template<typename _IteratorL, typename _IteratorR, typename _Container>
inline bool
operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs)
{ return __lhs.base() < __rhs.base(); }
template<typename _Iterator, typename _Container>
inline bool
operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
const __normal_iterator<_Iterator, _Container>& __rhs)
{ return __lhs.base() < __rhs.base(); }
template<typename _IteratorL, typename _IteratorR, typename _Container>
inline bool
operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs)
{ return __lhs.base() > __rhs.base(); }
template<typename _Iterator, typename _Container>
inline bool
operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
const __normal_iterator<_Iterator, _Container>& __rhs)
{ return __lhs.base() > __rhs.base(); }
template<typename _IteratorL, typename _IteratorR, typename _Container>
inline bool
operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs)
{ return __lhs.base() <= __rhs.base(); }
template<typename _Iterator, typename _Container>
inline bool
operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
const __normal_iterator<_Iterator, _Container>& __rhs)
{ return __lhs.base() <= __rhs.base(); }
template<typename _IteratorL, typename _IteratorR, typename _Container>
inline bool
operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs)
{ return __lhs.base() >= __rhs.base(); }
template<typename _Iterator, typename _Container>
inline bool
operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
const __normal_iterator<_Iterator, _Container>& __rhs)
{ return __lhs.base() >= __rhs.base(); }
template<typename _IteratorL, typename _IteratorR, typename _Container>
inline typename __normal_iterator<_IteratorL, _Container>::difference_type
operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs)
{ return __lhs.base() - __rhs.base(); }
template<typename _Iterator, typename _Container>
inline typename __normal_iterator<_Iterator, _Container>::difference_type
operator-(const __normal_iterator<_Iterator, _Container>& __lhs,
const __normal_iterator<_Iterator, _Container>& __rhs)
{ return __lhs.base() - __rhs.base(); }
template<typename _Iterator, typename _Container>
inline __normal_iterator<_Iterator, _Container>
operator+(typename __normal_iterator<_Iterator, _Container>::difference_type
__n, const __normal_iterator<_Iterator, _Container>& __i)
{ return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
}
#69 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_algobase.h" 2 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/debug/debug.h" 1 3
#47 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/debug/debug.h" 3
namespace std
{
namespace __debug { }
}
namespace __gnu_debug
{
using namespace std::__debug;
}
#71 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_algobase.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
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);
}
};
template<>
struct __iter_swap<true>
{
template<typename _ForwardIterator1, typename _ForwardIterator2>
static void
iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
{
swap(*__a, *__b);
}
};
#116 "/opt/Xilinx/Vivado/2017.3/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 _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;
#135 "/opt/Xilinx/Vivado/2017.3/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);
}
#157 "/opt/Xilinx/Vivado/2017.3/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 _ForwardIterator1, typename _ForwardIterator2>
_ForwardIterator2
swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2)
{
;
for (; __first1 != __last1; ++__first1, ++__first2)
std::iter_swap(__first1, __first2);
return __first2;
}
#185 "/opt/Xilinx/Vivado/2017.3/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 _Tp>
inline const _Tp&
min(const _Tp& __a, const _Tp& __b)
{
if (__b < __a)
return __b;
return __a;
}
#208 "/opt/Xilinx/Vivado/2017.3/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 _Tp>
inline const _Tp&
max(const _Tp& __a, const _Tp& __b)
{
if (__a < __b)
return __b;
return __a;
}
#231 "/opt/Xilinx/Vivado/2017.3/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 _Tp, typename _Compare>
inline const _Tp&
min(const _Tp& __a, const _Tp& __b, _Compare __comp)
{
if (__comp(__b, __a))
return __b;
return __a;
}
#252 "/opt/Xilinx/Vivado/2017.3/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 _Tp, typename _Compare>
inline const _Tp&
max(const _Tp& __a, const _Tp& __b, _Compare __comp)
{
if (__comp(__a, __b))
return __b;
return __a;
}
template<typename _Iterator>
struct _Niter_base
: _Iter_base<_Iterator, __is_normal_iterator<_Iterator>::__value>
{ };
template<typename _Iterator>
inline typename _Niter_base<_Iterator>::iterator_type
__niter_base(_Iterator __it)
{ return std::_Niter_base<_Iterator>::_S_base(__it); }
template<typename _Iterator>
struct _Miter_base
: _Iter_base<_Iterator, __is_move_iterator<_Iterator>::__value>
{ };
template<typename _Iterator>
inline typename _Miter_base<_Iterator>::iterator_type
__miter_base(_Iterator __it)
{ return std::_Miter_base<_Iterator>::_S_base(__it); }
template<bool, bool, typename>
struct __copy_move
{
template<typename _II, typename _OI>
static _OI
__copy_m(_II __first, _II __last, _OI __result)
{
for (; __first != __last; ++__result, ++__first)
*__result = *__first;
return __result;
}
};
#319 "/opt/Xilinx/Vivado/2017.3/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;
}
};
#357 "/opt/Xilinx/Vivado/2017.3/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;
}
};
template<bool _IsMove, typename _II, typename _OI>
inline _OI
__copy_move_a(_II __first, _II __last, _OI __result)
{
typedef typename iterator_traits<_II>::value_type _ValueTypeI;
typedef typename iterator_traits<_OI>::value_type _ValueTypeO;
typedef typename iterator_traits<_II>::iterator_category _Category;
const bool __simple = (__is_trivial(_ValueTypeI)
&& __is_pointer<_II>::__value
&& __is_pointer<_OI>::__value
&& __are_same<_ValueTypeI, _ValueTypeO>::__value);
return std::__copy_move<_IsMove, __simple,
_Category>::__copy_m(__first, __last, __result);
}
template<typename _CharT>
struct char_traits;
template<typename _CharT, typename _Traits>
class istreambuf_iterator;
template<typename _CharT, typename _Traits>
class ostreambuf_iterator;
template<bool _IsMove, typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
__copy_move_a2(_CharT*, _CharT*,
ostreambuf_iterator<_CharT, char_traits<_CharT> >);
template<bool _IsMove, typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
__copy_move_a2(const _CharT*, const _CharT*,
ostreambuf_iterator<_CharT, char_traits<_CharT> >);
template<bool _IsMove, typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
_CharT*>::__type
__copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >,
istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*);
template<bool _IsMove, typename _II, typename _OI>
inline _OI
__copy_move_a2(_II __first, _II __last, _OI __result)
{
return _OI(std::__copy_move_a<_IsMove>(std::__niter_base(__first),
std::__niter_base(__last),
std::__niter_base(__result)));
}
#442 "/opt/Xilinx/Vivado/2017.3/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 _II, typename _OI>
inline _OI
copy(_II __first, _II __last, _OI __result)
{
;
return (std::__copy_move_a2<__is_move_iterator<_II>::__value>
(std::__miter_base(__first), std::__miter_base(__last),
__result));
}
#494 "/opt/Xilinx/Vivado/2017.3/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;
}
};
#522 "/opt/Xilinx/Vivado/2017.3/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;
}
};
#552 "/opt/Xilinx/Vivado/2017.3/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;
}
};
template<bool _IsMove, typename _BI1, typename _BI2>
inline _BI2
__copy_move_backward_a(_BI1 __first, _BI1 __last, _BI2 __result)
{
typedef typename iterator_traits<_BI1>::value_type _ValueType1;
typedef typename iterator_traits<_BI2>::value_type _ValueType2;
typedef typename iterator_traits<_BI1>::iterator_category _Category;
const bool __simple = (__is_trivial(_ValueType1)
&& __is_pointer<_BI1>::__value
&& __is_pointer<_BI2>::__value
&& __are_same<_ValueType1, _ValueType2>::__value);
return std::__copy_move_backward<_IsMove, __simple,
_Category>::__copy_move_b(__first,
__last,
__result);
}
template<bool _IsMove, typename _BI1, typename _BI2>
inline _BI2
__copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result)
{
return _BI2(std::__copy_move_backward_a<_IsMove>
(std::__niter_base(__first), std::__niter_base(__last),
std::__niter_base(__result)));
}
#611 "/opt/Xilinx/Vivado/2017.3/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 _BI1, typename _BI2>
inline _BI2
copy_backward(_BI1 __first, _BI1 __last, _BI2 __result)
{
;
return (std::__copy_move_backward_a2<__is_move_iterator<_BI1>::__value>
(std::__miter_base(__first), std::__miter_base(__last),
__result));
}
#669 "/opt/Xilinx/Vivado/2017.3/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;
}
template<typename _ForwardIterator, typename _Tp>
inline typename
__gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type
__fill_a(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __value)
{
const _Tp __tmp = __value;
for (; __first != __last; ++__first)
*__first = __tmp;
}
template<typename _Tp>
inline typename
__gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type
__fill_a(_Tp* __first, _Tp* __last, const _Tp& __c)
{
const _Tp __tmp = __c;
__builtin_memset(__first, static_cast<unsigned char>(__tmp),
__last - __first);
}
#713 "/opt/Xilinx/Vivado/2017.3/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 void
fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
{
;
std::__fill_a(std::__niter_base(__first), std::__niter_base(__last),
__value);
}
template<typename _OutputIterator, typename _Size, typename _Tp>
inline typename
__gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, _OutputIterator>::__type
__fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
{
for (__decltype(__n + 0) __niter = __n;
__niter > 0; --__niter, ++__first)
*__first = __value;
return __first;
}
template<typename _OutputIterator, typename _Size, typename _Tp>
inline typename
__gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type
__fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
{
const _Tp __tmp = __value;
for (__decltype(__n + 0) __niter = __n;
__niter > 0; --__niter, ++__first)
*__first = __tmp;
return __first;
}
template<typename _Size, typename _Tp>
inline typename
__gnu_cxx::__enable_if<__is_byte<_Tp>::__value, _Tp*>::__type
__fill_n_a(_Tp* __first, _Size __n, const _Tp& __c)
{
std::__fill_a(__first, __first + __n, __c);
return __first + __n;
}
#773 "/opt/Xilinx/Vivado/2017.3/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 _OI, typename _Size, typename _Tp>
inline _OI
fill_n(_OI __first, _Size __n, const _Tp& __value)
{
return _OI(std::__fill_n_a(std::__niter_base(__first), __n, __value));
}
template<bool _BoolType>
struct __equal
{
template<typename _II1, typename _II2>
static bool
equal(_II1 __first1, _II1 __last1, _II2 __first2)
{
for (; __first1 != __last1; ++__first1, ++__first2)
if (!(*__first1 == *__first2))
return false;
return true;
}
};
template<>
struct __equal<true>
{
template<typename _Tp>
static bool
equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2)
{
return !__builtin_memcmp(__first1, __first2, sizeof(_Tp)
* (__last1 - __first1));
}
};
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);
return std::__equal<__simple>::equal(__first1, __last1, __first2);
}
template<typename, typename>
struct __lc_rai
{
template<typename _II1, typename _II2>
static _II1
__newlast1(_II1, _II1 __last1, _II2, _II2)
{ return __last1; }
template<typename _II>
static bool
__cnd2(_II __first, _II __last)
{ return __first != __last; }
};
template<>
struct __lc_rai<random_access_iterator_tag, random_access_iterator_tag>
{
template<typename _RAI1, typename _RAI2>
static _RAI1
__newlast1(_RAI1 __first1, _RAI1 __last1,
_RAI2 __first2, _RAI2 __last2)
{
const typename iterator_traits<_RAI1>::difference_type
__diff1 = __last1 - __first1;
const typename iterator_traits<_RAI2>::difference_type
__diff2 = __last2 - __first2;
return __diff2 < __diff1 ? __first1 + __diff2 : __last1;
}
template<typename _RAI>
static bool
__cnd2(_RAI, _RAI)
{ return true; }
};
template<bool _BoolType>
struct __lexicographical_compare
{
template<typename _II1, typename _II2>
static bool __lc(_II1, _II1, _II2, _II2);
};
template<bool _BoolType>
template<typename _II1, typename _II2>
bool
__lexicographical_compare<_BoolType>::
__lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
{
typedef typename iterator_traits<_II1>::iterator_category _Category1;
typedef typename iterator_traits<_II2>::iterator_category _Category2;
typedef std::__lc_rai<_Category1, _Category2> __rai_type;
__last1 = __rai_type::__newlast1(__first1, __last1,
__first2, __last2);
for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2);
++__first1, ++__first2)
{
if (*__first1 < *__first2)
return true;
if (*__first2 < *__first1)
return false;
}
return __first1 == __last1 && __first2 != __last2;
}
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;
}
};
template<typename _II1, typename _II2>
inline bool
__lexicographical_compare_aux(_II1 __first1, _II1 __last1,
_II2 __first2, _II2 __last2)
{
typedef typename iterator_traits<_II1>::value_type _ValueType1;
typedef typename iterator_traits<_II2>::value_type _ValueType2;
const bool __simple =
(__is_byte<_ValueType1>::__value && __is_byte<_ValueType2>::__value
&& !__gnu_cxx::__numeric_traits<_ValueType1>::__is_signed
&& !__gnu_cxx::__numeric_traits<_ValueType2>::__is_signed
&& __is_pointer<_II1>::__value
&& __is_pointer<_II2>::__value);
return std::__lexicographical_compare<__simple>::__lc(__first1, __last1,
__first2, __last2);
}
#934 "/opt/Xilinx/Vivado/2017.3/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>
_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;
;
_DistanceType __len = std::distance(__first, __last);
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;
}
template<typename _Size>
inline _Size
__lg(_Size __n)
{
_Size __k;
for (__k = 0; __n != 0; __n >>= 1)
++__k;
return __k - 1;
}
inline int
__lg(int __n)
{ return sizeof(int) * 8 - 1 - __builtin_clz(__n); }
inline long
__lg(long __n)
{ return sizeof(long) * 8 - 1 - __builtin_clzl(__n); }
inline long long
__lg(long long __n)
{ return sizeof(long long) * 8 - 1 - __builtin_clzll(__n); }
#1008 "/opt/Xilinx/Vivado/2017.3/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 _II1, typename _II2>
inline bool
equal(_II1 __first1, _II1 __last1, _II2 __first2)
{
;
return std::__equal_aux(std::__niter_base(__first1),
std::__niter_base(__last1),
std::__niter_base(__first2));
}
#1040 "/opt/Xilinx/Vivado/2017.3/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 _IIter1, typename _IIter2, typename _BinaryPredicate>
inline bool
equal(_IIter1 __first1, _IIter1 __last1,
_IIter2 __first2, _BinaryPredicate __binary_pred)
{
;
for (; __first1 != __last1; ++__first1, ++__first2)
if (!bool(__binary_pred(*__first1, *__first2)))
return false;
return true;
}
#1071 "/opt/Xilinx/Vivado/2017.3/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 _II1, typename _II2>
inline bool
lexicographical_compare(_II1 __first1, _II1 __last1,
_II2 __first2, _II2 __last2)
{
typedef typename iterator_traits<_II1>::value_type _ValueType1;
typedef typename iterator_traits<_II2>::value_type _ValueType2;
;
;
return std::__lexicographical_compare_aux(std::__niter_base(__first1),
std::__niter_base(__last1),
std::__niter_base(__first2),
std::__niter_base(__last2));
}
#1105 "/opt/Xilinx/Vivado/2017.3/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 _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;
;
;
__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;
}
#1145 "/opt/Xilinx/Vivado/2017.3/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 _InputIterator1, typename _InputIterator2>
pair<_InputIterator1, _InputIterator2>
mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2)
{
;
while (__first1 != __last1 && *__first1 == *__first2)
{
++__first1;
++__first2;
}
return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
}
#1182 "/opt/Xilinx/Vivado/2017.3/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 _InputIterator1, typename _InputIterator2,
typename _BinaryPredicate>
pair<_InputIterator1, _InputIterator2>
mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _BinaryPredicate __binary_pred)
{
;
while (__first1 != __last1 && bool(__binary_pred(*__first1, *__first2)))
{
++__first1;
++__first2;
}
return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
}
}
#41 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/char_traits.h" 2 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cwchar" 1 3
#41 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cwchar" 3
#41 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cwchar" 3
#1 "/usr/include/wchar.h" 1 3 4
#46 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cwchar" 2 3
#43 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/char_traits.h" 2 3
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
#58 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/char_traits.h" 3
template<typename _CharT>
struct _Char_types
{
typedef unsigned long int_type;
typedef std::streampos pos_type;
typedef std::streamoff off_type;
typedef std::mbstate_t state_type;
};
#83 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/char_traits.h" 3
template<typename _CharT>
struct char_traits
{
typedef _CharT char_type;
typedef typename _Char_types<_CharT>::int_type int_type;
typedef typename _Char_types<_CharT>::pos_type pos_type;
typedef typename _Char_types<_CharT>::off_type off_type;
typedef typename _Char_types<_CharT>::state_type state_type;
static void
assign(char_type& __c1, const char_type& __c2)
{ __c1 = __c2; }
static bool
eq(const char_type& __c1, const char_type& __c2)
{ return __c1 == __c2; }
static bool
lt(const char_type& __c1, const char_type& __c2)
{ return __c1 < __c2; }
static int
compare(const char_type* __s1, const char_type* __s2, std::size_t __n);
static std::size_t
length(const char_type* __s);
static const char_type*
find(const char_type* __s, std::size_t __n, const char_type& __a);
static char_type*
move(char_type* __s1, const char_type* __s2, std::size_t __n);
static char_type*
copy(char_type* __s1, const char_type* __s2, std::size_t __n);
static char_type*
assign(char_type* __s, std::size_t __n, char_type __a);
static char_type
to_char_type(const int_type& __c)
{ return static_cast<char_type>(__c); }
static int_type
to_int_type(const char_type& __c)
{ return static_cast<int_type>(__c); }
static bool
eq_int_type(const int_type& __c1, const int_type& __c2)
{ return __c1 == __c2; }
static int_type
eof()
{ return static_cast<int_type>(-1); }
static int_type
not_eof(const int_type& __c)
{ return !eq_int_type(__c, eof()) ? __c : to_int_type(char_type()); }
};
template<typename _CharT>
int
char_traits<_CharT>::
compare(const char_type* __s1, const char_type* __s2, std::size_t __n)
{
for (std::size_t __i = 0; __i < __n; ++__i)
if (lt(__s1[__i], __s2[__i]))
return -1;
else if (lt(__s2[__i], __s1[__i]))
return 1;
return 0;
}
template<typename _CharT>
std::size_t
char_traits<_CharT>::
length(const char_type* __p)
{
std::size_t __i = 0;
while (!eq(__p[__i], char_type()))
++__i;
return __i;
}
template<typename _CharT>
const typename char_traits<_CharT>::char_type*
char_traits<_CharT>::
find(const char_type* __s, std::size_t __n, const char_type& __a)
{
for (std::size_t __i = 0; __i < __n; ++__i)
if (eq(__s[__i], __a))
return __s + __i;
return 0;
}
template<typename _CharT>
typename char_traits<_CharT>::char_type*
char_traits<_CharT>::
move(char_type* __s1, const char_type* __s2, std::size_t __n)
{
return static_cast<_CharT*>(__builtin_memmove(__s1, __s2,
__n * sizeof(char_type)));
}
template<typename _CharT>
typename char_traits<_CharT>::char_type*
char_traits<_CharT>::
copy(char_type* __s1, const char_type* __s2, std::size_t __n)
{
std::copy(__s2, __s2 + __n, __s1);
return __s1;
}
template<typename _CharT>
typename char_traits<_CharT>::char_type*
char_traits<_CharT>::
assign(char_type* __s, std::size_t __n, char_type __a)
{
std::fill_n(__s, __n, __a);
return __s;
}
}
namespace std __attribute__ ((__visibility__ ("default")))
{
#227 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/char_traits.h" 3
template<class _CharT>
struct char_traits : public __gnu_cxx::char_traits<_CharT>
{ };
template<>
struct char_traits<char>
{
typedef char char_type;
typedef int int_type;
typedef streampos pos_type;
typedef streamoff off_type;
typedef mbstate_t state_type;
static void
assign(char_type& __c1, const char_type& __c2)
{ __c1 = __c2; }
static bool
eq(const char_type& __c1, const char_type& __c2)
{ return __c1 == __c2; }
static bool
lt(const char_type& __c1, const char_type& __c2)
{ return __c1 < __c2; }
static int
compare(const char_type* __s1, const char_type* __s2, size_t __n)
{ return __builtin_memcmp(__s1, __s2, __n); }
static size_t
length(const char_type* __s)
{ return __builtin_strlen(__s); }
static const char_type*
find(const char_type* __s, size_t __n, const char_type& __a)
{ return static_cast<const char_type*>(__builtin_memchr(__s, __a, __n)); }
static char_type*
move(char_type* __s1, const char_type* __s2, size_t __n)
{ return static_cast<char_type*>(__builtin_memmove(__s1, __s2, __n)); }
static char_type*
copy(char_type* __s1, const char_type* __s2, size_t __n)
{ return static_cast<char_type*>(__builtin_memcpy(__s1, __s2, __n)); }
static char_type*
assign(char_type* __s, size_t __n, char_type __a)
{ return static_cast<char_type*>(__builtin_memset(__s, __a, __n)); }
static char_type
to_char_type(const int_type& __c)
{ return static_cast<char_type>(__c); }
static int_type
to_int_type(const char_type& __c)
{ return static_cast<int_type>(static_cast<unsigned char>(__c)); }
static bool
eq_int_type(const int_type& __c1, const int_type& __c2)
{ return __c1 == __c2; }
static int_type
eof()
{ return static_cast<int_type>(-1); }
static int_type
not_eof(const int_type& __c)
{ return (__c == eof()) ? 0 : __c; }
};
template<>
struct char_traits<wchar_t>
{
typedef wchar_t char_type;
typedef wint_t int_type;
typedef streamoff off_type;
typedef wstreampos pos_type;
typedef mbstate_t state_type;
static void
assign(char_type& __c1, const char_type& __c2)
{ __c1 = __c2; }
static bool
eq(const char_type& __c1, const char_type& __c2)
{ return __c1 == __c2; }
static bool
lt(const char_type& __c1, const char_type& __c2)
{ return __c1 < __c2; }
static int
compare(const char_type* __s1, const char_type* __s2, size_t __n)
{ return wmemcmp(__s1, __s2, __n); }
static size_t
length(const char_type* __s)
{ return wcslen(__s); }
static const char_type*
find(const char_type* __s, size_t __n, const char_type& __a)
{ return wmemchr(__s, __a, __n); }
static char_type*
move(char_type* __s1, const char_type* __s2, size_t __n)
{ return wmemmove(__s1, __s2, __n); }
static char_type*
copy(char_type* __s1, const char_type* __s2, size_t __n)
{ return wmemcpy(__s1, __s2, __n); }
static char_type*
assign(char_type* __s, size_t __n, char_type __a)
{ return wmemset(__s, __a, __n); }
static char_type
to_char_type(const int_type& __c)
{ return char_type(__c); }
static int_type
to_int_type(const char_type& __c)
{ return int_type(__c); }
static bool
eq_int_type(const int_type& __c1, const int_type& __c2)
{ return __c1 == __c2; }
static int_type
eof()
{ return static_cast<int_type>((0xffffffffu)); }
static int_type
not_eof(const int_type& __c)
{ return eq_int_type(__c, eof()) ? 0 : __c; }
};
}
#41 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ios" 2 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/localefwd.h" 1 3
#39 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/localefwd.h" 3
#39 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/localefwd.h" 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/c++locale.h" 1 3
#40 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/c++locale.h" 3
#40 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/c++locale.h" 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/clocale" 1 3
#41 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/clocale" 3
#41 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/clocale" 3
#1 "/usr/include/locale.h" 1 3 4
#29 "/usr/include/locale.h" 3 4
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/clang/bin/../lib/clang/3.1/include/stddef.h" 1 3 4
#30 "/usr/include/locale.h" 2 3 4
#1 "/usr/include/bits/locale.h" 1 3 4
#31 "/usr/include/locale.h" 2 3 4
extern "C" {
#54 "/usr/include/locale.h" 3 4
struct lconv
{
char *decimal_point;
char *thousands_sep;
char *grouping;
char *int_curr_symbol;
char *currency_symbol;
char *mon_decimal_point;
char *mon_thousands_sep;
char *mon_grouping;
char *positive_sign;
char *negative_sign;
char int_frac_digits;
char frac_digits;
char p_cs_precedes;
char p_sep_by_space;
char n_cs_precedes;
char n_sep_by_space;
char p_sign_posn;
char n_sign_posn;
char int_p_cs_precedes;
char int_p_sep_by_space;
char int_n_cs_precedes;
char int_n_sep_by_space;
char int_p_sign_posn;
char int_n_sign_posn;
#121 "/usr/include/locale.h" 3 4
};
extern char *setlocale (int __category, const char *__locale) throw ();
extern struct lconv *localeconv (void) throw ();
#152 "/usr/include/locale.h" 3 4
extern __locale_t newlocale (int __category_mask, const char *__locale,
__locale_t __base) throw ();
#187 "/usr/include/locale.h" 3 4
extern __locale_t duplocale (__locale_t __dataset) throw ();
extern void freelocale (__locale_t __dataset) throw ();
extern __locale_t uselocale (__locale_t __dataset) throw ();
}
#44 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/clocale" 2 3
namespace std
{
using ::lconv;
using ::setlocale;
using ::localeconv;
}
#42 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/c++locale.h" 2 3
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
extern "C" __typeof(uselocale) __uselocale;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
typedef __locale_t __c_locale;
inline int
__convert_from_v(const __c_locale& __cloc __attribute__ ((__unused__)),
char* __out,
const int __size __attribute__ ((__unused__)),
const char* __fmt, ...)
{
__c_locale __old = __gnu_cxx::__uselocale(__cloc);
#88 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/c++locale.h" 3
__builtin_va_list __args;
__builtin_va_start(__args, __fmt);
const int __ret = __builtin_vsnprintf(__out, __size, __fmt, __args);
__builtin_va_end(__args);
__gnu_cxx::__uselocale(__old);
return __ret;
}
}
#42 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/localefwd.h" 2 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cctype" 1 3
#41 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cctype" 3
#41 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cctype" 3
#1 "/usr/include/ctype.h" 1 3 4
#27 "/usr/include/ctype.h" 3 4
#1 "/usr/include/bits/types.h" 1 3 4
#27 "/usr/include/bits/types.h" 3 4
#1 "/usr/include/bits/wordsize.h" 1 3 4
#28 "/usr/include/bits/types.h" 2 3 4
typedef unsigned char __u_char;
typedef unsigned short int __u_short;
typedef unsigned int __u_int;
typedef unsigned long int __u_long;
typedef signed char __int8_t;
typedef unsigned char __uint8_t;
typedef signed short int __int16_t;
typedef unsigned short int __uint16_t;
typedef signed int __int32_t;
typedef unsigned int __uint32_t;
typedef signed long int __int64_t;
typedef unsigned long int __uint64_t;
typedef long int __quad_t;
typedef unsigned long int __u_quad_t;
#130 "/usr/include/bits/types.h" 3 4
#1 "/usr/include/bits/typesizes.h" 1 3 4
#131 "/usr/include/bits/types.h" 2 3 4
typedef unsigned long int __dev_t;
typedef unsigned int __uid_t;
typedef unsigned int __gid_t;
typedef unsigned long int __ino_t;
typedef unsigned long int __ino64_t;
typedef unsigned int __mode_t;
typedef unsigned long int __nlink_t;
typedef long int __off_t;
typedef long int __off64_t;
typedef int __pid_t;
typedef struct { int __val[2]; } __fsid_t;
typedef long int __clock_t;
typedef unsigned long int __rlim_t;
typedef unsigned long int __rlim64_t;
typedef unsigned int __id_t;
typedef long int __time_t;
typedef unsigned int __useconds_t;
typedef long int __suseconds_t;
typedef int __daddr_t;
typedef int __key_t;
typedef int __clockid_t;
typedef void * __timer_t;
typedef long int __blksize_t;
typedef long int __blkcnt_t;
typedef long int __blkcnt64_t;
typedef unsigned long int __fsblkcnt_t;
typedef unsigned long int __fsblkcnt64_t;
typedef unsigned long int __fsfilcnt_t;
typedef unsigned long int __fsfilcnt64_t;
typedef long int __fsword_t;
typedef long int __ssize_t;
typedef long int __syscall_slong_t;
typedef unsigned long int __syscall_ulong_t;
typedef __off64_t __loff_t;
typedef __quad_t *__qaddr_t;
typedef char *__caddr_t;
typedef long int __intptr_t;
typedef unsigned int __socklen_t;
#28 "/usr/include/ctype.h" 2 3 4
extern "C" {
#40 "/usr/include/ctype.h" 3 4
#1 "/usr/include/endian.h" 1 3 4
#36 "/usr/include/endian.h" 3 4
#1 "/usr/include/bits/endian.h" 1 3 4
#37 "/usr/include/endian.h" 2 3 4
#60 "/usr/include/endian.h" 3 4
#1 "/usr/include/bits/byteswap.h" 1 3 4
#28 "/usr/include/bits/byteswap.h" 3 4
#1 "/usr/include/bits/wordsize.h" 1 3 4
#29 "/usr/include/bits/byteswap.h" 2 3 4
#1 "/usr/include/bits/byteswap-16.h" 1 3 4
#36 "/usr/include/bits/byteswap.h" 2 3 4
#61 "/usr/include/endian.h" 2 3 4
#41 "/usr/include/ctype.h" 2 3 4
enum
{
_ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)),
_ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)),
_ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)),
_ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)),
_ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)),
_ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)),
_ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)),
_ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)),
_ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)),
_IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)),
_ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)),
_ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8))
};
#80 "/usr/include/ctype.h" 3 4
extern const unsigned short int **__ctype_b_loc (void)
throw () __attribute__ ((__const__));
extern const __int32_t **__ctype_tolower_loc (void)
throw () __attribute__ ((__const__));
extern const __int32_t **__ctype_toupper_loc (void)
throw () __attribute__ ((__const__));
#111 "/usr/include/ctype.h" 3 4
extern int isalnum (int) throw ();
extern int isalpha (int) throw ();
extern int iscntrl (int) throw ();
extern int isdigit (int) throw ();
extern int islower (int) throw ();
extern int isgraph (int) throw ();
extern int isprint (int) throw ();
extern int ispunct (int) throw ();
extern int isspace (int) throw ();
extern int isupper (int) throw ();
extern int isxdigit (int) throw ();
extern int tolower (int __c) throw ();
extern int toupper (int __c) throw ();
#137 "/usr/include/ctype.h" 3 4
extern int isblank (int) throw ();
extern int isctype (int __c, int __mask) throw ();
extern int isascii (int __c) throw ();
extern int toascii (int __c) throw ();
extern int _toupper (int) throw ();
extern int _tolower (int) throw ();
#272 "/usr/include/ctype.h" 3 4
extern int isalnum_l (int, __locale_t) throw ();
extern int isalpha_l (int, __locale_t) throw ();
extern int iscntrl_l (int, __locale_t) throw ();
extern int isdigit_l (int, __locale_t) throw ();
extern int islower_l (int, __locale_t) throw ();
extern int isgraph_l (int, __locale_t) throw ();
extern int isprint_l (int, __locale_t) throw ();
extern int ispunct_l (int, __locale_t) throw ();
extern int isspace_l (int, __locale_t) throw ();
extern int isupper_l (int, __locale_t) throw ();
extern int isxdigit_l (int, __locale_t) throw ();
extern int isblank_l (int, __locale_t) throw ();
extern int __tolower_l (int __c, __locale_t __l) throw ();
extern int tolower_l (int __c, __locale_t __l) throw ();
extern int __toupper_l (int __c, __locale_t __l) throw ();
extern int toupper_l (int __c, __locale_t __l) throw ();
#348 "/usr/include/ctype.h" 3 4
}
#44 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cctype" 2 3
#63 "/opt/Xilinx/Vivado/2017.3/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;
}
#44 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/localefwd.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
#56 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/localefwd.h" 3
class locale;
template<typename _Facet>
bool
has_facet(const locale&) throw();
template<typename _Facet>
const _Facet&
use_facet(const locale&);
template<typename _CharT>
bool
isspace(_CharT, const locale&);
template<typename _CharT>
bool
isprint(_CharT, const locale&);
template<typename _CharT>
bool
iscntrl(_CharT, const locale&);
template<typename _CharT>
bool
isupper(_CharT, const locale&);
template<typename _CharT>
bool
islower(_CharT, const locale&);
template<typename _CharT>
bool
isalpha(_CharT, const locale&);
template<typename _CharT>
bool
isdigit(_CharT, const locale&);
template<typename _CharT>
bool
ispunct(_CharT, const locale&);
template<typename _CharT>
bool
isxdigit(_CharT, const locale&);
template<typename _CharT>
bool
isalnum(_CharT, const locale&);
template<typename _CharT>
bool
isgraph(_CharT, const locale&);
template<typename _CharT>
_CharT
toupper(_CharT, const locale&);
template<typename _CharT>
_CharT
tolower(_CharT, const locale&);
class ctype_base;
template<typename _CharT>
class ctype;
template<> class ctype<char>;
template<> class ctype<wchar_t>;
template<typename _CharT>
class ctype_byname;
class codecvt_base;
template<typename _InternT, typename _ExternT, typename _StateT>
class codecvt;
template<> class codecvt<char, char, mbstate_t>;
template<> class codecvt<wchar_t, char, mbstate_t>;
template<typename _InternT, typename _ExternT, typename _StateT>
class codecvt_byname;
template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
class num_get;
template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
class num_put;
template<typename _CharT> class numpunct;
template<typename _CharT> class numpunct_byname;
template<typename _CharT>
class collate;
template<typename _CharT> class
collate_byname;
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;
class money_base;
template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
class money_get;
template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
class money_put;
template<typename _CharT, bool _Intl = false>
class moneypunct;
template<typename _CharT, bool _Intl = false>
class moneypunct_byname;
class messages_base;
template<typename _CharT>
class messages;
template<typename _CharT>
class messages_byname;
}
#42 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ios" 2 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/ios_base.h" 1 3
#39 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/ios_base.h" 3
#39 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/ios_base.h" 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ext/atomicity.h" 1 3
#34 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ext/atomicity.h" 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/gthr.h" 1 3
#30 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/gthr.h" 3
#pragma GCC visibility push(default)
#170 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/gthr.h" 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/gthr-default.h" 1 3
#41 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/gthr-default.h" 3
#1 "/usr/include/pthread.h" 1 3 4
#23 "/usr/include/pthread.h" 3 4
#1 "/usr/include/sched.h" 1 3 4
#29 "/usr/include/sched.h" 3 4
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/clang/bin/../lib/clang/3.1/include/stddef.h" 1 3 4
#30 "/usr/include/sched.h" 2 3 4
#1 "/usr/include/time.h" 1 3 4
#75 "/usr/include/time.h" 3 4
typedef __time_t time_t;
#120 "/usr/include/time.h" 3 4
struct timespec
{
__time_t tv_sec;
__syscall_slong_t tv_nsec;
};
#34 "/usr/include/sched.h" 2 3 4
typedef __pid_t pid_t;
#1 "/usr/include/bits/sched.h" 1 3 4
#73 "/usr/include/bits/sched.h" 3 4
struct sched_param
{
int __sched_priority;
};
extern "C" {
extern int clone (int (*__fn) (void *__arg), void *__child_stack,
int __flags, void *__arg, ...) throw ();
extern int unshare (int __flags) throw ();
extern int sched_getcpu (void) throw ();
extern int setns (int __fd, int __nstype) throw ();
}
struct __sched_param
{
int __sched_priority;
};
#119 "/usr/include/bits/sched.h" 3 4
typedef unsigned long int __cpu_mask;
typedef struct
{
__cpu_mask __bits[1024 / (8 * sizeof (__cpu_mask))];
} cpu_set_t;
#202 "/usr/include/bits/sched.h" 3 4
extern "C" {
extern int __sched_cpucount (size_t __setsize, const cpu_set_t *__setp)
throw ();
extern cpu_set_t *__sched_cpualloc (size_t __count) throw () ;
extern void __sched_cpufree (cpu_set_t *__set) throw ();
}
#43 "/usr/include/sched.h" 2 3 4
extern "C" {
extern int sched_setparam (__pid_t __pid, const struct sched_param *__param)
throw ();
extern int sched_getparam (__pid_t __pid, struct sched_param *__param) throw ();
extern int sched_setscheduler (__pid_t __pid, int __policy,
const struct sched_param *__param) throw ();
extern int sched_getscheduler (__pid_t __pid) throw ();
extern int sched_yield (void) throw ();
extern int sched_get_priority_max (int __algorithm) throw ();
extern int sched_get_priority_min (int __algorithm) throw ();
extern int sched_rr_get_interval (__pid_t __pid, struct timespec *__t) throw ();
#117 "/usr/include/sched.h" 3 4
extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize,
const cpu_set_t *__cpuset) throw ();
extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize,
cpu_set_t *__cpuset) throw ();
}
#24 "/usr/include/pthread.h" 2 3 4
#1 "/usr/include/time.h" 1 3 4
#29 "/usr/include/time.h" 3 4
extern "C" {
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/clang/bin/../lib/clang/3.1/include/stddef.h" 1 3 4
#38 "/usr/include/time.h" 2 3 4
#1 "/usr/include/bits/time.h" 1 3 4
#30 "/usr/include/bits/time.h" 3 4
struct timeval
{
__time_t tv_sec;
__suseconds_t tv_usec;
};
#86 "/usr/include/bits/time.h" 3 4
#1 "/usr/include/bits/timex.h" 1 3 4
#25 "/usr/include/bits/timex.h" 3 4
struct timex
{
unsigned int modes;
__syscall_slong_t offset;
__syscall_slong_t freq;
__syscall_slong_t maxerror;
__syscall_slong_t esterror;
int status;
__syscall_slong_t constant;
__syscall_slong_t precision;
__syscall_slong_t tolerance;
struct timeval time;
__syscall_slong_t tick;
__syscall_slong_t ppsfreq;
__syscall_slong_t jitter;
int shift;
__syscall_slong_t stabil;
__syscall_slong_t jitcnt;
__syscall_slong_t calcnt;
__syscall_slong_t errcnt;
__syscall_slong_t stbcnt;
int tai;
int :32; int :32; int :32; int :32;
int :32; int :32; int :32; int :32;
int :32; int :32; int :32;
};
#87 "/usr/include/bits/time.h" 2 3 4
extern "C" {
extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) throw ();
}
#42 "/usr/include/time.h" 2 3 4
#59 "/usr/include/time.h" 3 4
typedef __clock_t clock_t;
#91 "/usr/include/time.h" 3 4
typedef __clockid_t clockid_t;
#103 "/usr/include/time.h" 3 4
typedef __timer_t timer_t;
#133 "/usr/include/time.h" 3 4
struct tm
{
int tm_sec;
int tm_min;
int tm_hour;
int tm_mday;
int tm_mon;
int tm_year;
int tm_wday;
int tm_yday;
int tm_isdst;
long int tm_gmtoff;
const char *tm_zone;
};
#161 "/usr/include/time.h" 3 4
struct itimerspec
{
struct timespec it_interval;
struct timespec it_value;
};
struct sigevent;
#189 "/usr/include/time.h" 3 4
extern clock_t clock (void) throw ();
extern time_t time (time_t *__timer) throw ();
extern double difftime (time_t __time1, time_t __time0)
throw () __attribute__ ((__const__));
extern time_t mktime (struct tm *__tp) throw ();
extern size_t strftime (char *__restrict __s, size_t __maxsize,
const char *__restrict __format,
const struct tm *__restrict __tp) throw ();
extern char *strptime (const char *__restrict __s,
const char *__restrict __fmt, struct tm *__tp)
throw ();
extern size_t strftime_l (char *__restrict __s, size_t __maxsize,
const char *__restrict __format,
const struct tm *__restrict __tp,
__locale_t __loc) throw ();
extern char *strptime_l (const char *__restrict __s,
const char *__restrict __fmt, struct tm *__tp,
__locale_t __loc) throw ();
extern struct tm *gmtime (const time_t *__timer) throw ();
extern struct tm *localtime (const time_t *__timer) throw ();
extern struct tm *gmtime_r (const time_t *__restrict __timer,
struct tm *__restrict __tp) throw ();
extern struct tm *localtime_r (const time_t *__restrict __timer,
struct tm *__restrict __tp) throw ();
extern char *asctime (const struct tm *__tp) throw ();
extern char *ctime (const time_t *__timer) throw ();
extern char *asctime_r (const struct tm *__restrict __tp,
char *__restrict __buf) throw ();
extern char *ctime_r (const time_t *__restrict __timer,
char *__restrict __buf) throw ();
extern char *__tzname[2];
extern int __daylight;
extern long int __timezone;
extern char *tzname[2];
extern void tzset (void) throw ();
extern int daylight;
extern long int timezone;
extern int stime (const time_t *__when) throw ();
#319 "/usr/include/time.h" 3 4
extern time_t timegm (struct tm *__tp) throw ();
extern time_t timelocal (struct tm *__tp) throw ();
extern int dysize (int __year) throw () __attribute__ ((__const__));
#334 "/usr/include/time.h" 3 4
extern int nanosleep (const struct timespec *__requested_time,
struct timespec *__remaining);
extern int clock_getres (clockid_t __clock_id, struct timespec *__res) throw ();
extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) throw ();
extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp)
throw ();
extern int clock_nanosleep (clockid_t __clock_id, int __flags,
const struct timespec *__req,
struct timespec *__rem);
extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) throw ();
extern int timer_create (clockid_t __clock_id,
struct sigevent *__restrict __evp,
timer_t *__restrict __timerid) throw ();
extern int timer_delete (timer_t __timerid) throw ();
extern int timer_settime (timer_t __timerid, int __flags,
const struct itimerspec *__restrict __value,
struct itimerspec *__restrict __ovalue) throw ();
extern int timer_gettime (timer_t __timerid, struct itimerspec *__value)
throw ();
extern int timer_getoverrun (timer_t __timerid) throw ();
extern int timespec_get (struct timespec *__ts, int __base)
throw () __attribute__ ((__nonnull__ (1)));
#403 "/usr/include/time.h" 3 4
extern int getdate_err;
#412 "/usr/include/time.h" 3 4
extern struct tm *getdate (const char *__string);
#426 "/usr/include/time.h" 3 4
extern int getdate_r (const char *__restrict __string,
struct tm *__restrict __resbufp);
}
#25 "/usr/include/pthread.h" 2 3 4
#1 "/usr/include/bits/pthreadtypes.h" 1 3 4
#21 "/usr/include/bits/pthreadtypes.h" 3 4
#1 "/usr/include/bits/wordsize.h" 1 3 4
#22 "/usr/include/bits/pthreadtypes.h" 2 3 4
#60 "/usr/include/bits/pthreadtypes.h" 3 4
typedef unsigned long int pthread_t;
union pthread_attr_t
{
char __size[56];
long int __align;
};
typedef union pthread_attr_t pthread_attr_t;
typedef struct __pthread_internal_list
{
struct __pthread_internal_list *__prev;
struct __pthread_internal_list *__next;
} __pthread_list_t;
#90 "/usr/include/bits/pthreadtypes.h" 3 4
typedef union
{
struct __pthread_mutex_s
{
int __lock;
unsigned int __count;
int __owner;
unsigned int __nusers;
int __kind;
short __spins;
short __elision;
__pthread_list_t __list;
#124 "/usr/include/bits/pthreadtypes.h" 3 4
} __data;
char __size[40];
long int __align;
} pthread_mutex_t;
typedef union
{
char __size[4];
int __align;
} pthread_mutexattr_t;
typedef union
{
struct
{
int __lock;
unsigned int __futex;
__extension__ unsigned long long int __total_seq;
__extension__ unsigned long long int __wakeup_seq;
__extension__ unsigned long long int __woken_seq;
void *__mutex;
unsigned int __nwaiters;
unsigned int __broadcast_seq;
} __data;
char __size[48];
__extension__ long long int __align;
} pthread_cond_t;
typedef union
{
char __size[4];
int __align;
} pthread_condattr_t;
typedef unsigned int pthread_key_t;
typedef int pthread_once_t;
typedef union
{
struct
{
int __lock;
unsigned int __nr_readers;
unsigned int __readers_wakeup;
unsigned int __writer_wakeup;
unsigned int __nr_readers_queued;
unsigned int __nr_writers_queued;
int __writer;
int __shared;
unsigned long int __pad1;
unsigned long int __pad2;
unsigned int __flags;
} __data;
#211 "/usr/include/bits/pthreadtypes.h" 3 4
char __size[56];
long int __align;
} pthread_rwlock_t;
typedef union
{
char __size[8];
long int __align;
} pthread_rwlockattr_t;
typedef volatile int pthread_spinlock_t;
typedef union
{
char __size[32];
long int __align;
} pthread_barrier_t;
typedef union
{
char __size[4];
int __align;
} pthread_barrierattr_t;
#27 "/usr/include/pthread.h" 2 3 4
#1 "/usr/include/bits/setjmp.h" 1 3 4
#26 "/usr/include/bits/setjmp.h" 3 4
#1 "/usr/include/bits/wordsize.h" 1 3 4
#27 "/usr/include/bits/setjmp.h" 2 3 4
typedef long int __jmp_buf[8];
#28 "/usr/include/pthread.h" 2 3 4
#1 "/usr/include/bits/wordsize.h" 1 3 4
#29 "/usr/include/pthread.h" 2 3 4
enum
{
PTHREAD_CREATE_JOINABLE,
PTHREAD_CREATE_DETACHED
};
enum
{
PTHREAD_MUTEX_TIMED_NP,
PTHREAD_MUTEX_RECURSIVE_NP,
PTHREAD_MUTEX_ERRORCHECK_NP,
PTHREAD_MUTEX_ADAPTIVE_NP
,
PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_TIMED_NP,
PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP,
PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP,
PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL
, PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_TIMED_NP
};
enum
{
PTHREAD_MUTEX_STALLED,
PTHREAD_MUTEX_STALLED_NP = PTHREAD_MUTEX_STALLED,
PTHREAD_MUTEX_ROBUST,
PTHREAD_MUTEX_ROBUST_NP = PTHREAD_MUTEX_ROBUST
};
enum
{
PTHREAD_PRIO_NONE,
PTHREAD_PRIO_INHERIT,
PTHREAD_PRIO_PROTECT
};
#125 "/usr/include/pthread.h" 3 4
enum
{
PTHREAD_RWLOCK_PREFER_READER_NP,
PTHREAD_RWLOCK_PREFER_WRITER_NP,
PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP,
PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_READER_NP
};
#166 "/usr/include/pthread.h" 3 4
enum
{
PTHREAD_INHERIT_SCHED,
PTHREAD_EXPLICIT_SCHED
};
enum
{
PTHREAD_SCOPE_SYSTEM,
PTHREAD_SCOPE_PROCESS
};
enum
{
PTHREAD_PROCESS_PRIVATE,
PTHREAD_PROCESS_SHARED
};
#201 "/usr/include/pthread.h" 3 4
struct _pthread_cleanup_buffer
{
void (*__routine) (void *);
void *__arg;
int __canceltype;
struct _pthread_cleanup_buffer *__prev;
};
enum
{
PTHREAD_CANCEL_ENABLE,
PTHREAD_CANCEL_DISABLE
};
enum
{
PTHREAD_CANCEL_DEFERRED,
PTHREAD_CANCEL_ASYNCHRONOUS
};
#239 "/usr/include/pthread.h" 3 4
extern "C" {
extern int pthread_create (pthread_t *__restrict __newthread,
const pthread_attr_t *__restrict __attr,
void *(*__start_routine) (void *),
void *__restrict __arg) throw () __attribute__ ((__nonnull__ (1, 3)));
extern void pthread_exit (void *__retval) __attribute__ ((__noreturn__));
extern int pthread_join (pthread_t __th, void **__thread_return);
extern int pthread_tryjoin_np (pthread_t __th, void **__thread_return) throw ();
extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return,
const struct timespec *__abstime);
extern int pthread_detach (pthread_t __th) throw ();
extern pthread_t pthread_self (void) throw () __attribute__ ((__const__));
extern int pthread_equal (pthread_t __thread1, pthread_t __thread2)
throw () __attribute__ ((__const__));
extern int pthread_attr_init (pthread_attr_t *__attr) throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_destroy (pthread_attr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_getdetachstate (const pthread_attr_t *__attr,
int *__detachstate)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_attr_setdetachstate (pthread_attr_t *__attr,
int __detachstate)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_getguardsize (const pthread_attr_t *__attr,
size_t *__guardsize)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_attr_setguardsize (pthread_attr_t *__attr,
size_t __guardsize)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict __attr,
struct sched_param *__restrict __param)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr,
const struct sched_param *__restrict
__param) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_attr_getschedpolicy (const pthread_attr_t *__restrict
__attr, int *__restrict __policy)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_getinheritsched (const pthread_attr_t *__restrict
__attr, int *__restrict __inherit)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_attr_setinheritsched (pthread_attr_t *__attr,
int __inherit)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_getscope (const pthread_attr_t *__restrict __attr,
int *__restrict __scope)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_getstackaddr (const pthread_attr_t *__restrict
__attr, void **__restrict __stackaddr)
throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__deprecated__));
extern int pthread_attr_setstackaddr (pthread_attr_t *__attr,
void *__stackaddr)
throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__));
extern int pthread_attr_getstacksize (const pthread_attr_t *__restrict
__attr, size_t *__restrict __stacksize)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_attr_setstacksize (pthread_attr_t *__attr,
size_t __stacksize)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_getstack (const pthread_attr_t *__restrict __attr,
void **__restrict __stackaddr,
size_t *__restrict __stacksize)
throw () __attribute__ ((__nonnull__ (1, 2, 3)));
extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr,
size_t __stacksize) throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_setaffinity_np (pthread_attr_t *__attr,
size_t __cpusetsize,
const cpu_set_t *__cpuset)
throw () __attribute__ ((__nonnull__ (1, 3)));
extern int pthread_attr_getaffinity_np (const pthread_attr_t *__attr,
size_t __cpusetsize,
cpu_set_t *__cpuset)
throw () __attribute__ ((__nonnull__ (1, 3)));
extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr)
throw () __attribute__ ((__nonnull__ (2)));
extern int pthread_setschedparam (pthread_t __target_thread, int __policy,
const struct sched_param *__param)
throw () __attribute__ ((__nonnull__ (3)));
extern int pthread_getschedparam (pthread_t __target_thread,
int *__restrict __policy,
struct sched_param *__restrict __param)
throw () __attribute__ ((__nonnull__ (2, 3)));
extern int pthread_setschedprio (pthread_t __target_thread, int __prio)
throw ();
extern int pthread_getname_np (pthread_t __target_thread, char *__buf,
size_t __buflen)
throw () __attribute__ ((__nonnull__ (2)));
extern int pthread_setname_np (pthread_t __target_thread, const char *__name)
throw () __attribute__ ((__nonnull__ (2)));
extern int pthread_getconcurrency (void) throw ();
extern int pthread_setconcurrency (int __level) throw ();
extern int pthread_yield (void) throw ();
extern int pthread_setaffinity_np (pthread_t __th, size_t __cpusetsize,
const cpu_set_t *__cpuset)
throw () __attribute__ ((__nonnull__ (3)));
extern int pthread_getaffinity_np (pthread_t __th, size_t __cpusetsize,
cpu_set_t *__cpuset)
throw () __attribute__ ((__nonnull__ (3)));
#497 "/usr/include/pthread.h" 3 4
extern int pthread_once (pthread_once_t *__once_control,
void (*__init_routine) (void)) __attribute__ ((__nonnull__ (1, 2)));
#509 "/usr/include/pthread.h" 3 4
extern int pthread_setcancelstate (int __state, int *__oldstate);
extern int pthread_setcanceltype (int __type, int *__oldtype);
extern int pthread_cancel (pthread_t __th);
extern void pthread_testcancel (void);
typedef struct
{
struct
{
__jmp_buf __cancel_jmp_buf;
int __mask_was_saved;
} __cancel_jmp_buf[1];
void *__pad[4];
} __pthread_unwind_buf_t __attribute__ ((__aligned__));
#543 "/usr/include/pthread.h" 3 4
struct __pthread_cleanup_frame
{
void (*__cancel_routine) (void *);
void *__cancel_arg;
int __do_it;
int __cancel_type;
};
#683 "/usr/include/pthread.h" 3 4
extern void __pthread_register_cancel (__pthread_unwind_buf_t *__buf)
;
#695 "/usr/include/pthread.h" 3 4
extern void __pthread_unregister_cancel (__pthread_unwind_buf_t *__buf)
;
#718 "/usr/include/pthread.h" 3 4
extern void __pthread_register_cancel_defer (__pthread_unwind_buf_t *__buf)
;
#731 "/usr/include/pthread.h" 3 4
extern void __pthread_unregister_cancel_restore (__pthread_unwind_buf_t *__buf)
;
extern void __pthread_unwind_next (__pthread_unwind_buf_t *__buf)
__attribute__ ((__noreturn__))
__attribute__ ((__weak__))
;
struct __jmp_buf_tag;
extern int __sigsetjmp (struct __jmp_buf_tag *__env, int __savemask) throw ();
extern int pthread_mutex_init (pthread_mutex_t *__mutex,
const pthread_mutexattr_t *__mutexattr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutex_destroy (pthread_mutex_t *__mutex)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutex_trylock (pthread_mutex_t *__mutex)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutex_lock (pthread_mutex_t *__mutex)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex,
const struct timespec *__restrict
__abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_mutex_unlock (pthread_mutex_t *__mutex)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutex_getprioceiling (const pthread_mutex_t *
__restrict __mutex,
int *__restrict __prioceiling)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex,
int __prioceiling,
int *__restrict __old_ceiling)
throw () __attribute__ ((__nonnull__ (1, 3)));
extern int pthread_mutex_consistent (pthread_mutex_t *__mutex)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutex_consistent_np (pthread_mutex_t *__mutex)
throw () __attribute__ ((__nonnull__ (1)));
#809 "/usr/include/pthread.h" 3 4
extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutexattr_getpshared (const pthread_mutexattr_t *
__restrict __attr,
int *__restrict __pshared)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr,
int __pshared)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutexattr_gettype (const pthread_mutexattr_t *__restrict
__attr, int *__restrict __kind)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutexattr_getprotocol (const pthread_mutexattr_t *
__restrict __attr,
int *__restrict __protocol)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_mutexattr_setprotocol (pthread_mutexattr_t *__attr,
int __protocol)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutexattr_getprioceiling (const pthread_mutexattr_t *
__restrict __attr,
int *__restrict __prioceiling)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_mutexattr_setprioceiling (pthread_mutexattr_t *__attr,
int __prioceiling)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutexattr_getrobust (const pthread_mutexattr_t *__attr,
int *__robustness)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_mutexattr_getrobust_np (const pthread_mutexattr_t *__attr,
int *__robustness)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_mutexattr_setrobust (pthread_mutexattr_t *__attr,
int __robustness)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutexattr_setrobust_np (pthread_mutexattr_t *__attr,
int __robustness)
throw () __attribute__ ((__nonnull__ (1)));
#891 "/usr/include/pthread.h" 3 4
extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock,
const pthread_rwlockattr_t *__restrict
__attr) throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock,
const struct timespec *__restrict
__abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock,
const struct timespec *__restrict
__abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *
__restrict __attr,
int *__restrict __pshared)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr,
int __pshared)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t *
__restrict __attr,
int *__restrict __pref)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr,
int __pref) throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_cond_init (pthread_cond_t *__restrict __cond,
const pthread_condattr_t *__restrict __cond_attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_cond_destroy (pthread_cond_t *__cond)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_cond_signal (pthread_cond_t *__cond)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_cond_broadcast (pthread_cond_t *__cond)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_cond_wait (pthread_cond_t *__restrict __cond,
pthread_mutex_t *__restrict __mutex)
__attribute__ ((__nonnull__ (1, 2)));
#1003 "/usr/include/pthread.h" 3 4
extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond,
pthread_mutex_t *__restrict __mutex,
const struct timespec *__restrict __abstime)
__attribute__ ((__nonnull__ (1, 2, 3)));
extern int pthread_condattr_init (pthread_condattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_condattr_destroy (pthread_condattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_condattr_getpshared (const pthread_condattr_t *
__restrict __attr,
int *__restrict __pshared)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_condattr_setpshared (pthread_condattr_t *__attr,
int __pshared) throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_condattr_getclock (const pthread_condattr_t *
__restrict __attr,
__clockid_t *__restrict __clock_id)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_condattr_setclock (pthread_condattr_t *__attr,
__clockid_t __clock_id)
throw () __attribute__ ((__nonnull__ (1)));
#1047 "/usr/include/pthread.h" 3 4
extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_spin_destroy (pthread_spinlock_t *__lock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_spin_lock (pthread_spinlock_t *__lock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_spin_trylock (pthread_spinlock_t *__lock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_spin_unlock (pthread_spinlock_t *__lock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier,
const pthread_barrierattr_t *__restrict
__attr, unsigned int __count)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_barrier_destroy (pthread_barrier_t *__barrier)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_barrier_wait (pthread_barrier_t *__barrier)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t *
__restrict __attr,
int *__restrict __pshared)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr,
int __pshared)
throw () __attribute__ ((__nonnull__ (1)));
#1114 "/usr/include/pthread.h" 3 4
extern int pthread_key_create (pthread_key_t *__key,
void (*__destr_function) (void *))
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_key_delete (pthread_key_t __key) throw ();
extern void *pthread_getspecific (pthread_key_t __key) throw ();
extern int pthread_setspecific (pthread_key_t __key,
const void *__pointer) throw () ;
extern int pthread_getcpuclockid (pthread_t __thread_id,
__clockid_t *__clock_id)
throw () __attribute__ ((__nonnull__ (2)));
#1148 "/usr/include/pthread.h" 3 4
extern int pthread_atfork (void (*__prepare) (void),
void (*__parent) (void),
void (*__child) (void)) throw ();
#1162 "/usr/include/pthread.h" 3 4
}
#42 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/gthr-default.h" 2 3
#1 "/usr/include/unistd.h" 1 3 4
#27 "/usr/include/unistd.h" 3 4
extern "C" {
#202 "/usr/include/unistd.h" 3 4
#1 "/usr/include/bits/posix_opt.h" 1 3 4
#203 "/usr/include/unistd.h" 2 3 4
#1 "/usr/include/bits/environments.h" 1 3 4
#22 "/usr/include/bits/environments.h" 3 4
#1 "/usr/include/bits/wordsize.h" 1 3 4
#23 "/usr/include/bits/environments.h" 2 3 4
#207 "/usr/include/unistd.h" 2 3 4
#220 "/usr/include/unistd.h" 3 4
typedef __ssize_t ssize_t;
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/clang/bin/../lib/clang/3.1/include/stddef.h" 1 3 4
#227 "/usr/include/unistd.h" 2 3 4
typedef __gid_t gid_t;
typedef __uid_t uid_t;
typedef __off_t off_t;
typedef __off64_t off64_t;
typedef __useconds_t useconds_t;
#267 "/usr/include/unistd.h" 3 4
typedef __intptr_t intptr_t;
typedef __socklen_t socklen_t;
#287 "/usr/include/unistd.h" 3 4
extern int access (const char *__name, int __type) throw () __attribute__ ((__nonnull__ (1)));
extern int euidaccess (const char *__name, int __type)
throw () __attribute__ ((__nonnull__ (1)));
extern int eaccess (const char *__name, int __type)
throw () __attribute__ ((__nonnull__ (1)));
extern int faccessat (int __fd, const char *__file, int __type, int __flag)
throw () __attribute__ ((__nonnull__ (2))) ;
#334 "/usr/include/unistd.h" 3 4
extern __off_t lseek (int __fd, __off_t __offset, int __whence) throw ();
#345 "/usr/include/unistd.h" 3 4
extern __off64_t lseek64 (int __fd, __off64_t __offset, int __whence)
throw ();
extern int close (int __fd);
extern ssize_t read (int __fd, void *__buf, size_t __nbytes) ;
extern ssize_t write (int __fd, const void *__buf, size_t __n) ;
#376 "/usr/include/unistd.h" 3 4
extern ssize_t pread (int __fd, void *__buf, size_t __nbytes,
__off_t __offset) ;
extern ssize_t pwrite (int __fd, const void *__buf, size_t __n,
__off_t __offset) ;
#404 "/usr/include/unistd.h" 3 4
extern ssize_t pread64 (int __fd, void *__buf, size_t __nbytes,
__off64_t __offset) ;
extern ssize_t pwrite64 (int __fd, const void *__buf, size_t __n,
__off64_t __offset) ;
extern int pipe (int __pipedes[2]) throw () ;
extern int pipe2 (int __pipedes[2], int __flags) throw () ;
#432 "/usr/include/unistd.h" 3 4
extern unsigned int alarm (unsigned int __seconds) throw ();
#444 "/usr/include/unistd.h" 3 4
extern unsigned int sleep (unsigned int __seconds);
extern __useconds_t ualarm (__useconds_t __value, __useconds_t __interval)
throw ();
extern int usleep (__useconds_t __useconds);
#469 "/usr/include/unistd.h" 3 4
extern int pause (void);
extern int chown (const char *__file, __uid_t __owner, __gid_t __group)
throw () __attribute__ ((__nonnull__ (1))) ;
extern int fchown (int __fd, __uid_t __owner, __gid_t __group) throw () ;
extern int lchown (const char *__file, __uid_t __owner, __gid_t __group)
throw () __attribute__ ((__nonnull__ (1))) ;
extern int fchownat (int __fd, const char *__file, __uid_t __owner,
__gid_t __group, int __flag)
throw () __attribute__ ((__nonnull__ (2))) ;
extern int chdir (const char *__path) throw () __attribute__ ((__nonnull__ (1))) ;
extern int fchdir (int __fd) throw () ;
#511 "/usr/include/unistd.h" 3 4
extern char *getcwd (char *__buf, size_t __size) throw () ;
extern char *get_current_dir_name (void) throw ();
extern char *getwd (char *__buf)
throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__)) ;
extern int dup (int __fd) throw () ;
extern int dup2 (int __fd, int __fd2) throw ();
extern int dup3 (int __fd, int __fd2, int __flags) throw ();
extern char **__environ;
extern char **environ;
extern int execve (const char *__path, char *const __argv[],
char *const __envp[]) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int fexecve (int __fd, char *const __argv[], char *const __envp[])
throw () __attribute__ ((__nonnull__ (2)));
extern int execv (const char *__path, char *const __argv[])
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int execle (const char *__path, const char *__arg, ...)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int execl (const char *__path, const char *__arg, ...)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int execvp (const char *__file, char *const __argv[])
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int execlp (const char *__file, const char *__arg, ...)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int execvpe (const char *__file, char *const __argv[],
char *const __envp[])
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int nice (int __inc) throw () ;
extern void _exit (int __status) __attribute__ ((__noreturn__));
#1 "/usr/include/bits/confname.h" 1 3 4
#25 "/usr/include/bits/confname.h" 3 4
enum
{
_PC_LINK_MAX,
_PC_MAX_CANON,
_PC_MAX_INPUT,
_PC_NAME_MAX,
_PC_PATH_MAX,
_PC_PIPE_BUF,
_PC_CHOWN_RESTRICTED,
_PC_NO_TRUNC,
_PC_VDISABLE,
_PC_SYNC_IO,
_PC_ASYNC_IO,
_PC_PRIO_IO,
_PC_SOCK_MAXBUF,
_PC_FILESIZEBITS,
_PC_REC_INCR_XFER_SIZE,
_PC_REC_MAX_XFER_SIZE,
_PC_REC_MIN_XFER_SIZE,
_PC_REC_XFER_ALIGN,
_PC_ALLOC_SIZE_MIN,
_PC_SYMLINK_MAX,
_PC_2_SYMLINKS
};
enum
{
_SC_ARG_MAX,
_SC_CHILD_MAX,
_SC_CLK_TCK,
_SC_NGROUPS_MAX,
_SC_OPEN_MAX,
_SC_STREAM_MAX,
_SC_TZNAME_MAX,
_SC_JOB_CONTROL,
_SC_SAVED_IDS,
_SC_REALTIME_SIGNALS,
_SC_PRIORITY_SCHEDULING,
_SC_TIMERS,
_SC_ASYNCHRONOUS_IO,
_SC_PRIORITIZED_IO,
_SC_SYNCHRONIZED_IO,
_SC_FSYNC,
_SC_MAPPED_FILES,
_SC_MEMLOCK,
_SC_MEMLOCK_RANGE,
_SC_MEMORY_PROTECTION,
_SC_MESSAGE_PASSING,
_SC_SEMAPHORES,
_SC_SHARED_MEMORY_OBJECTS,
_SC_AIO_LISTIO_MAX,
_SC_AIO_MAX,
_SC_AIO_PRIO_DELTA_MAX,
_SC_DELAYTIMER_MAX,
_SC_MQ_OPEN_MAX,
_SC_MQ_PRIO_MAX,
_SC_VERSION,
_SC_PAGESIZE,
_SC_RTSIG_MAX,
_SC_SEM_NSEMS_MAX,
_SC_SEM_VALUE_MAX,
_SC_SIGQUEUE_MAX,
_SC_TIMER_MAX,
_SC_BC_BASE_MAX,
_SC_BC_DIM_MAX,
_SC_BC_SCALE_MAX,
_SC_BC_STRING_MAX,
_SC_COLL_WEIGHTS_MAX,
_SC_EQUIV_CLASS_MAX,
_SC_EXPR_NEST_MAX,
_SC_LINE_MAX,
_SC_RE_DUP_MAX,
_SC_CHARCLASS_NAME_MAX,
_SC_2_VERSION,
_SC_2_C_BIND,
_SC_2_C_DEV,
_SC_2_FORT_DEV,
_SC_2_FORT_RUN,
_SC_2_SW_DEV,
_SC_2_LOCALEDEF,
_SC_PII,
_SC_PII_XTI,
_SC_PII_SOCKET,
_SC_PII_INTERNET,
_SC_PII_OSI,
_SC_POLL,
_SC_SELECT,
_SC_UIO_MAXIOV,
_SC_IOV_MAX = _SC_UIO_MAXIOV,
_SC_PII_INTERNET_STREAM,
_SC_PII_INTERNET_DGRAM,
_SC_PII_OSI_COTS,
_SC_PII_OSI_CLTS,
_SC_PII_OSI_M,
_SC_T_IOV_MAX,
_SC_THREADS,
_SC_THREAD_SAFE_FUNCTIONS,
_SC_GETGR_R_SIZE_MAX,
_SC_GETPW_R_SIZE_MAX,
_SC_LOGIN_NAME_MAX,
_SC_TTY_NAME_MAX,
_SC_THREAD_DESTRUCTOR_ITERATIONS,
_SC_THREAD_KEYS_MAX,
_SC_THREAD_STACK_MIN,
_SC_THREAD_THREADS_MAX,
_SC_THREAD_ATTR_STACKADDR,
_SC_THREAD_ATTR_STACKSIZE,
_SC_THREAD_PRIORITY_SCHEDULING,
_SC_THREAD_PRIO_INHERIT,
_SC_THREAD_PRIO_PROTECT,
_SC_THREAD_PROCESS_SHARED,
_SC_NPROCESSORS_CONF,
_SC_NPROCESSORS_ONLN,
_SC_PHYS_PAGES,
_SC_AVPHYS_PAGES,
_SC_ATEXIT_MAX,
_SC_PASS_MAX,
_SC_XOPEN_VERSION,
_SC_XOPEN_XCU_VERSION,
_SC_XOPEN_UNIX,
_SC_XOPEN_CRYPT,
_SC_XOPEN_ENH_I18N,
_SC_XOPEN_SHM,
_SC_2_CHAR_TERM,
_SC_2_C_VERSION,
_SC_2_UPE,
_SC_XOPEN_XPG2,
_SC_XOPEN_XPG3,
_SC_XOPEN_XPG4,
_SC_CHAR_BIT,
_SC_CHAR_MAX,
_SC_CHAR_MIN,
_SC_INT_MAX,
_SC_INT_MIN,
_SC_LONG_BIT,
_SC_WORD_BIT,
_SC_MB_LEN_MAX,
_SC_NZERO,
_SC_SSIZE_MAX,
_SC_SCHAR_MAX,
_SC_SCHAR_MIN,
_SC_SHRT_MAX,
_SC_SHRT_MIN,
_SC_UCHAR_MAX,
_SC_UINT_MAX,
_SC_ULONG_MAX,
_SC_USHRT_MAX,
_SC_NL_ARGMAX,
_SC_NL_LANGMAX,
_SC_NL_MSGMAX,
_SC_NL_NMAX,
_SC_NL_SETMAX,
_SC_NL_TEXTMAX,
_SC_XBS5_ILP32_OFF32,
_SC_XBS5_ILP32_OFFBIG,
_SC_XBS5_LP64_OFF64,
_SC_XBS5_LPBIG_OFFBIG,
_SC_XOPEN_LEGACY,
_SC_XOPEN_REALTIME,
_SC_XOPEN_REALTIME_THREADS,
_SC_ADVISORY_INFO,
_SC_BARRIERS,
_SC_BASE,
_SC_C_LANG_SUPPORT,
_SC_C_LANG_SUPPORT_R,
_SC_CLOCK_SELECTION,
_SC_CPUTIME,
_SC_THREAD_CPUTIME,
_SC_DEVICE_IO,
_SC_DEVICE_SPECIFIC,
_SC_DEVICE_SPECIFIC_R,
_SC_FD_MGMT,
_SC_FIFO,
_SC_PIPE,
_SC_FILE_ATTRIBUTES,
_SC_FILE_LOCKING,
_SC_FILE_SYSTEM,
_SC_MONOTONIC_CLOCK,
_SC_MULTI_PROCESS,
_SC_SINGLE_PROCESS,
_SC_NETWORKING,
_SC_READER_WRITER_LOCKS,
_SC_SPIN_LOCKS,
_SC_REGEXP,
_SC_REGEX_VERSION,
_SC_SHELL,
_SC_SIGNALS,
_SC_SPAWN,
_SC_SPORADIC_SERVER,
_SC_THREAD_SPORADIC_SERVER,
_SC_SYSTEM_DATABASE,
_SC_SYSTEM_DATABASE_R,
_SC_TIMEOUTS,
_SC_TYPED_MEMORY_OBJECTS,
_SC_USER_GROUPS,
_SC_USER_GROUPS_R,
_SC_2_PBS,
_SC_2_PBS_ACCOUNTING,
_SC_2_PBS_LOCATE,
_SC_2_PBS_MESSAGE,
_SC_2_PBS_TRACK,
_SC_SYMLOOP_MAX,
_SC_STREAMS,
_SC_2_PBS_CHECKPOINT,
_SC_V6_ILP32_OFF32,
_SC_V6_ILP32_OFFBIG,
_SC_V6_LP64_OFF64,
_SC_V6_LPBIG_OFFBIG,
_SC_HOST_NAME_MAX,
_SC_TRACE,
_SC_TRACE_EVENT_FILTER,
_SC_TRACE_INHERIT,
_SC_TRACE_LOG,
_SC_LEVEL1_ICACHE_SIZE,
_SC_LEVEL1_ICACHE_ASSOC,
_SC_LEVEL1_ICACHE_LINESIZE,
_SC_LEVEL1_DCACHE_SIZE,
_SC_LEVEL1_DCACHE_ASSOC,
_SC_LEVEL1_DCACHE_LINESIZE,
_SC_LEVEL2_CACHE_SIZE,
_SC_LEVEL2_CACHE_ASSOC,
_SC_LEVEL2_CACHE_LINESIZE,
_SC_LEVEL3_CACHE_SIZE,
_SC_LEVEL3_CACHE_ASSOC,
_SC_LEVEL3_CACHE_LINESIZE,
_SC_LEVEL4_CACHE_SIZE,
_SC_LEVEL4_CACHE_ASSOC,
_SC_LEVEL4_CACHE_LINESIZE,
_SC_IPV6 = _SC_LEVEL1_ICACHE_SIZE + 50,
_SC_RAW_SOCKETS,
_SC_V7_ILP32_OFF32,
_SC_V7_ILP32_OFFBIG,
_SC_V7_LP64_OFF64,
_SC_V7_LPBIG_OFFBIG,
_SC_SS_REPL_MAX,
_SC_TRACE_EVENT_NAME_MAX,
_SC_TRACE_NAME_MAX,
_SC_TRACE_SYS_MAX,
_SC_TRACE_USER_EVENT_MAX,
_SC_XOPEN_STREAMS,
_SC_THREAD_ROBUST_PRIO_INHERIT,
_SC_THREAD_ROBUST_PRIO_PROTECT
};
enum
{
_CS_PATH,
_CS_V6_WIDTH_RESTRICTED_ENVS,
_CS_GNU_LIBC_VERSION,
_CS_GNU_LIBPTHREAD_VERSION,
_CS_V5_WIDTH_RESTRICTED_ENVS,
_CS_V7_WIDTH_RESTRICTED_ENVS,
_CS_LFS_CFLAGS = 1000,
_CS_LFS_LDFLAGS,
_CS_LFS_LIBS,
_CS_LFS_LINTFLAGS,
_CS_LFS64_CFLAGS,
_CS_LFS64_LDFLAGS,
_CS_LFS64_LIBS,
_CS_LFS64_LINTFLAGS,
_CS_XBS5_ILP32_OFF32_CFLAGS = 1100,
_CS_XBS5_ILP32_OFF32_LDFLAGS,
_CS_XBS5_ILP32_OFF32_LIBS,
_CS_XBS5_ILP32_OFF32_LINTFLAGS,
_CS_XBS5_ILP32_OFFBIG_CFLAGS,
_CS_XBS5_ILP32_OFFBIG_LDFLAGS,
_CS_XBS5_ILP32_OFFBIG_LIBS,
_CS_XBS5_ILP32_OFFBIG_LINTFLAGS,
_CS_XBS5_LP64_OFF64_CFLAGS,
_CS_XBS5_LP64_OFF64_LDFLAGS,
_CS_XBS5_LP64_OFF64_LIBS,
_CS_XBS5_LP64_OFF64_LINTFLAGS,
_CS_XBS5_LPBIG_OFFBIG_CFLAGS,
_CS_XBS5_LPBIG_OFFBIG_LDFLAGS,
_CS_XBS5_LPBIG_OFFBIG_LIBS,
_CS_XBS5_LPBIG_OFFBIG_LINTFLAGS,
_CS_POSIX_V6_ILP32_OFF32_CFLAGS,
_CS_POSIX_V6_ILP32_OFF32_LDFLAGS,
_CS_POSIX_V6_ILP32_OFF32_LIBS,
_CS_POSIX_V6_ILP32_OFF32_LINTFLAGS,
_CS_POSIX_V6_ILP32_OFFBIG_CFLAGS,
_CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS,
_CS_POSIX_V6_ILP32_OFFBIG_LIBS,
_CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS,
_CS_POSIX_V6_LP64_OFF64_CFLAGS,
_CS_POSIX_V6_LP64_OFF64_LDFLAGS,
_CS_POSIX_V6_LP64_OFF64_LIBS,
_CS_POSIX_V6_LP64_OFF64_LINTFLAGS,
_CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS,
_CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS,
_CS_POSIX_V6_LPBIG_OFFBIG_LIBS,
_CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS,
_CS_POSIX_V7_ILP32_OFF32_CFLAGS,
_CS_POSIX_V7_ILP32_OFF32_LDFLAGS,
_CS_POSIX_V7_ILP32_OFF32_LIBS,
_CS_POSIX_V7_ILP32_OFF32_LINTFLAGS,
_CS_POSIX_V7_ILP32_OFFBIG_CFLAGS,
_CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS,
_CS_POSIX_V7_ILP32_OFFBIG_LIBS,
_CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS,
_CS_POSIX_V7_LP64_OFF64_CFLAGS,
_CS_POSIX_V7_LP64_OFF64_LDFLAGS,
_CS_POSIX_V7_LP64_OFF64_LIBS,
_CS_POSIX_V7_LP64_OFF64_LINTFLAGS,
_CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS,
_CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS,
_CS_POSIX_V7_LPBIG_OFFBIG_LIBS,
_CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS,
_CS_V6_ENV,
_CS_V7_ENV
};
#610 "/usr/include/unistd.h" 2 3 4
extern long int pathconf (const char *__path, int __name)
throw () __attribute__ ((__nonnull__ (1)));
extern long int fpathconf (int __fd, int __name) throw ();
extern long int sysconf (int __name) throw ();
extern size_t confstr (int __name, char *__buf, size_t __len) throw ();
extern __pid_t getpid (void) throw ();
extern __pid_t getppid (void) throw ();
extern __pid_t getpgrp (void) throw ();
#646 "/usr/include/unistd.h" 3 4
extern __pid_t __getpgid (__pid_t __pid) throw ();
extern __pid_t getpgid (__pid_t __pid) throw ();
extern int setpgid (__pid_t __pid, __pid_t __pgid) throw ();
#672 "/usr/include/unistd.h" 3 4
extern int setpgrp (void) throw ();
#689 "/usr/include/unistd.h" 3 4
extern __pid_t setsid (void) throw ();
extern __pid_t getsid (__pid_t __pid) throw ();
extern __uid_t getuid (void) throw ();
extern __uid_t geteuid (void) throw ();
extern __gid_t getgid (void) throw ();
extern __gid_t getegid (void) throw ();
extern int getgroups (int __size, __gid_t __list[]) throw () ;
extern int group_member (__gid_t __gid) throw ();
extern int setuid (__uid_t __uid) throw () ;
extern int setreuid (__uid_t __ruid, __uid_t __euid) throw () ;
extern int seteuid (__uid_t __uid) throw () ;
extern int setgid (__gid_t __gid) throw () ;
extern int setregid (__gid_t __rgid, __gid_t __egid) throw () ;
extern int setegid (__gid_t __gid) throw () ;
extern int getresuid (__uid_t *__ruid, __uid_t *__euid, __uid_t *__suid)
throw ();
extern int getresgid (__gid_t *__rgid, __gid_t *__egid, __gid_t *__sgid)
throw ();
extern int setresuid (__uid_t __ruid, __uid_t __euid, __uid_t __suid)
throw () ;
extern int setresgid (__gid_t __rgid, __gid_t __egid, __gid_t __sgid)
throw () ;
extern __pid_t fork (void) throw ();
extern __pid_t vfork (void) throw ();
extern char *ttyname (int __fd) throw ();
extern int ttyname_r (int __fd, char *__buf, size_t __buflen)
throw () __attribute__ ((__nonnull__ (2))) ;
extern int isatty (int __fd) throw ();
extern int ttyslot (void) throw ();
extern int link (const char *__from, const char *__to)
throw () __attribute__ ((__nonnull__ (1, 2))) ;
extern int linkat (int __fromfd, const char *__from, int __tofd,
const char *__to, int __flags)
throw () __attribute__ ((__nonnull__ (2, 4))) ;
extern int symlink (const char *__from, const char *__to)
throw () __attribute__ ((__nonnull__ (1, 2))) ;
extern ssize_t readlink (const char *__restrict __path,
char *__restrict __buf, size_t __len)
throw () __attribute__ ((__nonnull__ (1, 2))) ;
extern int symlinkat (const char *__from, int __tofd,
const char *__to) throw () __attribute__ ((__nonnull__ (1, 3))) ;
extern ssize_t readlinkat (int __fd, const char *__restrict __path,
char *__restrict __buf, size_t __len)
throw () __attribute__ ((__nonnull__ (2, 3))) ;
extern int unlink (const char *__name) throw () __attribute__ ((__nonnull__ (1)));
extern int unlinkat (int __fd, const char *__name, int __flag)
throw () __attribute__ ((__nonnull__ (2)));
extern int rmdir (const char *__path) throw () __attribute__ ((__nonnull__ (1)));
extern __pid_t tcgetpgrp (int __fd) throw ();
extern int tcsetpgrp (int __fd, __pid_t __pgrp_id) throw ();
extern char *getlogin (void);
extern int getlogin_r (char *__name, size_t __name_len) __attribute__ ((__nonnull__ (1)));
extern int setlogin (const char *__name) throw () __attribute__ ((__nonnull__ (1)));
#893 "/usr/include/unistd.h" 3 4
#1 "/usr/include/getopt.h" 1 3 4
#49 "/usr/include/getopt.h" 3 4
extern "C" {
#58 "/usr/include/getopt.h" 3 4
extern char *optarg;
#72 "/usr/include/getopt.h" 3 4
extern int optind;
extern int opterr;
extern int optopt;
#151 "/usr/include/getopt.h" 3 4
extern int getopt (int ___argc, char *const *___argv, const char *__shortopts)
throw ();
#186 "/usr/include/getopt.h" 3 4
}
#894 "/usr/include/unistd.h" 2 3 4
extern int gethostname (char *__name, size_t __len) throw () __attribute__ ((__nonnull__ (1)));
extern int sethostname (const char *__name, size_t __len)
throw () __attribute__ ((__nonnull__ (1))) ;
extern int sethostid (long int __id) throw () ;
extern int getdomainname (char *__name, size_t __len)
throw () __attribute__ ((__nonnull__ (1))) ;
extern int setdomainname (const char *__name, size_t __len)
throw () __attribute__ ((__nonnull__ (1))) ;
extern int vhangup (void) throw ();
extern int revoke (const char *__file) throw () __attribute__ ((__nonnull__ (1))) ;
extern int profil (unsigned short int *__sample_buffer, size_t __size,
size_t __offset, unsigned int __scale)
throw () __attribute__ ((__nonnull__ (1)));
extern int acct (const char *__name) throw ();
extern char *getusershell (void) throw ();
extern void endusershell (void) throw ();
extern void setusershell (void) throw ();
extern int daemon (int __nochdir, int __noclose) throw () ;
extern int chroot (const char *__path) throw () __attribute__ ((__nonnull__ (1))) ;
extern char *getpass (const char *__prompt) __attribute__ ((__nonnull__ (1)));
extern int fsync (int __fd);
extern int syncfs (int __fd) throw ();
extern long int gethostid (void);
extern void sync (void) throw ();
extern int getpagesize (void) throw () __attribute__ ((__const__));
extern int getdtablesize (void) throw ();
#1015 "/usr/include/unistd.h" 3 4
extern int truncate (const char *__file, __off_t __length)
throw () __attribute__ ((__nonnull__ (1))) ;
#1027 "/usr/include/unistd.h" 3 4
extern int truncate64 (const char *__file, __off64_t __length)
throw () __attribute__ ((__nonnull__ (1))) ;
#1038 "/usr/include/unistd.h" 3 4
extern int ftruncate (int __fd, __off_t __length) throw () ;
#1048 "/usr/include/unistd.h" 3 4
extern int ftruncate64 (int __fd, __off64_t __length) throw () ;
#1059 "/usr/include/unistd.h" 3 4
extern int brk (void *__addr) throw () ;
extern void *sbrk (intptr_t __delta) throw ();
#1080 "/usr/include/unistd.h" 3 4
extern long int syscall (long int __sysno, ...) throw ();
#1103 "/usr/include/unistd.h" 3 4
extern int lockf (int __fd, int __cmd, __off_t __len) ;
#1113 "/usr/include/unistd.h" 3 4
extern int lockf64 (int __fd, int __cmd, __off64_t __len) ;
#1134 "/usr/include/unistd.h" 3 4
extern int fdatasync (int __fildes);
extern char *crypt (const char *__key, const char *__salt)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern void encrypt (char *__block, int __edflag) throw () __attribute__ ((__nonnull__ (1)));
extern void swab (const void *__restrict __from, void *__restrict __to,
ssize_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
#1172 "/usr/include/unistd.h" 3 4
}
#43 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/gthr-default.h" 2 3
typedef pthread_t __gthread_t;
typedef pthread_key_t __gthread_key_t;
typedef pthread_once_t __gthread_once_t;
typedef pthread_mutex_t __gthread_mutex_t;
typedef pthread_mutex_t __gthread_recursive_mutex_t;
typedef pthread_cond_t __gthread_cond_t;
typedef struct timespec __gthread_time_t;
#118 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/gthr-default.h" 3
static __typeof(pthread_once) __gthrw_pthread_once __attribute__ ((__weakref__("pthread_once")));
static __typeof(pthread_getspecific) __gthrw_pthread_getspecific __attribute__ ((__weakref__("pthread_getspecific")));
static __typeof(pthread_setspecific) __gthrw_pthread_setspecific __attribute__ ((__weakref__("pthread_setspecific")));
static __typeof(pthread_create) __gthrw_pthread_create __attribute__ ((__weakref__("pthread_create")));
static __typeof(pthread_join) __gthrw_pthread_join __attribute__ ((__weakref__("pthread_join")));
static __typeof(pthread_equal) __gthrw_pthread_equal __attribute__ ((__weakref__("pthread_equal")));
static __typeof(pthread_self) __gthrw_pthread_self __attribute__ ((__weakref__("pthread_self")));
static __typeof(pthread_detach) __gthrw_pthread_detach __attribute__ ((__weakref__("pthread_detach")));
static __typeof(pthread_cancel) __gthrw_pthread_cancel __attribute__ ((__weakref__("pthread_cancel")));
static __typeof(sched_yield) __gthrw_sched_yield __attribute__ ((__weakref__("sched_yield")));
static __typeof(pthread_mutex_lock) __gthrw_pthread_mutex_lock __attribute__ ((__weakref__("pthread_mutex_lock")));
static __typeof(pthread_mutex_trylock) __gthrw_pthread_mutex_trylock __attribute__ ((__weakref__("pthread_mutex_trylock")));
static __typeof(pthread_mutex_timedlock) __gthrw_pthread_mutex_timedlock __attribute__ ((__weakref__("pthread_mutex_timedlock")));
static __typeof(pthread_mutex_unlock) __gthrw_pthread_mutex_unlock __attribute__ ((__weakref__("pthread_mutex_unlock")));
static __typeof(pthread_mutex_init) __gthrw_pthread_mutex_init __attribute__ ((__weakref__("pthread_mutex_init")));
static __typeof(pthread_mutex_destroy) __gthrw_pthread_mutex_destroy __attribute__ ((__weakref__("pthread_mutex_destroy")));
static __typeof(pthread_cond_broadcast) __gthrw_pthread_cond_broadcast __attribute__ ((__weakref__("pthread_cond_broadcast")));
static __typeof(pthread_cond_signal) __gthrw_pthread_cond_signal __attribute__ ((__weakref__("pthread_cond_signal")));
static __typeof(pthread_cond_wait) __gthrw_pthread_cond_wait __attribute__ ((__weakref__("pthread_cond_wait")));
static __typeof(pthread_cond_timedwait) __gthrw_pthread_cond_timedwait __attribute__ ((__weakref__("pthread_cond_timedwait")));
static __typeof(pthread_cond_destroy) __gthrw_pthread_cond_destroy __attribute__ ((__weakref__("pthread_cond_destroy")));
static __typeof(pthread_key_create) __gthrw_pthread_key_create __attribute__ ((__weakref__("pthread_key_create")));
static __typeof(pthread_key_delete) __gthrw_pthread_key_delete __attribute__ ((__weakref__("pthread_key_delete")));
static __typeof(pthread_mutexattr_init) __gthrw_pthread_mutexattr_init __attribute__ ((__weakref__("pthread_mutexattr_init")));
static __typeof(pthread_mutexattr_settype) __gthrw_pthread_mutexattr_settype __attribute__ ((__weakref__("pthread_mutexattr_settype")));
static __typeof(pthread_mutexattr_destroy) __gthrw_pthread_mutexattr_destroy __attribute__ ((__weakref__("pthread_mutexattr_destroy")));
#239 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/gthr-default.h" 3
static inline int
__gthread_active_p (void)
{
static void *const __gthread_active_ptr
= __extension__ (void *) &__gthrw_pthread_cancel;
return __gthread_active_ptr != 0;
}
#657 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/gthr-default.h" 3
static inline int
__gthread_create (__gthread_t *__threadid, void *(*__func) (void*),
void *__args)
{
return __gthrw_pthread_create (__threadid, __null, __func, __args);
}
static inline int
__gthread_join (__gthread_t __threadid, void **__value_ptr)
{
return __gthrw_pthread_join (__threadid, __value_ptr);
}
static inline int
__gthread_detach (__gthread_t __threadid)
{
return __gthrw_pthread_detach (__threadid);
}
static inline int
__gthread_equal (__gthread_t __t1, __gthread_t __t2)
{
return __gthrw_pthread_equal (__t1, __t2);
}
static inline __gthread_t
__gthread_self (void)
{
return __gthrw_pthread_self ();
}
static inline int
__gthread_yield (void)
{
return __gthrw_sched_yield ();
}
static inline int
__gthread_once (__gthread_once_t *__once, void (*__func) (void))
{
if (__gthread_active_p ())
return __gthrw_pthread_once (__once, __func);
else
return -1;
}
static inline int
__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *))
{
return __gthrw_pthread_key_create (__key, __dtor);
}
static inline int
__gthread_key_delete (__gthread_key_t __key)
{
return __gthrw_pthread_key_delete (__key);
}
static inline void *
__gthread_getspecific (__gthread_key_t __key)
{
return __gthrw_pthread_getspecific (__key);
}
static inline int
__gthread_setspecific (__gthread_key_t __key, const void *__ptr)
{
return __gthrw_pthread_setspecific (__key, __ptr);
}
static inline int
__gthread_mutex_destroy (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
return __gthrw_pthread_mutex_destroy (__mutex);
else
return 0;
}
static inline int
__gthread_mutex_lock (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
return __gthrw_pthread_mutex_lock (__mutex);
else
return 0;
}
static inline int
__gthread_mutex_trylock (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
return __gthrw_pthread_mutex_trylock (__mutex);
else
return 0;
}
static inline int
__gthread_mutex_timedlock (__gthread_mutex_t *__mutex,
const __gthread_time_t *__abs_timeout)
{
if (__gthread_active_p ())
return __gthrw_pthread_mutex_timedlock (__mutex, __abs_timeout);
else
return 0;
}
static inline int
__gthread_mutex_unlock (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
return __gthrw_pthread_mutex_unlock (__mutex);
else
return 0;
}
#800 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/gthr-default.h" 3
static inline int
__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)
{
return __gthread_mutex_lock (__mutex);
}
static inline int
__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)
{
return __gthread_mutex_trylock (__mutex);
}
static inline int
__gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *__mutex,
const __gthread_time_t *__abs_timeout)
{
return __gthread_mutex_timedlock (__mutex, __abs_timeout);
}
static inline int
__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
{
return __gthread_mutex_unlock (__mutex);
}
static inline int
__gthread_cond_broadcast (__gthread_cond_t *__cond)
{
return __gthrw_pthread_cond_broadcast (__cond);
}
static inline int
__gthread_cond_signal (__gthread_cond_t *__cond)
{
return __gthrw_pthread_cond_signal (__cond);
}
static inline int
__gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex)
{
return __gthrw_pthread_cond_wait (__cond, __mutex);
}
static inline int
__gthread_cond_timedwait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex,
const __gthread_time_t *__abs_timeout)
{
return __gthrw_pthread_cond_timedwait (__cond, __mutex, __abs_timeout);
}
static inline int
__gthread_cond_wait_recursive (__gthread_cond_t *__cond,
__gthread_recursive_mutex_t *__mutex)
{
return __gthread_cond_wait (__cond, __mutex);
}
static inline int
__gthread_cond_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);
}
static inline int
__gthread_cond_destroy (__gthread_cond_t* __cond)
{
return __gthrw_pthread_cond_destroy (__cond);
}
#171 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/gthr.h" 2 3
#pragma GCC visibility pop
#35 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ext/atomicity.h" 2 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/atomic_word.h" 1 3
#32 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/atomic_word.h" 3
typedef int _Atomic_word;
#36 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ext/atomicity.h" 2 3
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
static inline _Atomic_word
__exchange_and_add(volatile _Atomic_word* __mem, int __val)
{ return __sync_fetch_and_add(__mem, __val); }
static inline void
__atomic_add(volatile _Atomic_word* __mem, int __val)
{ __sync_fetch_and_add(__mem, __val); }
#63 "/opt/Xilinx/Vivado/2017.3/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;
}
static inline void
__atomic_add_single(_Atomic_word* __mem, int __val)
{ *__mem += __val; }
static inline _Atomic_word
__attribute__ ((__unused__))
__exchange_and_add_dispatch(_Atomic_word* __mem, int __val)
{
if (__gthread_active_p())
return __exchange_and_add(__mem, __val);
else
return __exchange_and_add_single(__mem, __val);
}
static inline void
__attribute__ ((__unused__))
__atomic_add_dispatch(_Atomic_word* __mem, int __val)
{
if (__gthread_active_p())
__atomic_add(__mem, __val);
else
__atomic_add_single(__mem, __val);
}
}
#41 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/ios_base.h" 2 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_classes.h" 1 3
#39 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_classes.h" 3
#39 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_classes.h" 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/string" 1 3
#38 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/string" 3
#38 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/string" 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/allocator.h" 1 3
#48 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/allocator.h" 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/c++allocator.h" 1 3
#34 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/c++allocator.h" 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ext/new_allocator.h" 1 3
#34 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ext/new_allocator.h" 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/new" 1 3
#39 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/new" 3
#39 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/new" 3
#pragma GCC visibility push(default)
extern "C++" {
namespace std
{
class bad_alloc : public exception
{
public:
bad_alloc() throw() { }
virtual ~bad_alloc() throw();
virtual const char* what() const throw();
};
struct nothrow_t { };
extern const nothrow_t nothrow;
typedef void (*new_handler)();
new_handler set_new_handler(new_handler) throw();
}
#92 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/new" 3
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();
inline void* operator new(std::size_t, void* __p) throw() { return __p; }
inline void* operator new[](std::size_t, void* __p) throw() { return __p; }
inline void operator delete (void*, void*) throw() { }
inline void operator delete[](void*, void*) throw() { }
}
#pragma GCC visibility pop
#35 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ext/new_allocator.h" 2 3
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
using std::size_t;
using std::ptrdiff_t;
#53 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ext/new_allocator.h" 3
template<typename _Tp>
class new_allocator
{
public:
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef _Tp* pointer;
typedef const _Tp* const_pointer;
typedef _Tp& reference;
typedef const _Tp& const_reference;
typedef _Tp value_type;
template<typename _Tp1>
struct rebind
{ typedef new_allocator<_Tp1> other; };
new_allocator() throw() { }
new_allocator(const new_allocator&) throw() { }
template<typename _Tp1>
new_allocator(const new_allocator<_Tp1>&) throw() { }
~new_allocator() throw() { }
pointer
address(reference __x) const { return std::__addressof(__x); }
const_pointer
address(const_reference __x) const { return std::__addressof(__x); }
pointer
allocate(size_type __n, const void* = 0)
{
if (__n > this->max_size())
std::__throw_bad_alloc();
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
}
void
deallocate(pointer __p, size_type)
{ ::operator delete(__p); }
size_type
max_size() const throw()
{ return size_t(-1) / sizeof(_Tp); }
void
construct(pointer __p, const _Tp& __val)
{ ::new((void *)__p) _Tp(__val); }
#117 "/opt/Xilinx/Vivado/2017.3/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(); }
};
template<typename _Tp>
inline bool
operator==(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
{ return true; }
template<typename _Tp>
inline bool
operator!=(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
{ return false; }
}
#35 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/c++allocator.h" 2 3
#49 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/allocator.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
#65 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/allocator.h" 3
template<typename _Tp>
class allocator;
template<>
class allocator<void>
{
public:
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef void* pointer;
typedef const void* const_pointer;
typedef void value_type;
template<typename _Tp1>
struct rebind
{ typedef allocator<_Tp1> other; };
};
#91 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/allocator.h" 3
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;
template<typename _Tp1>
struct rebind
{ typedef allocator<_Tp1> other; };
allocator() throw() { }
allocator(const allocator& __a) throw()
: __gnu_cxx::new_allocator<_Tp>(__a) { }
template<typename _Tp1>
allocator(const allocator<_Tp1>&) throw() { }
~allocator() throw() { }
};
template<typename _T1, typename _T2>
inline bool
operator==(const allocator<_T1>&, const allocator<_T2>&)
{ return true; }
template<typename _Tp>
inline bool
operator==(const allocator<_Tp>&, const allocator<_Tp>&)
{ return true; }
template<typename _T1, typename _T2>
inline bool
operator!=(const allocator<_T1>&, const allocator<_T2>&)
{ return false; }
template<typename _Tp>
inline bool
operator!=(const allocator<_Tp>&, const allocator<_Tp>&)
{ return false; }
extern template class allocator<char>;
extern template class allocator<wchar_t>;
template<typename _Alloc, bool = __is_empty(_Alloc)>
struct __alloc_swap
{ static void _S_do_it(_Alloc&, _Alloc&) { } };
template<typename _Alloc>
struct __alloc_swap<_Alloc, false>
{
static void
_S_do_it(_Alloc& __one, _Alloc& __two)
{
if (__one != __two)
swap(__one, __two);
}
};
template<typename _Alloc, bool = __is_empty(_Alloc)>
struct __alloc_neq
{
static bool
_S_do_it(const _Alloc&, const _Alloc&)
{ return false; }
};
template<typename _Alloc>
struct __alloc_neq<_Alloc, false>
{
static bool
_S_do_it(const _Alloc& __one, const _Alloc& __two)
{ return __one != __two; }
};
#237 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/allocator.h" 3
}
#43 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/string" 2 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/ostream_insert.h" 1 3
#33 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/ostream_insert.h" 3
#33 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/ostream_insert.h" 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/cxxabi_forced.h" 1 3
#34 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/cxxabi_forced.h" 3
#34 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/cxxabi_forced.h" 3
#pragma GCC visibility push(default)
namespace __cxxabiv1
{
#define virtual
#47 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/cxxabi_forced.h"
class __forced_unwind
{
virtual ~__forced_unwind() throw();
#if 0
#52 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/cxxabi_forced.h"
virtual void __pure_dummy() = 0;
#endif
#53 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/cxxabi_forced.h"
};
#undef virtual
#54 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/cxxabi_forced.h"
}
#pragma GCC visibility pop
#36 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/ostream_insert.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits>
inline void
__ostream_write(basic_ostream<_CharT, _Traits>& __out,
const _CharT* __s, streamsize __n)
{
typedef basic_ostream<_CharT, _Traits> __ostream_type;
typedef typename __ostream_type::ios_base __ios_base;
const streamsize __put = __out.rdbuf()->sputn(__s, __n);
if (__put != __n)
__out.setstate(__ios_base::badbit);
}
template<typename _CharT, typename _Traits>
inline void
__ostream_fill(basic_ostream<_CharT, _Traits>& __out, streamsize __n)
{
typedef basic_ostream<_CharT, _Traits> __ostream_type;
typedef typename __ostream_type::ios_base __ios_base;
const _CharT __c = __out.fill();
for (; __n > 0; --__n)
{
const typename _Traits::int_type __put = __out.rdbuf()->sputc(__c);
if (_Traits::eq_int_type(__put, _Traits::eof()))
{
__out.setstate(__ios_base::badbit);
break;
}
}
}
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
__ostream_insert(basic_ostream<_CharT, _Traits>& __out,
const _CharT* __s, streamsize __n)
{
typedef basic_ostream<_CharT, _Traits> __ostream_type;
typedef typename __ostream_type::ios_base __ios_base;
typename __ostream_type::sentry __cerb(__out);
if (__cerb)
{
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;
}
extern template ostream& __ostream_insert(ostream&, const char*, streamsize);
extern template wostream& __ostream_insert(wostream&, const wchar_t*,
streamsize);
}
#46 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/string" 2 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_function.h" 1 3
#60 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_function.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
#101 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_function.h" 3
template<typename _Arg, typename _Result>
struct unary_function
{
typedef _Arg argument_type;
typedef _Result result_type;
};
template<typename _Arg1, typename _Arg2, typename _Result>
struct binary_function
{
typedef _Arg1 first_argument_type;
typedef _Arg2 second_argument_type;
typedef _Result result_type;
};
#140 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_function.h" 3
template<typename _Tp>
struct plus : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x + __y; }
};
template<typename _Tp>
struct minus : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x - __y; }
};
template<typename _Tp>
struct multiplies : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x * __y; }
};
template<typename _Tp>
struct divides : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x / __y; }
};
template<typename _Tp>
struct modulus : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x % __y; }
};
template<typename _Tp>
struct negate : public unary_function<_Tp, _Tp>
{
_Tp
operator()(const _Tp& __x) const
{ return -__x; }
};
#204 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_function.h" 3
template<typename _Tp>
struct equal_to : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x == __y; }
};
template<typename _Tp>
struct not_equal_to : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x != __y; }
};
template<typename _Tp>
struct greater : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x > __y; }
};
template<typename _Tp>
struct less : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x < __y; }
};
template<typename _Tp>
struct greater_equal : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x >= __y; }
};
template<typename _Tp>
struct less_equal : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x <= __y; }
};
#268 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_function.h" 3
template<typename _Tp>
struct logical_and : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x && __y; }
};
template<typename _Tp>
struct logical_or : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x || __y; }
};
template<typename _Tp>
struct logical_not : public unary_function<_Tp, bool>
{
bool
operator()(const _Tp& __x) const
{ return !__x; }
};
template<typename _Tp>
struct bit_and : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x & __y; }
};
template<typename _Tp>
struct bit_or : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x | __y; }
};
template<typename _Tp>
struct bit_xor : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x ^ __y; }
};
#351 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_function.h" 3
template<typename _Predicate>
class unary_negate
: public unary_function<typename _Predicate::argument_type, bool>
{
protected:
_Predicate _M_pred;
public:
explicit
unary_negate(const _Predicate& __x) : _M_pred(__x) { }
bool
operator()(const typename _Predicate::argument_type& __x) const
{ return !_M_pred(__x); }
};
template<typename _Predicate>
inline unary_negate<_Predicate>
not1(const _Predicate& __pred)
{ return unary_negate<_Predicate>(__pred); }
template<typename _Predicate>
class binary_negate
: public binary_function<typename _Predicate::first_argument_type,
typename _Predicate::second_argument_type, bool>
{
protected:
_Predicate _M_pred;
public:
explicit
binary_negate(const _Predicate& __x) : _M_pred(__x) { }
bool
operator()(const typename _Predicate::first_argument_type& __x,
const typename _Predicate::second_argument_type& __y) const
{ return !_M_pred(__x, __y); }
};
template<typename _Predicate>
inline binary_negate<_Predicate>
not2(const _Predicate& __pred)
{ return binary_negate<_Predicate>(__pred); }
#422 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_function.h" 3
template<typename _Arg, typename _Result>
class pointer_to_unary_function : public unary_function<_Arg, _Result>
{
protected:
_Result (*_M_ptr)(_Arg);
public:
pointer_to_unary_function() { }
explicit
pointer_to_unary_function(_Result (*__x)(_Arg))
: _M_ptr(__x) { }
_Result
operator()(_Arg __x) const
{ return _M_ptr(__x); }
};
template<typename _Arg, typename _Result>
inline pointer_to_unary_function<_Arg, _Result>
ptr_fun(_Result (*__x)(_Arg))
{ return pointer_to_unary_function<_Arg, _Result>(__x); }
template<typename _Arg1, typename _Arg2, typename _Result>
class pointer_to_binary_function
: public binary_function<_Arg1, _Arg2, _Result>
{
protected:
_Result (*_M_ptr)(_Arg1, _Arg2);
public:
pointer_to_binary_function() { }
explicit
pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
: _M_ptr(__x) { }
_Result
operator()(_Arg1 __x, _Arg2 __y) const
{ return _M_ptr(__x, __y); }
};
template<typename _Arg1, typename _Arg2, typename _Result>
inline pointer_to_binary_function<_Arg1, _Arg2, _Result>
ptr_fun(_Result (*__x)(_Arg1, _Arg2))
{ return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); }
template<typename _Tp>
struct _Identity : public unary_function<_Tp,_Tp>
{
_Tp&
operator()(_Tp& __x) const
{ return __x; }
const _Tp&
operator()(const _Tp& __x) const
{ return __x; }
};
template<typename _Pair>
struct _Select1st : public unary_function<_Pair,
typename _Pair::first_type>
{
typename _Pair::first_type&
operator()(_Pair& __x) const
{ return __x.first; }
const typename _Pair::first_type&
operator()(const _Pair& __x) const
{ return __x.first; }
#508 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_function.h" 3
};
template<typename _Pair>
struct _Select2nd : public unary_function<_Pair,
typename _Pair::second_type>
{
typename _Pair::second_type&
operator()(_Pair& __x) const
{ return __x.second; }
const typename _Pair::second_type&
operator()(const _Pair& __x) const
{ return __x.second; }
};
#541 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_function.h" 3
template<typename _Ret, typename _Tp>
class mem_fun_t : public unary_function<_Tp*, _Ret>
{
public:
explicit
mem_fun_t(_Ret (_Tp::*__pf)())
: _M_f(__pf) { }
_Ret
operator()(_Tp* __p) const
{ return (__p->*_M_f)(); }
private:
_Ret (_Tp::*_M_f)();
};
template<typename _Ret, typename _Tp>
class const_mem_fun_t : public unary_function<const _Tp*, _Ret>
{
public:
explicit
const_mem_fun_t(_Ret (_Tp::*__pf)() const)
: _M_f(__pf) { }
_Ret
operator()(const _Tp* __p) const
{ return (__p->*_M_f)(); }
private:
_Ret (_Tp::*_M_f)() const;
};
template<typename _Ret, typename _Tp>
class mem_fun_ref_t : public unary_function<_Tp, _Ret>
{
public:
explicit
mem_fun_ref_t(_Ret (_Tp::*__pf)())
: _M_f(__pf) { }
_Ret
operator()(_Tp& __r) const
{ return (__r.*_M_f)(); }
private:
_Ret (_Tp::*_M_f)();
};
template<typename _Ret, typename _Tp>
class const_mem_fun_ref_t : public unary_function<_Tp, _Ret>
{
public:
explicit
const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const)
: _M_f(__pf) { }
_Ret
operator()(const _Tp& __r) const
{ return (__r.*_M_f)(); }
private:
_Ret (_Tp::*_M_f)() const;
};
template<typename _Ret, typename _Tp, typename _Arg>
class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret>
{
public:
explicit
mem_fun1_t(_Ret (_Tp::*__pf)(_Arg))
: _M_f(__pf) { }
_Ret
operator()(_Tp* __p, _Arg __x) const
{ return (__p->*_M_f)(__x); }
private:
_Ret (_Tp::*_M_f)(_Arg);
};
template<typename _Ret, typename _Tp, typename _Arg>
class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret>
{
public:
explicit
const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const)
: _M_f(__pf) { }
_Ret
operator()(const _Tp* __p, _Arg __x) const
{ return (__p->*_M_f)(__x); }
private:
_Ret (_Tp::*_M_f)(_Arg) const;
};
template<typename _Ret, typename _Tp, typename _Arg>
class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
{
public:
explicit
mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg))
: _M_f(__pf) { }
_Ret
operator()(_Tp& __r, _Arg __x) const
{ return (__r.*_M_f)(__x); }
private:
_Ret (_Tp::*_M_f)(_Arg);
};
template<typename _Ret, typename _Tp, typename _Arg>
class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
{
public:
explicit
const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const)
: _M_f(__pf) { }
_Ret
operator()(const _Tp& __r, _Arg __x) const
{ return (__r.*_M_f)(__x); }
private:
_Ret (_Tp::*_M_f)(_Arg) const;
};
template<typename _Ret, typename _Tp>
inline mem_fun_t<_Ret, _Tp>
mem_fun(_Ret (_Tp::*__f)())
{ return mem_fun_t<_Ret, _Tp>(__f); }
template<typename _Ret, typename _Tp>
inline const_mem_fun_t<_Ret, _Tp>
mem_fun(_Ret (_Tp::*__f)() const)
{ return const_mem_fun_t<_Ret, _Tp>(__f); }
template<typename _Ret, typename _Tp>
inline mem_fun_ref_t<_Ret, _Tp>
mem_fun_ref(_Ret (_Tp::*__f)())
{ return mem_fun_ref_t<_Ret, _Tp>(__f); }
template<typename _Ret, typename _Tp>
inline const_mem_fun_ref_t<_Ret, _Tp>
mem_fun_ref(_Ret (_Tp::*__f)() const)
{ return const_mem_fun_ref_t<_Ret, _Tp>(__f); }
template<typename _Ret, typename _Tp, typename _Arg>
inline mem_fun1_t<_Ret, _Tp, _Arg>
mem_fun(_Ret (_Tp::*__f)(_Arg))
{ return mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
template<typename _Ret, typename _Tp, typename _Arg>
inline const_mem_fun1_t<_Ret, _Tp, _Arg>
mem_fun(_Ret (_Tp::*__f)(_Arg) const)
{ return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
template<typename _Ret, typename _Tp, typename _Arg>
inline mem_fun1_ref_t<_Ret, _Tp, _Arg>
mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
{ return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
template<typename _Ret, typename _Tp, typename _Arg>
inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg>
mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
{ return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
}
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/backward/binders.h" 1 3
#60 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/backward/binders.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
#99 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/backward/binders.h" 3
template<typename _Operation>
class binder1st
: public unary_function<typename _Operation::second_argument_type,
typename _Operation::result_type>
{
protected:
_Operation op;
typename _Operation::first_argument_type value;
public:
binder1st(const _Operation& __x,
const typename _Operation::first_argument_type& __y)
: op(__x), value(__y) { }
typename _Operation::result_type
operator()(const typename _Operation::second_argument_type& __x) const
{ return op(value, __x); }
typename _Operation::result_type
operator()(typename _Operation::second_argument_type& __x) const
{ return op(value, __x); }
} ;
template<typename _Operation, typename _Tp>
inline binder1st<_Operation>
bind1st(const _Operation& __fn, const _Tp& __x)
{
typedef typename _Operation::first_argument_type _Arg1_type;
return binder1st<_Operation>(__fn, _Arg1_type(__x));
}
template<typename _Operation>
class binder2nd
: public unary_function<typename _Operation::first_argument_type,
typename _Operation::result_type>
{
protected:
_Operation op;
typename _Operation::second_argument_type value;
public:
binder2nd(const _Operation& __x,
const typename _Operation::second_argument_type& __y)
: op(__x), value(__y) { }
typename _Operation::result_type
operator()(const typename _Operation::first_argument_type& __x) const
{ return op(__x, value); }
typename _Operation::result_type
operator()(typename _Operation::first_argument_type& __x) const
{ return op(__x, value); }
} ;
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));
}
}
#732 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stl_function.h" 2 3
#50 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/string" 2 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/range_access.h" 1 3
#33 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/range_access.h" 3
#33 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/range_access.h" 3
#53 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/string" 2 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 1 3
#39 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
#39 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/initializer_list" 1 3
#33 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/initializer_list" 3
#33 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/initializer_list" 3
#43 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
#105 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
template<typename _CharT, typename _Traits, typename _Alloc>
class basic_string
{
typedef typename _Alloc::template rebind<_CharT>::other _CharT_alloc_type;
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;
private:
#142 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
struct _Rep_base
{
size_type _M_length;
size_type _M_capacity;
_Atomic_word _M_refcount;
};
struct _Rep : _Rep_base
{
typedef typename _Alloc::template rebind<char>::other _Raw_bytes_alloc;
#167 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
static const size_type _S_max_size;
static const _CharT _S_terminal;
static size_type _S_empty_rep_storage[];
static _Rep&
_S_empty_rep()
{
void* __p = reinterpret_cast<void*>(&_S_empty_rep_storage);
return *reinterpret_cast<_Rep*>(__p);
}
bool
_M_is_leaked() const
{ return this->_M_refcount < 0; }
bool
_M_is_shared() const
{ return this->_M_refcount > 0; }
void
_M_set_leaked()
{ this->_M_refcount = -1; }
void
_M_set_sharable()
{ this->_M_refcount = 0; }
void
_M_set_length_and_sharable(size_type __n)
{
if (__builtin_expect(this != &_S_empty_rep(), false))
{
this->_M_set_sharable();
this->_M_length = __n;
traits_type::assign(this->_M_refdata()[__n], _S_terminal);
}
}
_CharT*
_M_refdata() throw()
{ return reinterpret_cast<_CharT*>(this + 1); }
_CharT*
_M_grab(const _Alloc& __alloc1, const _Alloc& __alloc2)
{
return (!_M_is_leaked() && __alloc1 == __alloc2)
? _M_refcopy() : _M_clone(__alloc1);
}
static _Rep*
_S_create(size_type, size_type, const _Alloc&);
void
_M_dispose(const _Alloc& __a)
{
if (__builtin_expect(this != &_S_empty_rep(), false))
{
;
if (__gnu_cxx::__exchange_and_add_dispatch(&this->_M_refcount,
-1) <= 0)
{
;
_M_destroy(__a);
}
}
}
void
_M_destroy(const _Alloc&) throw();
_CharT*
_M_refcopy() throw()
{
if (__builtin_expect(this != &_S_empty_rep(), false))
__gnu_cxx::__atomic_add_dispatch(&this->_M_refcount, 1);
return _M_refdata();
}
_CharT*
_M_clone(const _Alloc&, size_type __res = 0);
};
struct _Alloc_hider : _Alloc
{
_Alloc_hider(_CharT* __dat, const _Alloc& __a)
: _Alloc(__a), _M_p(__dat) { }
_CharT* _M_p;
};
public:
static const size_type npos = static_cast<size_type>(-1);
private:
mutable _Alloc_hider _M_dataplus;
_CharT*
_M_data() const
{ return _M_dataplus._M_p; }
_CharT*
_M_data(_CharT* __p)
{ return (_M_dataplus._M_p = __p); }
_Rep*
_M_rep() const
{ return &((reinterpret_cast<_Rep*> (_M_data()))[-1]); }
iterator
_M_ibegin() const
{ return iterator(_M_data()); }
iterator
_M_iend() const
{ return iterator(_M_data() + this->size()); }
void
_M_leak()
{
if (!_M_rep()->_M_is_leaked())
_M_leak_hard();
}
size_type
_M_check(size_type __pos, const char* __s) const
{
if (__pos > this->size())
__throw_out_of_range((__s));
return __pos;
}
void
_M_check_length(size_type __n1, size_type __n2, const char* __s) const
{
if (this->max_size() - (this->size() - __n1) < __n2)
__throw_length_error((__s));
}
size_type
_M_limit(size_type __pos, size_type __off) const
{
const bool __testoff = __off < this->size() - __pos;
return __testoff ? __off : this->size() - __pos;
}
bool
_M_disjunct(const _CharT* __s) const
{
return (less<const _CharT*>()(__s, _M_data())
|| less<const _CharT*>()(_M_data() + this->size(), __s));
}
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);
}
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);
}
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);
}
template<class _Iterator>
static void
_S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2)
{
for (; __k1 != __k2; ++__k1, ++__p)
traits_type::assign(*__p, *__k1);
}
static void
_S_copy_chars(_CharT* __p, iterator __k1, iterator __k2)
{ _S_copy_chars(__p, __k1.base(), __k2.base()); }
static void
_S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2)
{ _S_copy_chars(__p, __k1.base(), __k2.base()); }
static void
_S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2)
{ _M_copy(__p, __k1, __k2 - __k1); }
static void
_S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
{ _M_copy(__p, __k1, __k2 - __k1); }
static int
_S_compare(size_type __n1, size_type __n2)
{
const difference_type __d = difference_type(__n1 - __n2);
if (__d > __gnu_cxx::__numeric_traits<int>::__max)
return __gnu_cxx::__numeric_traits<int>::__max;
else if (__d < __gnu_cxx::__numeric_traits<int>::__min)
return __gnu_cxx::__numeric_traits<int>::__min;
else
return int(__d);
}
void
_M_mutate(size_type __pos, size_type __len1, size_type __len2);
void
_M_leak_hard();
static _Rep&
_S_empty_rep()
{ return _Rep::_S_empty_rep(); }
public:
basic_string()
: _M_dataplus(_S_empty_rep()._M_refdata(), _Alloc()) { }
explicit
basic_string(const _Alloc& __a);
basic_string(const basic_string& __str);
basic_string(const basic_string& __str, size_type __pos,
size_type __n = npos);
basic_string(const basic_string& __str, size_type __pos,
size_type __n, const _Alloc& __a);
#477 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
basic_string(const _CharT* __s, size_type __n,
const _Alloc& __a = _Alloc());
basic_string(const _CharT* __s, const _Alloc& __a = _Alloc());
basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc());
#525 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
template<class _InputIterator>
basic_string(_InputIterator __beg, _InputIterator __end,
const _Alloc& __a = _Alloc());
~basic_string()
{ _M_rep()->_M_dispose(this->get_allocator()); }
basic_string&
operator=(const basic_string& __str)
{ return this->assign(__str); }
basic_string&
operator=(const _CharT* __s)
{ return this->assign(__s); }
#558 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
basic_string&
operator=(_CharT __c)
{
this->assign(1, __c);
return *this;
}
#598 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
iterator
begin()
{
_M_leak();
return iterator(_M_data());
}
const_iterator
begin() const
{ return const_iterator(_M_data()); }
iterator
end()
{
_M_leak();
return iterator(_M_data() + this->size());
}
const_iterator
end() const
{ return const_iterator(_M_data() + this->size()); }
reverse_iterator
rbegin()
{ return reverse_iterator(this->end()); }
const_reverse_iterator
rbegin() const
{ return const_reverse_iterator(this->end()); }
reverse_iterator
rend()
{ return reverse_iterator(this->begin()); }
const_reverse_iterator
rend() const
{ return const_reverse_iterator(this->begin()); }
#704 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
public:
size_type
size() const
{ return _M_rep()->_M_length; }
size_type
length() const
{ return _M_rep()->_M_length; }
size_type
max_size() const
{ return _Rep::_S_max_size; }
#733 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
void
resize(size_type __n, _CharT __c);
#746 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
void
resize(size_type __n)
{ this->resize(__n, _CharT()); }
#766 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
size_type
capacity() const
{ return _M_rep()->_M_capacity; }
#787 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
void
reserve(size_type __res_arg = 0);
void
clear()
{ _M_mutate(0, this->size(), 0); }
bool
empty() const
{ return this->size() == 0; }
#816 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
const_reference
operator[] (size_type __pos) const
{
;
return _M_data()[__pos];
}
#833 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
reference
operator[](size_type __pos)
{
;
;
_M_leak();
return _M_data()[__pos];
}
#854 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
const_reference
at(size_type __n) const
{
if (__n >= this->size())
__throw_out_of_range(("basic_string::at"));
return _M_data()[__n];
}
#907 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
reference
at(size_type __n)
{
if (__n >= size())
__throw_out_of_range(("basic_string::at"));
_M_leak();
return _M_data()[__n];
}
basic_string&
operator+=(const basic_string& __str)
{ return this->append(__str); }
basic_string&
operator+=(const _CharT* __s)
{ return this->append(__s); }
basic_string&
operator+=(_CharT __c)
{
this->push_back(__c);
return *this;
}
#963 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
basic_string&
append(const basic_string& __str);
#978 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
basic_string&
append(const basic_string& __str, size_type __pos, size_type __n);
basic_string&
append(const _CharT* __s, size_type __n);
basic_string&
append(const _CharT* __s)
{
;
return this->append(__s, traits_type::length(__s));
}
#1010 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
basic_string&
append(size_type __n, _CharT __c);
#1032 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
template<class _InputIterator>
basic_string&
append(_InputIterator __first, _InputIterator __last)
{ return this->replace(_M_iend(), _M_iend(), __first, __last); }
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);
}
basic_string&
assign(const basic_string& __str);
#1088 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
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)); }
#1104 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
basic_string&
assign(const _CharT* __s, size_type __n);
#1116 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
basic_string&
assign(const _CharT* __s)
{
;
return this->assign(__s, traits_type::length(__s));
}
#1132 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
basic_string&
assign(size_type __n, _CharT __c)
{ return _M_replace_aux(size_type(0), this->size(), __n, __c); }
#1144 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
template<class _InputIterator>
basic_string&
assign(_InputIterator __first, _InputIterator __last)
{ return this->replace(_M_ibegin(), _M_iend(), __first, __last); }
#1172 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
void
insert(iterator __p, size_type __n, _CharT __c)
{ this->replace(__p, __p, __n, __c); }
#1187 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
template<class _InputIterator>
void
insert(iterator __p, _InputIterator __beg, _InputIterator __end)
{ this->replace(__p, __p, __beg, __end); }
#1218 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
basic_string&
insert(size_type __pos1, const basic_string& __str)
{ return this->insert(__pos1, __str, size_type(0), __str.size()); }
#1240 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
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)); }
#1263 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
basic_string&
insert(size_type __pos, const _CharT* __s, size_type __n);
#1281 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
basic_string&
insert(size_type __pos, const _CharT* __s)
{
;
return this->insert(__pos, __s, traits_type::length(__s));
}
#1304 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
basic_string&
insert(size_type __pos, size_type __n, _CharT __c)
{ return _M_replace_aux(_M_check(__pos, "basic_string::insert"),
size_type(0), __n, __c); }
#1321 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
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);
}
#1345 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
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;
}
#1361 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
iterator
erase(iterator __position)
{
;
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);
}
#1381 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
iterator
erase(iterator __first, iterator __last);
#1400 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
basic_string&
replace(size_type __pos, size_type __n, const basic_string& __str)
{ return this->replace(__pos, __n, __str._M_data(), __str.size()); }
#1422 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
basic_string&
replace(size_type __pos1, size_type __n1, const basic_string& __str,
size_type __pos2, size_type __n2)
{ return this->replace(__pos1, __n1, __str._M_data()
+ __str._M_check(__pos2, "basic_string::replace"),
__str._M_limit(__pos2, __n2)); }
#1446 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
basic_string&
replace(size_type __pos, size_type __n1, const _CharT* __s,
size_type __n2);
#1465 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
basic_string&
replace(size_type __pos, size_type __n1, const _CharT* __s)
{
;
return this->replace(__pos, __n1, __s, traits_type::length(__s));
}
#1488 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
basic_string&
replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
{ return _M_replace_aux(_M_check(__pos, "basic_string::replace"),
_M_limit(__pos, __n1), __n2, __c); }
#1506 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
basic_string&
replace(iterator __i1, iterator __i2, const basic_string& __str)
{ return this->replace(__i1, __i2, __str._M_data(), __str.size()); }
#1524 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
basic_string&
replace(iterator __i1, iterator __i2, const _CharT* __s, size_type __n)
{
;
return this->replace(__i1 - _M_ibegin(), __i2 - __i1, __s, __n);
}
#1545 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
basic_string&
replace(iterator __i1, iterator __i2, const _CharT* __s)
{
;
return this->replace(__i1, __i2, __s, traits_type::length(__s));
}
#1566 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
basic_string&
replace(iterator __i1, iterator __i2, size_type __n, _CharT __c)
{
;
return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __c);
}
#1588 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
template<class _InputIterator>
basic_string&
replace(iterator __i1, iterator __i2,
_InputIterator __k1, _InputIterator __k2)
{
;
;
typedef typename std::__is_integer<_InputIterator>::__type _Integral;
return _M_replace_dispatch(__i1, __i2, __k1, __k2, _Integral());
}
basic_string&
replace(iterator __i1, iterator __i2, _CharT* __k1, _CharT* __k2)
{
;
;
return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
__k1, __k2 - __k1);
}
basic_string&
replace(iterator __i1, iterator __i2,
const _CharT* __k1, const _CharT* __k2)
{
;
;
return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
__k1, __k2 - __k1);
}
basic_string&
replace(iterator __i1, iterator __i2, iterator __k1, iterator __k2)
{
;
;
return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
__k1.base(), __k2 - __k1);
}
basic_string&
replace(iterator __i1, iterator __i2,
const_iterator __k1, const_iterator __k2)
{
;
;
return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
__k1.base(), __k2 - __k1);
}
#1663 "/opt/Xilinx/Vivado/2017.3/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); }
template<class _InputIterator>
basic_string&
_M_replace_dispatch(iterator __i1, iterator __i2, _InputIterator __k1,
_InputIterator __k2, __false_type);
basic_string&
_M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
_CharT __c);
basic_string&
_M_replace_safe(size_type __pos1, size_type __n1, const _CharT* __s,
size_type __n2);
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());
}
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); }
static _CharT*
_S_construct_aux_2(size_type __req, _CharT __c, const _Alloc& __a)
{ return _S_construct(__req, __c, __a); }
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());
}
template<class _InIterator>
static _CharT*
_S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
input_iterator_tag);
template<class _FwdIterator>
static _CharT*
_S_construct(_FwdIterator __beg, _FwdIterator __end, const _Alloc& __a,
forward_iterator_tag);
static _CharT*
_S_construct(size_type __req, _CharT __c, const _Alloc& __a);
public:
#1744 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
size_type
copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
#1754 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
void
swap(basic_string& __s);
#1764 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
const _CharT*
c_str() const
{ return _M_data(); }
const _CharT*
data() const
{ return _M_data(); }
allocator_type
get_allocator() const
{ return _M_dataplus; }
#1796 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
size_type
find(const _CharT* __s, size_type __pos, size_type __n) const;
#1809 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
size_type
find(const basic_string& __str, size_type __pos = 0) const
{ return this->find(__str.data(), __pos, __str.size()); }
#1823 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
size_type
find(const _CharT* __s, size_type __pos = 0) const
{
;
return this->find(__s, __pos, traits_type::length(__s));
}
#1840 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
size_type
find(_CharT __c, size_type __pos = 0) const;
#1853 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
size_type
rfind(const basic_string& __str, size_type __pos = npos) const
{ return this->rfind(__str.data(), __pos, __str.size()); }
#1868 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
size_type
rfind(const _CharT* __s, size_type __pos, size_type __n) const;
#1881 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
size_type
rfind(const _CharT* __s, size_type __pos = npos) const
{
;
return this->rfind(__s, __pos, traits_type::length(__s));
}
#1898 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
size_type
rfind(_CharT __c, size_type __pos = npos) const;
#1911 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
size_type
find_first_of(const basic_string& __str, size_type __pos = 0) const
{ return this->find_first_of(__str.data(), __pos, __str.size()); }
#1926 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
size_type
find_first_of(const _CharT* __s, size_type __pos, size_type __n) const;
#1939 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
size_type
find_first_of(const _CharT* __s, size_type __pos = 0) const
{
;
return this->find_first_of(__s, __pos, traits_type::length(__s));
}
#1958 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
size_type
find_first_of(_CharT __c, size_type __pos = 0) const
{ return this->find(__c, __pos); }
#1972 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
size_type
find_last_of(const basic_string& __str, size_type __pos = npos) const
{ return this->find_last_of(__str.data(), __pos, __str.size()); }
#1987 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
size_type
find_last_of(const _CharT* __s, size_type __pos, size_type __n) const;
#2000 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
size_type
find_last_of(const _CharT* __s, size_type __pos = npos) const
{
;
return this->find_last_of(__s, __pos, traits_type::length(__s));
}
#2019 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
size_type
find_last_of(_CharT __c, size_type __pos = npos) const
{ return this->rfind(__c, __pos); }
#2033 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
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()); }
#2048 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
size_type
find_first_not_of(const _CharT* __s, size_type __pos,
size_type __n) const;
#2062 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
size_type
find_first_not_of(const _CharT* __s, size_type __pos = 0) const
{
;
return this->find_first_not_of(__s, __pos, traits_type::length(__s));
}
#2079 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
size_type
find_first_not_of(_CharT __c, size_type __pos = 0) const;
#2092 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
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()); }
#2108 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
size_type
find_last_not_of(const _CharT* __s, size_type __pos,
size_type __n) const;
#2121 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
size_type
find_last_not_of(const _CharT* __s, size_type __pos = npos) const
{
;
return this->find_last_not_of(__s, __pos, traits_type::length(__s));
}
#2138 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
size_type
find_last_not_of(_CharT __c, size_type __pos = npos) const;
#2153 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
basic_string
substr(size_type __pos = 0, size_type __n = npos) const
{ return basic_string(*this,
_M_check(__pos, "basic_string::substr"), __n); }
#2171 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
int
compare(const basic_string& __str) const
{
const size_type __size = this->size();
const size_type __osize = __str.size();
const size_type __len = std::min(__size, __osize);
int __r = traits_type::compare(_M_data(), __str.data(), __len);
if (!__r)
__r = _S_compare(__size, __osize);
return __r;
}
#2201 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
int
compare(size_type __pos, size_type __n, const basic_string& __str) const;
#2225 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
int
compare(size_type __pos1, size_type __n1, const basic_string& __str,
size_type __pos2, size_type __n2) const;
#2243 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
int
compare(const _CharT* __s) const;
#2266 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
int
compare(size_type __pos, size_type __n1, const _CharT* __s) const;
#2291 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
int
compare(size_type __pos, size_type __n1, const _CharT* __s,
size_type __n2) const;
};
#2303 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>
operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{
basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
__str.append(__rhs);
return __str;
}
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT,_Traits,_Alloc>
operator+(const _CharT* __lhs,
const basic_string<_CharT,_Traits,_Alloc>& __rhs);
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT,_Traits,_Alloc>
operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs);
template<typename _CharT, typename _Traits, typename _Alloc>
inline basic_string<_CharT, _Traits, _Alloc>
operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
{
basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
__str.append(__rhs);
return __str;
}
template<typename _CharT, typename _Traits, typename _Alloc>
inline basic_string<_CharT, _Traits, _Alloc>
operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs)
{
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
typedef typename __string_type::size_type __size_type;
__string_type __str(__lhs);
__str.append(__size_type(1), __rhs);
return __str;
}
#2424 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ return __lhs.compare(__rhs) == 0; }
template<typename _CharT>
inline
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, bool>::__type
operator==(const basic_string<_CharT>& __lhs,
const basic_string<_CharT>& __rhs)
{ return (__lhs.size() == __rhs.size()
&& !std::char_traits<_CharT>::compare(__lhs.data(), __rhs.data(),
__lhs.size())); }
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator==(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ return __rhs.compare(__lhs) == 0; }
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
{ return __lhs.compare(__rhs) == 0; }
#2470 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ return !(__lhs == __rhs); }
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator!=(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ return !(__lhs == __rhs); }
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
{ return !(__lhs == __rhs); }
#2507 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ return __lhs.compare(__rhs) < 0; }
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
{ return __lhs.compare(__rhs) < 0; }
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator<(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ return __rhs.compare(__lhs) > 0; }
#2544 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ return __lhs.compare(__rhs) > 0; }
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
{ return __lhs.compare(__rhs) > 0; }
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator>(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ return __rhs.compare(__lhs) < 0; }
#2581 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ return __lhs.compare(__rhs) <= 0; }
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
{ return __lhs.compare(__rhs) <= 0; }
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator<=(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ return __rhs.compare(__lhs) >= 0; }
#2618 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ return __lhs.compare(__rhs) >= 0; }
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
{ return __lhs.compare(__rhs) >= 0; }
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator>=(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ return __rhs.compare(__lhs) <= 0; }
#2655 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
template<typename _CharT, typename _Traits, typename _Alloc>
inline void
swap(basic_string<_CharT, _Traits, _Alloc>& __lhs,
basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ __lhs.swap(__rhs); }
#2672 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
template<typename _CharT, typename _Traits, typename _Alloc>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is,
basic_string<_CharT, _Traits, _Alloc>& __str);
template<>
basic_istream<char>&
operator>>(basic_istream<char>& __is, basic_string<char>& __str);
#2690 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
template<typename _CharT, typename _Traits, typename _Alloc>
inline basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os,
const basic_string<_CharT, _Traits, _Alloc>& __str)
{
return __ostream_insert(__os, __str.data(), __str.size());
}
#2713 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
template<typename _CharT, typename _Traits, typename _Alloc>
basic_istream<_CharT, _Traits>&
getline(basic_istream<_CharT, _Traits>& __is,
basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim);
#2731 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.h" 3
template<typename _CharT, typename _Traits, typename _Alloc>
inline basic_istream<_CharT, _Traits>&
getline(basic_istream<_CharT, _Traits>& __is,
basic_string<_CharT, _Traits, _Alloc>& __str)
{ return getline(__is, __str, __is.widen('\n')); }
template<>
basic_istream<char>&
getline(basic_istream<char>& __in, basic_string<char>& __str,
char __delim);
template<>
basic_istream<wchar_t>&
getline(basic_istream<wchar_t>& __in, basic_string<wchar_t>& __str,
wchar_t __delim);
}
#54 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/string" 2 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.tcc" 1 3
#42 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.tcc" 3
#42 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits, typename _Alloc>
const typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
_Rep::_S_max_size = (((npos - sizeof(_Rep_base))/sizeof(_CharT)) - 1) / 4;
template<typename _CharT, typename _Traits, typename _Alloc>
const _CharT
basic_string<_CharT, _Traits, _Alloc>::
_Rep::_S_terminal = _CharT();
template<typename _CharT, typename _Traits, typename _Alloc>
const typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::npos;
template<typename _CharT, typename _Traits, typename _Alloc>
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)];
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)
{
if (__beg == __end && __a == _Alloc())
return _S_empty_rep()._M_refdata();
_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)
{
_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();
}
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)
{
if (__beg == __end && __a == _Alloc())
return _S_empty_rep()._M_refdata();
if (__gnu_cxx::__is_null_pointer(__beg) && __beg != __end)
__throw_logic_error(("basic_string::_S_construct null not valid"));
const size_type __dnew = static_cast<size_type>(std::distance(__beg,
__end));
_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();
}
template<typename _CharT, typename _Traits, typename _Alloc>
_CharT*
basic_string<_CharT, _Traits, _Alloc>::
_S_construct(size_type __n, _CharT __c, const _Alloc& __a)
{
if (__n == 0 && __a == _Alloc())
return _S_empty_rep()._M_refdata();
_Rep* __r = _Rep::_S_create(__n, size_type(0), __a);
if (__n)
_M_assign(__r->_M_refdata(), __n, __c);
__r->_M_set_length_and_sharable(__n);
return __r->_M_refdata();
}
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())
{ }
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)
{ }
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())
{ }
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)
{ }
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)
{ }
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)
{ }
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)
{ }
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)
{ }
#241 "/opt/Xilinx/Vivado/2017.3/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())
{
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;
}
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
{
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;
}
}
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;
}
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;
}
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;
}
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;
}
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
{
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;
}
}
template<typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::iterator
basic_string<_CharT, _Traits, _Alloc>::
erase(iterator __first, iterator __last)
{
;
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;
}
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)
{
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
{
const basic_string __tmp(__s, __n2);
return _M_replace_safe(__pos, __n1, __tmp._M_data(), __n2);
}
}
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);
}
template<typename _CharT, typename _Traits, typename _Alloc>
void
basic_string<_CharT, _Traits, _Alloc>::
_M_leak_hard()
{
if (_M_rep() == &_S_empty_rep())
return;
if (_M_rep()->_M_is_shared())
_M_mutate(0, 0, 0);
_M_rep()->_M_set_leaked();
}
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;
if (__new_size > this->capacity() || _M_rep()->_M_is_shared())
{
const allocator_type __a = get_allocator();
_Rep* __r = _Rep::_S_create(__new_size, this->capacity(), __a);
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);
_M_rep()->_M_dispose(__a);
_M_data(__r->_M_refdata());
}
else if (__how_much && __len1 != __len2)
{
_M_move(_M_data() + __pos + __len2,
_M_data() + __pos + __len1, __how_much);
}
_M_rep()->_M_set_length_and_sharable(__new_size);
}
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())
{
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);
}
}
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);
}
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;
}
}
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)
{
if (__capacity > _S_max_size)
__throw_length_error(("basic_string::_S_create"));
#578 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_string.tcc" 3
const size_type __pagesize = 4096;
const size_type __malloc_header_size = 4 * sizeof(void*);
if (__capacity > __old_capacity && __capacity < 2 * __old_capacity)
__capacity = 2 * __old_capacity;
size_type __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);
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);
if (__capacity > _S_max_size)
__capacity = _S_max_size;
__size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);
}
void* __place = _Raw_bytes_alloc(__alloc).allocate(__size);
_Rep *__p = new (__place) _Rep;
__p->_M_capacity = __capacity;
__p->_M_set_sharable();
return __p;
}
template<typename _CharT, typename _Traits, typename _Alloc>
_CharT*
basic_string<_CharT, _Traits, _Alloc>::_Rep::
_M_clone(const _Alloc& __alloc, size_type __res)
{
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);
__r->_M_set_length_and_sharable(this->_M_length);
return __r->_M_refdata();
}
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);
}
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());
}
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;
}
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;
}
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>
operator+(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{
;
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
typedef typename __string_type::size_type __size_type;
const __size_type __len = _Traits::length(__lhs);
__string_type __str;
__str.reserve(__len + __rhs.size());
__str.append(__lhs, __len);
__str.append(__rhs);
return __str;
}
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>
operator+(_CharT __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
typedef typename __string_type::size_type __size_type;
__string_type __str;
const __size_type __len = __rhs.size();
__str.reserve(__len + 1);
__str.append(__size_type(1), __lhs);
__str.append(__rhs);
return __str;
}
template<typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
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);
return __n;
}
template<typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
find(const _CharT* __s, size_type __pos, size_type __n) const
{
;
const size_type __size = this->size();
const _CharT* __data = _M_data();
if (__n == 0)
return __pos <= __size ? __pos : npos;
if (__n <= __size)
{
for (; __pos <= __size - __n; ++__pos)
if (traits_type::eq(__data[__pos], __s[0])
&& traits_type::compare(__data + __pos + 1,
__s + 1, __n - 1) == 0)
return __pos;
}
return npos;
}
template<typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
find(_CharT __c, size_type __pos) const
{
size_type __ret = npos;
const size_type __size = this->size();
if (__pos < __size)
{
const _CharT* __data = _M_data();
const size_type __n = __size - __pos;
const _CharT* __p = traits_type::find(__data + __pos, __n, __c);
if (__p)
__ret = __p - __data;
}
return __ret;
}
template<typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
rfind(const _CharT* __s, size_type __pos, size_type __n) const
{
;
const size_type __size = this->size();
if (__n <= __size)
{
__pos = std::min(size_type(__size - __n), __pos);
const _CharT* __data = _M_data();
do
{
if (traits_type::compare(__data + __pos, __s, __n) == 0)
return __pos;
}
while (__pos-- > 0);
}
return npos;
}
template<typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
rfind(_CharT __c, size_type __pos) const
{
size_type __size = this->size();
if (__size)
{
if (--__size > __pos)
__size = __pos;
for (++__size; __size-- > 0; )
if (traits_type::eq(_M_data()[__size], __c))
return __size;
}
return npos;
}
template<typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
{
;
for (; __n && __pos < this->size(); ++__pos)
{
const _CharT* __p = traits_type::find(__s, __n, _M_data()[__pos]);
if (__p)
return __pos;
}
return npos;
}
template<typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
{
;
size_type __size = this->size();
if (__size && __n)
{
if (--__size > __pos)
__size = __pos;
do
{
if (traits_type::find(__s, __n, _M_data()[__size]))
return __size;
}
while (__size-- != 0);
}
return npos;
}
template<typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const
{
;
for (; __pos < this->size(); ++__pos)
if (!traits_type::find(__s, __n, _M_data()[__pos]))
return __pos;
return npos;
}
template<typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
find_first_not_of(_CharT __c, size_type __pos) const
{
for (; __pos < this->size(); ++__pos)
if (!traits_type::eq(_M_data()[__pos], __c))
return __pos;
return npos;
}
template<typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const
{
;
size_type __size = this->size();
if (__size)
{
if (--__size > __pos)
__size = __pos;
do
{
if (!traits_type::find(__s, __n, _M_data()[__size]))
return __size;
}
while (__size--);
}
return npos;
}
template<typename _CharT, typename _Traits, typename _Alloc>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
find_last_not_of(_CharT __c, size_type __pos) const
{
size_type __size = this->size();
if (__size)
{
if (--__size > __pos)
__size = __pos;
do
{
if (!traits_type::eq(_M_data()[__size], __c))
return __size;
}
while (__size--);
}
return npos;
}
template<typename _CharT, typename _Traits, typename _Alloc>
int
basic_string<_CharT, _Traits, _Alloc>::
compare(size_type __pos, size_type __n, const basic_string& __str) const
{
_M_check(__pos, "basic_string::compare");
__n = _M_limit(__pos, __n);
const size_type __osize = __str.size();
const size_type __len = std::min(__n, __osize);
int __r = traits_type::compare(_M_data() + __pos, __str.data(), __len);
if (!__r)
__r = _S_compare(__n, __osize);
return __r;
}
template<typename _CharT, typename _Traits, typename _Alloc>
int
basic_string<_CharT, _Traits, _Alloc>::
compare(size_type __pos1, size_type __n1, const basic_string& __str,
size_type __pos2, size_type __n2) const
{
_M_check(__pos1, "basic_string::compare");
__str._M_check(__pos2, "basic_string::compare");
__n1 = _M_limit(__pos1, __n1);
__n2 = __str._M_limit(__pos2, __n2);
const size_type __len = std::min(__n1, __n2);
int __r = traits_type::compare(_M_data() + __pos1,
__str.data() + __pos2, __len);
if (!__r)
__r = _S_compare(__n1, __n2);
return __r;
}
template<typename _CharT, typename _Traits, typename _Alloc>
int
basic_string<_CharT, _Traits, _Alloc>::
compare(const _CharT* __s) const
{
;
const size_type __size = this->size();
const size_type __osize = traits_type::length(__s);
const size_type __len = std::min(__size, __osize);
int __r = traits_type::compare(_M_data(), __s, __len);
if (!__r)
__r = _S_compare(__size, __osize);
return __r;
}
template<typename _CharT, typename _Traits, typename _Alloc>
int
basic_string <_CharT, _Traits, _Alloc>::
compare(size_type __pos, size_type __n1, const _CharT* __s) const
{
;
_M_check(__pos, "basic_string::compare");
__n1 = _M_limit(__pos, __n1);
const size_type __osize = traits_type::length(__s);
const size_type __len = std::min(__n1, __osize);
int __r = traits_type::compare(_M_data() + __pos, __s, __len);
if (!__r)
__r = _S_compare(__n1, __osize);
return __r;
}
template<typename _CharT, typename _Traits, typename _Alloc>
int
basic_string <_CharT, _Traits, _Alloc>::
compare(size_type __pos, size_type __n1, const _CharT* __s,
size_type __n2) const
{
;
_M_check(__pos, "basic_string::compare");
__n1 = _M_limit(__pos, __n1);
const size_type __len = std::min(__n1, __n2);
int __r = traits_type::compare(_M_data() + __pos, __s, __len);
if (!__r)
__r = _S_compare(__n1, __n2);
return __r;
}
template<typename _CharT, typename _Traits, typename _Alloc>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __in,
basic_string<_CharT, _Traits, _Alloc>& __str)
{
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
typedef typename __istream_type::ios_base __ios_base;
typedef typename __istream_type::int_type __int_type;
typedef typename __string_type::size_type __size_type;
typedef ctype<_CharT> __ctype_type;
typedef typename __ctype_type::ctype_base __ctype_base;
__size_type __extracted = 0;
typename __ios_base::iostate __err = __ios_base::goodbit;
typename __istream_type::sentry __cerb(__in, false);
if (__cerb)
{
if (true)
{
__str.erase();
_CharT __buf[128];
__size_type __len = 0;
const streamsize __w = __in.width();
const __size_type __n = __w > 0 ? static_cast<__size_type>(__w)
: __str.max_size();
const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
const __int_type __eof = _Traits::eof();
__int_type __c = __in.rdbuf()->sgetc();
while (__extracted < __n
&& !_Traits::eq_int_type(__c, __eof)
&& !__ct.is(__ctype_base::space,
_Traits::to_char_type(__c)))
{
if (__len == sizeof(__buf) / sizeof(_CharT))
{
__str.append(__buf, sizeof(__buf) / sizeof(_CharT));
__len = 0;
}
__buf[__len++] = _Traits::to_char_type(__c);
++__extracted;
__c = __in.rdbuf()->snextc();
}
__str.append(__buf, __len);
if (_Traits::eq_int_type(__c, __eof))
__err |= __ios_base::eofbit;
__in.width(0);
}
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;
}
template<typename _CharT, typename _Traits, typename _Alloc>
basic_istream<_CharT, _Traits>&
getline(basic_istream<_CharT, _Traits>& __in,
basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
{
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
typedef typename __istream_type::ios_base __ios_base;
typedef typename __istream_type::int_type __int_type;
typedef typename __string_type::size_type __size_type;
__size_type __extracted = 0;
const __size_type __n = __str.max_size();
typename __ios_base::iostate __err = __ios_base::goodbit;
typename __istream_type::sentry __cerb(__in, true);
if (__cerb)
{
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();
while (__extracted < __n
&& !_Traits::eq_int_type(__c, __eof)
&& !_Traits::eq_int_type(__c, __idelim))
{
__str += _Traits::to_char_type(__c);
++__extracted;
__c = __in.rdbuf()->snextc();
}
if (_Traits::eq_int_type(__c, __eof))
__err |= __ios_base::eofbit;
else if (_Traits::eq_int_type(__c, __idelim))
{
++__extracted;
__in.rdbuf()->sbumpc();
}
else
__err |= __ios_base::failbit;
}
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;
}
extern template class basic_string<char>;
extern template
basic_istream<char>&
operator>>(basic_istream<char>&, string&);
extern template
basic_ostream<char>&
operator<<(basic_ostream<char>&, const string&);
extern template
basic_istream<char>&
getline(basic_istream<char>&, string&, char);
extern template
basic_istream<char>&
getline(basic_istream<char>&, string&);
extern template class basic_string<wchar_t>;
extern template
basic_istream<wchar_t>&
operator>>(basic_istream<wchar_t>&, wstring&);
extern template
basic_ostream<wchar_t>&
operator<<(basic_ostream<wchar_t>&, const wstring&);
extern template
basic_istream<wchar_t>&
getline(basic_istream<wchar_t>&, wstring&, wchar_t);
extern template
basic_istream<wchar_t>&
getline(basic_istream<wchar_t>&, wstring&);
}
#55 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/string" 2 3
#42 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_classes.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
#63 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_classes.h" 3
class locale
{
public:
typedef int category;
class facet;
class id;
class _Impl;
friend class facet;
friend class _Impl;
template<typename _Facet>
friend bool
has_facet(const locale&) throw();
template<typename _Facet>
friend const _Facet&
use_facet(const locale&);
template<typename _Cache>
friend struct __use_cache;
#99 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_classes.h" 3
static const category none = 0;
static const category ctype = 1L << 0;
static const category numeric = 1L << 1;
static const category collate = 1L << 2;
static const category time = 1L << 3;
static const category monetary = 1L << 4;
static const category messages = 1L << 5;
static const category all = (ctype | numeric | collate |
time | monetary | messages);
#118 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_classes.h" 3
locale() throw();
#127 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_classes.h" 3
locale(const locale& __other) throw();
#137 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_classes.h" 3
explicit
locale(const char* __s);
#152 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_classes.h" 3
locale(const locale& __base, const char* __s, category __cat);
#165 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_classes.h" 3
locale(const locale& __base, const locale& __add, category __cat);
#177 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_classes.h" 3
template<typename _Facet>
locale(const locale& __other, _Facet* __f);
~locale() throw();
#191 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_classes.h" 3
const locale&
operator=(const locale& __other) throw();
#206 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_classes.h" 3
template<typename _Facet>
locale
combine(const locale& __other) const;
string
name() const;
#225 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_classes.h" 3
bool
operator==(const locale& __other) const throw();
bool
operator!=(const locale& __other) const throw()
{ return !(this->operator==(__other)); }
#253 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_classes.h" 3
template<typename _Char, typename _Traits, typename _Alloc>
bool
operator()(const basic_string<_Char, _Traits, _Alloc>& __s1,
const basic_string<_Char, _Traits, _Alloc>& __s2) const;
#269 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_classes.h" 3
static locale
global(const locale&);
static const locale&
classic();
private:
_Impl* _M_impl;
static _Impl* _S_classic;
static _Impl* _S_global;
static const char* const* const _S_categories;
#304 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_classes.h" 3
enum { _S_categories_size = 6 + 6 };
static __gthread_once_t _S_once;
explicit
locale(_Impl*) throw();
static void
_S_initialize();
static void
_S_initialize_once() throw();
static category
_S_normalize_category(category);
void
_M_coalesce(const locale& __base, const locale& __add, category __cat);
};
#338 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_classes.h" 3
class locale::facet
{
private:
friend class locale;
friend class locale::_Impl;
mutable _Atomic_word _M_refcount;
static __c_locale _S_c_locale;
static const char _S_c_name[2];
static __gthread_once_t _S_once;
static void
_S_initialize_once();
protected:
#369 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_classes.h" 3
explicit
facet(size_t __refs = 0) throw() : _M_refcount(__refs ? 1 : 0)
{ }
virtual
~facet();
static void
_S_create_c_locale(__c_locale& __cloc, const char* __s,
__c_locale __old = 0);
static __c_locale
_S_clone_c_locale(__c_locale& __cloc) throw();
static void
_S_destroy_c_locale(__c_locale& __cloc);
static __c_locale
_S_lc_ctype_c_locale(__c_locale __cloc, const char* __s);
static __c_locale
_S_get_c_locale();
__attribute__ ((__const__)) static const char*
_S_get_c_name() throw();
private:
void
_M_add_reference() const throw()
{ __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
void
_M_remove_reference() const throw()
{
;
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
{
;
if (true)
{ delete this; }
if (false)
{ }
}
}
facet(const facet&);
facet&
operator=(const facet&);
};
#436 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_classes.h" 3
class locale::id
{
private:
friend class locale;
friend class locale::_Impl;
template<typename _Facet>
friend const _Facet&
use_facet(const locale&);
template<typename _Facet>
friend bool
has_facet(const locale&) throw();
mutable size_t _M_index;
static _Atomic_word _S_refcount;
void
operator=(const id&);
id(const id&);
public:
id() { }
size_t
_M_id() const throw();
};
class locale::_Impl
{
public:
friend class locale;
friend class locale::facet;
template<typename _Facet>
friend bool
has_facet(const locale&) throw();
template<typename _Facet>
friend const _Facet&
use_facet(const locale&);
template<typename _Cache>
friend struct __use_cache;
private:
_Atomic_word _M_refcount;
const facet** _M_facets;
size_t _M_facets_size;
const facet** _M_caches;
char** _M_names;
static const locale::id* const _S_id_ctype[];
static const locale::id* const _S_id_numeric[];
static const locale::id* const _S_id_collate[];
static const locale::id* const _S_id_time[];
static const locale::id* const _S_id_monetary[];
static const locale::id* const _S_id_messages[];
static const locale::id* const* const _S_facet_categories[];
void
_M_add_reference() throw()
{ __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
void
_M_remove_reference() throw()
{
;
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
{
;
if (true)
{ delete this; }
if (false)
{ }
}
}
_Impl(const _Impl&, size_t);
_Impl(const char*, size_t);
_Impl(size_t) throw();
~_Impl() throw();
_Impl(const _Impl&);
void
operator=(const _Impl&);
bool
_M_check_same_name()
{
bool __ret = true;
if (_M_names[1])
for (size_t __i = 0; __ret && __i < _S_categories_size - 1; ++__i)
__ret = __builtin_strcmp(_M_names[__i], _M_names[__i + 1]) == 0;
return __ret;
}
void
_M_replace_categories(const _Impl*, category);
void
_M_replace_category(const _Impl*, const locale::id* const*);
void
_M_replace_facet(const _Impl*, const locale::id*);
void
_M_install_facet(const locale::id*, const facet*);
template<typename _Facet>
void
_M_init_facet(_Facet* __facet)
{ _M_install_facet(&_Facet::id, __facet); }
void
_M_install_cache(const facet*, size_t);
};
#582 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_classes.h" 3
template<typename _Facet>
bool
has_facet(const locale& __loc) throw();
#599 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_classes.h" 3
template<typename _Facet>
const _Facet&
use_facet(const locale& __loc);
#616 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_classes.h" 3
template<typename _CharT>
class collate : public locale::facet
{
public:
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;
protected:
__c_locale _M_c_locale_collate;
public:
static locale::id id;
#643 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_classes.h" 3
explicit
collate(size_t __refs = 0)
: facet(__refs), _M_c_locale_collate(_S_get_c_locale())
{ }
#657 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_classes.h" 3
explicit
collate(__c_locale __cloc, size_t __refs = 0)
: facet(__refs), _M_c_locale_collate(_S_clone_c_locale(__cloc))
{ }
#674 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_classes.h" 3
int
compare(const _CharT* __lo1, const _CharT* __hi1,
const _CharT* __lo2, const _CharT* __hi2) const
{ return this->do_compare(__lo1, __hi1, __lo2, __hi2); }
#693 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_classes.h" 3
string_type
transform(const _CharT* __lo, const _CharT* __hi) const
{ return this->do_transform(__lo, __hi); }
#707 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_classes.h" 3
long
hash(const _CharT* __lo, const _CharT* __hi) const
{ return this->do_hash(__lo, __hi); }
int
_M_compare(const _CharT*, const _CharT*) const throw();
size_t
_M_transform(_CharT*, const _CharT*, size_t) const throw();
protected:
virtual
~collate()
{ _S_destroy_c_locale(_M_c_locale_collate); }
#736 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_classes.h" 3
virtual int
do_compare(const _CharT* __lo1, const _CharT* __hi1,
const _CharT* __lo2, const _CharT* __hi2) const;
#752 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_classes.h" 3
virtual string_type
do_transform(const _CharT* __lo, const _CharT* __hi) const;
#765 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_classes.h" 3
virtual long
do_hash(const _CharT* __lo, const _CharT* __hi) const;
};
template<typename _CharT>
locale::id collate<_CharT>::id;
template<>
int
collate<char>::_M_compare(const char*, const char*) const throw();
template<>
size_t
collate<char>::_M_transform(char*, const char*, size_t) const throw();
template<>
int
collate<wchar_t>::_M_compare(const wchar_t*, const wchar_t*) const throw();
template<>
size_t
collate<wchar_t>::_M_transform(wchar_t*, const wchar_t*, size_t) const throw();
template<typename _CharT>
class collate_byname : public collate<_CharT>
{
public:
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;
explicit
collate_byname(const char* __s, size_t __refs = 0)
: collate<_CharT>(__refs)
{
if (__builtin_strcmp(__s, "C") != 0
&& __builtin_strcmp(__s, "POSIX") != 0)
{
this->_S_destroy_c_locale(this->_M_c_locale_collate);
this->_S_create_c_locale(this->_M_c_locale_collate, __s);
}
}
protected:
virtual
~collate_byname() { }
};
}
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_classes.tcc" 1 3
#37 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_classes.tcc" 3
#37 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_classes.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Facet>
locale::
locale(const locale& __other, _Facet* __f)
{
_M_impl = new _Impl(*__other._M_impl, 1);
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;
}
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);
}
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);
}
template<typename _Facet>
bool
has_facet(const locale& __loc) throw()
{
const size_t __i = _Facet::id._M_id();
const locale::facet** __facets = __loc._M_impl->_M_facets;
return (__i < __loc._M_impl->_M_facets_size
&& dynamic_cast<const _Facet*>(__facets[__i]));
}
template<typename _Facet>
const _Facet&
use_facet(const locale& __loc)
{
const size_t __i = _Facet::id._M_id();
const locale::facet** __facets = __loc._M_impl->_M_facets;
if (__i >= __loc._M_impl->_M_facets_size || !__facets[__i])
__throw_bad_cast();
return dynamic_cast<const _Facet&>(*__facets[__i]);
}
template<typename _CharT>
int
collate<_CharT>::_M_compare(const _CharT*, const _CharT*) const throw ()
{ return 0; }
template<typename _CharT>
size_t
collate<_CharT>::_M_transform(_CharT*, const _CharT*, size_t) const throw ()
{ return 0; }
template<typename _CharT>
int
collate<_CharT>::
do_compare(const _CharT* __lo1, const _CharT* __hi1,
const _CharT* __lo2, const _CharT* __hi2) const
{
const string_type __one(__lo1, __hi1);
const string_type __two(__lo2, __hi2);
const _CharT* __p = __one.c_str();
const _CharT* __pend = __one.data() + __one.length();
const _CharT* __q = __two.c_str();
const _CharT* __qend = __two.data() + __two.length();
for (;;)
{
const int __res = _M_compare(__p, __q);
if (__res)
return __res;
__p += char_traits<_CharT>::length(__p);
__q += char_traits<_CharT>::length(__q);
if (__p == __pend && __q == __qend)
return 0;
else if (__p == __pend)
return -1;
else if (__q == __qend)
return 1;
__p++;
__q++;
}
}
template<typename _CharT>
typename collate<_CharT>::string_type
collate<_CharT>::
do_transform(const _CharT* __lo, const _CharT* __hi) const
{
string_type __ret;
const string_type __str(__lo, __hi);
const _CharT* __p = __str.c_str();
const _CharT* __pend = __str.data() + __str.length();
size_t __len = (__hi - __lo) * 2;
_CharT* __c = new _CharT[__len];
if (true)
{
for (;;)
{
size_t __res = _M_transform(__c, __p, __len);
if (__res >= __len)
{
__len = __res + 1;
delete [] __c, __c = 0;
__c = new _CharT[__len];
__res = _M_transform(__c, __p, __len);
}
__ret.append(__c, __res);
__p += char_traits<_CharT>::length(__p);
if (__p == __pend)
break;
__p++;
__ret.push_back(_CharT());
}
}
if (false)
{
delete [] __c;
;
}
delete [] __c;
return __ret;
}
template<typename _CharT>
long
collate<_CharT>::
do_hash(const _CharT* __lo, const _CharT* __hi) const
{
unsigned long __val = 0;
for (; __lo < __hi; ++__lo)
__val =
*__lo + ((__val << 7)
| (__val >> (__gnu_cxx::__numeric_traits<unsigned long>::
__digits - 7)));
return static_cast<long>(__val);
}
extern template class collate<char>;
extern template class collate_byname<char>;
extern template
const collate<char>&
use_facet<collate<char> >(const locale&);
extern template
bool
has_facet<collate<char> >(const locale&);
extern template class collate<wchar_t>;
extern template class collate_byname<wchar_t>;
extern template
const collate<wchar_t>&
use_facet<collate<wchar_t> >(const locale&);
extern template
bool
has_facet<collate<wchar_t> >(const locale&);
}
#823 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_classes.h" 2 3
#43 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/ios_base.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
enum _Ios_Fmtflags
{
_S_boolalpha = 1L << 0,
_S_dec = 1L << 1,
_S_fixed = 1L << 2,
_S_hex = 1L << 3,
_S_internal = 1L << 4,
_S_left = 1L << 5,
_S_oct = 1L << 6,
_S_right = 1L << 7,
_S_scientific = 1L << 8,
_S_showbase = 1L << 9,
_S_showpoint = 1L << 10,
_S_showpos = 1L << 11,
_S_skipws = 1L << 12,
_S_unitbuf = 1L << 13,
_S_uppercase = 1L << 14,
_S_adjustfield = _S_left | _S_right | _S_internal,
_S_basefield = _S_dec | _S_oct | _S_hex,
_S_floatfield = _S_scientific | _S_fixed,
_S_ios_fmtflags_end = 1L << 16
};
inline _Ios_Fmtflags
operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
{ return _Ios_Fmtflags(static_cast<int>(__a) & static_cast<int>(__b)); }
inline _Ios_Fmtflags
operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
{ return _Ios_Fmtflags(static_cast<int>(__a) | static_cast<int>(__b)); }
inline _Ios_Fmtflags
operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
{ return _Ios_Fmtflags(static_cast<int>(__a) ^ static_cast<int>(__b)); }
inline _Ios_Fmtflags
operator~(_Ios_Fmtflags __a)
{ return _Ios_Fmtflags(~static_cast<int>(__a)); }
inline const _Ios_Fmtflags&
operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
{ return __a = __a | __b; }
inline const _Ios_Fmtflags&
operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
{ return __a = __a & __b; }
inline const _Ios_Fmtflags&
operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
{ return __a = __a ^ __b; }
enum _Ios_Openmode
{
_S_app = 1L << 0,
_S_ate = 1L << 1,
_S_bin = 1L << 2,
_S_in = 1L << 3,
_S_out = 1L << 4,
_S_trunc = 1L << 5,
_S_ios_openmode_end = 1L << 16
};
inline _Ios_Openmode
operator&(_Ios_Openmode __a, _Ios_Openmode __b)
{ return _Ios_Openmode(static_cast<int>(__a) & static_cast<int>(__b)); }
inline _Ios_Openmode
operator|(_Ios_Openmode __a, _Ios_Openmode __b)
{ return _Ios_Openmode(static_cast<int>(__a) | static_cast<int>(__b)); }
inline _Ios_Openmode
operator^(_Ios_Openmode __a, _Ios_Openmode __b)
{ return _Ios_Openmode(static_cast<int>(__a) ^ static_cast<int>(__b)); }
inline _Ios_Openmode
operator~(_Ios_Openmode __a)
{ return _Ios_Openmode(~static_cast<int>(__a)); }
inline const _Ios_Openmode&
operator|=(_Ios_Openmode& __a, _Ios_Openmode __b)
{ return __a = __a | __b; }
inline const _Ios_Openmode&
operator&=(_Ios_Openmode& __a, _Ios_Openmode __b)
{ return __a = __a & __b; }
inline const _Ios_Openmode&
operator^=(_Ios_Openmode& __a, _Ios_Openmode __b)
{ return __a = __a ^ __b; }
enum _Ios_Iostate
{
_S_goodbit = 0,
_S_badbit = 1L << 0,
_S_eofbit = 1L << 1,
_S_failbit = 1L << 2,
_S_ios_iostate_end = 1L << 16
};
inline _Ios_Iostate
operator&(_Ios_Iostate __a, _Ios_Iostate __b)
{ return _Ios_Iostate(static_cast<int>(__a) & static_cast<int>(__b)); }
inline _Ios_Iostate
operator|(_Ios_Iostate __a, _Ios_Iostate __b)
{ return _Ios_Iostate(static_cast<int>(__a) | static_cast<int>(__b)); }
inline _Ios_Iostate
operator^(_Ios_Iostate __a, _Ios_Iostate __b)
{ return _Ios_Iostate(static_cast<int>(__a) ^ static_cast<int>(__b)); }
inline _Ios_Iostate
operator~(_Ios_Iostate __a)
{ return _Ios_Iostate(~static_cast<int>(__a)); }
inline const _Ios_Iostate&
operator|=(_Ios_Iostate& __a, _Ios_Iostate __b)
{ return __a = __a | __b; }
inline const _Ios_Iostate&
operator&=(_Ios_Iostate& __a, _Ios_Iostate __b)
{ return __a = __a & __b; }
inline const _Ios_Iostate&
operator^=(_Ios_Iostate& __a, _Ios_Iostate __b)
{ return __a = __a ^ __b; }
enum _Ios_Seekdir
{
_S_beg = 0,
_S_cur = 1,
_S_end = 2,
_S_ios_seekdir_end = 1L << 16
};
#200 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/ios_base.h" 3
class ios_base
{
public:
class failure : public exception
{
public:
explicit
failure(const string& __str) throw();
virtual
~failure() throw();
virtual const char*
what() const throw();
private:
string _M_msg;
};
#256 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/ios_base.h" 3
typedef _Ios_Fmtflags fmtflags;
static const fmtflags boolalpha = _S_boolalpha;
static const fmtflags dec = _S_dec;
static const fmtflags fixed = _S_fixed;
static const fmtflags hex = _S_hex;
static const fmtflags internal = _S_internal;
static const fmtflags left = _S_left;
static const fmtflags oct = _S_oct;
static const fmtflags right = _S_right;
static const fmtflags scientific = _S_scientific;
static const fmtflags showbase = _S_showbase;
static const fmtflags showpoint = _S_showpoint;
static const fmtflags showpos = _S_showpos;
static const fmtflags skipws = _S_skipws;
static const fmtflags unitbuf = _S_unitbuf;
static const fmtflags uppercase = _S_uppercase;
static const fmtflags adjustfield = _S_adjustfield;
static const fmtflags basefield = _S_basefield;
static const fmtflags floatfield = _S_floatfield;
#331 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/ios_base.h" 3
typedef _Ios_Iostate iostate;
static const iostate badbit = _S_badbit;
static const iostate eofbit = _S_eofbit;
static const iostate failbit = _S_failbit;
static const iostate goodbit = _S_goodbit;
#362 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/ios_base.h" 3
typedef _Ios_Openmode openmode;
static const openmode app = _S_app;
static const openmode ate = _S_ate;
static const openmode binary = _S_bin;
static const openmode in = _S_in;
static const openmode out = _S_out;
static const openmode trunc = _S_trunc;
#394 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/ios_base.h" 3
typedef _Ios_Seekdir seekdir;
static const seekdir beg = _S_beg;
static const seekdir cur = _S_cur;
static const seekdir end = _S_end;
typedef int io_state;
typedef int open_mode;
typedef int seek_dir;
typedef std::streampos streampos;
typedef std::streamoff streamoff;
#420 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/ios_base.h" 3
enum event
{
erase_event,
imbue_event,
copyfmt_event
};
#437 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/ios_base.h" 3
typedef void (*event_callback) (event, ios_base&, int);
#449 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/ios_base.h" 3
void
register_callback(event_callback __fn, int __index);
protected:
streamsize _M_precision;
streamsize _M_width;
fmtflags _M_flags;
iostate _M_exception;
iostate _M_streambuf_state;
struct _Callback_list
{
_Callback_list* _M_next;
ios_base::event_callback _M_fn;
int _M_index;
_Atomic_word _M_refcount;
_Callback_list(ios_base::event_callback __fn, int __index,
_Callback_list* __cb)
: _M_next(__cb), _M_fn(__fn), _M_index(__index), _M_refcount(0) { }
void
_M_add_reference() { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
int
_M_remove_reference()
{
;
int __res = __gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1);
if (__res == 0)
{
;
}
return __res;
}
};
_Callback_list* _M_callbacks;
void
_M_call_callbacks(event __ev) throw();
void
_M_dispose_callbacks(void) throw();
struct _Words
{
void* _M_pword;
long _M_iword;
_Words() : _M_pword(0), _M_iword(0) { }
};
_Words _M_word_zero;
enum { _S_local_word_size = 8 };
_Words _M_local_word[_S_local_word_size];
int _M_word_size;
_Words* _M_word;
_Words&
_M_grow_words(int __index, bool __iword);
locale _M_ios_locale;
void
_M_init() throw();
public:
class Init
{
friend class ios_base;
public:
Init();
~Init();
private:
static _Atomic_word _S_refcount;
static bool _S_synced_with_stdio;
};
fmtflags
flags() const
{ return _M_flags; }
#562 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/ios_base.h" 3
fmtflags
flags(fmtflags __fmtfl)
{
fmtflags __old = _M_flags;
_M_flags = __fmtfl;
return __old;
}
#578 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/ios_base.h" 3
fmtflags
setf(fmtflags __fmtfl)
{
fmtflags __old = _M_flags;
_M_flags |= __fmtfl;
return __old;
}
#595 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/ios_base.h" 3
fmtflags
setf(fmtflags __fmtfl, fmtflags __mask)
{
fmtflags __old = _M_flags;
_M_flags &= ~__mask;
_M_flags |= (__fmtfl & __mask);
return __old;
}
void
unsetf(fmtflags __mask)
{ _M_flags &= ~__mask; }
#621 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/ios_base.h" 3
streamsize
precision() const
{ return _M_precision; }
streamsize
precision(streamsize __prec)
{
streamsize __old = _M_precision;
_M_precision = __prec;
return __old;
}
streamsize
width() const
{ return _M_width; }
streamsize
width(streamsize __wide)
{
streamsize __old = _M_width;
_M_width = __wide;
return __old;
}
#672 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/ios_base.h" 3
static bool
sync_with_stdio(bool __sync = true);
#684 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/ios_base.h" 3
locale
imbue(const locale& __loc) throw();
#695 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/ios_base.h" 3
locale
getloc() const
{ return _M_ios_locale; }
#706 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/ios_base.h" 3
const locale&
_M_getloc() const
{ return _M_ios_locale; }
#725 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/ios_base.h" 3
static int
xalloc() throw();
#741 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/ios_base.h" 3
long&
iword(int __ix)
{
_Words& __word = (__ix < _M_word_size)
? _M_word[__ix] : _M_grow_words(__ix, true);
return __word._M_iword;
}
#762 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/ios_base.h" 3
void*&
pword(int __ix)
{
_Words& __word = (__ix < _M_word_size)
? _M_word[__ix] : _M_grow_words(__ix, false);
return __word._M_pword;
}
#779 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/ios_base.h" 3
virtual ~ios_base();
protected:
ios_base() throw ();
private:
ios_base(const ios_base&);
ios_base&
operator=(const ios_base&);
};
inline ios_base&
boolalpha(ios_base& __base)
{
__base.setf(ios_base::boolalpha);
return __base;
}
inline ios_base&
noboolalpha(ios_base& __base)
{
__base.unsetf(ios_base::boolalpha);
return __base;
}
inline ios_base&
showbase(ios_base& __base)
{
__base.setf(ios_base::showbase);
return __base;
}
inline ios_base&
noshowbase(ios_base& __base)
{
__base.unsetf(ios_base::showbase);
return __base;
}
inline ios_base&
showpoint(ios_base& __base)
{
__base.setf(ios_base::showpoint);
return __base;
}
inline ios_base&
noshowpoint(ios_base& __base)
{
__base.unsetf(ios_base::showpoint);
return __base;
}
inline ios_base&
showpos(ios_base& __base)
{
__base.setf(ios_base::showpos);
return __base;
}
inline ios_base&
noshowpos(ios_base& __base)
{
__base.unsetf(ios_base::showpos);
return __base;
}
inline ios_base&
skipws(ios_base& __base)
{
__base.setf(ios_base::skipws);
return __base;
}
inline ios_base&
noskipws(ios_base& __base)
{
__base.unsetf(ios_base::skipws);
return __base;
}
inline ios_base&
uppercase(ios_base& __base)
{
__base.setf(ios_base::uppercase);
return __base;
}
inline ios_base&
nouppercase(ios_base& __base)
{
__base.unsetf(ios_base::uppercase);
return __base;
}
inline ios_base&
unitbuf(ios_base& __base)
{
__base.setf(ios_base::unitbuf);
return __base;
}
inline ios_base&
nounitbuf(ios_base& __base)
{
__base.unsetf(ios_base::unitbuf);
return __base;
}
inline ios_base&
internal(ios_base& __base)
{
__base.setf(ios_base::internal, ios_base::adjustfield);
return __base;
}
inline ios_base&
left(ios_base& __base)
{
__base.setf(ios_base::left, ios_base::adjustfield);
return __base;
}
inline ios_base&
right(ios_base& __base)
{
__base.setf(ios_base::right, ios_base::adjustfield);
return __base;
}
inline ios_base&
dec(ios_base& __base)
{
__base.setf(ios_base::dec, ios_base::basefield);
return __base;
}
inline ios_base&
hex(ios_base& __base)
{
__base.setf(ios_base::hex, ios_base::basefield);
return __base;
}
inline ios_base&
oct(ios_base& __base)
{
__base.setf(ios_base::oct, ios_base::basefield);
return __base;
}
inline ios_base&
fixed(ios_base& __base)
{
__base.setf(ios_base::fixed, ios_base::floatfield);
return __base;
}
inline ios_base&
scientific(ios_base& __base)
{
__base.setf(ios_base::scientific, ios_base::floatfield);
return __base;
}
}
#43 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ios" 2 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/streambuf" 1 3
#37 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/streambuf" 3
#37 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/streambuf" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits>
streamsize
__copy_streambufs_eof(basic_streambuf<_CharT, _Traits>*,
basic_streambuf<_CharT, _Traits>*, bool&);
#115 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/streambuf" 3
template<typename _CharT, typename _Traits>
class basic_streambuf
{
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type;
typedef basic_streambuf<char_type, traits_type> __streambuf_type;
friend class basic_ios<char_type, traits_type>;
friend class basic_istream<char_type, traits_type>;
friend class basic_ostream<char_type, traits_type>;
friend class istreambuf_iterator<char_type, traits_type>;
friend class ostreambuf_iterator<char_type, traits_type>;
friend streamsize
__copy_streambufs_eof<>(__streambuf_type*, __streambuf_type*, bool&);
template<bool _IsMove, typename _CharT2>
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
_CharT2*>::__type
__copy_move_a2(istreambuf_iterator<_CharT2>,
istreambuf_iterator<_CharT2>, _CharT2*);
template<typename _CharT2>
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
istreambuf_iterator<_CharT2> >::__type
find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
const _CharT2&);
template<typename _CharT2, typename _Traits2>
friend basic_istream<_CharT2, _Traits2>&
operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2*);
template<typename _CharT2, typename _Traits2, typename _Alloc>
friend basic_istream<_CharT2, _Traits2>&
operator>>(basic_istream<_CharT2, _Traits2>&,
basic_string<_CharT2, _Traits2, _Alloc>&);
template<typename _CharT2, typename _Traits2, typename _Alloc>
friend basic_istream<_CharT2, _Traits2>&
getline(basic_istream<_CharT2, _Traits2>&,
basic_string<_CharT2, _Traits2, _Alloc>&, _CharT2);
protected:
#181 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/streambuf" 3
char_type* _M_in_beg;
char_type* _M_in_cur;
char_type* _M_in_end;
char_type* _M_out_beg;
char_type* _M_out_cur;
char_type* _M_out_end;
locale _M_buf_locale;
public:
virtual
~basic_streambuf()
{ }
#205 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/streambuf" 3
locale
pubimbue(const locale &__loc)
{
locale __tmp(this->getloc());
this->imbue(__loc);
_M_buf_locale = __loc;
return __tmp;
}
#222 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/streambuf" 3
locale
getloc() const
{ return _M_buf_locale; }
#235 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/streambuf" 3
__streambuf_type*
pubsetbuf(char_type* __s, streamsize __n)
{ return this->setbuf(__s, __n); }
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); }
pos_type
pubseekpos(pos_type __sp,
ios_base::openmode __mode = ios_base::in | ios_base::out)
{ return this->seekpos(__sp, __mode); }
int
pubsync() { return this->sync(); }
#262 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/streambuf" 3
streamsize
in_avail()
{
const streamsize __ret = this->egptr() - this->gptr();
return __ret ? __ret : this->showmanyc();
}
#276 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/streambuf" 3
int_type
snextc()
{
int_type __ret = traits_type::eof();
if (__builtin_expect(!traits_type::eq_int_type(this->sbumpc(),
__ret), true))
__ret = this->sgetc();
return __ret;
}
#294 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/streambuf" 3
int_type
sbumpc()
{
int_type __ret;
if (__builtin_expect(this->gptr() < this->egptr(), true))
{
__ret = traits_type::to_int_type(*this->gptr());
this->gbump(1);
}
else
__ret = this->uflow();
return __ret;
}
#316 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/streambuf" 3
int_type
sgetc()
{
int_type __ret;
if (__builtin_expect(this->gptr() < this->egptr(), true))
__ret = traits_type::to_int_type(*this->gptr());
else
__ret = this->underflow();
return __ret;
}
#335 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/streambuf" 3
streamsize
sgetn(char_type* __s, streamsize __n)
{ return this->xsgetn(__s, __n); }
#350 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/streambuf" 3
int_type
sputbackc(char_type __c)
{
int_type __ret;
const bool __testpos = this->eback() < this->gptr();
if (__builtin_expect(!__testpos ||
!traits_type::eq(__c, this->gptr()[-1]), false))
__ret = this->pbackfail(traits_type::to_int_type(__c));
else
{
this->gbump(-1);
__ret = traits_type::to_int_type(*this->gptr());
}
return __ret;
}
#375 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/streambuf" 3
int_type
sungetc()
{
int_type __ret;
if (__builtin_expect(this->eback() < this->gptr(), true))
{
this->gbump(-1);
__ret = traits_type::to_int_type(*this->gptr());
}
else
__ret = this->pbackfail();
return __ret;
}
#402 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/streambuf" 3
int_type
sputc(char_type __c)
{
int_type __ret;
if (__builtin_expect(this->pptr() < this->epptr(), true))
{
*this->pptr() = __c;
this->pbump(1);
__ret = traits_type::to_int_type(__c);
}
else
__ret = this->overflow(traits_type::to_int_type(__c));
return __ret;
}
#428 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/streambuf" 3
streamsize
sputn(const char_type* __s, streamsize __n)
{ return this->xsputn(__s, __n); }
protected:
#442 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/streambuf" 3
basic_streambuf()
: _M_in_beg(0), _M_in_cur(0), _M_in_end(0),
_M_out_beg(0), _M_out_cur(0), _M_out_end(0),
_M_buf_locale(locale())
{ }
#460 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/streambuf" 3
char_type*
eback() const { return _M_in_beg; }
char_type*
gptr() const { return _M_in_cur; }
char_type*
egptr() const { return _M_in_end; }
#476 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/streambuf" 3
void
gbump(int __n) { _M_in_cur += __n; }
#487 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/streambuf" 3
void
setg(char_type* __gbeg, char_type* __gnext, char_type* __gend)
{
_M_in_beg = __gbeg;
_M_in_cur = __gnext;
_M_in_end = __gend;
}
#507 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/streambuf" 3
char_type*
pbase() const { return _M_out_beg; }
char_type*
pptr() const { return _M_out_cur; }
char_type*
epptr() const { return _M_out_end; }
#523 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/streambuf" 3
void
pbump(int __n) { _M_out_cur += __n; }
#533 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/streambuf" 3
void
setp(char_type* __pbeg, char_type* __pend)
{
_M_out_beg = _M_out_cur = __pbeg;
_M_out_end = __pend;
}
#554 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/streambuf" 3
virtual void
imbue(const locale&)
{ }
#569 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/streambuf" 3
virtual basic_streambuf<char_type,_Traits>*
setbuf(char_type*, streamsize)
{ return this; }
#580 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/streambuf" 3
virtual pos_type
seekoff(off_type, ios_base::seekdir,
ios_base::openmode = ios_base::in | ios_base::out)
{ return pos_type(off_type(-1)); }
#592 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/streambuf" 3
virtual pos_type
seekpos(pos_type,
ios_base::openmode = ios_base::in | ios_base::out)
{ return pos_type(off_type(-1)); }
#605 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/streambuf" 3
virtual int
sync() { return 0; }
#627 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/streambuf" 3
virtual streamsize
showmanyc() { return 0; }
#643 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/streambuf" 3
virtual streamsize
xsgetn(char_type* __s, streamsize __n);
#665 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/streambuf" 3
virtual int_type
underflow()
{ return traits_type::eof(); }
#678 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/streambuf" 3
virtual int_type
uflow()
{
int_type __ret = traits_type::eof();
const bool __testeof = traits_type::eq_int_type(this->underflow(),
__ret);
if (!__testeof)
{
__ret = traits_type::to_int_type(*this->gptr());
this->gbump(1);
}
return __ret;
}
#702 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/streambuf" 3
virtual int_type
pbackfail(int_type = traits_type::eof())
{ return traits_type::eof(); }
#720 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/streambuf" 3
virtual streamsize
xsputn(const char_type* __s, streamsize __n);
#746 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/streambuf" 3
virtual int_type
overflow(int_type = traits_type::eof())
{ return traits_type::eof(); }
public:
#761 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/streambuf" 3
void
stossc()
{
if (this->gptr() < this->egptr())
this->gbump(1);
else
this->uflow();
}
void
__safe_gbump(streamsize __n) { _M_in_cur += __n; }
void
__safe_pbump(streamsize __n) { _M_out_cur += __n; }
private:
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)
{ }
__streambuf_type&
operator=(const __streambuf_type&) { return *this; };
};
template<>
streamsize
__copy_streambufs_eof(basic_streambuf<char>* __sbin,
basic_streambuf<char>* __sbout, bool& __ineof);
template<>
streamsize
__copy_streambufs_eof(basic_streambuf<wchar_t>* __sbin,
basic_streambuf<wchar_t>* __sbout, bool& __ineof);
}
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/streambuf.tcc" 1 3
#38 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/streambuf.tcc" 3
#38 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/streambuf.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits>
streamsize
basic_streambuf<_CharT, _Traits>::
xsgetn(char_type* __s, streamsize __n)
{
streamsize __ret = 0;
while (__ret < __n)
{
const streamsize __buf_len = this->egptr() - this->gptr();
if (__buf_len)
{
const streamsize __remaining = __n - __ret;
const streamsize __len = std::min(__buf_len, __remaining);
traits_type::copy(__s, this->gptr(), __len);
__ret += __len;
__s += __len;
this->__safe_gbump(__len);
}
if (__ret < __n)
{
const int_type __c = this->uflow();
if (!traits_type::eq_int_type(__c, traits_type::eof()))
{
traits_type::assign(*__s++, traits_type::to_char_type(__c));
++__ret;
}
else
break;
}
}
return __ret;
}
template<typename _CharT, typename _Traits>
streamsize
basic_streambuf<_CharT, _Traits>::
xsputn(const char_type* __s, streamsize __n)
{
streamsize __ret = 0;
while (__ret < __n)
{
const streamsize __buf_len = this->epptr() - this->pptr();
if (__buf_len)
{
const streamsize __remaining = __n - __ret;
const streamsize __len = std::min(__buf_len, __remaining);
traits_type::copy(this->pptr(), __s, __len);
__ret += __len;
__s += __len;
this->__safe_pbump(__len);
}
if (__ret < __n)
{
int_type __c = this->overflow(traits_type::to_int_type(*__s));
if (!traits_type::eq_int_type(__c, traits_type::eof()))
{
++__ret;
++__s;
}
else
break;
}
}
return __ret;
}
template<typename _CharT, typename _Traits>
streamsize
__copy_streambufs_eof(basic_streambuf<_CharT, _Traits>* __sbin,
basic_streambuf<_CharT, _Traits>* __sbout,
bool& __ineof)
{
streamsize __ret = 0;
__ineof = true;
typename _Traits::int_type __c = __sbin->sgetc();
while (!_Traits::eq_int_type(__c, _Traits::eof()))
{
__c = __sbout->sputc(_Traits::to_char_type(__c));
if (_Traits::eq_int_type(__c, _Traits::eof()))
{
__ineof = false;
break;
}
++__ret;
__c = __sbin->snextc();
}
return __ret;
}
template<typename _CharT, typename _Traits>
inline streamsize
__copy_streambufs(basic_streambuf<_CharT, _Traits>* __sbin,
basic_streambuf<_CharT, _Traits>* __sbout)
{
bool __ineof;
return __copy_streambufs_eof(__sbin, __sbout, __ineof);
}
extern template class basic_streambuf<char>;
extern template
streamsize
__copy_streambufs(basic_streambuf<char>*,
basic_streambuf<char>*);
extern template
streamsize
__copy_streambufs_eof(basic_streambuf<char>*,
basic_streambuf<char>*, bool&);
extern template class basic_streambuf<wchar_t>;
extern template
streamsize
__copy_streambufs(basic_streambuf<wchar_t>*,
basic_streambuf<wchar_t>*);
extern template
streamsize
__copy_streambufs_eof(basic_streambuf<wchar_t>*,
basic_streambuf<wchar_t>*, bool&);
}
#808 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/streambuf" 2 3
#44 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ios" 2 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_ios.h" 1 3
#35 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_ios.h" 3
#35 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_ios.h" 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 1 3
#39 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
#39 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cwctype" 1 3
#41 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cwctype" 3
#41 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cwctype" 3
#51 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cwctype" 3
#1 "/usr/include/wctype.h" 1 3 4
#33 "/usr/include/wctype.h" 3 4
#1 "/usr/include/wchar.h" 1 3 4
#34 "/usr/include/wctype.h" 2 3 4
#52 "/usr/include/wctype.h" 3 4
typedef unsigned long int wctype_t;
#71 "/usr/include/wctype.h" 3 4
enum
{
__ISwupper = 0,
__ISwlower = 1,
__ISwalpha = 2,
__ISwdigit = 3,
__ISwxdigit = 4,
__ISwspace = 5,
__ISwprint = 6,
__ISwgraph = 7,
__ISwblank = 8,
__ISwcntrl = 9,
__ISwpunct = 10,
__ISwalnum = 11,
_ISwupper = ((__ISwupper) < 8 ? (int) ((1UL << (__ISwupper)) << 24) : ((__ISwupper) < 16 ? (int) ((1UL << (__ISwupper)) << 8) : ((__ISwupper) < 24 ? (int) ((1UL << (__ISwupper)) >> 8) : (int) ((1UL << (__ISwupper)) >> 24)))),
_ISwlower = ((__ISwlower) < 8 ? (int) ((1UL << (__ISwlower)) << 24) : ((__ISwlower) < 16 ? (int) ((1UL << (__ISwlower)) << 8) : ((__ISwlower) < 24 ? (int) ((1UL << (__ISwlower)) >> 8) : (int) ((1UL << (__ISwlower)) >> 24)))),
_ISwalpha = ((__ISwalpha) < 8 ? (int) ((1UL << (__ISwalpha)) << 24) : ((__ISwalpha) < 16 ? (int) ((1UL << (__ISwalpha)) << 8) : ((__ISwalpha) < 24 ? (int) ((1UL << (__ISwalpha)) >> 8) : (int) ((1UL << (__ISwalpha)) >> 24)))),
_ISwdigit = ((__ISwdigit) < 8 ? (int) ((1UL << (__ISwdigit)) << 24) : ((__ISwdigit) < 16 ? (int) ((1UL << (__ISwdigit)) << 8) : ((__ISwdigit) < 24 ? (int) ((1UL << (__ISwdigit)) >> 8) : (int) ((1UL << (__ISwdigit)) >> 24)))),
_ISwxdigit = ((__ISwxdigit) < 8 ? (int) ((1UL << (__ISwxdigit)) << 24) : ((__ISwxdigit) < 16 ? (int) ((1UL << (__ISwxdigit)) << 8) : ((__ISwxdigit) < 24 ? (int) ((1UL << (__ISwxdigit)) >> 8) : (int) ((1UL << (__ISwxdigit)) >> 24)))),
_ISwspace = ((__ISwspace) < 8 ? (int) ((1UL << (__ISwspace)) << 24) : ((__ISwspace) < 16 ? (int) ((1UL << (__ISwspace)) << 8) : ((__ISwspace) < 24 ? (int) ((1UL << (__ISwspace)) >> 8) : (int) ((1UL << (__ISwspace)) >> 24)))),
_ISwprint = ((__ISwprint) < 8 ? (int) ((1UL << (__ISwprint)) << 24) : ((__ISwprint) < 16 ? (int) ((1UL << (__ISwprint)) << 8) : ((__ISwprint) < 24 ? (int) ((1UL << (__ISwprint)) >> 8) : (int) ((1UL << (__ISwprint)) >> 24)))),
_ISwgraph = ((__ISwgraph) < 8 ? (int) ((1UL << (__ISwgraph)) << 24) : ((__ISwgraph) < 16 ? (int) ((1UL << (__ISwgraph)) << 8) : ((__ISwgraph) < 24 ? (int) ((1UL << (__ISwgraph)) >> 8) : (int) ((1UL << (__ISwgraph)) >> 24)))),
_ISwblank = ((__ISwblank) < 8 ? (int) ((1UL << (__ISwblank)) << 24) : ((__ISwblank) < 16 ? (int) ((1UL << (__ISwblank)) << 8) : ((__ISwblank) < 24 ? (int) ((1UL << (__ISwblank)) >> 8) : (int) ((1UL << (__ISwblank)) >> 24)))),
_ISwcntrl = ((__ISwcntrl) < 8 ? (int) ((1UL << (__ISwcntrl)) << 24) : ((__ISwcntrl) < 16 ? (int) ((1UL << (__ISwcntrl)) << 8) : ((__ISwcntrl) < 24 ? (int) ((1UL << (__ISwcntrl)) >> 8) : (int) ((1UL << (__ISwcntrl)) >> 24)))),
_ISwpunct = ((__ISwpunct) < 8 ? (int) ((1UL << (__ISwpunct)) << 24) : ((__ISwpunct) < 16 ? (int) ((1UL << (__ISwpunct)) << 8) : ((__ISwpunct) < 24 ? (int) ((1UL << (__ISwpunct)) >> 8) : (int) ((1UL << (__ISwpunct)) >> 24)))),
_ISwalnum = ((__ISwalnum) < 8 ? (int) ((1UL << (__ISwalnum)) << 24) : ((__ISwalnum) < 16 ? (int) ((1UL << (__ISwalnum)) << 8) : ((__ISwalnum) < 24 ? (int) ((1UL << (__ISwalnum)) >> 8) : (int) ((1UL << (__ISwalnum)) >> 24))))
};
extern "C" {
#111 "/usr/include/wctype.h" 3 4
extern int iswalnum (wint_t __wc) throw ();
extern int iswalpha (wint_t __wc) throw ();
extern int iswcntrl (wint_t __wc) throw ();
extern int iswdigit (wint_t __wc) throw ();
extern int iswgraph (wint_t __wc) throw ();
extern int iswlower (wint_t __wc) throw ();
extern int iswprint (wint_t __wc) throw ();
extern int iswpunct (wint_t __wc) throw ();
extern int iswspace (wint_t __wc) throw ();
extern int iswupper (wint_t __wc) throw ();
extern int iswxdigit (wint_t __wc) throw ();
extern int iswblank (wint_t __wc) throw ();
#171 "/usr/include/wctype.h" 3 4
extern wctype_t wctype (const char *__property) throw ();
extern int iswctype (wint_t __wc, wctype_t __desc) throw ();
#186 "/usr/include/wctype.h" 3 4
typedef const __int32_t *wctrans_t;
extern wint_t towlower (wint_t __wc) throw ();
extern wint_t towupper (wint_t __wc) throw ();
}
#213 "/usr/include/wctype.h" 3 4
extern "C" {
extern wctrans_t wctrans (const char *__property) throw ();
extern wint_t towctrans (wint_t __wc, wctrans_t __desc) throw ();
#230 "/usr/include/wctype.h" 3 4
extern int iswalnum_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswalpha_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswcntrl_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswdigit_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswgraph_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswlower_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswprint_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswpunct_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswspace_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswupper_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswxdigit_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswblank_l (wint_t __wc, __locale_t __locale) throw ();
extern wctype_t wctype_l (const char *__property, __locale_t __locale)
throw ();
extern int iswctype_l (wint_t __wc, wctype_t __desc, __locale_t __locale)
throw ();
extern wint_t towlower_l (wint_t __wc, __locale_t __locale) throw ();
extern wint_t towupper_l (wint_t __wc, __locale_t __locale) throw ();
extern wctrans_t wctrans_l (const char *__property, __locale_t __locale)
throw ();
extern wint_t towctrans_l (wint_t __wc, wctrans_t __desc,
__locale_t __locale) throw ();
}
#52 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cwctype" 2 3
#81 "/opt/Xilinx/Vivado/2017.3/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;
using ::iswalnum;
using ::iswalpha;
using ::iswblank;
using ::iswcntrl;
using ::iswctype;
using ::iswdigit;
using ::iswgraph;
using ::iswlower;
using ::iswprint;
using ::iswpunct;
using ::iswspace;
using ::iswupper;
using ::iswxdigit;
using ::towctrans;
using ::towlower;
using ::towupper;
using ::wctrans;
using ::wctype;
}
#41 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 2 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cctype" 1 3
#41 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cctype" 3
#41 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cctype" 3
#42 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 2 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/ctype_base.h" 1 3
#37 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/ctype_base.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
struct ctype_base
{
typedef const int* __to_type;
typedef unsigned short mask;
static const mask upper = _ISupper;
static const mask lower = _ISlower;
static const mask alpha = _ISalpha;
static const mask digit = _ISdigit;
static const mask xdigit = _ISxdigit;
static const mask space = _ISspace;
static const mask print = _ISprint;
static const mask graph = _ISalpha | _ISdigit | _ISpunct;
static const mask cntrl = _IScntrl;
static const mask punct = _ISpunct;
static const mask alnum = _ISalpha | _ISdigit;
};
}
#43 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 2 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/streambuf_iterator.h" 1 3
#35 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/streambuf_iterator.h" 3
#35 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/streambuf_iterator.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
#50 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/streambuf_iterator.h" 3
template<typename _CharT, typename _Traits>
class istreambuf_iterator
: public iterator<input_iterator_tag, _CharT, typename _Traits::off_type,
_CharT*, _CharT&>
{
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef typename _Traits::int_type int_type;
typedef basic_streambuf<_CharT, _Traits> streambuf_type;
typedef basic_istream<_CharT, _Traits> istream_type;
template<typename _CharT2>
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
ostreambuf_iterator<_CharT2> >::__type
copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
ostreambuf_iterator<_CharT2>);
template<bool _IsMove, typename _CharT2>
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
_CharT2*>::__type
__copy_move_a2(istreambuf_iterator<_CharT2>,
istreambuf_iterator<_CharT2>, _CharT2*);
template<typename _CharT2>
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
istreambuf_iterator<_CharT2> >::__type
find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
const _CharT2&);
private:
mutable streambuf_type* _M_sbuf;
mutable int_type _M_c;
public:
istreambuf_iterator() throw()
: _M_sbuf(0), _M_c(traits_type::eof()) { }
istreambuf_iterator(istream_type& __s) throw()
: _M_sbuf(__s.rdbuf()), _M_c(traits_type::eof()) { }
istreambuf_iterator(streambuf_type* __s) throw()
: _M_sbuf(__s), _M_c(traits_type::eof()) { }
char_type
operator*() const
{
return traits_type::to_char_type(_M_get());
}
istreambuf_iterator&
operator++()
{
;
if (_M_sbuf)
{
_M_sbuf->sbumpc();
_M_c = traits_type::eof();
}
return *this;
}
istreambuf_iterator
operator++(int)
{
;
istreambuf_iterator __old = *this;
if (_M_sbuf)
{
__old._M_c = _M_sbuf->sbumpc();
_M_c = traits_type::eof();
}
return __old;
}
bool
equal(const istreambuf_iterator& __b) const
{ return _M_at_eof() == __b._M_at_eof(); }
private:
int_type
_M_get() const
{
const int_type __eof = traits_type::eof();
int_type __ret = __eof;
if (_M_sbuf)
{
if (!traits_type::eq_int_type(_M_c, __eof))
__ret = _M_c;
else if (!traits_type::eq_int_type((__ret = _M_sbuf->sgetc()),
__eof))
_M_c = __ret;
else
_M_sbuf = 0;
}
return __ret;
}
bool
_M_at_eof() const
{
const int_type __eof = traits_type::eof();
return traits_type::eq_int_type(_M_get(), __eof);
}
};
template<typename _CharT, typename _Traits>
inline bool
operator==(const istreambuf_iterator<_CharT, _Traits>& __a,
const istreambuf_iterator<_CharT, _Traits>& __b)
{ return __a.equal(__b); }
template<typename _CharT, typename _Traits>
inline bool
operator!=(const istreambuf_iterator<_CharT, _Traits>& __a,
const istreambuf_iterator<_CharT, _Traits>& __b)
{ return !__a.equal(__b); }
template<typename _CharT, typename _Traits>
class ostreambuf_iterator
: public iterator<output_iterator_tag, void, void, void, void>
{
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef basic_streambuf<_CharT, _Traits> streambuf_type;
typedef basic_ostream<_CharT, _Traits> ostream_type;
template<typename _CharT2>
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
ostreambuf_iterator<_CharT2> >::__type
copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
ostreambuf_iterator<_CharT2>);
private:
streambuf_type* _M_sbuf;
bool _M_failed;
public:
ostreambuf_iterator(ostream_type& __s) throw ()
: _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { }
ostreambuf_iterator(streambuf_type* __s) throw ()
: _M_sbuf(__s), _M_failed(!_M_sbuf) { }
ostreambuf_iterator&
operator=(_CharT __c)
{
if (!_M_failed &&
_Traits::eq_int_type(_M_sbuf->sputc(__c), _Traits::eof()))
_M_failed = true;
return *this;
}
ostreambuf_iterator&
operator*()
{ return *this; }
ostreambuf_iterator&
operator++(int)
{ return *this; }
ostreambuf_iterator&
operator++()
{ return *this; }
bool
failed() const throw()
{ return _M_failed; }
ostreambuf_iterator&
_M_put(const _CharT* __ws, streamsize __len)
{
if (__builtin_expect(!_M_failed, true)
&& __builtin_expect(this->_M_sbuf->sputn(__ws, __len) != __len,
false))
_M_failed = true;
return *this;
}
};
template<typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
ostreambuf_iterator<_CharT> >::__type
copy(istreambuf_iterator<_CharT> __first,
istreambuf_iterator<_CharT> __last,
ostreambuf_iterator<_CharT> __result)
{
if (__first._M_sbuf && !__last._M_sbuf && !__result._M_failed)
{
bool __ineof;
__copy_streambufs_eof(__first._M_sbuf, __result._M_sbuf, __ineof);
if (!__ineof)
__result._M_failed = true;
}
return __result;
}
template<bool _IsMove, typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
ostreambuf_iterator<_CharT> >::__type
__copy_move_a2(_CharT* __first, _CharT* __last,
ostreambuf_iterator<_CharT> __result)
{
const streamsize __num = __last - __first;
if (__num > 0)
__result._M_put(__first, __num);
return __result;
}
template<bool _IsMove, typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
ostreambuf_iterator<_CharT> >::__type
__copy_move_a2(const _CharT* __first, const _CharT* __last,
ostreambuf_iterator<_CharT> __result)
{
const streamsize __num = __last - __first;
if (__num > 0)
__result._M_put(__first, __num);
return __result;
}
template<bool _IsMove, typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
_CharT*>::__type
__copy_move_a2(istreambuf_iterator<_CharT> __first,
istreambuf_iterator<_CharT> __last, _CharT* __result)
{
typedef istreambuf_iterator<_CharT> __is_iterator_type;
typedef typename __is_iterator_type::traits_type traits_type;
typedef typename __is_iterator_type::streambuf_type streambuf_type;
typedef typename traits_type::int_type int_type;
if (__first._M_sbuf && !__last._M_sbuf)
{
streambuf_type* __sb = __first._M_sbuf;
int_type __c = __sb->sgetc();
while (!traits_type::eq_int_type(__c, traits_type::eof()))
{
const streamsize __n = __sb->egptr() - __sb->gptr();
if (__n > 1)
{
traits_type::copy(__result, __sb->gptr(), __n);
__sb->__safe_gbump(__n);
__result += __n;
__c = __sb->underflow();
}
else
{
*__result++ = traits_type::to_char_type(__c);
__c = __sb->snextc();
}
}
}
return __result;
}
template<typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
istreambuf_iterator<_CharT> >::__type
find(istreambuf_iterator<_CharT> __first,
istreambuf_iterator<_CharT> __last, const _CharT& __val)
{
typedef istreambuf_iterator<_CharT> __is_iterator_type;
typedef typename __is_iterator_type::traits_type traits_type;
typedef typename __is_iterator_type::streambuf_type streambuf_type;
typedef typename traits_type::int_type int_type;
if (__first._M_sbuf && !__last._M_sbuf)
{
const int_type __ival = traits_type::to_int_type(__val);
streambuf_type* __sb = __first._M_sbuf;
int_type __c = __sb->sgetc();
while (!traits_type::eq_int_type(__c, traits_type::eof())
&& !traits_type::eq_int_type(__c, __ival))
{
streamsize __n = __sb->egptr() - __sb->gptr();
if (__n > 1)
{
const _CharT* __p = traits_type::find(__sb->gptr(),
__n, __val);
if (__p)
__n = __p - __sb->gptr();
__sb->__safe_gbump(__n);
__c = __sb->sgetc();
}
else
__c = __sb->snextc();
}
if (!traits_type::eq_int_type(__c, traits_type::eof()))
__first._M_c = __c;
else
__first._M_sbuf = 0;
}
return __first;
}
}
#50 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
#65 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
template<typename _Tp>
void
__convert_to_v(const char*, _Tp&, ios_base::iostate&,
const __c_locale&) throw();
template<>
void
__convert_to_v(const char*, float&, ios_base::iostate&,
const __c_locale&) throw();
template<>
void
__convert_to_v(const char*, double&, ios_base::iostate&,
const __c_locale&) throw();
template<>
void
__convert_to_v(const char*, long double&, ios_base::iostate&,
const __c_locale&) throw();
template<typename _CharT, typename _Traits>
struct __pad
{
static void
_S_pad(ios_base& __io, _CharT __fill, _CharT* __news,
const _CharT* __olds, streamsize __newlen, streamsize __oldlen);
};
template<typename _CharT>
_CharT*
__add_grouping(_CharT* __s, _CharT __sep,
const char* __gbeg, size_t __gsize,
const _CharT* __first, const _CharT* __last);
template<typename _CharT>
inline
ostreambuf_iterator<_CharT>
__write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len)
{
__s._M_put(__ws, __len);
return __s;
}
template<typename _CharT, typename _OutIter>
inline
_OutIter
__write(_OutIter __s, const _CharT* __ws, int __len)
{
for (int __j = 0; __j < __len; __j++, ++__s)
*__s = __ws[__j];
return __s;
}
#143 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
template<typename _CharT>
class __ctype_abstract_base : public locale::facet, public ctype_base
{
public:
typedef _CharT char_type;
#161 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
bool
is(mask __m, char_type __c) const
{ return this->do_is(__m, __c); }
#178 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
const char_type*
is(const char_type *__lo, const char_type *__hi, mask *__vec) const
{ return this->do_is(__lo, __hi, __vec); }
#194 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
const char_type*
scan_is(mask __m, const char_type* __lo, const char_type* __hi) const
{ return this->do_scan_is(__m, __lo, __hi); }
#210 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
const char_type*
scan_not(mask __m, const char_type* __lo, const char_type* __hi) const
{ return this->do_scan_not(__m, __lo, __hi); }
#224 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
char_type
toupper(char_type __c) const
{ return this->do_toupper(__c); }
#239 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
const char_type*
toupper(char_type *__lo, const char_type* __hi) const
{ return this->do_toupper(__lo, __hi); }
#253 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
char_type
tolower(char_type __c) const
{ return this->do_tolower(__c); }
#268 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
const char_type*
tolower(char_type* __lo, const char_type* __hi) const
{ return this->do_tolower(__lo, __hi); }
#285 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
char_type
widen(char __c) const
{ return this->do_widen(__c); }
#304 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
const char*
widen(const char* __lo, const char* __hi, char_type* __to) const
{ return this->do_widen(__lo, __hi, __to); }
#323 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
char
narrow(char_type __c, char __dfault) const
{ return this->do_narrow(__c, __dfault); }
#345 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
const char_type*
narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char *__to) const
{ return this->do_narrow(__lo, __hi, __dfault, __to); }
protected:
explicit
__ctype_abstract_base(size_t __refs = 0): facet(__refs) { }
virtual
~__ctype_abstract_base() { }
#370 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
virtual bool
do_is(mask __m, char_type __c) const = 0;
#389 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
virtual const char_type*
do_is(const char_type* __lo, const char_type* __hi,
mask* __vec) const = 0;
#408 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
virtual const char_type*
do_scan_is(mask __m, const char_type* __lo,
const char_type* __hi) const = 0;
#427 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
virtual const char_type*
do_scan_not(mask __m, const char_type* __lo,
const char_type* __hi) const = 0;
#445 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
virtual char_type
do_toupper(char_type) const = 0;
#462 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
virtual const char_type*
do_toupper(char_type* __lo, const char_type* __hi) const = 0;
#478 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
virtual char_type
do_tolower(char_type) const = 0;
#495 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
virtual const char_type*
do_tolower(char_type* __lo, const char_type* __hi) const = 0;
#514 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
virtual char_type
do_widen(char) const = 0;
#535 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
virtual const char*
do_widen(const char* __lo, const char* __hi,
char_type* __dest) const = 0;
#557 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
virtual char
do_narrow(char_type, char __dfault) const = 0;
#581 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
virtual const char_type*
do_narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char* __dest) const = 0;
};
#604 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
template<typename _CharT>
class ctype : public __ctype_abstract_base<_CharT>
{
public:
typedef _CharT char_type;
typedef typename __ctype_abstract_base<_CharT>::mask mask;
static locale::id id;
explicit
ctype(size_t __refs = 0) : __ctype_abstract_base<_CharT>(__refs) { }
protected:
virtual
~ctype();
virtual bool
do_is(mask __m, char_type __c) const;
virtual const char_type*
do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
virtual const char_type*
do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
virtual const char_type*
do_scan_not(mask __m, const char_type* __lo,
const char_type* __hi) const;
virtual char_type
do_toupper(char_type __c) const;
virtual const char_type*
do_toupper(char_type* __lo, const char_type* __hi) const;
virtual char_type
do_tolower(char_type __c) const;
virtual const char_type*
do_tolower(char_type* __lo, const char_type* __hi) const;
virtual char_type
do_widen(char __c) const;
virtual const char*
do_widen(const char* __lo, const char* __hi, char_type* __dest) const;
virtual char
do_narrow(char_type, char __dfault) const;
virtual const char_type*
do_narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char* __dest) const;
};
template<typename _CharT>
locale::id ctype<_CharT>::id;
#673 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
template<>
class ctype<char> : public locale::facet, public ctype_base
{
public:
typedef char char_type;
protected:
__c_locale _M_c_locale_ctype;
bool _M_del;
__to_type _M_toupper;
__to_type _M_tolower;
const mask* _M_table;
mutable char _M_widen_ok;
mutable char _M_widen[1 + static_cast<unsigned char>(-1)];
mutable char _M_narrow[1 + static_cast<unsigned char>(-1)];
mutable char _M_narrow_ok;
public:
static locale::id id;
static const size_t table_size = 1 + static_cast<unsigned char>(-1);
#710 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
explicit
ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0);
#723 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
explicit
ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false,
size_t __refs = 0);
#736 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
inline bool
is(mask __m, char __c) const;
#751 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
inline const char*
is(const char* __lo, const char* __hi, mask* __vec) const;
#765 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
inline const char*
scan_is(mask __m, const char* __lo, const char* __hi) const;
#779 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
inline const char*
scan_not(mask __m, const char* __lo, const char* __hi) const;
#794 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
char_type
toupper(char_type __c) const
{ return this->do_toupper(__c); }
#811 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
const char_type*
toupper(char_type *__lo, const char_type* __hi) const
{ return this->do_toupper(__lo, __hi); }
#827 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
char_type
tolower(char_type __c) const
{ return this->do_tolower(__c); }
#844 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
const char_type*
tolower(char_type* __lo, const char_type* __hi) const
{ return this->do_tolower(__lo, __hi); }
#864 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
char_type
widen(char __c) const
{
if (_M_widen_ok)
return _M_widen[static_cast<unsigned char>(__c)];
this->_M_widen_init();
return this->do_widen(__c);
}
#891 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
const char*
widen(const char* __lo, const char* __hi, char_type* __to) const
{
if (_M_widen_ok == 1)
{
__builtin_memcpy(__to, __lo, __hi - __lo);
return __hi;
}
if (!_M_widen_ok)
_M_widen_init();
return this->do_widen(__lo, __hi, __to);
}
#922 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
char
narrow(char_type __c, char __dfault) const
{
if (_M_narrow[static_cast<unsigned char>(__c)])
return _M_narrow[static_cast<unsigned char>(__c)];
const char __t = do_narrow(__c, __dfault);
if (__t != __dfault)
_M_narrow[static_cast<unsigned char>(__c)] = __t;
return __t;
}
#955 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
const char_type*
narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char *__to) const
{
if (__builtin_expect(_M_narrow_ok == 1, true))
{
__builtin_memcpy(__to, __lo, __hi - __lo);
return __hi;
}
if (!_M_narrow_ok)
_M_narrow_init();
return this->do_narrow(__lo, __hi, __dfault, __to);
}
const mask*
table() const throw()
{ return _M_table; }
static const mask*
classic_table() throw();
protected:
virtual
~ctype();
#1004 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
virtual char_type
do_toupper(char_type) const;
#1021 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
virtual const char_type*
do_toupper(char_type* __lo, const char_type* __hi) const;
#1037 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
virtual char_type
do_tolower(char_type) const;
#1054 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
virtual const char_type*
do_tolower(char_type* __lo, const char_type* __hi) const;
#1074 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
virtual char_type
do_widen(char __c) const
{ return __c; }
#1097 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
virtual const char*
do_widen(const char* __lo, const char* __hi, char_type* __dest) const
{
__builtin_memcpy(__dest, __lo, __hi - __lo);
return __hi;
}
#1123 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
virtual char
do_narrow(char_type __c, char) const
{ return __c; }
#1149 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
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;
}
private:
void _M_narrow_init() const;
void _M_widen_init() const;
};
#1174 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
template<>
class ctype<wchar_t> : public __ctype_abstract_base<wchar_t>
{
public:
typedef wchar_t char_type;
typedef wctype_t __wmask_type;
protected:
__c_locale _M_c_locale_ctype;
bool _M_narrow_ok;
char _M_narrow[128];
wint_t _M_widen[1 + static_cast<unsigned char>(-1)];
mask _M_bit[16];
__wmask_type _M_wmask[16];
public:
static locale::id id;
#1207 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
explicit
ctype(size_t __refs = 0);
#1218 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
explicit
ctype(__c_locale __cloc, size_t __refs = 0);
protected:
__wmask_type
_M_convert_to_wmask(const mask __m) const throw();
virtual
~ctype();
#1242 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
virtual bool
do_is(mask __m, char_type __c) const;
#1261 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
virtual const char_type*
do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
#1279 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
virtual const char_type*
do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
#1297 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
virtual const char_type*
do_scan_not(mask __m, const char_type* __lo,
const char_type* __hi) const;
#1314 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
virtual char_type
do_toupper(char_type) const;
#1331 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
virtual const char_type*
do_toupper(char_type* __lo, const char_type* __hi) const;
#1347 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
virtual char_type
do_tolower(char_type) const;
#1364 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
virtual const char_type*
do_tolower(char_type* __lo, const char_type* __hi) const;
#1384 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
virtual char_type
do_widen(char) const;
#1406 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
virtual const char*
do_widen(const char* __lo, const char* __hi, char_type* __dest) const;
#1429 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
virtual char
do_narrow(char_type, char __dfault) const;
#1455 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
virtual const char_type*
do_narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char* __dest) const;
void
_M_initialize_ctype() throw();
};
template<typename _CharT>
class ctype_byname : public ctype<_CharT>
{
public:
typedef typename ctype<_CharT>::mask mask;
explicit
ctype_byname(const char* __s, size_t __refs = 0);
protected:
virtual
~ctype_byname() { };
};
template<>
class ctype_byname<char> : public ctype<char>
{
public:
explicit
ctype_byname(const char* __s, size_t __refs = 0);
protected:
virtual
~ctype_byname();
};
template<>
class ctype_byname<wchar_t> : public ctype<wchar_t>
{
public:
explicit
ctype_byname(const char* __s, size_t __refs = 0);
protected:
virtual
~ctype_byname();
};
}
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/ctype_inline.h" 1 3
#37 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/ctype_inline.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
bool
ctype<char>::
is(mask __m, char __c) const
{ return _M_table[static_cast<unsigned char>(__c)] & __m; }
const char*
ctype<char>::
is(const char* __low, const char* __high, mask* __vec) const
{
while (__low < __high)
*__vec++ = _M_table[static_cast<unsigned char>(*__low++)];
return __high;
}
const char*
ctype<char>::
scan_is(mask __m, const char* __low, const char* __high) const
{
while (__low < __high
&& !(_M_table[static_cast<unsigned char>(*__low)] & __m))
++__low;
return __low;
}
const char*
ctype<char>::
scan_not(mask __m, const char* __low, const char* __high) const
{
while (__low < __high
&& (_M_table[static_cast<unsigned char>(*__low)] & __m) != 0)
++__low;
return __low;
}
}
#1512 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
class __num_base
{
public:
enum
{
_S_ominus,
_S_oplus,
_S_ox,
_S_oX,
_S_odigits,
_S_odigits_end = _S_odigits + 16,
_S_oudigits = _S_odigits_end,
_S_oudigits_end = _S_oudigits + 16,
_S_oe = _S_odigits + 14,
_S_oE = _S_oudigits + 14,
_S_oend = _S_oudigits_end
};
static const char* _S_atoms_out;
static const char* _S_atoms_in;
enum
{
_S_iminus,
_S_iplus,
_S_ix,
_S_iX,
_S_izero,
_S_ie = _S_izero + 14,
_S_iE = _S_izero + 20,
_S_iend = 26
};
static void
_S_format_float(const ios_base& __io, char* __fptr, char __mod) throw();
};
template<typename _CharT>
struct __numpunct_cache : public locale::facet
{
const char* _M_grouping;
size_t _M_grouping_size;
bool _M_use_grouping;
const _CharT* _M_truename;
size_t _M_truename_size;
const _CharT* _M_falsename;
size_t _M_falsename_size;
_CharT _M_decimal_point;
_CharT _M_thousands_sep;
_CharT _M_atoms_out[__num_base::_S_oend];
_CharT _M_atoms_in[__num_base::_S_iend];
bool _M_allocated;
__numpunct_cache(size_t __refs = 0)
: facet(__refs), _M_grouping(0), _M_grouping_size(0),
_M_use_grouping(false),
_M_truename(0), _M_truename_size(0), _M_falsename(0),
_M_falsename_size(0), _M_decimal_point(_CharT()),
_M_thousands_sep(_CharT()), _M_allocated(false)
{ }
~__numpunct_cache();
void
_M_cache(const locale& __loc);
private:
__numpunct_cache&
operator=(const __numpunct_cache&);
explicit
__numpunct_cache(const __numpunct_cache&);
};
template<typename _CharT>
__numpunct_cache<_CharT>::~__numpunct_cache()
{
if (_M_allocated)
{
delete [] _M_grouping;
delete [] _M_truename;
delete [] _M_falsename;
}
}
#1640 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
template<typename _CharT>
class numpunct : public locale::facet
{
public:
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;
typedef __numpunct_cache<_CharT> __cache_type;
protected:
__cache_type* _M_data;
public:
static locale::id id;
explicit
numpunct(size_t __refs = 0)
: facet(__refs), _M_data(0)
{ _M_initialize_numpunct(); }
#1678 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
explicit
numpunct(__cache_type* __cache, size_t __refs = 0)
: facet(__refs), _M_data(__cache)
{ _M_initialize_numpunct(); }
#1692 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
explicit
numpunct(__c_locale __cloc, size_t __refs = 0)
: facet(__refs), _M_data(0)
{ _M_initialize_numpunct(__cloc); }
#1706 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
char_type
decimal_point() const
{ return this->do_decimal_point(); }
#1719 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
char_type
thousands_sep() const
{ return this->do_thousands_sep(); }
#1750 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
string
grouping() const
{ return this->do_grouping(); }
#1763 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
string_type
truename() const
{ return this->do_truename(); }
#1776 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
string_type
falsename() const
{ return this->do_falsename(); }
protected:
virtual
~numpunct();
#1793 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
virtual char_type
do_decimal_point() const
{ return _M_data->_M_decimal_point; }
#1805 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
virtual char_type
do_thousands_sep() const
{ return _M_data->_M_thousands_sep; }
#1818 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
virtual string
do_grouping() const
{ return _M_data->_M_grouping; }
#1831 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
virtual string_type
do_truename() const
{ return _M_data->_M_truename; }
#1844 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
virtual string_type
do_falsename() const
{ return _M_data->_M_falsename; }
void
_M_initialize_numpunct(__c_locale __cloc = 0);
};
template<typename _CharT>
locale::id numpunct<_CharT>::id;
template<>
numpunct<char>::~numpunct();
template<>
void
numpunct<char>::_M_initialize_numpunct(__c_locale __cloc);
template<>
numpunct<wchar_t>::~numpunct();
template<>
void
numpunct<wchar_t>::_M_initialize_numpunct(__c_locale __cloc);
template<typename _CharT>
class numpunct_byname : public numpunct<_CharT>
{
public:
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;
explicit
numpunct_byname(const char* __s, size_t __refs = 0)
: numpunct<_CharT>(__refs)
{
if (__builtin_strcmp(__s, "C") != 0
&& __builtin_strcmp(__s, "POSIX") != 0)
{
__c_locale __tmp;
this->_S_create_c_locale(__tmp, __s);
this->_M_initialize_numpunct(__tmp);
this->_S_destroy_c_locale(__tmp);
}
}
protected:
virtual
~numpunct_byname() { }
};
#1914 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
template<typename _CharT, typename _InIter>
class num_get : public locale::facet
{
public:
typedef _CharT char_type;
typedef _InIter iter_type;
static locale::id id;
#1935 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
explicit
num_get(size_t __refs = 0) : facet(__refs) { }
#1961 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, bool& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }
#1997 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned short& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned int& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned long& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long long& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned long long& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }
#2056 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, float& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, double& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long double& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }
#2098 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, void*& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }
protected:
virtual ~num_get() { }
iter_type
_M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&,
string&) const;
template<typename _ValueT>
iter_type
_M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&,
_ValueT&) const;
template<typename _CharT2>
typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, int>::__type
_M_find(const _CharT2*, size_t __len, _CharT2 __c) const
{
int __ret = -1;
if (__len <= 10)
{
if (__c >= _CharT2('0') && __c < _CharT2(_CharT2('0') + __len))
__ret = __c - _CharT2('0');
}
else
{
if (__c >= _CharT2('0') && __c <= _CharT2('9'))
__ret = __c - _CharT2('0');
else if (__c >= _CharT2('a') && __c <= _CharT2('f'))
__ret = 10 + (__c - _CharT2('a'));
else if (__c >= _CharT2('A') && __c <= _CharT2('F'))
__ret = 10 + (__c - _CharT2('A'));
}
return __ret;
}
template<typename _CharT2>
typename __gnu_cxx::__enable_if<!__is_char<_CharT2>::__value,
int>::__type
_M_find(const _CharT2* __zero, size_t __len, _CharT2 __c) const
{
int __ret = -1;
const char_type* __q = char_traits<_CharT2>::find(__zero, __len, __c);
if (__q)
{
__ret = __q - __zero;
if (__ret > 15)
__ret -= 6;
}
return __ret;
}
#2169 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
virtual iter_type
do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const;
virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long& __v) const
{ return _M_extract_int(__beg, __end, __io, __err, __v); }
virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned short& __v) const
{ return _M_extract_int(__beg, __end, __io, __err, __v); }
virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned int& __v) const
{ return _M_extract_int(__beg, __end, __io, __err, __v); }
virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned long& __v) const
{ return _M_extract_int(__beg, __end, __io, __err, __v); }
virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long long& __v) const
{ return _M_extract_int(__beg, __end, __io, __err, __v); }
virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned long long& __v) const
{ return _M_extract_int(__beg, __end, __io, __err, __v); }
virtual iter_type
do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
float&) const;
virtual iter_type
do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
double&) const;
virtual iter_type
do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
long double&) const;
virtual iter_type
do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
void*&) const;
#2234 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
};
template<typename _CharT, typename _InIter>
locale::id num_get<_CharT, _InIter>::id;
#2252 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
template<typename _CharT, typename _OutIter>
class num_put : public locale::facet
{
public:
typedef _CharT char_type;
typedef _OutIter iter_type;
static locale::id id;
#2273 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
explicit
num_put(size_t __refs = 0) : facet(__refs) { }
#2291 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
iter_type
put(iter_type __s, ios_base& __f, char_type __fill, bool __v) const
{ return this->do_put(__s, __f, __fill, __v); }
#2333 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
iter_type
put(iter_type __s, ios_base& __f, char_type __fill, long __v) const
{ return this->do_put(__s, __f, __fill, __v); }
iter_type
put(iter_type __s, ios_base& __f, char_type __fill,
unsigned long __v) const
{ return this->do_put(__s, __f, __fill, __v); }
iter_type
put(iter_type __s, ios_base& __f, char_type __fill, long long __v) const
{ return this->do_put(__s, __f, __fill, __v); }
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); }
#2396 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
iter_type
put(iter_type __s, ios_base& __f, char_type __fill, double __v) const
{ return this->do_put(__s, __f, __fill, __v); }
iter_type
put(iter_type __s, ios_base& __f, char_type __fill,
long double __v) const
{ return this->do_put(__s, __f, __fill, __v); }
#2421 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
iter_type
put(iter_type __s, ios_base& __f, char_type __fill,
const void* __v) const
{ return this->do_put(__s, __f, __fill, __v); }
protected:
template<typename _ValueT>
iter_type
_M_insert_float(iter_type, ios_base& __io, char_type __fill,
char __mod, _ValueT __v) const;
void
_M_group_float(const char* __grouping, size_t __grouping_size,
char_type __sep, const char_type* __p, char_type* __new,
char_type* __cs, int& __len) const;
template<typename _ValueT>
iter_type
_M_insert_int(iter_type, ios_base& __io, char_type __fill,
_ValueT __v) const;
void
_M_group_int(const char* __grouping, size_t __grouping_size,
char_type __sep, ios_base& __io, char_type* __new,
char_type* __cs, int& __len) const;
void
_M_pad(char_type __fill, streamsize __w, ios_base& __io,
char_type* __new, const char_type* __cs, int& __len) const;
virtual
~num_put() { };
#2469 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
virtual iter_type
do_put(iter_type, ios_base&, char_type __fill, bool __v) const;
virtual iter_type
do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
{ return _M_insert_int(__s, __io, __fill, __v); }
virtual iter_type
do_put(iter_type __s, ios_base& __io, char_type __fill,
unsigned long __v) const
{ return _M_insert_int(__s, __io, __fill, __v); }
virtual iter_type
do_put(iter_type __s, ios_base& __io, char_type __fill,
long long __v) const
{ return _M_insert_int(__s, __io, __fill, __v); }
virtual iter_type
do_put(iter_type __s, ios_base& __io, char_type __fill,
unsigned long long __v) const
{ return _M_insert_int(__s, __io, __fill, __v); }
virtual iter_type
do_put(iter_type, ios_base&, char_type __fill, double __v) const;
virtual iter_type
do_put(iter_type, ios_base&, char_type __fill, long double __v) const;
virtual iter_type
do_put(iter_type, ios_base&, char_type __fill, const void* __v) const;
};
template <typename _CharT, typename _OutIter>
locale::id num_put<_CharT, _OutIter>::id;
#2527 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 3
template<typename _CharT>
inline bool
isspace(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c); }
template<typename _CharT>
inline bool
isprint(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c); }
template<typename _CharT>
inline bool
iscntrl(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c); }
template<typename _CharT>
inline bool
isupper(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c); }
template<typename _CharT>
inline bool
islower(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c); }
template<typename _CharT>
inline bool
isalpha(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c); }
template<typename _CharT>
inline bool
isdigit(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c); }
template<typename _CharT>
inline bool
ispunct(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c); }
template<typename _CharT>
inline bool
isxdigit(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c); }
template<typename _CharT>
inline bool
isalnum(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c); }
template<typename _CharT>
inline bool
isgraph(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c); }
template<typename _CharT>
inline _CharT
toupper(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).toupper(__c); }
template<typename _CharT>
inline _CharT
tolower(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).tolower(__c); }
}
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.tcc" 1 3
#35 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.tcc" 3
#35 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Facet>
struct __use_cache
{
const _Facet*
operator() (const locale& __loc) const;
};
template<typename _CharT>
struct __use_cache<__numpunct_cache<_CharT> >
{
const __numpunct_cache<_CharT>*
operator() (const locale& __loc) const
{
const size_t __i = numpunct<_CharT>::id._M_id();
const locale::facet** __caches = __loc._M_impl->_M_caches;
if (!__caches[__i])
{
__numpunct_cache<_CharT>* __tmp = 0;
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]);
}
};
template<typename _CharT>
void
__numpunct_cache<_CharT>::_M_cache(const locale& __loc)
{
_M_allocated = true;
const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
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));
_M_truename_size = __np.truename().size();
__truename = new _CharT[_M_truename_size];
__np.truename().copy(__truename, _M_truename_size);
_M_truename = __truename;
_M_falsename_size = __np.falsename().size();
__falsename = new _CharT[_M_falsename_size];
__np.falsename().copy(__falsename, _M_falsename_size);
_M_falsename = __falsename;
_M_decimal_point = __np.decimal_point();
_M_thousands_sep = __np.thousands_sep();
const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
__ct.widen(__num_base::_S_atoms_out,
__num_base::_S_atoms_out
+ __num_base::_S_oend, _M_atoms_out);
__ct.widen(__num_base::_S_atoms_in,
__num_base::_S_atoms_in
+ __num_base::_S_iend, _M_atoms_in);
}
if (false)
{
delete [] __grouping;
delete [] __truename;
delete [] __falsename;
;
}
}
#137 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.tcc" 3
__attribute__ ((__pure__)) bool
__verify_grouping(const char* __grouping, size_t __grouping_size,
const string& __grouping_tmp) throw ();
template<typename _CharT, typename _InIter>
_InIter
num_get<_CharT, _InIter>::
_M_extract_float(_InIter __beg, _InIter __end, ios_base& __io,
ios_base::iostate& __err, string& __xtrc) const
{
typedef char_traits<_CharT> __traits_type;
typedef __numpunct_cache<_CharT> __cache_type;
__use_cache<__cache_type> __uc;
const locale& __loc = __io._M_getloc();
const __cache_type* __lc = __uc(__loc);
const _CharT* __lit = __lc->_M_atoms_in;
char_type __c = char_type();
bool __testeof = __beg == __end;
if (!__testeof)
{
__c = *__beg;
const bool __plus = __c == __lit[__num_base::_S_iplus];
if ((__plus || __c == __lit[__num_base::_S_iminus])
&& !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
&& !(__c == __lc->_M_decimal_point))
{
__xtrc += __plus ? '+' : '-';
if (++__beg != __end)
__c = *__beg;
else
__testeof = true;
}
}
bool __found_mantissa = false;
int __sep_pos = 0;
while (!__testeof)
{
if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
|| __c == __lc->_M_decimal_point)
break;
else if (__c == __lit[__num_base::_S_izero])
{
if (!__found_mantissa)
{
__xtrc += '0';
__found_mantissa = true;
}
++__sep_pos;
if (++__beg != __end)
__c = *__beg;
else
__testeof = true;
}
else
break;
}
bool __found_dec = false;
bool __found_sci = false;
string __found_grouping;
if (__lc->_M_use_grouping)
__found_grouping.reserve(32);
const char_type* __lit_zero = __lit + __num_base::_S_izero;
if (!__lc->_M_allocated)
while (!__testeof)
{
const int __digit = _M_find(__lit_zero, 10, __c);
if (__digit != -1)
{
__xtrc += '0' + __digit;
__found_mantissa = true;
}
else if (__c == __lc->_M_decimal_point
&& !__found_dec && !__found_sci)
{
__xtrc += '.';
__found_dec = true;
}
else if ((__c == __lit[__num_base::_S_ie]
|| __c == __lit[__num_base::_S_iE])
&& !__found_sci && __found_mantissa)
{
__xtrc += 'e';
__found_sci = true;
if (++__beg != __end)
{
__c = *__beg;
const bool __plus = __c == __lit[__num_base::_S_iplus];
if (__plus || __c == __lit[__num_base::_S_iminus])
__xtrc += __plus ? '+' : '-';
else
continue;
}
else
{
__testeof = true;
break;
}
}
else
break;
if (++__beg != __end)
__c = *__beg;
else
__testeof = true;
}
else
while (!__testeof)
{
if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
{
if (!__found_dec && !__found_sci)
{
if (__sep_pos)
{
__found_grouping += static_cast<char>(__sep_pos);
__sep_pos = 0;
}
else
{
__xtrc.clear();
break;
}
}
else
break;
}
else if (__c == __lc->_M_decimal_point)
{
if (!__found_dec && !__found_sci)
{
if (__found_grouping.size())
__found_grouping += static_cast<char>(__sep_pos);
__xtrc += '.';
__found_dec = true;
}
else
break;
}
else
{
const char_type* __q =
__traits_type::find(__lit_zero, 10, __c);
if (__q)
{
__xtrc += '0' + (__q - __lit_zero);
__found_mantissa = true;
++__sep_pos;
}
else if ((__c == __lit[__num_base::_S_ie]
|| __c == __lit[__num_base::_S_iE])
&& !__found_sci && __found_mantissa)
{
if (__found_grouping.size() && !__found_dec)
__found_grouping += static_cast<char>(__sep_pos);
__xtrc += 'e';
__found_sci = true;
if (++__beg != __end)
{
__c = *__beg;
const bool __plus = __c == __lit[__num_base::_S_iplus];
if ((__plus || __c == __lit[__num_base::_S_iminus])
&& !(__lc->_M_use_grouping
&& __c == __lc->_M_thousands_sep)
&& !(__c == __lc->_M_decimal_point))
__xtrc += __plus ? '+' : '-';
else
continue;
}
else
{
__testeof = true;
break;
}
}
else
break;
}
if (++__beg != __end)
__c = *__beg;
else
__testeof = true;
}
if (__found_grouping.size())
{
if (!__found_dec && !__found_sci)
__found_grouping += static_cast<char>(__sep_pos);
if (!std::__verify_grouping(__lc->_M_grouping,
__lc->_M_grouping_size,
__found_grouping))
__err = ios_base::failbit;
}
return __beg;
}
template<typename _CharT, typename _InIter>
template<typename _ValueT>
_InIter
num_get<_CharT, _InIter>::
_M_extract_int(_InIter __beg, _InIter __end, ios_base& __io,
ios_base::iostate& __err, _ValueT& __v) const
{
typedef char_traits<_CharT> __traits_type;
using __gnu_cxx::__add_unsigned;
typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
typedef __numpunct_cache<_CharT> __cache_type;
__use_cache<__cache_type> __uc;
const locale& __loc = __io._M_getloc();
const __cache_type* __lc = __uc(__loc);
const _CharT* __lit = __lc->_M_atoms_in;
char_type __c = char_type();
const ios_base::fmtflags __basefield = __io.flags()
& ios_base::basefield;
const bool __oct = __basefield == ios_base::oct;
int __base = __oct ? 8 : (__basefield == ios_base::hex ? 16 : 10);
bool __testeof = __beg == __end;
bool __negative = false;
if (!__testeof)
{
__c = *__beg;
__negative = __c == __lit[__num_base::_S_iminus];
if ((__negative || __c == __lit[__num_base::_S_iplus])
&& !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
&& !(__c == __lc->_M_decimal_point))
{
if (++__beg != __end)
__c = *__beg;
else
__testeof = true;
}
}
bool __found_zero = false;
int __sep_pos = 0;
while (!__testeof)
{
if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
|| __c == __lc->_M_decimal_point)
break;
else if (__c == __lit[__num_base::_S_izero]
&& (!__found_zero || __base == 10))
{
__found_zero = true;
++__sep_pos;
if (__basefield == 0)
__base = 8;
if (__base == 8)
__sep_pos = 0;
}
else if (__found_zero
&& (__c == __lit[__num_base::_S_ix]
|| __c == __lit[__num_base::_S_iX]))
{
if (__basefield == 0)
__base = 16;
if (__base == 16)
{
__found_zero = false;
__sep_pos = 0;
}
else
break;
}
else
break;
if (++__beg != __end)
{
__c = *__beg;
if (!__found_zero)
break;
}
else
__testeof = true;
}
const size_t __len = (__base == 16 ? __num_base::_S_iend
- __num_base::_S_izero : __base);
string __found_grouping;
if (__lc->_M_use_grouping)
__found_grouping.reserve(32);
bool __testfail = false;
bool __testoverflow = false;
const __unsigned_type __max =
(__negative && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
? -__gnu_cxx::__numeric_traits<_ValueT>::__min
: __gnu_cxx::__numeric_traits<_ValueT>::__max;
const __unsigned_type __smax = __max / __base;
__unsigned_type __result = 0;
int __digit = 0;
const char_type* __lit_zero = __lit + __num_base::_S_izero;
if (!__lc->_M_allocated)
while (!__testeof)
{
__digit = _M_find(__lit_zero, __len, __c);
if (__digit == -1)
break;
if (__result > __smax)
__testoverflow = true;
else
{
__result *= __base;
__testoverflow |= __result > __max - __digit;
__result += __digit;
++__sep_pos;
}
if (++__beg != __end)
__c = *__beg;
else
__testeof = true;
}
else
while (!__testeof)
{
if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
{
if (__sep_pos)
{
__found_grouping += static_cast<char>(__sep_pos);
__sep_pos = 0;
}
else
{
__testfail = true;
break;
}
}
else if (__c == __lc->_M_decimal_point)
break;
else
{
const char_type* __q =
__traits_type::find(__lit_zero, __len, __c);
if (!__q)
break;
__digit = __q - __lit_zero;
if (__digit > 15)
__digit -= 6;
if (__result > __smax)
__testoverflow = true;
else
{
__result *= __base;
__testoverflow |= __result > __max - __digit;
__result += __digit;
++__sep_pos;
}
}
if (++__beg != __end)
__c = *__beg;
else
__testeof = true;
}
if (__found_grouping.size())
{
__found_grouping += static_cast<char>(__sep_pos);
if (!std::__verify_grouping(__lc->_M_grouping,
__lc->_M_grouping_size,
__found_grouping))
__err = ios_base::failbit;
}
if ((!__sep_pos && !__found_zero && !__found_grouping.size())
|| __testfail)
{
__v = 0;
__err = ios_base::failbit;
}
else if (__testoverflow)
{
if (__negative
&& __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
__v = __gnu_cxx::__numeric_traits<_ValueT>::__min;
else
__v = __gnu_cxx::__numeric_traits<_ValueT>::__max;
__err = ios_base::failbit;
}
else
__v = __negative ? -__result : __result;
if (__testeof)
__err |= ios_base::eofbit;
return __beg;
}
template<typename _CharT, typename _InIter>
_InIter
num_get<_CharT, _InIter>::
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, bool& __v) const
{
if (!(__io.flags() & ios_base::boolalpha))
{
long __l = -1;
__beg = _M_extract_int(__beg, __end, __io, __err, __l);
if (__l == 0 || __l == 1)
__v = bool(__l);
else
{
__v = true;
__err = ios_base::failbit;
if (__beg == __end)
__err |= ios_base::eofbit;
}
}
else
{
typedef __numpunct_cache<_CharT> __cache_type;
__use_cache<__cache_type> __uc;
const locale& __loc = __io._M_getloc();
const __cache_type* __lc = __uc(__loc);
bool __testf = true;
bool __testt = true;
bool __donef = __lc->_M_falsename_size == 0;
bool __donet = __lc->_M_truename_size == 0;
bool __testeof = false;
size_t __n = 0;
while (!__donef || !__donet)
{
if (__beg == __end)
{
__testeof = true;
break;
}
const char_type __c = *__beg;
if (!__donef)
__testf = __c == __lc->_M_falsename[__n];
if (!__testf && __donet)
break;
if (!__donet)
__testt = __c == __lc->_M_truename[__n];
if (!__testt && __donef)
break;
if (!__testt && !__testf)
break;
++__n;
++__beg;
__donef = !__testf || __n >= __lc->_M_falsename_size;
__donet = !__testt || __n >= __lc->_M_truename_size;
}
if (__testf && __n == __lc->_M_falsename_size && __n)
{
__v = false;
if (__testt && __n == __lc->_M_truename_size)
__err = ios_base::failbit;
else
__err = __testeof ? ios_base::eofbit : ios_base::goodbit;
}
else if (__testt && __n == __lc->_M_truename_size && __n)
{
__v = true;
__err = __testeof ? ios_base::eofbit : ios_base::goodbit;
}
else
{
__v = false;
__err = ios_base::failbit;
if (__testeof)
__err |= ios_base::eofbit;
}
}
return __beg;
}
template<typename _CharT, typename _InIter>
_InIter
num_get<_CharT, _InIter>::
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, float& __v) const
{
string __xtrc;
__xtrc.reserve(32);
__beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
if (__beg == __end)
__err |= ios_base::eofbit;
return __beg;
}
template<typename _CharT, typename _InIter>
_InIter
num_get<_CharT, _InIter>::
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, double& __v) const
{
string __xtrc;
__xtrc.reserve(32);
__beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
if (__beg == __end)
__err |= ios_base::eofbit;
return __beg;
}
#731 "/opt/Xilinx/Vivado/2017.3/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;
}
template<typename _CharT, typename _InIter>
_InIter
num_get<_CharT, _InIter>::
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, void*& __v) const
{
typedef ios_base::fmtflags fmtflags;
const fmtflags __fmt = __io.flags();
__io.flags((__fmt & ~ios_base::basefield) | ios_base::hex);
typedef __gnu_cxx::__conditional_type<(sizeof(void*)
<= sizeof(unsigned long)),
unsigned long, unsigned long long>::__type _UIntPtrType;
_UIntPtrType __ul;
__beg = _M_extract_int(__beg, __end, __io, __err, __ul);
__io.flags(__fmt);
__v = reinterpret_cast<void*>(__ul);
return __beg;
}
template<typename _CharT, typename _OutIter>
void
num_put<_CharT, _OutIter>::
_M_pad(_CharT __fill, streamsize __w, ios_base& __io,
_CharT* __new, const _CharT* __cs, int& __len) const
{
__pad<_CharT, char_traits<_CharT> >::_S_pad(__io, __fill, __new,
__cs, __w, __len);
__len = static_cast<int>(__w);
}
template<typename _CharT, typename _ValueT>
int
__int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit,
ios_base::fmtflags __flags, bool __dec)
{
_CharT* __buf = __bufend;
if (__builtin_expect(__dec, true))
{
do
{
*--__buf = __lit[(__v % 10) + __num_base::_S_odigits];
__v /= 10;
}
while (__v != 0);
}
else if ((__flags & ios_base::basefield) == ios_base::oct)
{
do
{
*--__buf = __lit[(__v & 0x7) + __num_base::_S_odigits];
__v >>= 3;
}
while (__v != 0);
}
else
{
const bool __uppercase = __flags & ios_base::uppercase;
const int __case_offset = __uppercase ? __num_base::_S_oudigits
: __num_base::_S_odigits;
do
{
*--__buf = __lit[(__v & 0xf) + __case_offset];
__v >>= 4;
}
while (__v != 0);
}
return __bufend - __buf;
}
template<typename _CharT, typename _OutIter>
void
num_put<_CharT, _OutIter>::
_M_group_int(const char* __grouping, size_t __grouping_size, _CharT __sep,
ios_base&, _CharT* __new, _CharT* __cs, int& __len) const
{
_CharT* __p = std::__add_grouping(__new, __sep, __grouping,
__grouping_size, __cs, __cs + __len);
__len = __p - __new;
}
template<typename _CharT, typename _OutIter>
template<typename _ValueT>
_OutIter
num_put<_CharT, _OutIter>::
_M_insert_int(_OutIter __s, ios_base& __io, _CharT __fill,
_ValueT __v) const
{
using __gnu_cxx::__add_unsigned;
typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
typedef __numpunct_cache<_CharT> __cache_type;
__use_cache<__cache_type> __uc;
const locale& __loc = __io._M_getloc();
const __cache_type* __lc = __uc(__loc);
const _CharT* __lit = __lc->_M_atoms_out;
const ios_base::fmtflags __flags = __io.flags();
const int __ilen = 5 * sizeof(_ValueT);
_CharT* __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
* __ilen));
const ios_base::fmtflags __basefield = __flags & ios_base::basefield;
const bool __dec = (__basefield != ios_base::oct
&& __basefield != ios_base::hex);
const __unsigned_type __u = ((__v > 0 || !__dec)
? __unsigned_type(__v)
: -__unsigned_type(__v));
int __len = __int_to_char(__cs + __ilen, __u, __lit, __flags, __dec);
__cs += __ilen - __len;
if (__lc->_M_use_grouping)
{
_CharT* __cs2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
* (__len + 1)
* 2));
_M_group_int(__lc->_M_grouping, __lc->_M_grouping_size,
__lc->_M_thousands_sep, __io, __cs2 + 2, __cs, __len);
__cs = __cs2 + 2;
}
if (__builtin_expect(__dec, true))
{
if (__v >= 0)
{
if (bool(__flags & ios_base::showpos)
&& __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
*--__cs = __lit[__num_base::_S_oplus], ++__len;
}
else
*--__cs = __lit[__num_base::_S_ominus], ++__len;
}
else if (bool(__flags & ios_base::showbase) && __v)
{
if (__basefield == ios_base::oct)
*--__cs = __lit[__num_base::_S_odigits], ++__len;
else
{
const bool __uppercase = __flags & ios_base::uppercase;
*--__cs = __lit[__num_base::_S_ox + __uppercase];
*--__cs = __lit[__num_base::_S_odigits];
__len += 2;
}
}
const streamsize __w = __io.width();
if (__w > static_cast<streamsize>(__len))
{
_CharT* __cs3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
* __w));
_M_pad(__fill, __w, __io, __cs3, __cs, __len);
__cs = __cs3;
}
__io.width(0);
return std::__write(__s, __cs, __len);
}
template<typename _CharT, typename _OutIter>
void
num_put<_CharT, _OutIter>::
_M_group_float(const char* __grouping, size_t __grouping_size,
_CharT __sep, const _CharT* __p, _CharT* __new,
_CharT* __cs, int& __len) const
{
const int __declen = __p ? __p - __cs : __len;
_CharT* __p2 = std::__add_grouping(__new, __sep, __grouping,
__grouping_size,
__cs, __cs + __declen);
int __newlen = __p2 - __new;
if (__p)
{
char_traits<_CharT>::copy(__p2, __p, __len - __declen);
__newlen += __len - __declen;
}
__len = __newlen;
}
#967 "/opt/Xilinx/Vivado/2017.3/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>
template<typename _ValueT>
_OutIter
num_put<_CharT, _OutIter>::
_M_insert_float(_OutIter __s, ios_base& __io, _CharT __fill, char __mod,
_ValueT __v) const
{
typedef __numpunct_cache<_CharT> __cache_type;
__use_cache<__cache_type> __uc;
const locale& __loc = __io._M_getloc();
const __cache_type* __lc = __uc(__loc);
const streamsize __prec = __io.precision() < 0 ? 6 : __io.precision();
const int __max_digits =
__gnu_cxx::__numeric_traits<_ValueT>::__digits10;
int __len;
char __fbuf[16];
__num_base::_S_format_float(__io, __fbuf, __mod);
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);
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);
}
#1028 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.tcc" 3
const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
_CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
* __len));
__ctype.widen(__cs, __cs + __len, __ws);
_CharT* __wp = 0;
const char* __p = char_traits<char>::find(__cs, __len, '.');
if (__p)
{
__wp = __ws + (__p - __cs);
*__wp = __lc->_M_decimal_point;
}
if (__lc->_M_use_grouping
&& (__wp || __len < 3 || (__cs[1] <= '9' && __cs[2] <= '9'
&& __cs[1] >= '0' && __cs[2] >= '0')))
{
_CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
* __len * 2));
streamsize __off = 0;
if (__cs[0] == '-' || __cs[0] == '+')
{
__off = 1;
__ws2[0] = __ws[0];
__len -= 1;
}
_M_group_float(__lc->_M_grouping, __lc->_M_grouping_size,
__lc->_M_thousands_sep, __wp, __ws2 + __off,
__ws + __off, __len);
__len += __off;
__ws = __ws2;
}
const streamsize __w = __io.width();
if (__w > static_cast<streamsize>(__len))
{
_CharT* __ws3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
* __w));
_M_pad(__fill, __w, __io, __ws3, __ws, __len);
__ws = __ws3;
}
__io.width(0);
return std::__write(__s, __ws, __len);
}
template<typename _CharT, typename _OutIter>
_OutIter
num_put<_CharT, _OutIter>::
do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
{
const ios_base::fmtflags __flags = __io.flags();
if ((__flags & ios_base::boolalpha) == 0)
{
const long __l = __v;
__s = _M_insert_int(__s, __io, __fill, __l);
}
else
{
typedef __numpunct_cache<_CharT> __cache_type;
__use_cache<__cache_type> __uc;
const locale& __loc = __io._M_getloc();
const __cache_type* __lc = __uc(__loc);
const _CharT* __name = __v ? __lc->_M_truename
: __lc->_M_falsename;
int __len = __v ? __lc->_M_truename_size
: __lc->_M_falsename_size;
const streamsize __w = __io.width();
if (__w > static_cast<streamsize>(__len))
{
const streamsize __plen = __w - __len;
_CharT* __ps
= static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
* __plen));
char_traits<_CharT>::assign(__ps, __plen, __fill);
__io.width(0);
if ((__flags & ios_base::adjustfield) == ios_base::left)
{
__s = std::__write(__s, __name, __len);
__s = std::__write(__s, __ps, __plen);
}
else
{
__s = std::__write(__s, __ps, __plen);
__s = std::__write(__s, __name, __len);
}
return __s;
}
__io.width(0);
__s = std::__write(__s, __name, __len);
}
return __s;
}
template<typename _CharT, typename _OutIter>
_OutIter
num_put<_CharT, _OutIter>::
do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
{ return _M_insert_float(__s, __io, __fill, char(), __v); }
#1153 "/opt/Xilinx/Vivado/2017.3/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); }
template<typename _CharT, typename _OutIter>
_OutIter
num_put<_CharT, _OutIter>::
do_put(iter_type __s, ios_base& __io, char_type __fill,
const void* __v) const
{
const ios_base::fmtflags __flags = __io.flags();
const ios_base::fmtflags __fmt = ~(ios_base::basefield
| ios_base::uppercase);
__io.flags((__flags & __fmt) | (ios_base::hex | ios_base::showbase));
typedef __gnu_cxx::__conditional_type<(sizeof(const void*)
<= sizeof(unsigned long)),
unsigned long, unsigned long long>::__type _UIntPtrType;
__s = _M_insert_int(__s, __io, __fill,
reinterpret_cast<_UIntPtrType>(__v));
__io.flags(__flags);
return __s;
}
#1190 "/opt/Xilinx/Vivado/2017.3/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 _Traits>
void
__pad<_CharT, _Traits>::_S_pad(ios_base& __io, _CharT __fill,
_CharT* __news, const _CharT* __olds,
streamsize __newlen, streamsize __oldlen)
{
const size_t __plen = static_cast<size_t>(__newlen - __oldlen);
const ios_base::fmtflags __adjust = __io.flags() & ios_base::adjustfield;
if (__adjust == ios_base::left)
{
_Traits::copy(__news, __olds, __oldlen);
_Traits::assign(__news + __oldlen, __plen, __fill);
return;
}
size_t __mod = 0;
if (__adjust == ios_base::internal)
{
const locale& __loc = __io._M_getloc();
const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
if (__ctype.widen('-') == __olds[0]
|| __ctype.widen('+') == __olds[0])
{
__news[0] = __olds[0];
__mod = 1;
++__news;
}
else if (__ctype.widen('0') == __olds[0]
&& __oldlen > 1
&& (__ctype.widen('x') == __olds[1]
|| __ctype.widen('X') == __olds[1]))
{
__news[0] = __olds[0];
__news[1] = __olds[1];
__mod = 2;
__news += 2;
}
}
_Traits::assign(__news, __plen, __fill);
_Traits::copy(__news + __plen, __olds + __mod, __oldlen - __mod);
}
template<typename _CharT>
_CharT*
__add_grouping(_CharT* __s, _CharT __sep,
const char* __gbeg, size_t __gsize,
const _CharT* __first, const _CharT* __last)
{
size_t __idx = 0;
size_t __ctr = 0;
while (__last - __first > __gbeg[__idx]
&& static_cast<signed char>(__gbeg[__idx]) > 0
&& __gbeg[__idx] != __gnu_cxx::__numeric_traits<char>::__max)
{
__last -= __gbeg[__idx];
__idx < __gsize - 1 ? ++__idx : ++__ctr;
}
while (__first != __last)
*__s++ = *__first++;
while (__ctr--)
{
*__s++ = __sep;
for (char __i = __gbeg[__idx]; __i > 0; --__i)
*__s++ = *__first++;
}
while (__idx--)
{
*__s++ = __sep;
for (char __i = __gbeg[__idx]; __i > 0; --__i)
*__s++ = *__first++;
}
return __s;
}
extern template class 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>;
extern template
const ctype<char>&
use_facet<ctype<char> >(const locale&);
extern template
const numpunct<char>&
use_facet<numpunct<char> >(const locale&);
extern template
const num_put<char>&
use_facet<num_put<char> >(const locale&);
extern template
const num_get<char>&
use_facet<num_get<char> >(const locale&);
extern template
bool
has_facet<ctype<char> >(const locale&);
extern template
bool
has_facet<numpunct<char> >(const locale&);
extern template
bool
has_facet<num_put<char> >(const locale&);
extern template
bool
has_facet<num_get<char> >(const locale&);
extern template class 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>;
extern template
const ctype<wchar_t>&
use_facet<ctype<wchar_t> >(const locale&);
extern template
const numpunct<wchar_t>&
use_facet<numpunct<wchar_t> >(const locale&);
extern template
const num_put<wchar_t>&
use_facet<num_put<wchar_t> >(const locale&);
extern template
const num_get<wchar_t>&
use_facet<num_get<wchar_t> >(const locale&);
extern template
bool
has_facet<ctype<wchar_t> >(const locale&);
extern template
bool
has_facet<numpunct<wchar_t> >(const locale&);
extern template
bool
has_facet<num_put<wchar_t> >(const locale&);
extern template
bool
has_facet<num_get<wchar_t> >(const locale&);
}
#2608 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/locale_facets.h" 2 3
#39 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_ios.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Facet>
inline const _Facet&
__check_facet(const _Facet* __f)
{
if (!__f)
__throw_bad_cast();
return *__f;
}
#62 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_ios.h" 3
template<typename _CharT, typename _Traits>
class basic_ios : public ios_base
{
public:
typedef _CharT char_type;
typedef typename _Traits::int_type int_type;
typedef typename _Traits::pos_type pos_type;
typedef typename _Traits::off_type off_type;
typedef _Traits traits_type;
typedef ctype<_CharT> __ctype_type;
typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
__num_put_type;
typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
__num_get_type;
protected:
basic_ostream<_CharT, _Traits>* _M_tie;
mutable char_type _M_fill;
mutable bool _M_fill_init;
basic_streambuf<_CharT, _Traits>* _M_streambuf;
const __ctype_type* _M_ctype;
const __num_put_type* _M_num_put;
const __num_get_type* _M_num_get;
public:
operator void*() const
{ return this->fail() ? 0 : const_cast<basic_ios*>(this); }
bool
operator!() const
{ return this->fail(); }
#127 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_ios.h" 3
iostate
rdstate() const
{ return _M_streambuf_state; }
#138 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_ios.h" 3
void
clear(iostate __state = goodbit);
void
setstate(iostate __state)
{ this->clear(this->rdstate() | __state); }
void
_M_setstate(iostate __state)
{
_M_streambuf_state |= __state;
if (this->exceptions() & __state)
;
}
bool
good() const
{ return this->rdstate() == 0; }
bool
eof() const
{ return (this->rdstate() & eofbit) != 0; }
#191 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_ios.h" 3
bool
fail() const
{ return (this->rdstate() & (badbit | failbit)) != 0; }
bool
bad() const
{ return (this->rdstate() & badbit) != 0; }
#212 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_ios.h" 3
iostate
exceptions() const
{ return _M_exception; }
#247 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_ios.h" 3
void
exceptions(iostate __except)
{
_M_exception = __except;
this->clear(_M_streambuf_state);
}
explicit
basic_ios(basic_streambuf<_CharT, _Traits>* __sb)
: ios_base(), _M_tie(0), _M_fill(), _M_fill_init(false), _M_streambuf(0),
_M_ctype(0), _M_num_put(0), _M_num_get(0)
{ this->init(__sb); }
virtual
~basic_ios() { }
#285 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_ios.h" 3
basic_ostream<_CharT, _Traits>*
tie() const
{ return _M_tie; }
#297 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_ios.h" 3
basic_ostream<_CharT, _Traits>*
tie(basic_ostream<_CharT, _Traits>* __tiestr)
{
basic_ostream<_CharT, _Traits>* __old = _M_tie;
_M_tie = __tiestr;
return __old;
}
basic_streambuf<_CharT, _Traits>*
rdbuf() const
{ return _M_streambuf; }
#337 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_ios.h" 3
basic_streambuf<_CharT, _Traits>*
rdbuf(basic_streambuf<_CharT, _Traits>* __sb);
#351 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_ios.h" 3
basic_ios&
copyfmt(const basic_ios& __rhs);
char_type
fill() const
{
if (!_M_fill_init)
{
_M_fill = this->widen(' ');
_M_fill_init = true;
}
return _M_fill;
}
#380 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_ios.h" 3
char_type
fill(char_type __ch)
{
char_type __old = this->fill();
_M_fill = __ch;
return __old;
}
#400 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_ios.h" 3
locale
imbue(const locale& __loc);
#420 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_ios.h" 3
char
narrow(char_type __c, char __dfault) const
{ return __check_facet(_M_ctype).narrow(__c, __dfault); }
#439 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_ios.h" 3
char_type
widen(char __c) const
{ return __check_facet(_M_ctype).widen(__c); }
protected:
basic_ios()
: ios_base(), _M_tie(0), _M_fill(char_type()), _M_fill_init(false),
_M_streambuf(0), _M_ctype(0), _M_num_put(0), _M_num_get(0)
{ }
void
init(basic_streambuf<_CharT, _Traits>* __sb);
void
_M_cache_locale(const locale& __loc);
};
}
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_ios.tcc" 1 3
#34 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_ios.tcc" 3
#34 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_ios.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits>
void
basic_ios<_CharT, _Traits>::clear(iostate __state)
{
if (this->rdbuf())
_M_streambuf_state = __state;
else
_M_streambuf_state = __state | badbit;
if (this->exceptions() & this->rdstate())
__throw_ios_failure(("basic_ios::clear"));
}
template<typename _CharT, typename _Traits>
basic_streambuf<_CharT, _Traits>*
basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<_CharT, _Traits>* __sb)
{
basic_streambuf<_CharT, _Traits>* __old = _M_streambuf;
_M_streambuf = __sb;
this->clear();
return __old;
}
template<typename _CharT, typename _Traits>
basic_ios<_CharT, _Traits>&
basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs)
{
if (this != &__rhs)
{
_Words* __words = (__rhs._M_word_size <= _S_local_word_size) ?
_M_local_word : new _Words[__rhs._M_word_size];
_Callback_list* __cb = __rhs._M_callbacks;
if (__cb)
__cb->_M_add_reference();
_M_call_callbacks(erase_event);
if (_M_word != _M_local_word)
{
delete [] _M_word;
_M_word = 0;
}
_M_dispose_callbacks();
_M_callbacks = __cb;
for (int __i = 0; __i < __rhs._M_word_size; ++__i)
__words[__i] = __rhs._M_word[__i];
_M_word = __words;
_M_word_size = __rhs._M_word_size;
this->flags(__rhs.flags());
this->width(__rhs.width());
this->precision(__rhs.precision());
this->tie(__rhs.tie());
this->fill(__rhs.fill());
_M_ios_locale = __rhs.getloc();
_M_cache_locale(_M_ios_locale);
_M_call_callbacks(copyfmt_event);
this->exceptions(__rhs.exceptions());
}
return *this;
}
template<typename _CharT, typename _Traits>
locale
basic_ios<_CharT, _Traits>::imbue(const locale& __loc)
{
locale __old(this->getloc());
ios_base::imbue(__loc);
_M_cache_locale(__loc);
if (this->rdbuf() != 0)
this->rdbuf()->pubimbue(__loc);
return __old;
}
template<typename _CharT, typename _Traits>
void
basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __sb)
{
ios_base::_M_init();
_M_cache_locale(_M_ios_locale);
#146 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_ios.tcc" 3
_M_fill = _CharT();
_M_fill_init = false;
_M_tie = 0;
_M_exception = goodbit;
_M_streambuf = __sb;
_M_streambuf_state = __sb ? goodbit : badbit;
}
template<typename _CharT, typename _Traits>
void
basic_ios<_CharT, _Traits>::_M_cache_locale(const locale& __loc)
{
if (__builtin_expect(has_facet<__ctype_type>(__loc), true))
_M_ctype = &use_facet<__ctype_type>(__loc);
else
_M_ctype = 0;
if (__builtin_expect(has_facet<__num_put_type>(__loc), true))
_M_num_put = &use_facet<__num_put_type>(__loc);
else
_M_num_put = 0;
if (__builtin_expect(has_facet<__num_get_type>(__loc), true))
_M_num_get = &use_facet<__num_get_type>(__loc);
else
_M_num_get = 0;
}
extern template class basic_ios<char>;
extern template class basic_ios<wchar_t>;
}
#473 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/basic_ios.h" 2 3
#45 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ios" 2 3
#40 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ostream" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
#55 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ostream" 3
template<typename _CharT, typename _Traits>
class basic_ostream : virtual public basic_ios<_CharT, _Traits>
{
public:
typedef _CharT char_type;
typedef typename _Traits::int_type int_type;
typedef typename _Traits::pos_type pos_type;
typedef typename _Traits::off_type off_type;
typedef _Traits traits_type;
typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
typedef basic_ios<_CharT, _Traits> __ios_type;
typedef basic_ostream<_CharT, _Traits> __ostream_type;
typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
__num_put_type;
typedef ctype<_CharT> __ctype_type;
#82 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ostream" 3
explicit
basic_ostream(__streambuf_type* __sb)
{ this->init(__sb); }
virtual
~basic_ostream() { }
class sentry;
friend class sentry;
#108 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ostream" 3
__ostream_type&
operator<<(__ostream_type& (*__pf)(__ostream_type&))
{
return __pf(*this);
}
__ostream_type&
operator<<(__ios_type& (*__pf)(__ios_type&))
{
__pf(*this);
return *this;
}
__ostream_type&
operator<<(ios_base& (*__pf) (ios_base&))
{
__pf(*this);
return *this;
}
#165 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ostream" 3
__ostream_type&
operator<<(long __n)
{ return _M_insert(__n); }
__ostream_type&
operator<<(unsigned long __n)
{ return _M_insert(__n); }
__ostream_type&
operator<<(bool __n)
{ return _M_insert(__n); }
__ostream_type&
operator<<(short __n);
__ostream_type&
operator<<(unsigned short __n)
{
return _M_insert(static_cast<unsigned long>(__n));
}
__ostream_type&
operator<<(int __n);
__ostream_type&
operator<<(unsigned int __n)
{
return _M_insert(static_cast<unsigned long>(__n));
}
__ostream_type&
operator<<(long long __n)
{ return _M_insert(__n); }
__ostream_type&
operator<<(unsigned long long __n)
{ return _M_insert(__n); }
__ostream_type&
operator<<(double __f)
{ return _M_insert(__f); }
__ostream_type&
operator<<(float __f)
{
return _M_insert(static_cast<double>(__f));
}
__ostream_type&
operator<<(long double __f)
{ return _M_insert(__f); }
__ostream_type&
operator<<(const void* __p)
{ return _M_insert(__p); }
#250 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ostream" 3
__ostream_type&
operator<<(__streambuf_type* __sb);
#283 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ostream" 3
__ostream_type&
put(char_type __c);
void
_M_write(const char_type* __s, streamsize __n)
{
const streamsize __put = this->rdbuf()->sputn(__s, __n);
if (__put != __n)
this->setstate(ios_base::badbit);
}
#311 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ostream" 3
__ostream_type&
write(const char_type* __s, streamsize __n);
#324 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ostream" 3
__ostream_type&
flush();
#335 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ostream" 3
pos_type
tellp();
#346 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ostream" 3
__ostream_type&
seekp(pos_type);
#358 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ostream" 3
__ostream_type&
seekp(off_type, ios_base::seekdir);
protected:
basic_ostream()
{ this->init(0); }
template<typename _ValueT>
__ostream_type&
_M_insert(_ValueT __v);
};
#377 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ostream" 3
template <typename _CharT, typename _Traits>
class basic_ostream<_CharT, _Traits>::sentry
{
bool _M_ok;
basic_ostream<_CharT, _Traits>& _M_os;
public:
#396 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ostream" 3
explicit
sentry(basic_ostream<_CharT, _Traits>& __os);
#406 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ostream" 3
~sentry()
{
if (bool(_M_os.flags() & ios_base::unitbuf) && !uncaught_exception())
{
if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() == -1)
_M_os.setstate(ios_base::badbit);
}
}
#427 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ostream" 3
operator bool() const
{ return _M_ok; }
};
#448 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ostream" 3
template<typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c)
{ return __ostream_insert(__out, &__c, 1); }
template<typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __out, char __c)
{ return (__out << __out.widen(__c)); }
template <class _Traits>
inline basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, char __c)
{ return __ostream_insert(__out, &__c, 1); }
template<class _Traits>
inline basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, signed char __c)
{ return (__out << static_cast<char>(__c)); }
template<class _Traits>
inline basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c)
{ return (__out << static_cast<char>(__c)); }
#490 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ostream" 3
template<typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
{
if (!__s)
__out.setstate(ios_base::badbit);
else
__ostream_insert(__out, __s,
static_cast<streamsize>(_Traits::length(__s)));
return __out;
}
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits> &
operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s);
template<class _Traits>
inline basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, const char* __s)
{
if (!__s)
__out.setstate(ios_base::badbit);
else
__ostream_insert(__out, __s,
static_cast<streamsize>(_Traits::length(__s)));
return __out;
}
template<class _Traits>
inline basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, const signed char* __s)
{ return (__out << reinterpret_cast<const char*>(__s)); }
template<class _Traits>
inline basic_ostream<char, _Traits> &
operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s)
{ return (__out << reinterpret_cast<const char*>(__s)); }
#540 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ostream" 3
template<typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits>&
endl(basic_ostream<_CharT, _Traits>& __os)
{ return flush(__os.put(__os.widen('\n'))); }
template<typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits>&
ends(basic_ostream<_CharT, _Traits>& __os)
{ return __os.put(_CharT()); }
template<typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits>&
flush(basic_ostream<_CharT, _Traits>& __os)
{ return __os.flush(); }
#585 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ostream" 3
}
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/ostream.tcc" 1 3
#39 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/ostream.tcc" 3
#39 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/ostream.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>::sentry::
sentry(basic_ostream<_CharT, _Traits>& __os)
: _M_ok(false), _M_os(__os)
{
if (__os.tie() && __os.good())
__os.tie()->flush();
if (__os.good())
_M_ok = true;
else
__os.setstate(ios_base::failbit);
}
template<typename _CharT, typename _Traits>
template<typename _ValueT>
basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::
_M_insert(_ValueT __v)
{
sentry __cerb(*this);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
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;
}
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::
operator<<(short __n)
{
const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
if (__fmt == ios_base::oct || __fmt == ios_base::hex)
return _M_insert(static_cast<long>(static_cast<unsigned short>(__n)));
else
return _M_insert(static_cast<long>(__n));
}
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::
operator<<(int __n)
{
const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
if (__fmt == ios_base::oct || __fmt == ios_base::hex)
return _M_insert(static_cast<long>(static_cast<unsigned int>(__n)));
else
return _M_insert(static_cast<long>(__n));
}
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::
operator<<(__streambuf_type* __sbin)
{
ios_base::iostate __err = ios_base::goodbit;
sentry __cerb(*this);
if (__cerb && __sbin)
{
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;
}
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::
put(char_type __c)
{
sentry __cerb(*this);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
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;
}
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::
write(const _CharT* __s, streamsize __n)
{
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;
}
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::
flush()
{
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;
}
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;
}
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())
{
const pos_type __p = this->rdbuf()->pubseekpos(__pos,
ios_base::out);
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;
}
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())
{
const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
ios_base::out);
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;
}
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s)
{
if (!__s)
__out.setstate(ios_base::badbit);
else
{
const size_t __clen = char_traits<char>::length(__s);
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]);
_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;
}
extern template class basic_ostream<char>;
extern template ostream& endl(ostream&);
extern template ostream& ends(ostream&);
extern template ostream& flush(ostream&);
extern template ostream& operator<<(ostream&, char);
extern template ostream& operator<<(ostream&, unsigned char);
extern template ostream& operator<<(ostream&, signed char);
extern template ostream& operator<<(ostream&, const char*);
extern template ostream& operator<<(ostream&, const unsigned char*);
extern template ostream& operator<<(ostream&, const signed char*);
extern template ostream& ostream::_M_insert(long);
extern template ostream& ostream::_M_insert(unsigned long);
extern template ostream& ostream::_M_insert(bool);
extern template ostream& ostream::_M_insert(long long);
extern template ostream& ostream::_M_insert(unsigned long long);
extern template ostream& ostream::_M_insert(double);
extern template ostream& ostream::_M_insert(long double);
extern template ostream& ostream::_M_insert(const void*);
extern template class basic_ostream<wchar_t>;
extern template wostream& endl(wostream&);
extern template wostream& ends(wostream&);
extern template wostream& flush(wostream&);
extern template wostream& operator<<(wostream&, wchar_t);
extern template wostream& operator<<(wostream&, char);
extern template wostream& operator<<(wostream&, const wchar_t*);
extern template wostream& operator<<(wostream&, const char*);
extern template wostream& wostream::_M_insert(long);
extern template wostream& wostream::_M_insert(unsigned long);
extern template wostream& wostream::_M_insert(bool);
extern template wostream& wostream::_M_insert(long long);
extern template wostream& wostream::_M_insert(unsigned long long);
extern template wostream& wostream::_M_insert(double);
extern template wostream& wostream::_M_insert(long double);
extern template wostream& wostream::_M_insert(const void*);
}
#588 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/ostream" 2 3
#40 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/iostream" 2 3
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/istream" 1 3
#38 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/istream" 3
#38 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/istream" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
#55 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/istream" 3
template<typename _CharT, typename _Traits>
class basic_istream : virtual public basic_ios<_CharT, _Traits>
{
public:
typedef _CharT char_type;
typedef typename _Traits::int_type int_type;
typedef typename _Traits::pos_type pos_type;
typedef typename _Traits::off_type off_type;
typedef _Traits traits_type;
typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
typedef basic_ios<_CharT, _Traits> __ios_type;
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
__num_get_type;
typedef ctype<_CharT> __ctype_type;
protected:
streamsize _M_gcount;
public:
#91 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/istream" 3
explicit
basic_istream(__streambuf_type* __sb)
: _M_gcount(streamsize(0))
{ this->init(__sb); }
virtual
~basic_istream()
{ _M_gcount = streamsize(0); }
class sentry;
friend class sentry;
#120 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/istream" 3
__istream_type&
operator>>(__istream_type& (*__pf)(__istream_type&))
{ return __pf(*this); }
__istream_type&
operator>>(__ios_type& (*__pf)(__ios_type&))
{
__pf(*this);
return *this;
}
__istream_type&
operator>>(ios_base& (*__pf)(ios_base&))
{
__pf(*this);
return *this;
}
#167 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/istream" 3
__istream_type&
operator>>(bool& __n)
{ return _M_extract(__n); }
__istream_type&
operator>>(short& __n);
__istream_type&
operator>>(unsigned short& __n)
{ return _M_extract(__n); }
__istream_type&
operator>>(int& __n);
__istream_type&
operator>>(unsigned int& __n)
{ return _M_extract(__n); }
__istream_type&
operator>>(long& __n)
{ return _M_extract(__n); }
__istream_type&
operator>>(unsigned long& __n)
{ return _M_extract(__n); }
__istream_type&
operator>>(long long& __n)
{ return _M_extract(__n); }
__istream_type&
operator>>(unsigned long long& __n)
{ return _M_extract(__n); }
__istream_type&
operator>>(float& __f)
{ return _M_extract(__f); }
__istream_type&
operator>>(double& __f)
{ return _M_extract(__f); }
__istream_type&
operator>>(long double& __f)
{ return _M_extract(__f); }
__istream_type&
operator>>(void*& __p)
{ return _M_extract(__p); }
#239 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/istream" 3
__istream_type&
operator>>(__streambuf_type* __sb);
#249 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/istream" 3
streamsize
gcount() const
{ return _M_gcount; }
#281 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/istream" 3
int_type
get();
#295 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/istream" 3
__istream_type&
get(char_type& __c);
#322 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/istream" 3
__istream_type&
get(char_type* __s, streamsize __n, char_type __delim);
#333 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/istream" 3
__istream_type&
get(char_type* __s, streamsize __n)
{ return this->get(__s, __n, this->widen('\n')); }
#356 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/istream" 3
__istream_type&
get(__streambuf_type& __sb, char_type __delim);
#366 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/istream" 3
__istream_type&
get(__streambuf_type& __sb)
{ return this->get(__sb, this->widen('\n')); }
#395 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/istream" 3
__istream_type&
getline(char_type* __s, streamsize __n, char_type __delim);
#406 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/istream" 3
__istream_type&
getline(char_type* __s, streamsize __n)
{ return this->getline(__s, __n, this->widen('\n')); }
#430 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/istream" 3
__istream_type&
ignore();
__istream_type&
ignore(streamsize __n);
__istream_type&
ignore(streamsize __n, int_type __delim);
#447 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/istream" 3
int_type
peek();
#465 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/istream" 3
__istream_type&
read(char_type* __s, streamsize __n);
#484 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/istream" 3
streamsize
readsome(char_type* __s, streamsize __n);
#501 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/istream" 3
__istream_type&
putback(char_type __c);
#517 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/istream" 3
__istream_type&
unget();
#535 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/istream" 3
int
sync();
#550 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/istream" 3
pos_type
tellg();
#565 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/istream" 3
__istream_type&
seekg(pos_type);
#581 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/istream" 3
__istream_type&
seekg(off_type, ios_base::seekdir);
protected:
basic_istream()
: _M_gcount(streamsize(0))
{ this->init(0); }
template<typename _ValueT>
__istream_type&
_M_extract(_ValueT& __v);
};
template<>
basic_istream<char>&
basic_istream<char>::
getline(char_type* __s, streamsize __n, char_type __delim);
template<>
basic_istream<char>&
basic_istream<char>::
ignore(streamsize __n);
template<>
basic_istream<char>&
basic_istream<char>::
ignore(streamsize __n, int_type __delim);
template<>
basic_istream<wchar_t>&
basic_istream<wchar_t>::
getline(char_type* __s, streamsize __n, char_type __delim);
template<>
basic_istream<wchar_t>&
basic_istream<wchar_t>::
ignore(streamsize __n);
template<>
basic_istream<wchar_t>&
basic_istream<wchar_t>::
ignore(streamsize __n, int_type __delim);
#636 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/istream" 3
template<typename _CharT, typename _Traits>
class basic_istream<_CharT, _Traits>::sentry
{
bool _M_ok;
public:
typedef _Traits traits_type;
typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef typename __istream_type::__ctype_type __ctype_type;
typedef typename _Traits::int_type __int_type;
#672 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/istream" 3
explicit
sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
#685 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/istream" 3
operator bool() const
{ return _M_ok; }
};
#702 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/istream" 3
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c);
template<class _Traits>
inline basic_istream<char, _Traits>&
operator>>(basic_istream<char, _Traits>& __in, unsigned char& __c)
{ return (__in >> reinterpret_cast<char&>(__c)); }
template<class _Traits>
inline basic_istream<char, _Traits>&
operator>>(basic_istream<char, _Traits>& __in, signed char& __c)
{ return (__in >> reinterpret_cast<char&>(__c)); }
#744 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/istream" 3
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s);
template<>
basic_istream<char>&
operator>>(basic_istream<char>& __in, char* __s);
template<class _Traits>
inline basic_istream<char, _Traits>&
operator>>(basic_istream<char, _Traits>& __in, unsigned char* __s)
{ return (__in >> reinterpret_cast<char*>(__s)); }
template<class _Traits>
inline basic_istream<char, _Traits>&
operator>>(basic_istream<char, _Traits>& __in, signed char* __s)
{ return (__in >> reinterpret_cast<char*>(__s)); }
#772 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/istream" 3
template<typename _CharT, typename _Traits>
class basic_iostream
: public basic_istream<_CharT, _Traits>,
public basic_ostream<_CharT, _Traits>
{
public:
typedef _CharT char_type;
typedef typename _Traits::int_type int_type;
typedef typename _Traits::pos_type pos_type;
typedef typename _Traits::off_type off_type;
typedef _Traits traits_type;
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef basic_ostream<_CharT, _Traits> __ostream_type;
explicit
basic_iostream(basic_streambuf<_CharT, _Traits>* __sb)
: __istream_type(__sb), __ostream_type(__sb) { }
virtual
~basic_iostream() { }
protected:
basic_iostream()
: __istream_type(), __ostream_type() { }
};
#833 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/istream" 3
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
ws(basic_istream<_CharT, _Traits>& __is);
#856 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/istream" 3
}
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/istream.tcc" 1 3
#39 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/istream.tcc" 3
#39 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/istream.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>::sentry::
sentry(basic_istream<_CharT, _Traits>& __in, bool __noskip) : _M_ok(false)
{
ios_base::iostate __err = ios_base::goodbit;
if (__in.good())
{
if (__in.tie())
__in.tie()->flush();
if (!__noskip && bool(__in.flags() & ios_base::skipws))
{
const __int_type __eof = traits_type::eof();
__streambuf_type* __sb = __in.rdbuf();
__int_type __c = __sb->sgetc();
const __ctype_type& __ct = __check_facet(__in._M_ctype);
while (!traits_type::eq_int_type(__c, __eof)
&& __ct.is(ctype_base::space,
traits_type::to_char_type(__c)))
__c = __sb->snextc();
if (traits_type::eq_int_type(__c, __eof))
__err |= ios_base::eofbit;
}
}
if (__in.good() && __err == ios_base::goodbit)
_M_ok = true;
else
{
__err |= ios_base::failbit;
__in.setstate(__err);
}
}
template<typename _CharT, typename _Traits>
template<typename _ValueT>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
_M_extract(_ValueT& __v)
{
sentry __cerb(*this, false);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
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;
}
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
operator>>(short& __n)
{
sentry __cerb(*this, false);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
if (true)
{
long __l;
const __num_get_type& __ng = __check_facet(this->_M_num_get);
__ng.get(*this, 0, *this, __err, __l);
if (__l < __gnu_cxx::__numeric_traits<short>::__min)
{
__err |= ios_base::failbit;
__n = __gnu_cxx::__numeric_traits<short>::__min;
}
else if (__l > __gnu_cxx::__numeric_traits<short>::__max)
{
__err |= ios_base::failbit;
__n = __gnu_cxx::__numeric_traits<short>::__max;
}
else
__n = short(__l);
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
}
return *this;
}
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
operator>>(int& __n)
{
sentry __cerb(*this, false);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
if (true)
{
long __l;
const __num_get_type& __ng = __check_facet(this->_M_num_get);
__ng.get(*this, 0, *this, __err, __l);
if (__l < __gnu_cxx::__numeric_traits<int>::__min)
{
__err |= ios_base::failbit;
__n = __gnu_cxx::__numeric_traits<int>::__min;
}
else if (__l > __gnu_cxx::__numeric_traits<int>::__max)
{
__err |= ios_base::failbit;
__n = __gnu_cxx::__numeric_traits<int>::__max;
}
else
__n = int(__l);
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
}
return *this;
}
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
operator>>(__streambuf_type* __sbout)
{
ios_base::iostate __err = ios_base::goodbit;
sentry __cerb(*this, false);
if (__cerb && __sbout)
{
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;
}
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();
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;
}
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();
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;
}
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();
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); }
}
if (__n > 0)
*__s = char_type();
if (!_M_gcount)
__err |= ios_base::failbit;
if (__err)
this->setstate(__err);
return *this;
}
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
get(__streambuf_type& __sb, char_type __delim)
{
_M_gcount = 0;
ios_base::iostate __err = ios_base::goodbit;
sentry __cerb(*this, true);
if (__cerb)
{
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);
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;
}
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();
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); }
}
if (__n > 0)
*__s = char_type();
if (!_M_gcount)
__err |= ios_base::failbit;
if (__err)
this->setstate(__err);
return *this;
}
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
ignore(void)
{
_M_gcount = 0;
sentry __cerb(*this, true);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
if (true)
{
const int_type __eof = traits_type::eof();
__streambuf_type* __sb = this->rdbuf();
if (traits_type::eq_int_type(__sb->sbumpc(), __eof))
__err |= ios_base::eofbit;
else
_M_gcount = 1;
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
}
return *this;
}
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
ignore(streamsize __n)
{
_M_gcount = 0;
sentry __cerb(*this, true);
if (__cerb && __n > 0)
{
ios_base::iostate __err = ios_base::goodbit;
if (true)
{
const int_type __eof = traits_type::eof();
__streambuf_type* __sb = this->rdbuf();
int_type __c = __sb->sgetc();
#514 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/istream.tcc" 3
bool __large_ignore = false;
while (true)
{
while (_M_gcount < __n
&& !traits_type::eq_int_type(__c, __eof))
{
++_M_gcount;
__c = __sb->snextc();
}
if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
&& !traits_type::eq_int_type(__c, __eof))
{
_M_gcount =
__gnu_cxx::__numeric_traits<streamsize>::__min;
__large_ignore = true;
}
else
break;
}
if (__large_ignore)
_M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
if (traits_type::eq_int_type(__c, __eof))
__err |= ios_base::eofbit;
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
}
return *this;
}
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
ignore(streamsize __n, int_type __delim)
{
_M_gcount = 0;
sentry __cerb(*this, true);
if (__cerb && __n > 0)
{
ios_base::iostate __err = ios_base::goodbit;
if (true)
{
const int_type __eof = traits_type::eof();
__streambuf_type* __sb = this->rdbuf();
int_type __c = __sb->sgetc();
bool __large_ignore = false;
while (true)
{
while (_M_gcount < __n
&& !traits_type::eq_int_type(__c, __eof)
&& !traits_type::eq_int_type(__c, __delim))
{
++_M_gcount;
__c = __sb->snextc();
}
if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
&& !traits_type::eq_int_type(__c, __eof)
&& !traits_type::eq_int_type(__c, __delim))
{
_M_gcount =
__gnu_cxx::__numeric_traits<streamsize>::__min;
__large_ignore = true;
}
else
break;
}
if (__large_ignore)
_M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
if (traits_type::eq_int_type(__c, __eof))
__err |= ios_base::eofbit;
else if (traits_type::eq_int_type(__c, __delim))
{
if (_M_gcount
< __gnu_cxx::__numeric_traits<streamsize>::__max)
++_M_gcount;
__sb->sbumpc();
}
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
}
return *this;
}
template<typename _CharT, typename _Traits>
typename basic_istream<_CharT, _Traits>::int_type
basic_istream<_CharT, _Traits>::
peek(void)
{
int_type __c = traits_type::eof();
_M_gcount = 0;
sentry __cerb(*this, true);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
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;
}
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;
}
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)
{
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;
}
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
putback(char_type __c)
{
_M_gcount = 0;
this->clear(this->rdstate() & ~ios_base::eofbit);
sentry __cerb(*this, true);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
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;
}
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
unget(void)
{
_M_gcount = 0;
this->clear(this->rdstate() & ~ios_base::eofbit);
sentry __cerb(*this, true);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
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;
}
template<typename _CharT, typename _Traits>
int
basic_istream<_CharT, _Traits>::
sync(void)
{
int __ret = -1;
sentry __cerb(*this, true);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
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;
}
template<typename _CharT, typename _Traits>
typename basic_istream<_CharT, _Traits>::pos_type
basic_istream<_CharT, _Traits>::
tellg(void)
{
pos_type __ret = pos_type(-1);
sentry __cerb(*this, true);
if (__cerb)
{
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;
}
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
seekg(pos_type __pos)
{
this->clear(this->rdstate() & ~ios_base::eofbit);
sentry __cerb(*this, true);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
if (true)
{
if (!this->fail())
{
const pos_type __p = this->rdbuf()->pubseekpos(__pos,
ios_base::in);
if (__p == pos_type(off_type(-1)))
__err |= ios_base::failbit;
}
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
}
return *this;
}
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
seekg(off_type __off, ios_base::seekdir __dir)
{
this->clear(this->rdstate() & ~ios_base::eofbit);
sentry __cerb(*this, true);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
if (true)
{
if (!this->fail())
{
const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
ios_base::in);
if (__p == pos_type(off_type(-1)))
__err |= ios_base::failbit;
}
}
if (false)
{
this->_M_setstate(ios_base::badbit);
;
}
if (false)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
}
return *this;
}
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
{
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef typename __istream_type::int_type __int_type;
typename __istream_type::sentry __cerb(__in, false);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
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;
}
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
{
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
typedef typename _Traits::int_type int_type;
typedef _CharT char_type;
typedef ctype<_CharT> __ctype_type;
streamsize __extracted = 0;
ios_base::iostate __err = ios_base::goodbit;
typename __istream_type::sentry __cerb(__in, false);
if (__cerb)
{
if (true)
{
streamsize __num = __in.width();
if (__num <= 0)
__num = __gnu_cxx::__numeric_traits<streamsize>::__max;
const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
const int_type __eof = _Traits::eof();
__streambuf_type* __sb = __in.rdbuf();
int_type __c = __sb->sgetc();
while (__extracted < __num - 1
&& !_Traits::eq_int_type(__c, __eof)
&& !__ct.is(ctype_base::space,
_Traits::to_char_type(__c)))
{
*__s++ = _Traits::to_char_type(__c);
++__extracted;
__c = __sb->snextc();
}
if (_Traits::eq_int_type(__c, __eof))
__err |= ios_base::eofbit;
*__s = char_type();
__in.width(0);
}
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;
}
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
ws(basic_istream<_CharT, _Traits>& __in)
{
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
typedef typename __istream_type::int_type __int_type;
typedef ctype<_CharT> __ctype_type;
const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
const __int_type __eof = _Traits::eof();
__streambuf_type* __sb = __in.rdbuf();
__int_type __c = __sb->sgetc();
while (!_Traits::eq_int_type(__c, __eof)
&& __ct.is(ctype_base::space, _Traits::to_char_type(__c)))
__c = __sb->snextc();
if (_Traits::eq_int_type(__c, __eof))
__in.setstate(ios_base::eofbit);
return __in;
}
extern template class basic_istream<char>;
extern template istream& ws(istream&);
extern template istream& operator>>(istream&, char&);
extern template istream& operator>>(istream&, char*);
extern template istream& operator>>(istream&, unsigned char&);
extern template istream& operator>>(istream&, signed char&);
extern template istream& operator>>(istream&, unsigned char*);
extern template istream& operator>>(istream&, signed char*);
extern template istream& istream::_M_extract(unsigned short&);
extern template istream& istream::_M_extract(unsigned int&);
extern template istream& istream::_M_extract(long&);
extern template istream& istream::_M_extract(unsigned long&);
extern template istream& istream::_M_extract(bool&);
extern template istream& istream::_M_extract(long long&);
extern template istream& istream::_M_extract(unsigned long long&);
extern template istream& istream::_M_extract(float&);
extern template istream& istream::_M_extract(double&);
extern template istream& istream::_M_extract(long double&);
extern template istream& istream::_M_extract(void*&);
extern template class basic_iostream<char>;
extern template class basic_istream<wchar_t>;
extern template wistream& ws(wistream&);
extern template wistream& operator>>(wistream&, wchar_t&);
extern template wistream& operator>>(wistream&, wchar_t*);
extern template wistream& wistream::_M_extract(unsigned short&);
extern template wistream& wistream::_M_extract(unsigned int&);
extern template wistream& wistream::_M_extract(long&);
extern template wistream& wistream::_M_extract(unsigned long&);
extern template wistream& wistream::_M_extract(bool&);
extern template wistream& wistream::_M_extract(long long&);
extern template wistream& wistream::_M_extract(unsigned long long&);
extern template wistream& wistream::_M_extract(float&);
extern template wistream& wistream::_M_extract(double&);
extern template wistream& wistream::_M_extract(long double&);
extern template wistream& wistream::_M_extract(void*&);
extern template class basic_iostream<wchar_t>;
}
#859 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/istream" 2 3
#41 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/iostream" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
#60 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/iostream" 3
extern istream cin;
extern ostream cout;
extern ostream cerr;
extern ostream clog;
extern wistream wcin;
extern wostream wcout;
extern wostream wcerr;
extern wostream wclog;
static ios_base::Init __ioinit;
}
#15 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/ap_systemc.h" 2
using std::iostream;
using std::istream;
using std::ostream;
using std::cin;
using std::cout;
using std::cerr;
using std::endl;
using std::flush;
using std::dec;
using std::hex;
using std::oct;
#1 "/usr/include/string.h" 1 3 4
#27 "/usr/include/string.h" 3 4
extern "C" {
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/clang/bin/../lib/clang/3.1/include/stddef.h" 1 3 4
#33 "/usr/include/string.h" 2 3 4
#42 "/usr/include/string.h" 3 4
extern void *memcpy (void *__restrict __dest, const void *__restrict __src,
size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
extern void *memmove (void *__dest, const void *__src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern void *memccpy (void *__restrict __dest, const void *__restrict __src,
int __c, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern void *memset (void *__s, int __c, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
extern int memcmp (const void *__s1, const void *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
#92 "/usr/include/string.h" 3 4
extern void *memchr (const void *__s, int __c, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
#106 "/usr/include/string.h" 3 4
extern void *rawmemchr (const void *__s, int __c)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
#117 "/usr/include/string.h" 3 4
extern void *memrchr (const void *__s, int __c, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern char *strcpy (char *__restrict __dest, const char *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *strncpy (char *__restrict __dest,
const char *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *strcat (char *__restrict __dest, const char *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *strncat (char *__restrict __dest, const char *__restrict __src,
size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int strcmp (const char *__s1, const char *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern int strncmp (const char *__s1, const char *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern int strcoll (const char *__s1, const char *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern size_t strxfrm (char *__restrict __dest,
const char *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (2)));
#162 "/usr/include/string.h" 3 4
extern int strcoll_l (const char *__s1, const char *__s2, __locale_t __l)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n,
__locale_t __l) throw () __attribute__ ((__nonnull__ (2, 4)));
extern char *strdup (const char *__s)
throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
extern char *strndup (const char *__string, size_t __n)
throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
#232 "/usr/include/string.h" 3 4
extern char *strchr (const char *__s, int __c)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
#259 "/usr/include/string.h" 3 4
extern char *strrchr (const char *__s, int __c)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
#273 "/usr/include/string.h" 3 4
extern char *strchrnul (const char *__s, int __c)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern size_t strcspn (const char *__s, const char *__reject)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern size_t strspn (const char *__s, const char *__accept)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
#311 "/usr/include/string.h" 3 4
extern char *strpbrk (const char *__s, const char *__accept)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
#338 "/usr/include/string.h" 3 4
extern char *strstr (const char *__haystack, const char *__needle)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern char *strtok (char *__restrict __s, const char *__restrict __delim)
throw () __attribute__ ((__nonnull__ (2)));
extern char *__strtok_r (char *__restrict __s,
const char *__restrict __delim,
char **__restrict __save_ptr)
throw () __attribute__ ((__nonnull__ (2, 3)));
extern char *strtok_r (char *__restrict __s, const char *__restrict __delim,
char **__restrict __save_ptr)
throw () __attribute__ ((__nonnull__ (2, 3)));
#369 "/usr/include/string.h" 3 4
extern char *strcasestr (const char *__haystack, const char *__needle)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern void *memmem (const void *__haystack, size_t __haystacklen,
const void *__needle, size_t __needlelen)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3)));
extern void *__mempcpy (void *__restrict __dest,
const void *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern void *mempcpy (void *__restrict __dest,
const void *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern size_t strlen (const char *__s)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern size_t strnlen (const char *__string, size_t __maxlen)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern char *strerror (int __errnum) throw ();
#434 "/usr/include/string.h" 3 4
extern char *strerror_r (int __errnum, char *__buf, size_t __buflen)
throw () __attribute__ ((__nonnull__ (2))) ;
extern char *strerror_l (int __errnum, __locale_t __l) throw ();
extern void __bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
extern void bcopy (const void *__src, void *__dest, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern void bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
extern int bcmp (const void *__s1, const void *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
#485 "/usr/include/string.h" 3 4
extern char *index (const char *__s, int __c)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
#513 "/usr/include/string.h" 3 4
extern char *rindex (const char *__s, int __c)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern int ffs (int __i) throw () __attribute__ ((__const__));
extern int ffsl (long int __l) throw () __attribute__ ((__const__));
__extension__ extern int ffsll (long long int __ll)
throw () __attribute__ ((__const__));
extern int strcasecmp (const char *__s1, const char *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern int strncasecmp (const char *__s1, const char *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern int strcasecmp_l (const char *__s1, const char *__s2,
__locale_t __loc)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
extern int strncasecmp_l (const char *__s1, const char *__s2,
size_t __n, __locale_t __loc)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4)));
extern char *strsep (char **__restrict __stringp,
const char *__restrict __delim)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *strsignal (int __sig) throw ();
extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *stpcpy (char *__restrict __dest, const char *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *__stpncpy (char *__restrict __dest,
const char *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *stpncpy (char *__restrict __dest,
const char *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int strverscmp (const char *__s1, const char *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern char *strfry (char *__string) throw () __attribute__ ((__nonnull__ (1)));
extern void *memfrob (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
#602 "/usr/include/string.h" 3 4
extern char *basename (const char *__filename) throw () __attribute__ ((__nonnull__ (1)));
#642 "/usr/include/string.h" 3 4
}
#29 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/ap_systemc.h" 2
#1 "/usr/include/stdio.h" 1 3 4
#29 "/usr/include/stdio.h" 3 4
extern "C" {
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/clang/bin/../lib/clang/3.1/include/stddef.h" 1 3 4
#34 "/usr/include/stdio.h" 2 3 4
#74 "/usr/include/stdio.h" 3 4
#1 "/usr/include/libio.h" 1 3 4
#32 "/usr/include/libio.h" 3 4
#1 "/usr/include/_G_config.h" 1 3 4
#15 "/usr/include/_G_config.h" 3 4
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/clang/bin/../lib/clang/3.1/include/stddef.h" 1 3 4
#16 "/usr/include/_G_config.h" 2 3 4
#1 "/usr/include/wchar.h" 1 3 4
#21 "/usr/include/_G_config.h" 2 3 4
typedef struct
{
__off_t __pos;
__mbstate_t __state;
} _G_fpos_t;
typedef struct
{
__off64_t __pos;
__mbstate_t __state;
} _G_fpos64_t;
#33 "/usr/include/libio.h" 2 3 4
#145 "/usr/include/libio.h" 3 4
struct _IO_jump_t; struct _IO_FILE;
#155 "/usr/include/libio.h" 3 4
typedef void _IO_lock_t;
struct _IO_marker {
struct _IO_marker *_next;
struct _IO_FILE *_sbuf;
int _pos;
#178 "/usr/include/libio.h" 3 4
};
enum __codecvt_result
{
__codecvt_ok,
__codecvt_partial,
__codecvt_error,
__codecvt_noconv
};
#246 "/usr/include/libio.h" 3 4
struct _IO_FILE {
int _flags;
char* _IO_read_ptr;
char* _IO_read_end;
char* _IO_read_base;
char* _IO_write_base;
char* _IO_write_ptr;
char* _IO_write_end;
char* _IO_buf_base;
char* _IO_buf_end;
char *_IO_save_base;
char *_IO_backup_base;
char *_IO_save_end;
struct _IO_marker *_markers;
struct _IO_FILE *_chain;
int _fileno;
int _flags2;
__off_t _old_offset;
unsigned short _cur_column;
signed char _vtable_offset;
char _shortbuf[1];
_IO_lock_t *_lock;
#294 "/usr/include/libio.h" 3 4
__off64_t _offset;
#303 "/usr/include/libio.h" 3 4
void *__pad1;
void *__pad2;
void *__pad3;
void *__pad4;
size_t __pad5;
int _mode;
char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)];
};
struct _IO_FILE_plus;
extern struct _IO_FILE_plus _IO_2_1_stdin_;
extern struct _IO_FILE_plus _IO_2_1_stdout_;
extern struct _IO_FILE_plus _IO_2_1_stderr_;
#339 "/usr/include/libio.h" 3 4
typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t __nbytes);
typedef __ssize_t __io_write_fn (void *__cookie, const char *__buf,
size_t __n);
typedef int __io_seek_fn (void *__cookie, __off64_t *__pos, int __w);
typedef int __io_close_fn (void *__cookie);
typedef __io_read_fn cookie_read_function_t;
typedef __io_write_fn cookie_write_function_t;
typedef __io_seek_fn cookie_seek_function_t;
typedef __io_close_fn cookie_close_function_t;
typedef struct
{
__io_read_fn *read;
__io_write_fn *write;
__io_seek_fn *seek;
__io_close_fn *close;
} _IO_cookie_io_functions_t;
typedef _IO_cookie_io_functions_t cookie_io_functions_t;
struct _IO_cookie_file;
extern void _IO_cookie_init (struct _IO_cookie_file *__cfile, int __read_write,
void *__cookie, _IO_cookie_io_functions_t __fns);
extern "C" {
extern int __underflow (_IO_FILE *);
extern int __uflow (_IO_FILE *);
extern int __overflow (_IO_FILE *, int);
#435 "/usr/include/libio.h" 3 4
extern int _IO_getc (_IO_FILE *__fp);
extern int _IO_putc (int __c, _IO_FILE *__fp);
extern int _IO_feof (_IO_FILE *__fp) throw ();
extern int _IO_ferror (_IO_FILE *__fp) throw ();
extern int _IO_peekc_locked (_IO_FILE *__fp);
extern void _IO_flockfile (_IO_FILE *) throw ();
extern void _IO_funlockfile (_IO_FILE *) throw ();
extern int _IO_ftrylockfile (_IO_FILE *) throw ();
#465 "/usr/include/libio.h" 3 4
extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict,
__gnuc_va_list, int *__restrict);
extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict,
__gnuc_va_list);
extern __ssize_t _IO_padn (_IO_FILE *, int, __ssize_t);
extern size_t _IO_sgetn (_IO_FILE *, void *, size_t);
extern __off64_t _IO_seekoff (_IO_FILE *, __off64_t, int, int);
extern __off64_t _IO_seekpos (_IO_FILE *, __off64_t, int);
extern void _IO_free_backup_area (_IO_FILE *) throw ();
#527 "/usr/include/libio.h" 3 4
}
#75 "/usr/include/stdio.h" 2 3 4
typedef __gnuc_va_list va_list;
#110 "/usr/include/stdio.h" 3 4
typedef _G_fpos_t fpos_t;
typedef _G_fpos64_t fpos64_t;
#164 "/usr/include/stdio.h" 3 4
#1 "/usr/include/bits/stdio_lim.h" 1 3 4
#165 "/usr/include/stdio.h" 2 3 4
extern struct _IO_FILE *stdin;
extern struct _IO_FILE *stdout;
extern struct _IO_FILE *stderr;
extern int remove (const char *__filename) throw ();
extern int rename (const char *__old, const char *__new) throw ();
extern int renameat (int __oldfd, const char *__old, int __newfd,
const char *__new) throw ();
#195 "/usr/include/stdio.h" 3 4
extern FILE *tmpfile (void) ;
#205 "/usr/include/stdio.h" 3 4
extern FILE *tmpfile64 (void) ;
extern char *tmpnam (char *__s) throw () ;
extern char *tmpnam_r (char *__s) throw () ;
#227 "/usr/include/stdio.h" 3 4
extern char *tempnam (const char *__dir, const char *__pfx)
throw () __attribute__ ((__malloc__)) ;
#237 "/usr/include/stdio.h" 3 4
extern int fclose (FILE *__stream);
extern int fflush (FILE *__stream);
#252 "/usr/include/stdio.h" 3 4
extern int fflush_unlocked (FILE *__stream);
#262 "/usr/include/stdio.h" 3 4
extern int fcloseall (void);
#272 "/usr/include/stdio.h" 3 4
extern FILE *fopen (const char *__restrict __filename,
const char *__restrict __modes) ;
extern FILE *freopen (const char *__restrict __filename,
const char *__restrict __modes,
FILE *__restrict __stream) ;
#297 "/usr/include/stdio.h" 3 4
extern FILE *fopen64 (const char *__restrict __filename,
const char *__restrict __modes) ;
extern FILE *freopen64 (const char *__restrict __filename,
const char *__restrict __modes,
FILE *__restrict __stream) ;
extern FILE *fdopen (int __fd, const char *__modes) throw () ;
extern FILE *fopencookie (void *__restrict __magic_cookie,
const char *__restrict __modes,
_IO_cookie_io_functions_t __io_funcs) throw () ;
extern FILE *fmemopen (void *__s, size_t __len, const char *__modes)
throw () ;
extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) throw () ;
extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) throw ();
extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
int __modes, size_t __n) throw ();
extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
size_t __size) throw ();
extern void setlinebuf (FILE *__stream) throw ();
#356 "/usr/include/stdio.h" 3 4
extern int fprintf (FILE *__restrict __stream,
const char *__restrict __format, ...);
extern int printf (const char *__restrict __format, ...);
extern int sprintf (char *__restrict __s,
const char *__restrict __format, ...) throw ();
extern int vfprintf (FILE *__restrict __s, const char *__restrict __format,
__gnuc_va_list __arg);
extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg);
extern int vsprintf (char *__restrict __s, const char *__restrict __format,
__gnuc_va_list __arg) throw ();
extern int snprintf (char *__restrict __s, size_t __maxlen,
const char *__restrict __format, ...)
throw () __attribute__ ((__format__ (__printf__, 3, 4)));
extern int vsnprintf (char *__restrict __s, size_t __maxlen,
const char *__restrict __format, __gnuc_va_list __arg)
throw () __attribute__ ((__format__ (__printf__, 3, 0)));
extern int vasprintf (char **__restrict __ptr, const char *__restrict __f,
__gnuc_va_list __arg)
throw () __attribute__ ((__format__ (__printf__, 2, 0))) ;
extern int __asprintf (char **__restrict __ptr,
const char *__restrict __fmt, ...)
throw () __attribute__ ((__format__ (__printf__, 2, 3))) ;
extern int asprintf (char **__restrict __ptr,
const char *__restrict __fmt, ...)
throw () __attribute__ ((__format__ (__printf__, 2, 3))) ;
extern int vdprintf (int __fd, const char *__restrict __fmt,
__gnuc_va_list __arg)
__attribute__ ((__format__ (__printf__, 2, 0)));
extern int dprintf (int __fd, const char *__restrict __fmt, ...)
__attribute__ ((__format__ (__printf__, 2, 3)));
#425 "/usr/include/stdio.h" 3 4
extern int fscanf (FILE *__restrict __stream,
const char *__restrict __format, ...) ;
extern int scanf (const char *__restrict __format, ...) ;
extern int sscanf (const char *__restrict __s,
const char *__restrict __format, ...) throw ();
#471 "/usr/include/stdio.h" 3 4
extern int vfscanf (FILE *__restrict __s, const char *__restrict __format,
__gnuc_va_list __arg)
__attribute__ ((__format__ (__scanf__, 2, 0))) ;
extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg)
__attribute__ ((__format__ (__scanf__, 1, 0))) ;
extern int vsscanf (const char *__restrict __s,
const char *__restrict __format, __gnuc_va_list __arg)
throw () __attribute__ ((__format__ (__scanf__, 2, 0)));
#531 "/usr/include/stdio.h" 3 4
extern int fgetc (FILE *__stream);
extern int getc (FILE *__stream);
extern int getchar (void);
#550 "/usr/include/stdio.h" 3 4
extern int getc_unlocked (FILE *__stream);
extern int getchar_unlocked (void);
#561 "/usr/include/stdio.h" 3 4
extern int fgetc_unlocked (FILE *__stream);
#573 "/usr/include/stdio.h" 3 4
extern int fputc (int __c, FILE *__stream);
extern int putc (int __c, FILE *__stream);
extern int putchar (int __c);
#594 "/usr/include/stdio.h" 3 4
extern int fputc_unlocked (int __c, FILE *__stream);
extern int putc_unlocked (int __c, FILE *__stream);
extern int putchar_unlocked (int __c);
extern int getw (FILE *__stream);
extern int putw (int __w, FILE *__stream);
#622 "/usr/include/stdio.h" 3 4
extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
;
#638 "/usr/include/stdio.h" 3 4
extern char *gets (char *__s) __attribute__ ((__deprecated__));
#649 "/usr/include/stdio.h" 3 4
extern char *fgets_unlocked (char *__restrict __s, int __n,
FILE *__restrict __stream) ;
#665 "/usr/include/stdio.h" 3 4
extern __ssize_t __getdelim (char **__restrict __lineptr,
size_t *__restrict __n, int __delimiter,
FILE *__restrict __stream) ;
extern __ssize_t getdelim (char **__restrict __lineptr,
size_t *__restrict __n, int __delimiter,
FILE *__restrict __stream) ;
extern __ssize_t getline (char **__restrict __lineptr,
size_t *__restrict __n,
FILE *__restrict __stream) ;
#689 "/usr/include/stdio.h" 3 4
extern int fputs (const char *__restrict __s, FILE *__restrict __stream);
extern int puts (const char *__s);
extern int ungetc (int __c, FILE *__stream);
extern size_t fread (void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __stream) ;
extern size_t fwrite (const void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __s);
#726 "/usr/include/stdio.h" 3 4
extern int fputs_unlocked (const char *__restrict __s,
FILE *__restrict __stream);
#737 "/usr/include/stdio.h" 3 4
extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __stream) ;
extern size_t fwrite_unlocked (const void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __stream);
#749 "/usr/include/stdio.h" 3 4
extern int fseek (FILE *__stream, long int __off, int __whence);
extern long int ftell (FILE *__stream) ;
extern void rewind (FILE *__stream);
#773 "/usr/include/stdio.h" 3 4
extern int fseeko (FILE *__stream, __off_t __off, int __whence);
extern __off_t ftello (FILE *__stream) ;
#798 "/usr/include/stdio.h" 3 4
extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos);
extern int fsetpos (FILE *__stream, const fpos_t *__pos);
#818 "/usr/include/stdio.h" 3 4
extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence);
extern __off64_t ftello64 (FILE *__stream) ;
extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos);
extern int fsetpos64 (FILE *__stream, const fpos64_t *__pos);
extern void clearerr (FILE *__stream) throw ();
extern int feof (FILE *__stream) throw () ;
extern int ferror (FILE *__stream) throw () ;
extern void clearerr_unlocked (FILE *__stream) throw ();
extern int feof_unlocked (FILE *__stream) throw () ;
extern int ferror_unlocked (FILE *__stream) throw () ;
#846 "/usr/include/stdio.h" 3 4
extern void perror (const char *__s);
#1 "/usr/include/bits/sys_errlist.h" 1 3 4
#26 "/usr/include/bits/sys_errlist.h" 3 4
extern int sys_nerr;
extern const char *const sys_errlist[];
extern int _sys_nerr;
extern const char *const _sys_errlist[];
#854 "/usr/include/stdio.h" 2 3 4
extern int fileno (FILE *__stream) throw () ;
extern int fileno_unlocked (FILE *__stream) throw () ;
#873 "/usr/include/stdio.h" 3 4
extern FILE *popen (const char *__command, const char *__modes) ;
extern int pclose (FILE *__stream);
extern char *ctermid (char *__s) throw ();
extern char *cuserid (char *__s);
struct obstack;
extern int obstack_printf (struct obstack *__restrict __obstack,
const char *__restrict __format, ...)
throw () __attribute__ ((__format__ (__printf__, 2, 3)));
extern int obstack_vprintf (struct obstack *__restrict __obstack,
const char *__restrict __format,
__gnuc_va_list __args)
throw () __attribute__ ((__format__ (__printf__, 2, 0)));
extern void flockfile (FILE *__stream) throw ();
extern int ftrylockfile (FILE *__stream) throw () ;
extern void funlockfile (FILE *__stream) throw ();
#943 "/usr/include/stdio.h" 3 4
}
#30 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/ap_systemc.h" 2
extern "C" {
#1 "/usr/include/math.h" 1 3 4
#29 "/usr/include/math.h" 3 4
extern "C" {
#1 "/usr/include/bits/huge_val.h" 1 3 4
#34 "/usr/include/math.h" 2 3 4
#1 "/usr/include/bits/huge_valf.h" 1 3 4
#36 "/usr/include/math.h" 2 3 4
#1 "/usr/include/bits/huge_vall.h" 1 3 4
#37 "/usr/include/math.h" 2 3 4
#1 "/usr/include/bits/inf.h" 1 3 4
#40 "/usr/include/math.h" 2 3 4
#1 "/usr/include/bits/nan.h" 1 3 4
#43 "/usr/include/math.h" 2 3 4
#1 "/usr/include/bits/mathdef.h" 1 3 4
#28 "/usr/include/bits/mathdef.h" 3 4
typedef float float_t;
typedef double double_t;
#47 "/usr/include/math.h" 2 3 4
#70 "/usr/include/math.h" 3 4
#1 "/usr/include/bits/mathcalls.h" 1 3 4
#54 "/usr/include/bits/mathcalls.h" 3 4
extern double acos (double __x) throw (); extern double __acos (double __x) throw ();
extern double asin (double __x) throw (); extern double __asin (double __x) throw ();
extern double atan (double __x) throw (); extern double __atan (double __x) throw ();
extern double atan2 (double __y, double __x) throw (); extern double __atan2 (double __y, double __x) throw ();
extern double cos (double __x) throw (); extern double __cos (double __x) throw ();
extern double sin (double __x) throw (); extern double __sin (double __x) throw ();
extern double tan (double __x) throw (); extern double __tan (double __x) throw ();
extern double cosh (double __x) throw (); extern double __cosh (double __x) throw ();
extern double sinh (double __x) throw (); extern double __sinh (double __x) throw ();
extern double tanh (double __x) throw (); extern double __tanh (double __x) throw ();
extern void sincos (double __x, double *__sinx, double *__cosx) throw (); extern void __sincos (double __x, double *__sinx, double *__cosx) throw ();
extern double acosh (double __x) throw (); extern double __acosh (double __x) throw ();
extern double asinh (double __x) throw (); extern double __asinh (double __x) throw ();
extern double atanh (double __x) throw (); extern double __atanh (double __x) throw ();
extern double exp (double __x) throw (); extern double __exp (double __x) throw ();
extern double frexp (double __x, int *__exponent) throw (); extern double __frexp (double __x, int *__exponent) throw ();
extern double ldexp (double __x, int __exponent) throw (); extern double __ldexp (double __x, int __exponent) throw ();
extern double log (double __x) throw (); extern double __log (double __x) throw ();
extern double log10 (double __x) throw (); extern double __log10 (double __x) throw ();
extern double modf (double __x, double *__iptr) throw (); extern double __modf (double __x, double *__iptr) throw ()
__attribute__ ((__nonnull__ (2)));
extern double exp10 (double __x) throw (); extern double __exp10 (double __x) throw ();
extern double pow10 (double __x) throw (); extern double __pow10 (double __x) throw ();
extern double expm1 (double __x) throw (); extern double __expm1 (double __x) throw ();
extern double log1p (double __x) throw (); extern double __log1p (double __x) throw ();
extern double logb (double __x) throw (); extern double __logb (double __x) throw ();
extern double exp2 (double __x) throw (); extern double __exp2 (double __x) throw ();
extern double log2 (double __x) throw (); extern double __log2 (double __x) throw ();
#154 "/usr/include/bits/mathcalls.h" 3 4
extern double pow (double __x, double __y) throw (); extern double __pow (double __x, double __y) throw ();
extern double sqrt (double __x) throw (); extern double __sqrt (double __x) throw ();
extern double hypot (double __x, double __y) throw (); extern double __hypot (double __x, double __y) throw ();
extern double cbrt (double __x) throw (); extern double __cbrt (double __x) throw ();
#179 "/usr/include/bits/mathcalls.h" 3 4
extern double ceil (double __x) throw () __attribute__ ((__const__)); extern double __ceil (double __x) throw () __attribute__ ((__const__));
extern double fabs (double __x) throw () __attribute__ ((__const__)); extern double __fabs (double __x) throw () __attribute__ ((__const__));
extern double floor (double __x) throw () __attribute__ ((__const__)); extern double __floor (double __x) throw () __attribute__ ((__const__));
extern double fmod (double __x, double __y) throw (); extern double __fmod (double __x, double __y) throw ();
extern int __isinf (double __value) throw () __attribute__ ((__const__));
extern int __finite (double __value) throw () __attribute__ ((__const__));
extern int isinf (double __value) throw () __attribute__ ((__const__));
extern int finite (double __value) throw () __attribute__ ((__const__));
extern double drem (double __x, double __y) throw (); extern double __drem (double __x, double __y) throw ();
extern double significand (double __x) throw (); extern double __significand (double __x) throw ();
extern double copysign (double __x, double __y) throw () __attribute__ ((__const__)); extern double __copysign (double __x, double __y) throw () __attribute__ ((__const__));
extern double nan (const char *__tagb) throw () __attribute__ ((__const__)); extern double __nan (const char *__tagb) throw () __attribute__ ((__const__));
extern int __isnan (double __value) throw () __attribute__ ((__const__));
extern int isnan (double __value) throw () __attribute__ ((__const__));
extern double j0 (double) throw (); extern double __j0 (double) throw ();
extern double j1 (double) throw (); extern double __j1 (double) throw ();
extern double jn (int, double) throw (); extern double __jn (int, double) throw ();
extern double y0 (double) throw (); extern double __y0 (double) throw ();
extern double y1 (double) throw (); extern double __y1 (double) throw ();
extern double yn (int, double) throw (); extern double __yn (int, double) throw ();
extern double erf (double) throw (); extern double __erf (double) throw ();
extern double erfc (double) throw (); extern double __erfc (double) throw ();
extern double lgamma (double) throw (); extern double __lgamma (double) throw ();
extern double tgamma (double) throw (); extern double __tgamma (double) throw ();
extern double gamma (double) throw (); extern double __gamma (double) throw ();
extern double lgamma_r (double, int *__signgamp) throw (); extern double __lgamma_r (double, int *__signgamp) throw ();
extern double rint (double __x) throw (); extern double __rint (double __x) throw ();
extern double nextafter (double __x, double __y) throw () __attribute__ ((__const__)); extern double __nextafter (double __x, double __y) throw () __attribute__ ((__const__));
extern double nexttoward (double __x, long double __y) throw () __attribute__ ((__const__)); extern double __nexttoward (double __x, long double __y) throw () __attribute__ ((__const__));
extern double remainder (double __x, double __y) throw (); extern double __remainder (double __x, double __y) throw ();
extern double scalbn (double __x, int __n) throw (); extern double __scalbn (double __x, int __n) throw ();
extern int ilogb (double __x) throw (); extern int __ilogb (double __x) throw ();
extern double scalbln (double __x, long int __n) throw (); extern double __scalbln (double __x, long int __n) throw ();
extern double nearbyint (double __x) throw (); extern double __nearbyint (double __x) throw ();
extern double round (double __x) throw () __attribute__ ((__const__)); extern double __round (double __x) throw () __attribute__ ((__const__));
extern double trunc (double __x) throw () __attribute__ ((__const__)); extern double __trunc (double __x) throw () __attribute__ ((__const__));
extern double remquo (double __x, double __y, int *__quo) throw (); extern double __remquo (double __x, double __y, int *__quo) throw ();
extern long int lrint (double __x) throw (); extern long int __lrint (double __x) throw ();
extern long long int llrint (double __x) throw (); extern long long int __llrint (double __x) throw ();
extern long int lround (double __x) throw (); extern long int __lround (double __x) throw ();
extern long long int llround (double __x) throw (); extern long long int __llround (double __x) throw ();
extern double fdim (double __x, double __y) throw (); extern double __fdim (double __x, double __y) throw ();
extern double fmax (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmax (double __x, double __y) throw () __attribute__ ((__const__));
extern double fmin (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmin (double __x, double __y) throw () __attribute__ ((__const__));
extern int __fpclassify (double __value) throw ()
__attribute__ ((__const__));
extern int __signbit (double __value) throw ()
__attribute__ ((__const__));
extern double fma (double __x, double __y, double __z) throw (); extern double __fma (double __x, double __y, double __z) throw ();
#364 "/usr/include/bits/mathcalls.h" 3 4
extern double scalb (double __x, double __n) throw (); extern double __scalb (double __x, double __n) throw ();
#71 "/usr/include/math.h" 2 3 4
#89 "/usr/include/math.h" 3 4
#1 "/usr/include/bits/mathcalls.h" 1 3 4
#54 "/usr/include/bits/mathcalls.h" 3 4
extern float acosf (float __x) throw (); extern float __acosf (float __x) throw ();
extern float asinf (float __x) throw (); extern float __asinf (float __x) throw ();
extern float atanf (float __x) throw (); extern float __atanf (float __x) throw ();
extern float atan2f (float __y, float __x) throw (); extern float __atan2f (float __y, float __x) throw ();
extern float cosf (float __x) throw (); extern float __cosf (float __x) throw ();
extern float sinf (float __x) throw (); extern float __sinf (float __x) throw ();
extern float tanf (float __x) throw (); extern float __tanf (float __x) throw ();
extern float coshf (float __x) throw (); extern float __coshf (float __x) throw ();
extern float sinhf (float __x) throw (); extern float __sinhf (float __x) throw ();
extern float tanhf (float __x) throw (); extern float __tanhf (float __x) throw ();
extern void sincosf (float __x, float *__sinx, float *__cosx) throw (); extern void __sincosf (float __x, float *__sinx, float *__cosx) throw ();
extern float acoshf (float __x) throw (); extern float __acoshf (float __x) throw ();
extern float asinhf (float __x) throw (); extern float __asinhf (float __x) throw ();
extern float atanhf (float __x) throw (); extern float __atanhf (float __x) throw ();
extern float expf (float __x) throw (); extern float __expf (float __x) throw ();
extern float frexpf (float __x, int *__exponent) throw (); extern float __frexpf (float __x, int *__exponent) throw ();
extern float ldexpf (float __x, int __exponent) throw (); extern float __ldexpf (float __x, int __exponent) throw ();
extern float logf (float __x) throw (); extern float __logf (float __x) throw ();
extern float log10f (float __x) throw (); extern float __log10f (float __x) throw ();
extern float modff (float __x, float *__iptr) throw (); extern float __modff (float __x, float *__iptr) throw ()
__attribute__ ((__nonnull__ (2)));
extern float exp10f (float __x) throw (); extern float __exp10f (float __x) throw ();
extern float pow10f (float __x) throw (); extern float __pow10f (float __x) throw ();
extern float expm1f (float __x) throw (); extern float __expm1f (float __x) throw ();
extern float log1pf (float __x) throw (); extern float __log1pf (float __x) throw ();
extern float logbf (float __x) throw (); extern float __logbf (float __x) throw ();
extern float exp2f (float __x) throw (); extern float __exp2f (float __x) throw ();
extern float log2f (float __x) throw (); extern float __log2f (float __x) throw ();
#154 "/usr/include/bits/mathcalls.h" 3 4
extern float powf (float __x, float __y) throw (); extern float __powf (float __x, float __y) throw ();
extern float sqrtf (float __x) throw (); extern float __sqrtf (float __x) throw ();
extern float hypotf (float __x, float __y) throw (); extern float __hypotf (float __x, float __y) throw ();
extern float cbrtf (float __x) throw (); extern float __cbrtf (float __x) throw ();
#179 "/usr/include/bits/mathcalls.h" 3 4
extern float ceilf (float __x) throw () __attribute__ ((__const__)); extern float __ceilf (float __x) throw () __attribute__ ((__const__));
extern float fabsf (float __x) throw () __attribute__ ((__const__)); extern float __fabsf (float __x) throw () __attribute__ ((__const__));
extern float floorf (float __x) throw () __attribute__ ((__const__)); extern float __floorf (float __x) throw () __attribute__ ((__const__));
extern float fmodf (float __x, float __y) throw (); extern float __fmodf (float __x, float __y) throw ();
extern int __isinff (float __value) throw () __attribute__ ((__const__));
extern int __finitef (float __value) throw () __attribute__ ((__const__));
extern int isinff (float __value) throw () __attribute__ ((__const__));
extern int finitef (float __value) throw () __attribute__ ((__const__));
extern float dremf (float __x, float __y) throw (); extern float __dremf (float __x, float __y) throw ();
extern float significandf (float __x) throw (); extern float __significandf (float __x) throw ();
extern float copysignf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) throw () __attribute__ ((__const__));
extern float nanf (const char *__tagb) throw () __attribute__ ((__const__)); extern float __nanf (const char *__tagb) throw () __attribute__ ((__const__));
extern int __isnanf (float __value) throw () __attribute__ ((__const__));
extern int isnanf (float __value) throw () __attribute__ ((__const__));
extern float j0f (float) throw (); extern float __j0f (float) throw ();
extern float j1f (float) throw (); extern float __j1f (float) throw ();
extern float jnf (int, float) throw (); extern float __jnf (int, float) throw ();
extern float y0f (float) throw (); extern float __y0f (float) throw ();
extern float y1f (float) throw (); extern float __y1f (float) throw ();
extern float ynf (int, float) throw (); extern float __ynf (int, float) throw ();
extern float erff (float) throw (); extern float __erff (float) throw ();
extern float erfcf (float) throw (); extern float __erfcf (float) throw ();
extern float lgammaf (float) throw (); extern float __lgammaf (float) throw ();
extern float tgammaf (float) throw (); extern float __tgammaf (float) throw ();
extern float gammaf (float) throw (); extern float __gammaf (float) throw ();
extern float lgammaf_r (float, int *__signgamp) throw (); extern float __lgammaf_r (float, int *__signgamp) throw ();
extern float rintf (float __x) throw (); extern float __rintf (float __x) throw ();
extern float nextafterf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __nextafterf (float __x, float __y) throw () __attribute__ ((__const__));
extern float nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__)); extern float __nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__));
extern float remainderf (float __x, float __y) throw (); extern float __remainderf (float __x, float __y) throw ();
extern float scalbnf (float __x, int __n) throw (); extern float __scalbnf (float __x, int __n) throw ();
extern int ilogbf (float __x) throw (); extern int __ilogbf (float __x) throw ();
extern float scalblnf (float __x, long int __n) throw (); extern float __scalblnf (float __x, long int __n) throw ();
extern float nearbyintf (float __x) throw (); extern float __nearbyintf (float __x) throw ();
extern float roundf (float __x) throw () __attribute__ ((__const__)); extern float __roundf (float __x) throw () __attribute__ ((__const__));
extern float truncf (float __x) throw () __attribute__ ((__const__)); extern float __truncf (float __x) throw () __attribute__ ((__const__));
extern float remquof (float __x, float __y, int *__quo) throw (); extern float __remquof (float __x, float __y, int *__quo) throw ();
extern long int lrintf (float __x) throw (); extern long int __lrintf (float __x) throw ();
extern long long int llrintf (float __x) throw (); extern long long int __llrintf (float __x) throw ();
extern long int lroundf (float __x) throw (); extern long int __lroundf (float __x) throw ();
extern long long int llroundf (float __x) throw (); extern long long int __llroundf (float __x) throw ();
extern float fdimf (float __x, float __y) throw (); extern float __fdimf (float __x, float __y) throw ();
extern float fmaxf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fmaxf (float __x, float __y) throw () __attribute__ ((__const__));
extern float fminf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fminf (float __x, float __y) throw () __attribute__ ((__const__));
extern int __fpclassifyf (float __value) throw ()
__attribute__ ((__const__));
extern int __signbitf (float __value) throw ()
__attribute__ ((__const__));
extern float fmaf (float __x, float __y, float __z) throw (); extern float __fmaf (float __x, float __y, float __z) throw ();
#364 "/usr/include/bits/mathcalls.h" 3 4
extern float scalbf (float __x, float __n) throw (); extern float __scalbf (float __x, float __n) throw ();
#90 "/usr/include/math.h" 2 3 4
#133 "/usr/include/math.h" 3 4
#1 "/usr/include/bits/mathcalls.h" 1 3 4
#54 "/usr/include/bits/mathcalls.h" 3 4
extern long double acosl (long double __x) throw (); extern long double __acosl (long double __x) throw ();
extern long double asinl (long double __x) throw (); extern long double __asinl (long double __x) throw ();
extern long double atanl (long double __x) throw (); extern long double __atanl (long double __x) throw ();
extern long double atan2l (long double __y, long double __x) throw (); extern long double __atan2l (long double __y, long double __x) throw ();
extern long double cosl (long double __x) throw (); extern long double __cosl (long double __x) throw ();
extern long double sinl (long double __x) throw (); extern long double __sinl (long double __x) throw ();
extern long double tanl (long double __x) throw (); extern long double __tanl (long double __x) throw ();
extern long double coshl (long double __x) throw (); extern long double __coshl (long double __x) throw ();
extern long double sinhl (long double __x) throw (); extern long double __sinhl (long double __x) throw ();
extern long double tanhl (long double __x) throw (); extern long double __tanhl (long double __x) throw ();
extern void sincosl (long double __x, long double *__sinx, long double *__cosx) throw (); extern void __sincosl (long double __x, long double *__sinx, long double *__cosx) throw ();
extern long double acoshl (long double __x) throw (); extern long double __acoshl (long double __x) throw ();
extern long double asinhl (long double __x) throw (); extern long double __asinhl (long double __x) throw ();
extern long double atanhl (long double __x) throw (); extern long double __atanhl (long double __x) throw ();
extern long double expl (long double __x) throw (); extern long double __expl (long double __x) throw ();
extern long double frexpl (long double __x, int *__exponent) throw (); extern long double __frexpl (long double __x, int *__exponent) throw ();
extern long double ldexpl (long double __x, int __exponent) throw (); extern long double __ldexpl (long double __x, int __exponent) throw ();
extern long double logl (long double __x) throw (); extern long double __logl (long double __x) throw ();
extern long double log10l (long double __x) throw (); extern long double __log10l (long double __x) throw ();
extern long double modfl (long double __x, long double *__iptr) throw (); extern long double __modfl (long double __x, long double *__iptr) throw ()
__attribute__ ((__nonnull__ (2)));
extern long double exp10l (long double __x) throw (); extern long double __exp10l (long double __x) throw ();
extern long double pow10l (long double __x) throw (); extern long double __pow10l (long double __x) throw ();
extern long double expm1l (long double __x) throw (); extern long double __expm1l (long double __x) throw ();
extern long double log1pl (long double __x) throw (); extern long double __log1pl (long double __x) throw ();
extern long double logbl (long double __x) throw (); extern long double __logbl (long double __x) throw ();
extern long double exp2l (long double __x) throw (); extern long double __exp2l (long double __x) throw ();
extern long double log2l (long double __x) throw (); extern long double __log2l (long double __x) throw ();
#154 "/usr/include/bits/mathcalls.h" 3 4
extern long double powl (long double __x, long double __y) throw (); extern long double __powl (long double __x, long double __y) throw ();
extern long double sqrtl (long double __x) throw (); extern long double __sqrtl (long double __x) throw ();
extern long double hypotl (long double __x, long double __y) throw (); extern long double __hypotl (long double __x, long double __y) throw ();
extern long double cbrtl (long double __x) throw (); extern long double __cbrtl (long double __x) throw ();
#179 "/usr/include/bits/mathcalls.h" 3 4
extern long double ceill (long double __x) throw () __attribute__ ((__const__)); extern long double __ceill (long double __x) throw () __attribute__ ((__const__));
extern long double fabsl (long double __x) throw () __attribute__ ((__const__)); extern long double __fabsl (long double __x) throw () __attribute__ ((__const__));
extern long double floorl (long double __x) throw () __attribute__ ((__const__)); extern long double __floorl (long double __x) throw () __attribute__ ((__const__));
extern long double fmodl (long double __x, long double __y) throw (); extern long double __fmodl (long double __x, long double __y) throw ();
extern int __isinfl (long double __value) throw () __attribute__ ((__const__));
extern int __finitel (long double __value) throw () __attribute__ ((__const__));
extern int isinfl (long double __value) throw () __attribute__ ((__const__));
extern int finitel (long double __value) throw () __attribute__ ((__const__));
extern long double dreml (long double __x, long double __y) throw (); extern long double __dreml (long double __x, long double __y) throw ();
extern long double significandl (long double __x) throw (); extern long double __significandl (long double __x) throw ();
extern long double copysignl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __copysignl (long double __x, long double __y) throw () __attribute__ ((__const__));
extern long double nanl (const char *__tagb) throw () __attribute__ ((__const__)); extern long double __nanl (const char *__tagb) throw () __attribute__ ((__const__));
extern int __isnanl (long double __value) throw () __attribute__ ((__const__));
extern int isnanl (long double __value) throw () __attribute__ ((__const__));
extern long double j0l (long double) throw (); extern long double __j0l (long double) throw ();
extern long double j1l (long double) throw (); extern long double __j1l (long double) throw ();
extern long double jnl (int, long double) throw (); extern long double __jnl (int, long double) throw ();
extern long double y0l (long double) throw (); extern long double __y0l (long double) throw ();
extern long double y1l (long double) throw (); extern long double __y1l (long double) throw ();
extern long double ynl (int, long double) throw (); extern long double __ynl (int, long double) throw ();
extern long double erfl (long double) throw (); extern long double __erfl (long double) throw ();
extern long double erfcl (long double) throw (); extern long double __erfcl (long double) throw ();
extern long double lgammal (long double) throw (); extern long double __lgammal (long double) throw ();
extern long double tgammal (long double) throw (); extern long double __tgammal (long double) throw ();
extern long double gammal (long double) throw (); extern long double __gammal (long double) throw ();
extern long double lgammal_r (long double, int *__signgamp) throw (); extern long double __lgammal_r (long double, int *__signgamp) throw ();
extern long double rintl (long double __x) throw (); extern long double __rintl (long double __x) throw ();
extern long double nextafterl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __nextafterl (long double __x, long double __y) throw () __attribute__ ((__const__));
extern long double nexttowardl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __nexttowardl (long double __x, long double __y) throw () __attribute__ ((__const__));
extern long double remainderl (long double __x, long double __y) throw (); extern long double __remainderl (long double __x, long double __y) throw ();
extern long double scalbnl (long double __x, int __n) throw (); extern long double __scalbnl (long double __x, int __n) throw ();
extern int ilogbl (long double __x) throw (); extern int __ilogbl (long double __x) throw ();
extern long double scalblnl (long double __x, long int __n) throw (); extern long double __scalblnl (long double __x, long int __n) throw ();
extern long double nearbyintl (long double __x) throw (); extern long double __nearbyintl (long double __x) throw ();
extern long double roundl (long double __x) throw () __attribute__ ((__const__)); extern long double __roundl (long double __x) throw () __attribute__ ((__const__));
extern long double truncl (long double __x) throw () __attribute__ ((__const__)); extern long double __truncl (long double __x) throw () __attribute__ ((__const__));
extern long double remquol (long double __x, long double __y, int *__quo) throw (); extern long double __remquol (long double __x, long double __y, int *__quo) throw ();
extern long int lrintl (long double __x) throw (); extern long int __lrintl (long double __x) throw ();
extern long long int llrintl (long double __x) throw (); extern long long int __llrintl (long double __x) throw ();
extern long int lroundl (long double __x) throw (); extern long int __lroundl (long double __x) throw ();
extern long long int llroundl (long double __x) throw (); extern long long int __llroundl (long double __x) throw ();
extern long double fdiml (long double __x, long double __y) throw (); extern long double __fdiml (long double __x, long double __y) throw ();
extern long double fmaxl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fmaxl (long double __x, long double __y) throw () __attribute__ ((__const__));
extern long double fminl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fminl (long double __x, long double __y) throw () __attribute__ ((__const__));
extern int __fpclassifyl (long double __value) throw ()
__attribute__ ((__const__));
extern int __signbitl (long double __value) throw ()
__attribute__ ((__const__));
extern long double fmal (long double __x, long double __y, long double __z) throw (); extern long double __fmal (long double __x, long double __y, long double __z) throw ();
#364 "/usr/include/bits/mathcalls.h" 3 4
extern long double scalbl (long double __x, long double __n) throw (); extern long double __scalbl (long double __x, long double __n) throw ();
#134 "/usr/include/math.h" 2 3 4
#149 "/usr/include/math.h" 3 4
extern int signgam;
#190 "/usr/include/math.h" 3 4
enum
{
FP_NAN =
0,
FP_INFINITE =
1,
FP_ZERO =
2,
FP_SUBNORMAL =
3,
FP_NORMAL =
4
};
#288 "/usr/include/math.h" 3 4
typedef enum
{
_IEEE_ = -1,
_SVID_,
_XOPEN_,
_POSIX_,
_ISOC_
} _LIB_VERSION_TYPE;
extern _LIB_VERSION_TYPE _LIB_VERSION;
#311 "/usr/include/math.h" 3 4
struct __exception
{
int type;
char *name;
double arg1;
double arg2;
double retval;
};
extern int matherr (struct __exception *__exc) throw ();
#475 "/usr/include/math.h" 3 4
}
#31 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/ap_systemc.h" 2
}
#31 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/ap_systemc.h"
#1 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/etc/autopilot_enum.h" 1
#58 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/etc/autopilot_enum.h"
enum SsdmDataTypes {
_ssdm_sc_int = 0,
_ssdm_c_int = _ssdm_sc_int,
_ssdm_sc_uint = 1,
_ssdm_c_uint = _ssdm_sc_uint,
_ssdm_sc_bigint = 2,
_ssdm_sc_biguint = 3,
};
enum SsdmPortTypes {
_ssdm_sc_in = 0,
_ssdm_sc_out = 1,
_ssdm_sc_inout = 2,
_ssdm_sc_in_clk,
_ssdm_fifo_in,
_ssdm_sc_fifo_in = _ssdm_fifo_in,
_ssdm_tlm_fifo_in = _ssdm_fifo_in,
_ssdm_fifo_out,
_ssdm_sc_fifo_out = _ssdm_fifo_out,
_ssdm_tlm_fifo_out = _ssdm_fifo_out,
_ssdm_fifo_inout,
_ssdm_sc_fifo_inout = _ssdm_fifo_inout,
_ssdm_tlm_fifo_inout = _ssdm_fifo_inout,
_ssdm_sc_bus,
_ssdm_hls_bus_port = _ssdm_sc_bus,
_ssdm_AXI4M_bus_port = _ssdm_sc_bus,
_ssdm_port_end,
};
enum SsdmProcessTypes {
_ssdm_method = 0,
_ssdm_sc_method = _ssdm_method,
_ssdm_thread = 1,
_ssdm_sc_thread = _ssdm_thread,
_ssdm_cthread = 2,
_ssdm_sc_cthread = _ssdm_cthread,
_ssdm_process_end,
};
enum SsdmSensitiveTypes {
_ssdm_sensitive = 0,
_ssdm_sensitive_pos,
_ssdm_sensitive_neg,
_ssdm_sensitive_reset0,
_ssdm_sensitive_reset1,
_ssdm_sensitive_end,
};
enum SsdmChannelTypes {
_ssdm_sc_sig,
_ssdm_fifo,
_ssdm_sc_fifo = _ssdm_fifo,
_ssdm_mem_fifo,
_ssdm_sc_mem_fifo = _ssdm_mem_fifo,
};
enum SsdmRegionTypes {
_ssdm_region_reset,
_ssdm_region_protocol,
_ssdm_region_pipeline,
_ssdm_region_parallel,
};
#32 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/ap_systemc.h" 2
#50 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/ap_systemc.h"
#1 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/ap_sc_dt.h" 1
#57 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/ap_sc_dt.h"
typedef void****** __ap_sc_dt_begin__;
#1 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_int_syn.h" 1
#73 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_int_syn.h"
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/clang/bin/../lib/clang/3.1/include/limits.h" 1 3
#38 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/clang/bin/../lib/clang/3.1/include/limits.h" 3
#1 "/usr/include/limits.h" 1 3 4
#144 "/usr/include/limits.h" 3 4
#1 "/usr/include/bits/posix1_lim.h" 1 3 4
#160 "/usr/include/bits/posix1_lim.h" 3 4
#1 "/usr/include/bits/local_lim.h" 1 3 4
#38 "/usr/include/bits/local_lim.h" 3 4
#1 "/usr/include/linux/limits.h" 1 3 4
#39 "/usr/include/bits/local_lim.h" 2 3 4
#161 "/usr/include/bits/posix1_lim.h" 2 3 4
#145 "/usr/include/limits.h" 2 3 4
#1 "/usr/include/bits/posix2_lim.h" 1 3 4
#149 "/usr/include/limits.h" 2 3 4
#1 "/usr/include/bits/xopen_lim.h" 1 3 4
#33 "/usr/include/bits/xopen_lim.h" 3 4
#1 "/usr/include/bits/stdio_lim.h" 1 3 4
#34 "/usr/include/bits/xopen_lim.h" 2 3 4
#153 "/usr/include/limits.h" 2 3 4
#39 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/clang/bin/../lib/clang/3.1/include/limits.h" 2 3
#74 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_int_syn.h" 2
#1 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/hls_half.h" 1
#32 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/hls_half.h"
#1 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cmath" 1 3
#41 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cmath" 3
#41 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cmath" 3
#76 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cmath" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
inline double
abs(double __x)
{ return __builtin_fabs(__x); }
inline float
abs(float __x)
{ return __builtin_fabsf(__x); }
inline long double
abs(long double __x)
{ return __builtin_fabsl(__x); }
template<typename _Tp>
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
abs(_Tp __x)
{ return __builtin_fabs(__x); }
using ::acos;
inline float
acos(float __x)
{ return __builtin_acosf(__x); }
inline long double
acos(long double __x)
{ return __builtin_acosl(__x); }
template<typename _Tp>
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
acos(_Tp __x)
{ return __builtin_acos(__x); }
using ::asin;
inline float
asin(float __x)
{ return __builtin_asinf(__x); }
inline long double
asin(long double __x)
{ return __builtin_asinl(__x); }
template<typename _Tp>
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
asin(_Tp __x)
{ return __builtin_asin(__x); }
using ::atan;
inline float
atan(float __x)
{ return __builtin_atanf(__x); }
inline long double
atan(long double __x)
{ return __builtin_atanl(__x); }
template<typename _Tp>
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
atan(_Tp __x)
{ return __builtin_atan(__x); }
using ::atan2;
inline float
atan2(float __y, float __x)
{ return __builtin_atan2f(__y, __x); }
inline long double
atan2(long double __y, long double __x)
{ return __builtin_atan2l(__y, __x); }
template<typename _Tp, typename _Up>
inline
typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
atan2(_Tp __y, _Up __x)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return atan2(__type(__y), __type(__x));
}
using ::ceil;
inline float
ceil(float __x)
{ return __builtin_ceilf(__x); }
inline long double
ceil(long double __x)
{ return __builtin_ceill(__x); }
template<typename _Tp>
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
ceil(_Tp __x)
{ return __builtin_ceil(__x); }
using ::cos;
inline float
cos(float __x)
{ return __builtin_cosf(__x); }
inline long double
cos(long double __x)
{ return __builtin_cosl(__x); }
template<typename _Tp>
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
cos(_Tp __x)
{ return __builtin_cos(__x); }
using ::cosh;
inline float
cosh(float __x)
{ return __builtin_coshf(__x); }
inline long double
cosh(long double __x)
{ return __builtin_coshl(__x); }
template<typename _Tp>
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
cosh(_Tp __x)
{ return __builtin_cosh(__x); }
using ::exp;
inline float
exp(float __x)
{ return __builtin_expf(__x); }
inline long double
exp(long double __x)
{ return __builtin_expl(__x); }
template<typename _Tp>
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
exp(_Tp __x)
{ return __builtin_exp(__x); }
using ::fabs;
inline float
fabs(float __x)
{ return __builtin_fabsf(__x); }
inline long double
fabs(long double __x)
{ return __builtin_fabsl(__x); }
template<typename _Tp>
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
fabs(_Tp __x)
{ return __builtin_fabs(__x); }
using ::floor;
inline float
floor(float __x)
{ return __builtin_floorf(__x); }
inline long double
floor(long double __x)
{ return __builtin_floorl(__x); }
template<typename _Tp>
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
floor(_Tp __x)
{ return __builtin_floor(__x); }
using ::fmod;
inline float
fmod(float __x, float __y)
{ return __builtin_fmodf(__x, __y); }
inline long double
fmod(long double __x, long double __y)
{ return __builtin_fmodl(__x, __y); }
using ::frexp;
inline float
frexp(float __x, int* __exp)
{ return __builtin_frexpf(__x, __exp); }
inline long double
frexp(long double __x, int* __exp)
{ return __builtin_frexpl(__x, __exp); }
template<typename _Tp>
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
frexp(_Tp __x, int* __exp)
{ return __builtin_frexp(__x, __exp); }
using ::ldexp;
inline float
ldexp(float __x, int __exp)
{ return __builtin_ldexpf(__x, __exp); }
inline long double
ldexp(long double __x, int __exp)
{ return __builtin_ldexpl(__x, __exp); }
template<typename _Tp>
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
ldexp(_Tp __x, int __exp)
{ return __builtin_ldexp(__x, __exp); }
using ::log;
inline float
log(float __x)
{ return __builtin_logf(__x); }
inline long double
log(long double __x)
{ return __builtin_logl(__x); }
template<typename _Tp>
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
log(_Tp __x)
{ return __builtin_log(__x); }
using ::log10;
inline float
log10(float __x)
{ return __builtin_log10f(__x); }
inline long double
log10(long double __x)
{ return __builtin_log10l(__x); }
template<typename _Tp>
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
log10(_Tp __x)
{ return __builtin_log10(__x); }
using ::modf;
inline float
modf(float __x, float* __iptr)
{ return __builtin_modff(__x, __iptr); }
inline long double
modf(long double __x, long double* __iptr)
{ return __builtin_modfl(__x, __iptr); }
using ::pow;
inline float
pow(float __x, float __y)
{ return __builtin_powf(__x, __y); }
inline long double
pow(long double __x, long double __y)
{ return __builtin_powl(__x, __y); }
inline double
pow(double __x, int __i)
{ return __builtin_powi(__x, __i); }
inline float
pow(float __x, int __n)
{ return __builtin_powif(__x, __n); }
inline long double
pow(long double __x, int __n)
{ return __builtin_powil(__x, __n); }
template<typename _Tp, typename _Up>
inline
typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
pow(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return pow(__type(__x), __type(__y));
}
using ::sin;
inline float
sin(float __x)
{ return __builtin_sinf(__x); }
inline long double
sin(long double __x)
{ return __builtin_sinl(__x); }
template<typename _Tp>
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
sin(_Tp __x)
{ return __builtin_sin(__x); }
using ::sinh;
inline float
sinh(float __x)
{ return __builtin_sinhf(__x); }
inline long double
sinh(long double __x)
{ return __builtin_sinhl(__x); }
template<typename _Tp>
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
sinh(_Tp __x)
{ return __builtin_sinh(__x); }
using ::sqrt;
inline float
sqrt(float __x)
{ return __builtin_sqrtf(__x); }
inline long double
sqrt(long double __x)
{ return __builtin_sqrtl(__x); }
template<typename _Tp>
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
sqrt(_Tp __x)
{ return __builtin_sqrt(__x); }
using ::tan;
inline float
tan(float __x)
{ return __builtin_tanf(__x); }
inline long double
tan(long double __x)
{ return __builtin_tanl(__x); }
template<typename _Tp>
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
tan(_Tp __x)
{ return __builtin_tan(__x); }
using ::tanh;
inline float
tanh(float __x)
{ return __builtin_tanhf(__x); }
inline long double
tanh(long double __x)
{ return __builtin_tanhl(__x); }
template<typename _Tp>
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
tanh(_Tp __x)
{ return __builtin_tanh(__x); }
}
#480 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cmath" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
#730 "/opt/Xilinx/Vivado/2017.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cmath" 3
template<typename _Tp>
inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
int>::__type
fpclassify(_Tp __f)
{
typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
return __builtin_fpclassify(0, 1, 4,
3, 2, __type(__f));
}
template<typename _Tp>
inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
int>::__type
isfinite(_Tp __f)
{
typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
return __builtin_isfinite(__type(__f));
}
template<typename _Tp>
inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
int>::__type
isinf(_Tp __f)
{
typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
return __builtin_isinf(__type(__f));
}
template<typename _Tp>
inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
int>::__type
isnan(_Tp __f)
{
typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
return __builtin_isnan(__type(__f));
}
template<typename _Tp>
inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
int>::__type
isnormal(_Tp __f)
{
typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
return __builtin_isnormal(__type(__f));
}
template<typename _Tp>
inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
int>::__type
signbit(_Tp __f)
{
typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
return __builtin_signbit(__type(__f));
}
template<typename _Tp>
inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
int>::__type
isgreater(_Tp __f1, _Tp __f2)
{
typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
return __builtin_isgreater(__type(__f1), __type(__f2));
}
template<typename _Tp>
inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
int>::__type
isgreaterequal(_Tp __f1, _Tp __f2)
{
typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
return __builtin_isgreaterequal(__type(__f1), __type(__f2));
}
template<typename _Tp>
inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
int>::__type
isless(_Tp __f1, _Tp __f2)
{
typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
return __builtin_isless(__type(__f1), __type(__f2));
}
template<typename _Tp>
inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
int>::__type
islessequal(_Tp __f1, _Tp __f2)
{
typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
return __builtin_islessequal(__type(__f1), __type(__f2));
}
template<typename _Tp>
inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
int>::__type
islessgreater(_Tp __f1, _Tp __f2)
{
typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
return __builtin_islessgreater(__type(__f1), __type(__f2));
}
template<typename _Tp>
inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
int>::__type
isunordered(_Tp __f1, _Tp __f2)
{
typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
return __builtin_isunordered(__type(__f1), __type(__f2));
}
}
#33 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/hls_half.h" 2
using std::fpclassify;
using std::isfinite;
using std::isinf;
using std::isnan;
using std::isnormal;
using std::signbit;
using std::isgreater;
using std::isgreaterequal;
using std::isless;
using std::islessequal;
using std::islessgreater;
using std::isunordered;
typedef __fp16 half;
#3274 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/hls_half.h"
extern half half_nan(const char *tagp);
extern half half_atan(half t);
extern half half_atan2(half y, half x);
extern half half_copysign(half x, half y);
extern half half_fabs(half x);
extern half half_abs(half x);
extern half half_fma(half x, half y, half z);
extern half half_mad(half x, half y, half z);
extern half half_frexp (half x, int* exp);
extern half half_ldexp (half x, int exp);
extern half half_fmax(half x, half y);
extern half half_fmin(half x, half y);
extern half half_asin(half t_in);
extern half half_acos(half t_in);
extern half half_sin(half t_in);
extern half half_cos(half t_in);
extern void half_sincos(half x, half *sin, half *cos);
extern half half_sinh(half t_in);
extern half half_cosh(half t_in);
extern half half_sinpi(half t_in);
extern half half_cospi(half t_in);
extern half half_recip(half x);
extern half half_sqrt(half x);
extern half half_rsqrt(half x);
extern half half_cbrt(half x);
extern half half_hypot(half x, half y);
extern half half_log(half x);
extern half half_log10(half x);
extern half half_log2(half x);
extern half half_logb(half x);
extern half half_log1p(half x);
extern int half_ilogb(half x);
extern half half_exp(half x);
extern half half_exp10(half x);
extern half half_exp2(half x);
extern half half_expm1(half x);
extern half half_pow(half x, half y);
extern half half_powr(half x, half y);
extern half half_pown(half x, int y);
extern half half_rootn(half x, int y);
extern half half_floor(half x);
extern half half_ceil(half x);
extern half half_trunc(half x);
extern half half_round(half x);
extern half half_nearbyint(half x);
extern half half_rint(half x);
extern long int half_lrint(half x);
extern long long int half_llrint(half x);
extern long int half_lround(half x);
extern long long int half_llround(half x);
extern half half_modf(half x, half *intpart);
extern half half_fract(half x, half *intpart);
extern half half_nextafter(half x, half y);
extern half half_fmod(half x, half y);
extern half half_remainder(half x, half y);
extern half half_remquo(half x, half y, int* quo);
extern half half_divide(half x, half y);
#75 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_int_syn.h" 2
#111 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_int_syn.h"
typedef unsigned long long ap_ulong;
typedef signed long long ap_slong;
#147 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_int_syn.h"
extern "C" void _ssdm_string2bits(...);
#158 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_int_syn.h"
template<int _AP_N, bool _AP_S> struct ssdm_int;
#184 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_int_syn.h"
#1 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/etc/autopilot_dt.def" 1
template<> struct ssdm_int<1 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<2 + 1024 * 0,true> { int V __attribute__ ((bitwidth(2 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<2 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<2 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(2 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<2 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<3 + 1024 * 0,true> { int V __attribute__ ((bitwidth(3 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<3 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<3 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(3 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<3 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<4 + 1024 * 0,true> { int V __attribute__ ((bitwidth(4 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<4 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<4 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(4 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<4 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<5 + 1024 * 0,true> { int V __attribute__ ((bitwidth(5 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<5 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<5 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(5 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<5 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<6 + 1024 * 0,true> { int V __attribute__ ((bitwidth(6 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<6 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<6 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(6 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<6 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<7 + 1024 * 0,true> { int V __attribute__ ((bitwidth(7 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<7 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<7 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(7 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<7 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<8 + 1024 * 0,true> { int V __attribute__ ((bitwidth(8 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<8 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<8 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(8 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<8 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<9 + 1024 * 0,true> { int V __attribute__ ((bitwidth(9 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<9 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<9 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(9 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<9 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<10 + 1024 * 0,true> { int V __attribute__ ((bitwidth(10 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<10 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<10 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(10 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<10 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<11 + 1024 * 0,true> { int V __attribute__ ((bitwidth(11 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<11 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<11 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(11 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<11 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<12 + 1024 * 0,true> { int V __attribute__ ((bitwidth(12 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<12 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<12 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(12 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<12 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<13 + 1024 * 0,true> { int V __attribute__ ((bitwidth(13 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<13 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<13 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(13 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<13 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<14 + 1024 * 0,true> { int V __attribute__ ((bitwidth(14 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<14 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<14 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(14 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<14 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<15 + 1024 * 0,true> { int V __attribute__ ((bitwidth(15 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<15 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<15 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(15 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<15 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<16 + 1024 * 0,true> { int V __attribute__ ((bitwidth(16 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<16 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<16 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(16 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<16 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<17 + 1024 * 0,true> { int V __attribute__ ((bitwidth(17 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<17 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<17 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(17 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<17 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<18 + 1024 * 0,true> { int V __attribute__ ((bitwidth(18 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<18 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<18 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(18 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<18 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<19 + 1024 * 0,true> { int V __attribute__ ((bitwidth(19 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<19 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<19 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(19 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<19 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<20 + 1024 * 0,true> { int V __attribute__ ((bitwidth(20 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<20 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<20 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(20 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<20 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<21 + 1024 * 0,true> { int V __attribute__ ((bitwidth(21 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<21 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<21 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(21 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<21 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<22 + 1024 * 0,true> { int V __attribute__ ((bitwidth(22 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<22 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<22 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(22 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<22 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<23 + 1024 * 0,true> { int V __attribute__ ((bitwidth(23 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<23 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<23 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(23 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<23 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<24 + 1024 * 0,true> { int V __attribute__ ((bitwidth(24 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<24 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<24 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(24 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<24 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<25 + 1024 * 0,true> { int V __attribute__ ((bitwidth(25 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<25 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<25 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(25 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<25 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<26 + 1024 * 0,true> { int V __attribute__ ((bitwidth(26 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<26 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<26 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(26 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<26 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<27 + 1024 * 0,true> { int V __attribute__ ((bitwidth(27 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<27 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<27 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(27 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<27 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<28 + 1024 * 0,true> { int V __attribute__ ((bitwidth(28 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<28 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<28 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(28 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<28 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<29 + 1024 * 0,true> { int V __attribute__ ((bitwidth(29 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<29 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<29 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(29 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<29 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<30 + 1024 * 0,true> { int V __attribute__ ((bitwidth(30 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<30 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<30 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(30 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<30 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<31 + 1024 * 0,true> { int V __attribute__ ((bitwidth(31 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<31 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<31 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(31 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<31 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<32 + 1024 * 0,true> { int V __attribute__ ((bitwidth(32 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<32 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<32 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(32 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<32 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<33 + 1024 * 0,true> { int V __attribute__ ((bitwidth(33 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<33 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<33 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(33 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<33 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<34 + 1024 * 0,true> { int V __attribute__ ((bitwidth(34 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<34 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<34 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(34 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<34 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<35 + 1024 * 0,true> { int V __attribute__ ((bitwidth(35 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<35 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<35 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(35 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<35 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<36 + 1024 * 0,true> { int V __attribute__ ((bitwidth(36 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<36 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<36 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(36 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<36 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<37 + 1024 * 0,true> { int V __attribute__ ((bitwidth(37 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<37 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<37 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(37 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<37 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<38 + 1024 * 0,true> { int V __attribute__ ((bitwidth(38 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<38 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<38 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(38 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<38 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<39 + 1024 * 0,true> { int V __attribute__ ((bitwidth(39 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<39 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<39 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(39 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<39 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<40 + 1024 * 0,true> { int V __attribute__ ((bitwidth(40 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<40 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<40 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(40 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<40 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<41 + 1024 * 0,true> { int V __attribute__ ((bitwidth(41 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<41 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<41 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(41 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<41 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<42 + 1024 * 0,true> { int V __attribute__ ((bitwidth(42 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<42 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<42 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(42 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<42 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<43 + 1024 * 0,true> { int V __attribute__ ((bitwidth(43 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<43 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<43 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(43 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<43 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<44 + 1024 * 0,true> { int V __attribute__ ((bitwidth(44 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<44 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<44 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(44 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<44 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<45 + 1024 * 0,true> { int V __attribute__ ((bitwidth(45 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<45 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<45 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(45 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<45 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<46 + 1024 * 0,true> { int V __attribute__ ((bitwidth(46 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<46 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<46 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(46 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<46 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<47 + 1024 * 0,true> { int V __attribute__ ((bitwidth(47 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<47 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<47 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(47 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<47 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<48 + 1024 * 0,true> { int V __attribute__ ((bitwidth(48 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<48 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<48 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(48 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<48 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<49 + 1024 * 0,true> { int V __attribute__ ((bitwidth(49 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<49 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<49 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(49 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<49 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<50 + 1024 * 0,true> { int V __attribute__ ((bitwidth(50 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<50 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<50 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(50 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<50 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<51 + 1024 * 0,true> { int V __attribute__ ((bitwidth(51 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<51 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<51 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(51 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<51 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<52 + 1024 * 0,true> { int V __attribute__ ((bitwidth(52 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<52 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<52 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(52 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<52 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<53 + 1024 * 0,true> { int V __attribute__ ((bitwidth(53 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<53 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<53 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(53 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<53 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<54 + 1024 * 0,true> { int V __attribute__ ((bitwidth(54 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<54 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<54 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(54 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<54 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<55 + 1024 * 0,true> { int V __attribute__ ((bitwidth(55 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<55 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<55 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(55 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<55 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<56 + 1024 * 0,true> { int V __attribute__ ((bitwidth(56 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<56 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<56 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(56 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<56 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<57 + 1024 * 0,true> { int V __attribute__ ((bitwidth(57 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<57 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<57 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(57 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<57 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<58 + 1024 * 0,true> { int V __attribute__ ((bitwidth(58 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<58 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<58 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(58 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<58 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<59 + 1024 * 0,true> { int V __attribute__ ((bitwidth(59 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<59 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<59 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(59 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<59 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<60 + 1024 * 0,true> { int V __attribute__ ((bitwidth(60 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<60 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<60 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(60 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<60 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<61 + 1024 * 0,true> { int V __attribute__ ((bitwidth(61 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<61 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<61 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(61 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<61 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<62 + 1024 * 0,true> { int V __attribute__ ((bitwidth(62 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<62 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<62 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(62 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<62 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<63 + 1024 * 0,true> { int V __attribute__ ((bitwidth(63 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<63 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<63 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(63 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<63 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<64 + 1024 * 0,true> { int V __attribute__ ((bitwidth(64 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<64 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<64 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(64 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<64 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<65 + 1024 * 0,true> { int V __attribute__ ((bitwidth(65 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<65 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<65 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(65 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<65 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<66 + 1024 * 0,true> { int V __attribute__ ((bitwidth(66 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<66 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<66 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(66 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<66 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<67 + 1024 * 0,true> { int V __attribute__ ((bitwidth(67 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<67 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<67 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(67 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<67 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<68 + 1024 * 0,true> { int V __attribute__ ((bitwidth(68 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<68 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<68 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(68 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<68 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<69 + 1024 * 0,true> { int V __attribute__ ((bitwidth(69 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<69 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<69 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(69 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<69 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<70 + 1024 * 0,true> { int V __attribute__ ((bitwidth(70 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<70 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<70 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(70 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<70 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<71 + 1024 * 0,true> { int V __attribute__ ((bitwidth(71 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<71 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<71 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(71 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<71 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<72 + 1024 * 0,true> { int V __attribute__ ((bitwidth(72 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<72 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<72 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(72 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<72 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<73 + 1024 * 0,true> { int V __attribute__ ((bitwidth(73 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<73 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<73 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(73 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<73 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<74 + 1024 * 0,true> { int V __attribute__ ((bitwidth(74 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<74 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<74 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(74 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<74 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<75 + 1024 * 0,true> { int V __attribute__ ((bitwidth(75 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<75 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<75 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(75 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<75 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<76 + 1024 * 0,true> { int V __attribute__ ((bitwidth(76 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<76 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<76 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(76 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<76 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<77 + 1024 * 0,true> { int V __attribute__ ((bitwidth(77 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<77 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<77 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(77 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<77 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<78 + 1024 * 0,true> { int V __attribute__ ((bitwidth(78 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<78 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<78 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(78 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<78 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<79 + 1024 * 0,true> { int V __attribute__ ((bitwidth(79 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<79 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<79 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(79 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<79 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<80 + 1024 * 0,true> { int V __attribute__ ((bitwidth(80 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<80 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<80 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(80 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<80 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<81 + 1024 * 0,true> { int V __attribute__ ((bitwidth(81 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<81 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<81 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(81 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<81 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<82 + 1024 * 0,true> { int V __attribute__ ((bitwidth(82 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<82 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<82 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(82 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<82 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<83 + 1024 * 0,true> { int V __attribute__ ((bitwidth(83 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<83 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<83 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(83 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<83 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<84 + 1024 * 0,true> { int V __attribute__ ((bitwidth(84 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<84 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<84 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(84 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<84 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<85 + 1024 * 0,true> { int V __attribute__ ((bitwidth(85 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<85 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<85 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(85 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<85 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<86 + 1024 * 0,true> { int V __attribute__ ((bitwidth(86 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<86 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<86 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(86 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<86 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<87 + 1024 * 0,true> { int V __attribute__ ((bitwidth(87 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<87 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<87 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(87 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<87 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<88 + 1024 * 0,true> { int V __attribute__ ((bitwidth(88 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<88 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<88 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(88 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<88 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<89 + 1024 * 0,true> { int V __attribute__ ((bitwidth(89 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<89 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<89 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(89 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<89 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<90 + 1024 * 0,true> { int V __attribute__ ((bitwidth(90 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<90 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<90 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(90 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<90 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<91 + 1024 * 0,true> { int V __attribute__ ((bitwidth(91 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<91 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<91 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(91 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<91 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<92 + 1024 * 0,true> { int V __attribute__ ((bitwidth(92 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<92 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<92 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(92 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<92 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<93 + 1024 * 0,true> { int V __attribute__ ((bitwidth(93 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<93 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<93 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(93 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<93 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<94 + 1024 * 0,true> { int V __attribute__ ((bitwidth(94 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<94 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<94 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(94 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<94 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<95 + 1024 * 0,true> { int V __attribute__ ((bitwidth(95 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<95 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<95 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(95 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<95 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<96 + 1024 * 0,true> { int V __attribute__ ((bitwidth(96 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<96 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<96 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(96 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<96 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<97 + 1024 * 0,true> { int V __attribute__ ((bitwidth(97 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<97 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<97 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(97 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<97 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<98 + 1024 * 0,true> { int V __attribute__ ((bitwidth(98 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<98 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<98 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(98 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<98 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<99 + 1024 * 0,true> { int V __attribute__ ((bitwidth(99 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<99 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<99 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(99 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<99 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<100 + 1024 * 0,true> { int V __attribute__ ((bitwidth(100 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<100 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<100 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(100 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<100 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<101 + 1024 * 0,true> { int V __attribute__ ((bitwidth(101 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<101 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<101 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(101 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<101 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<102 + 1024 * 0,true> { int V __attribute__ ((bitwidth(102 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<102 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<102 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(102 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<102 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<103 + 1024 * 0,true> { int V __attribute__ ((bitwidth(103 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<103 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<103 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(103 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<103 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<104 + 1024 * 0,true> { int V __attribute__ ((bitwidth(104 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<104 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<104 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(104 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<104 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<105 + 1024 * 0,true> { int V __attribute__ ((bitwidth(105 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<105 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<105 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(105 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<105 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<106 + 1024 * 0,true> { int V __attribute__ ((bitwidth(106 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<106 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<106 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(106 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<106 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<107 + 1024 * 0,true> { int V __attribute__ ((bitwidth(107 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<107 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<107 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(107 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<107 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<108 + 1024 * 0,true> { int V __attribute__ ((bitwidth(108 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<108 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<108 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(108 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<108 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<109 + 1024 * 0,true> { int V __attribute__ ((bitwidth(109 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<109 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<109 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(109 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<109 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<110 + 1024 * 0,true> { int V __attribute__ ((bitwidth(110 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<110 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<110 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(110 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<110 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<111 + 1024 * 0,true> { int V __attribute__ ((bitwidth(111 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<111 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<111 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(111 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<111 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<112 + 1024 * 0,true> { int V __attribute__ ((bitwidth(112 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<112 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<112 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(112 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<112 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<113 + 1024 * 0,true> { int V __attribute__ ((bitwidth(113 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<113 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<113 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(113 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<113 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<114 + 1024 * 0,true> { int V __attribute__ ((bitwidth(114 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<114 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<114 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(114 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<114 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<115 + 1024 * 0,true> { int V __attribute__ ((bitwidth(115 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<115 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<115 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(115 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<115 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<116 + 1024 * 0,true> { int V __attribute__ ((bitwidth(116 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<116 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<116 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(116 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<116 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<117 + 1024 * 0,true> { int V __attribute__ ((bitwidth(117 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<117 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<117 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(117 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<117 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<118 + 1024 * 0,true> { int V __attribute__ ((bitwidth(118 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<118 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<118 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(118 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<118 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<119 + 1024 * 0,true> { int V __attribute__ ((bitwidth(119 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<119 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<119 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(119 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<119 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<120 + 1024 * 0,true> { int V __attribute__ ((bitwidth(120 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<120 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<120 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(120 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<120 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<121 + 1024 * 0,true> { int V __attribute__ ((bitwidth(121 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<121 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<121 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(121 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<121 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<122 + 1024 * 0,true> { int V __attribute__ ((bitwidth(122 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<122 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<122 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(122 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<122 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<123 + 1024 * 0,true> { int V __attribute__ ((bitwidth(123 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<123 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<123 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(123 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<123 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<124 + 1024 * 0,true> { int V __attribute__ ((bitwidth(124 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<124 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<124 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(124 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<124 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<125 + 1024 * 0,true> { int V __attribute__ ((bitwidth(125 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<125 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<125 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(125 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<125 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<126 + 1024 * 0,true> { int V __attribute__ ((bitwidth(126 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<126 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<126 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(126 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<126 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<127 + 1024 * 0,true> { int V __attribute__ ((bitwidth(127 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<127 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<127 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(127 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<127 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<128 + 1024 * 0,true> { int V __attribute__ ((bitwidth(128 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<128 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<128 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(128 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<128 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<129 + 1024 * 0,true> { int V __attribute__ ((bitwidth(129 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<129 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<129 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(129 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<129 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<130 + 1024 * 0,true> { int V __attribute__ ((bitwidth(130 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<130 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<130 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(130 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<130 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<131 + 1024 * 0,true> { int V __attribute__ ((bitwidth(131 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<131 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<131 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(131 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<131 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<132 + 1024 * 0,true> { int V __attribute__ ((bitwidth(132 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<132 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<132 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(132 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<132 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<133 + 1024 * 0,true> { int V __attribute__ ((bitwidth(133 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<133 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<133 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(133 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<133 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<134 + 1024 * 0,true> { int V __attribute__ ((bitwidth(134 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<134 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<134 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(134 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<134 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<135 + 1024 * 0,true> { int V __attribute__ ((bitwidth(135 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<135 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<135 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(135 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<135 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<136 + 1024 * 0,true> { int V __attribute__ ((bitwidth(136 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<136 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<136 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(136 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<136 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<137 + 1024 * 0,true> { int V __attribute__ ((bitwidth(137 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<137 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<137 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(137 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<137 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<138 + 1024 * 0,true> { int V __attribute__ ((bitwidth(138 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<138 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<138 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(138 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<138 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<139 + 1024 * 0,true> { int V __attribute__ ((bitwidth(139 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<139 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<139 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(139 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<139 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<140 + 1024 * 0,true> { int V __attribute__ ((bitwidth(140 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<140 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<140 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(140 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<140 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<141 + 1024 * 0,true> { int V __attribute__ ((bitwidth(141 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<141 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<141 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(141 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<141 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<142 + 1024 * 0,true> { int V __attribute__ ((bitwidth(142 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<142 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<142 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(142 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<142 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<143 + 1024 * 0,true> { int V __attribute__ ((bitwidth(143 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<143 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<143 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(143 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<143 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<144 + 1024 * 0,true> { int V __attribute__ ((bitwidth(144 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<144 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<144 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(144 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<144 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<145 + 1024 * 0,true> { int V __attribute__ ((bitwidth(145 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<145 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<145 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(145 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<145 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<146 + 1024 * 0,true> { int V __attribute__ ((bitwidth(146 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<146 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<146 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(146 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<146 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<147 + 1024 * 0,true> { int V __attribute__ ((bitwidth(147 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<147 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<147 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(147 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<147 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<148 + 1024 * 0,true> { int V __attribute__ ((bitwidth(148 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<148 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<148 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(148 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<148 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<149 + 1024 * 0,true> { int V __attribute__ ((bitwidth(149 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<149 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<149 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(149 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<149 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<150 + 1024 * 0,true> { int V __attribute__ ((bitwidth(150 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<150 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<150 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(150 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<150 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<151 + 1024 * 0,true> { int V __attribute__ ((bitwidth(151 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<151 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<151 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(151 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<151 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<152 + 1024 * 0,true> { int V __attribute__ ((bitwidth(152 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<152 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<152 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(152 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<152 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<153 + 1024 * 0,true> { int V __attribute__ ((bitwidth(153 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<153 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<153 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(153 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<153 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<154 + 1024 * 0,true> { int V __attribute__ ((bitwidth(154 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<154 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<154 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(154 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<154 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<155 + 1024 * 0,true> { int V __attribute__ ((bitwidth(155 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<155 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<155 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(155 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<155 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<156 + 1024 * 0,true> { int V __attribute__ ((bitwidth(156 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<156 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<156 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(156 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<156 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<157 + 1024 * 0,true> { int V __attribute__ ((bitwidth(157 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<157 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<157 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(157 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<157 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<158 + 1024 * 0,true> { int V __attribute__ ((bitwidth(158 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<158 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<158 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(158 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<158 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<159 + 1024 * 0,true> { int V __attribute__ ((bitwidth(159 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<159 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<159 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(159 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<159 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<160 + 1024 * 0,true> { int V __attribute__ ((bitwidth(160 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<160 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<160 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(160 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<160 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<161 + 1024 * 0,true> { int V __attribute__ ((bitwidth(161 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<161 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<161 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(161 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<161 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<162 + 1024 * 0,true> { int V __attribute__ ((bitwidth(162 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<162 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<162 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(162 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<162 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<163 + 1024 * 0,true> { int V __attribute__ ((bitwidth(163 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<163 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<163 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(163 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<163 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<164 + 1024 * 0,true> { int V __attribute__ ((bitwidth(164 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<164 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<164 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(164 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<164 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<165 + 1024 * 0,true> { int V __attribute__ ((bitwidth(165 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<165 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<165 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(165 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<165 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<166 + 1024 * 0,true> { int V __attribute__ ((bitwidth(166 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<166 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<166 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(166 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<166 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<167 + 1024 * 0,true> { int V __attribute__ ((bitwidth(167 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<167 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<167 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(167 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<167 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<168 + 1024 * 0,true> { int V __attribute__ ((bitwidth(168 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<168 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<168 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(168 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<168 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<169 + 1024 * 0,true> { int V __attribute__ ((bitwidth(169 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<169 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<169 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(169 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<169 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<170 + 1024 * 0,true> { int V __attribute__ ((bitwidth(170 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<170 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<170 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(170 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<170 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<171 + 1024 * 0,true> { int V __attribute__ ((bitwidth(171 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<171 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<171 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(171 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<171 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<172 + 1024 * 0,true> { int V __attribute__ ((bitwidth(172 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<172 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<172 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(172 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<172 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<173 + 1024 * 0,true> { int V __attribute__ ((bitwidth(173 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<173 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<173 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(173 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<173 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<174 + 1024 * 0,true> { int V __attribute__ ((bitwidth(174 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<174 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<174 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(174 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<174 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<175 + 1024 * 0,true> { int V __attribute__ ((bitwidth(175 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<175 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<175 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(175 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<175 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<176 + 1024 * 0,true> { int V __attribute__ ((bitwidth(176 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<176 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<176 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(176 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<176 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<177 + 1024 * 0,true> { int V __attribute__ ((bitwidth(177 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<177 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<177 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(177 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<177 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<178 + 1024 * 0,true> { int V __attribute__ ((bitwidth(178 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<178 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<178 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(178 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<178 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<179 + 1024 * 0,true> { int V __attribute__ ((bitwidth(179 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<179 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<179 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(179 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<179 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<180 + 1024 * 0,true> { int V __attribute__ ((bitwidth(180 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<180 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<180 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(180 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<180 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<181 + 1024 * 0,true> { int V __attribute__ ((bitwidth(181 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<181 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<181 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(181 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<181 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<182 + 1024 * 0,true> { int V __attribute__ ((bitwidth(182 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<182 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<182 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(182 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<182 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<183 + 1024 * 0,true> { int V __attribute__ ((bitwidth(183 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<183 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<183 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(183 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<183 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<184 + 1024 * 0,true> { int V __attribute__ ((bitwidth(184 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<184 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<184 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(184 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<184 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<185 + 1024 * 0,true> { int V __attribute__ ((bitwidth(185 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<185 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<185 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(185 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<185 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<186 + 1024 * 0,true> { int V __attribute__ ((bitwidth(186 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<186 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<186 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(186 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<186 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<187 + 1024 * 0,true> { int V __attribute__ ((bitwidth(187 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<187 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<187 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(187 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<187 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<188 + 1024 * 0,true> { int V __attribute__ ((bitwidth(188 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<188 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<188 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(188 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<188 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<189 + 1024 * 0,true> { int V __attribute__ ((bitwidth(189 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<189 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<189 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(189 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<189 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<190 + 1024 * 0,true> { int V __attribute__ ((bitwidth(190 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<190 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<190 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(190 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<190 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<191 + 1024 * 0,true> { int V __attribute__ ((bitwidth(191 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<191 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<191 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(191 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<191 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<192 + 1024 * 0,true> { int V __attribute__ ((bitwidth(192 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<192 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<192 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(192 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<192 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<193 + 1024 * 0,true> { int V __attribute__ ((bitwidth(193 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<193 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<193 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(193 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<193 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<194 + 1024 * 0,true> { int V __attribute__ ((bitwidth(194 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<194 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<194 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(194 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<194 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<195 + 1024 * 0,true> { int V __attribute__ ((bitwidth(195 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<195 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<195 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(195 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<195 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<196 + 1024 * 0,true> { int V __attribute__ ((bitwidth(196 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<196 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<196 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(196 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<196 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<197 + 1024 * 0,true> { int V __attribute__ ((bitwidth(197 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<197 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<197 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(197 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<197 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<198 + 1024 * 0,true> { int V __attribute__ ((bitwidth(198 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<198 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<198 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(198 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<198 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<199 + 1024 * 0,true> { int V __attribute__ ((bitwidth(199 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<199 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<199 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(199 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<199 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<200 + 1024 * 0,true> { int V __attribute__ ((bitwidth(200 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<200 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<200 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(200 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<200 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<201 + 1024 * 0,true> { int V __attribute__ ((bitwidth(201 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<201 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<201 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(201 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<201 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<202 + 1024 * 0,true> { int V __attribute__ ((bitwidth(202 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<202 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<202 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(202 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<202 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<203 + 1024 * 0,true> { int V __attribute__ ((bitwidth(203 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<203 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<203 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(203 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<203 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<204 + 1024 * 0,true> { int V __attribute__ ((bitwidth(204 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<204 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<204 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(204 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<204 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<205 + 1024 * 0,true> { int V __attribute__ ((bitwidth(205 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<205 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<205 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(205 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<205 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<206 + 1024 * 0,true> { int V __attribute__ ((bitwidth(206 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<206 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<206 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(206 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<206 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<207 + 1024 * 0,true> { int V __attribute__ ((bitwidth(207 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<207 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<207 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(207 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<207 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<208 + 1024 * 0,true> { int V __attribute__ ((bitwidth(208 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<208 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<208 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(208 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<208 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<209 + 1024 * 0,true> { int V __attribute__ ((bitwidth(209 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<209 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<209 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(209 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<209 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<210 + 1024 * 0,true> { int V __attribute__ ((bitwidth(210 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<210 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<210 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(210 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<210 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<211 + 1024 * 0,true> { int V __attribute__ ((bitwidth(211 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<211 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<211 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(211 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<211 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<212 + 1024 * 0,true> { int V __attribute__ ((bitwidth(212 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<212 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<212 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(212 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<212 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<213 + 1024 * 0,true> { int V __attribute__ ((bitwidth(213 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<213 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<213 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(213 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<213 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<214 + 1024 * 0,true> { int V __attribute__ ((bitwidth(214 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<214 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<214 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(214 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<214 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<215 + 1024 * 0,true> { int V __attribute__ ((bitwidth(215 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<215 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<215 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(215 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<215 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<216 + 1024 * 0,true> { int V __attribute__ ((bitwidth(216 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<216 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<216 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(216 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<216 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<217 + 1024 * 0,true> { int V __attribute__ ((bitwidth(217 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<217 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<217 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(217 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<217 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<218 + 1024 * 0,true> { int V __attribute__ ((bitwidth(218 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<218 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<218 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(218 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<218 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<219 + 1024 * 0,true> { int V __attribute__ ((bitwidth(219 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<219 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<219 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(219 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<219 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<220 + 1024 * 0,true> { int V __attribute__ ((bitwidth(220 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<220 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<220 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(220 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<220 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<221 + 1024 * 0,true> { int V __attribute__ ((bitwidth(221 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<221 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<221 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(221 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<221 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<222 + 1024 * 0,true> { int V __attribute__ ((bitwidth(222 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<222 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<222 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(222 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<222 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<223 + 1024 * 0,true> { int V __attribute__ ((bitwidth(223 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<223 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<223 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(223 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<223 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<224 + 1024 * 0,true> { int V __attribute__ ((bitwidth(224 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<224 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<224 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(224 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<224 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<225 + 1024 * 0,true> { int V __attribute__ ((bitwidth(225 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<225 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<225 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(225 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<225 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<226 + 1024 * 0,true> { int V __attribute__ ((bitwidth(226 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<226 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<226 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(226 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<226 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<227 + 1024 * 0,true> { int V __attribute__ ((bitwidth(227 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<227 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<227 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(227 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<227 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<228 + 1024 * 0,true> { int V __attribute__ ((bitwidth(228 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<228 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<228 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(228 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<228 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<229 + 1024 * 0,true> { int V __attribute__ ((bitwidth(229 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<229 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<229 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(229 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<229 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<230 + 1024 * 0,true> { int V __attribute__ ((bitwidth(230 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<230 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<230 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(230 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<230 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<231 + 1024 * 0,true> { int V __attribute__ ((bitwidth(231 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<231 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<231 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(231 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<231 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<232 + 1024 * 0,true> { int V __attribute__ ((bitwidth(232 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<232 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<232 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(232 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<232 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<233 + 1024 * 0,true> { int V __attribute__ ((bitwidth(233 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<233 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<233 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(233 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<233 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<234 + 1024 * 0,true> { int V __attribute__ ((bitwidth(234 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<234 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<234 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(234 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<234 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<235 + 1024 * 0,true> { int V __attribute__ ((bitwidth(235 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<235 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<235 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(235 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<235 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<236 + 1024 * 0,true> { int V __attribute__ ((bitwidth(236 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<236 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<236 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(236 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<236 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<237 + 1024 * 0,true> { int V __attribute__ ((bitwidth(237 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<237 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<237 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(237 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<237 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<238 + 1024 * 0,true> { int V __attribute__ ((bitwidth(238 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<238 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<238 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(238 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<238 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<239 + 1024 * 0,true> { int V __attribute__ ((bitwidth(239 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<239 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<239 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(239 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<239 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<240 + 1024 * 0,true> { int V __attribute__ ((bitwidth(240 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<240 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<240 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(240 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<240 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<241 + 1024 * 0,true> { int V __attribute__ ((bitwidth(241 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<241 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<241 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(241 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<241 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<242 + 1024 * 0,true> { int V __attribute__ ((bitwidth(242 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<242 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<242 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(242 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<242 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<243 + 1024 * 0,true> { int V __attribute__ ((bitwidth(243 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<243 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<243 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(243 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<243 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<244 + 1024 * 0,true> { int V __attribute__ ((bitwidth(244 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<244 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<244 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(244 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<244 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<245 + 1024 * 0,true> { int V __attribute__ ((bitwidth(245 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<245 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<245 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(245 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<245 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<246 + 1024 * 0,true> { int V __attribute__ ((bitwidth(246 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<246 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<246 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(246 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<246 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<247 + 1024 * 0,true> { int V __attribute__ ((bitwidth(247 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<247 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<247 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(247 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<247 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<248 + 1024 * 0,true> { int V __attribute__ ((bitwidth(248 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<248 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<248 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(248 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<248 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<249 + 1024 * 0,true> { int V __attribute__ ((bitwidth(249 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<249 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<249 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(249 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<249 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<250 + 1024 * 0,true> { int V __attribute__ ((bitwidth(250 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<250 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<250 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(250 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<250 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<251 + 1024 * 0,true> { int V __attribute__ ((bitwidth(251 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<251 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<251 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(251 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<251 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<252 + 1024 * 0,true> { int V __attribute__ ((bitwidth(252 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<252 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<252 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(252 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<252 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<253 + 1024 * 0,true> { int V __attribute__ ((bitwidth(253 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<253 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<253 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(253 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<253 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<254 + 1024 * 0,true> { int V __attribute__ ((bitwidth(254 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<254 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<254 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(254 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<254 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<255 + 1024 * 0,true> { int V __attribute__ ((bitwidth(255 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<255 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<255 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(255 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<255 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<256 + 1024 * 0,true> { int V __attribute__ ((bitwidth(256 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<256 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<256 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(256 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<256 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<257 + 1024 * 0,true> { int V __attribute__ ((bitwidth(257 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<257 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<257 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(257 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<257 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<258 + 1024 * 0,true> { int V __attribute__ ((bitwidth(258 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<258 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<258 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(258 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<258 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<259 + 1024 * 0,true> { int V __attribute__ ((bitwidth(259 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<259 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<259 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(259 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<259 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<260 + 1024 * 0,true> { int V __attribute__ ((bitwidth(260 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<260 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<260 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(260 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<260 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<261 + 1024 * 0,true> { int V __attribute__ ((bitwidth(261 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<261 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<261 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(261 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<261 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<262 + 1024 * 0,true> { int V __attribute__ ((bitwidth(262 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<262 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<262 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(262 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<262 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<263 + 1024 * 0,true> { int V __attribute__ ((bitwidth(263 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<263 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<263 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(263 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<263 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<264 + 1024 * 0,true> { int V __attribute__ ((bitwidth(264 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<264 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<264 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(264 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<264 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<265 + 1024 * 0,true> { int V __attribute__ ((bitwidth(265 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<265 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<265 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(265 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<265 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<266 + 1024 * 0,true> { int V __attribute__ ((bitwidth(266 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<266 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<266 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(266 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<266 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<267 + 1024 * 0,true> { int V __attribute__ ((bitwidth(267 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<267 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<267 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(267 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<267 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<268 + 1024 * 0,true> { int V __attribute__ ((bitwidth(268 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<268 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<268 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(268 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<268 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<269 + 1024 * 0,true> { int V __attribute__ ((bitwidth(269 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<269 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<269 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(269 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<269 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<270 + 1024 * 0,true> { int V __attribute__ ((bitwidth(270 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<270 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<270 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(270 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<270 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<271 + 1024 * 0,true> { int V __attribute__ ((bitwidth(271 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<271 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<271 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(271 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<271 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<272 + 1024 * 0,true> { int V __attribute__ ((bitwidth(272 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<272 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<272 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(272 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<272 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<273 + 1024 * 0,true> { int V __attribute__ ((bitwidth(273 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<273 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<273 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(273 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<273 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<274 + 1024 * 0,true> { int V __attribute__ ((bitwidth(274 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<274 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<274 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(274 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<274 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<275 + 1024 * 0,true> { int V __attribute__ ((bitwidth(275 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<275 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<275 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(275 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<275 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<276 + 1024 * 0,true> { int V __attribute__ ((bitwidth(276 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<276 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<276 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(276 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<276 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<277 + 1024 * 0,true> { int V __attribute__ ((bitwidth(277 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<277 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<277 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(277 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<277 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<278 + 1024 * 0,true> { int V __attribute__ ((bitwidth(278 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<278 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<278 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(278 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<278 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<279 + 1024 * 0,true> { int V __attribute__ ((bitwidth(279 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<279 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<279 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(279 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<279 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<280 + 1024 * 0,true> { int V __attribute__ ((bitwidth(280 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<280 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<280 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(280 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<280 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<281 + 1024 * 0,true> { int V __attribute__ ((bitwidth(281 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<281 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<281 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(281 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<281 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<282 + 1024 * 0,true> { int V __attribute__ ((bitwidth(282 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<282 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<282 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(282 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<282 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<283 + 1024 * 0,true> { int V __attribute__ ((bitwidth(283 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<283 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<283 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(283 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<283 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<284 + 1024 * 0,true> { int V __attribute__ ((bitwidth(284 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<284 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<284 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(284 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<284 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<285 + 1024 * 0,true> { int V __attribute__ ((bitwidth(285 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<285 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<285 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(285 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<285 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<286 + 1024 * 0,true> { int V __attribute__ ((bitwidth(286 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<286 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<286 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(286 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<286 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<287 + 1024 * 0,true> { int V __attribute__ ((bitwidth(287 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<287 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<287 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(287 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<287 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<288 + 1024 * 0,true> { int V __attribute__ ((bitwidth(288 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<288 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<288 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(288 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<288 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<289 + 1024 * 0,true> { int V __attribute__ ((bitwidth(289 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<289 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<289 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(289 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<289 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<290 + 1024 * 0,true> { int V __attribute__ ((bitwidth(290 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<290 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<290 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(290 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<290 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<291 + 1024 * 0,true> { int V __attribute__ ((bitwidth(291 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<291 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<291 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(291 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<291 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<292 + 1024 * 0,true> { int V __attribute__ ((bitwidth(292 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<292 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<292 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(292 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<292 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<293 + 1024 * 0,true> { int V __attribute__ ((bitwidth(293 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<293 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<293 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(293 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<293 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<294 + 1024 * 0,true> { int V __attribute__ ((bitwidth(294 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<294 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<294 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(294 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<294 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<295 + 1024 * 0,true> { int V __attribute__ ((bitwidth(295 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<295 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<295 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(295 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<295 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<296 + 1024 * 0,true> { int V __attribute__ ((bitwidth(296 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<296 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<296 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(296 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<296 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<297 + 1024 * 0,true> { int V __attribute__ ((bitwidth(297 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<297 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<297 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(297 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<297 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<298 + 1024 * 0,true> { int V __attribute__ ((bitwidth(298 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<298 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<298 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(298 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<298 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<299 + 1024 * 0,true> { int V __attribute__ ((bitwidth(299 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<299 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<299 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(299 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<299 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<300 + 1024 * 0,true> { int V __attribute__ ((bitwidth(300 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<300 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<300 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(300 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<300 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<301 + 1024 * 0,true> { int V __attribute__ ((bitwidth(301 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<301 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<301 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(301 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<301 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<302 + 1024 * 0,true> { int V __attribute__ ((bitwidth(302 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<302 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<302 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(302 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<302 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<303 + 1024 * 0,true> { int V __attribute__ ((bitwidth(303 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<303 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<303 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(303 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<303 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<304 + 1024 * 0,true> { int V __attribute__ ((bitwidth(304 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<304 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<304 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(304 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<304 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<305 + 1024 * 0,true> { int V __attribute__ ((bitwidth(305 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<305 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<305 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(305 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<305 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<306 + 1024 * 0,true> { int V __attribute__ ((bitwidth(306 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<306 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<306 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(306 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<306 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<307 + 1024 * 0,true> { int V __attribute__ ((bitwidth(307 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<307 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<307 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(307 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<307 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<308 + 1024 * 0,true> { int V __attribute__ ((bitwidth(308 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<308 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<308 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(308 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<308 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<309 + 1024 * 0,true> { int V __attribute__ ((bitwidth(309 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<309 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<309 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(309 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<309 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<310 + 1024 * 0,true> { int V __attribute__ ((bitwidth(310 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<310 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<310 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(310 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<310 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<311 + 1024 * 0,true> { int V __attribute__ ((bitwidth(311 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<311 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<311 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(311 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<311 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<312 + 1024 * 0,true> { int V __attribute__ ((bitwidth(312 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<312 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<312 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(312 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<312 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<313 + 1024 * 0,true> { int V __attribute__ ((bitwidth(313 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<313 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<313 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(313 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<313 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<314 + 1024 * 0,true> { int V __attribute__ ((bitwidth(314 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<314 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<314 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(314 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<314 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<315 + 1024 * 0,true> { int V __attribute__ ((bitwidth(315 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<315 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<315 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(315 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<315 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<316 + 1024 * 0,true> { int V __attribute__ ((bitwidth(316 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<316 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<316 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(316 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<316 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<317 + 1024 * 0,true> { int V __attribute__ ((bitwidth(317 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<317 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<317 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(317 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<317 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<318 + 1024 * 0,true> { int V __attribute__ ((bitwidth(318 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<318 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<318 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(318 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<318 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<319 + 1024 * 0,true> { int V __attribute__ ((bitwidth(319 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<319 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<319 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(319 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<319 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<320 + 1024 * 0,true> { int V __attribute__ ((bitwidth(320 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<320 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<320 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(320 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<320 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<321 + 1024 * 0,true> { int V __attribute__ ((bitwidth(321 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<321 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<321 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(321 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<321 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<322 + 1024 * 0,true> { int V __attribute__ ((bitwidth(322 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<322 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<322 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(322 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<322 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<323 + 1024 * 0,true> { int V __attribute__ ((bitwidth(323 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<323 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<323 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(323 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<323 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<324 + 1024 * 0,true> { int V __attribute__ ((bitwidth(324 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<324 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<324 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(324 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<324 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<325 + 1024 * 0,true> { int V __attribute__ ((bitwidth(325 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<325 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<325 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(325 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<325 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<326 + 1024 * 0,true> { int V __attribute__ ((bitwidth(326 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<326 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<326 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(326 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<326 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<327 + 1024 * 0,true> { int V __attribute__ ((bitwidth(327 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<327 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<327 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(327 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<327 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<328 + 1024 * 0,true> { int V __attribute__ ((bitwidth(328 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<328 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<328 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(328 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<328 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<329 + 1024 * 0,true> { int V __attribute__ ((bitwidth(329 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<329 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<329 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(329 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<329 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<330 + 1024 * 0,true> { int V __attribute__ ((bitwidth(330 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<330 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<330 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(330 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<330 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<331 + 1024 * 0,true> { int V __attribute__ ((bitwidth(331 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<331 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<331 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(331 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<331 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<332 + 1024 * 0,true> { int V __attribute__ ((bitwidth(332 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<332 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<332 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(332 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<332 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<333 + 1024 * 0,true> { int V __attribute__ ((bitwidth(333 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<333 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<333 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(333 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<333 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<334 + 1024 * 0,true> { int V __attribute__ ((bitwidth(334 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<334 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<334 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(334 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<334 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<335 + 1024 * 0,true> { int V __attribute__ ((bitwidth(335 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<335 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<335 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(335 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<335 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<336 + 1024 * 0,true> { int V __attribute__ ((bitwidth(336 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<336 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<336 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(336 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<336 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<337 + 1024 * 0,true> { int V __attribute__ ((bitwidth(337 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<337 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<337 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(337 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<337 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<338 + 1024 * 0,true> { int V __attribute__ ((bitwidth(338 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<338 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<338 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(338 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<338 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<339 + 1024 * 0,true> { int V __attribute__ ((bitwidth(339 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<339 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<339 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(339 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<339 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<340 + 1024 * 0,true> { int V __attribute__ ((bitwidth(340 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<340 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<340 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(340 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<340 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<341 + 1024 * 0,true> { int V __attribute__ ((bitwidth(341 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<341 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<341 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(341 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<341 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<342 + 1024 * 0,true> { int V __attribute__ ((bitwidth(342 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<342 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<342 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(342 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<342 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<343 + 1024 * 0,true> { int V __attribute__ ((bitwidth(343 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<343 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<343 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(343 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<343 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<344 + 1024 * 0,true> { int V __attribute__ ((bitwidth(344 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<344 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<344 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(344 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<344 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<345 + 1024 * 0,true> { int V __attribute__ ((bitwidth(345 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<345 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<345 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(345 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<345 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<346 + 1024 * 0,true> { int V __attribute__ ((bitwidth(346 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<346 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<346 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(346 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<346 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<347 + 1024 * 0,true> { int V __attribute__ ((bitwidth(347 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<347 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<347 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(347 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<347 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<348 + 1024 * 0,true> { int V __attribute__ ((bitwidth(348 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<348 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<348 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(348 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<348 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<349 + 1024 * 0,true> { int V __attribute__ ((bitwidth(349 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<349 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<349 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(349 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<349 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<350 + 1024 * 0,true> { int V __attribute__ ((bitwidth(350 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<350 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<350 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(350 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<350 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<351 + 1024 * 0,true> { int V __attribute__ ((bitwidth(351 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<351 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<351 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(351 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<351 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<352 + 1024 * 0,true> { int V __attribute__ ((bitwidth(352 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<352 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<352 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(352 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<352 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<353 + 1024 * 0,true> { int V __attribute__ ((bitwidth(353 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<353 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<353 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(353 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<353 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<354 + 1024 * 0,true> { int V __attribute__ ((bitwidth(354 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<354 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<354 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(354 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<354 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<355 + 1024 * 0,true> { int V __attribute__ ((bitwidth(355 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<355 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<355 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(355 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<355 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<356 + 1024 * 0,true> { int V __attribute__ ((bitwidth(356 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<356 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<356 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(356 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<356 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<357 + 1024 * 0,true> { int V __attribute__ ((bitwidth(357 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<357 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<357 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(357 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<357 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<358 + 1024 * 0,true> { int V __attribute__ ((bitwidth(358 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<358 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<358 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(358 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<358 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<359 + 1024 * 0,true> { int V __attribute__ ((bitwidth(359 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<359 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<359 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(359 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<359 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<360 + 1024 * 0,true> { int V __attribute__ ((bitwidth(360 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<360 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<360 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(360 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<360 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<361 + 1024 * 0,true> { int V __attribute__ ((bitwidth(361 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<361 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<361 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(361 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<361 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<362 + 1024 * 0,true> { int V __attribute__ ((bitwidth(362 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<362 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<362 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(362 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<362 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<363 + 1024 * 0,true> { int V __attribute__ ((bitwidth(363 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<363 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<363 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(363 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<363 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<364 + 1024 * 0,true> { int V __attribute__ ((bitwidth(364 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<364 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<364 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(364 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<364 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<365 + 1024 * 0,true> { int V __attribute__ ((bitwidth(365 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<365 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<365 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(365 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<365 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<366 + 1024 * 0,true> { int V __attribute__ ((bitwidth(366 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<366 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<366 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(366 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<366 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<367 + 1024 * 0,true> { int V __attribute__ ((bitwidth(367 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<367 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<367 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(367 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<367 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<368 + 1024 * 0,true> { int V __attribute__ ((bitwidth(368 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<368 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<368 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(368 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<368 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<369 + 1024 * 0,true> { int V __attribute__ ((bitwidth(369 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<369 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<369 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(369 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<369 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<370 + 1024 * 0,true> { int V __attribute__ ((bitwidth(370 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<370 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<370 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(370 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<370 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<371 + 1024 * 0,true> { int V __attribute__ ((bitwidth(371 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<371 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<371 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(371 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<371 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<372 + 1024 * 0,true> { int V __attribute__ ((bitwidth(372 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<372 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<372 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(372 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<372 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<373 + 1024 * 0,true> { int V __attribute__ ((bitwidth(373 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<373 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<373 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(373 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<373 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<374 + 1024 * 0,true> { int V __attribute__ ((bitwidth(374 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<374 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<374 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(374 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<374 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<375 + 1024 * 0,true> { int V __attribute__ ((bitwidth(375 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<375 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<375 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(375 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<375 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<376 + 1024 * 0,true> { int V __attribute__ ((bitwidth(376 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<376 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<376 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(376 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<376 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<377 + 1024 * 0,true> { int V __attribute__ ((bitwidth(377 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<377 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<377 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(377 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<377 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<378 + 1024 * 0,true> { int V __attribute__ ((bitwidth(378 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<378 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<378 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(378 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<378 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<379 + 1024 * 0,true> { int V __attribute__ ((bitwidth(379 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<379 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<379 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(379 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<379 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<380 + 1024 * 0,true> { int V __attribute__ ((bitwidth(380 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<380 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<380 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(380 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<380 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<381 + 1024 * 0,true> { int V __attribute__ ((bitwidth(381 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<381 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<381 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(381 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<381 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<382 + 1024 * 0,true> { int V __attribute__ ((bitwidth(382 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<382 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<382 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(382 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<382 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<383 + 1024 * 0,true> { int V __attribute__ ((bitwidth(383 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<383 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<383 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(383 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<383 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<384 + 1024 * 0,true> { int V __attribute__ ((bitwidth(384 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<384 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<384 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(384 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<384 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<385 + 1024 * 0,true> { int V __attribute__ ((bitwidth(385 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<385 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<385 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(385 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<385 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<386 + 1024 * 0,true> { int V __attribute__ ((bitwidth(386 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<386 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<386 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(386 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<386 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<387 + 1024 * 0,true> { int V __attribute__ ((bitwidth(387 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<387 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<387 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(387 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<387 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<388 + 1024 * 0,true> { int V __attribute__ ((bitwidth(388 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<388 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<388 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(388 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<388 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<389 + 1024 * 0,true> { int V __attribute__ ((bitwidth(389 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<389 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<389 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(389 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<389 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<390 + 1024 * 0,true> { int V __attribute__ ((bitwidth(390 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<390 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<390 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(390 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<390 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<391 + 1024 * 0,true> { int V __attribute__ ((bitwidth(391 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<391 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<391 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(391 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<391 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<392 + 1024 * 0,true> { int V __attribute__ ((bitwidth(392 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<392 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<392 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(392 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<392 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<393 + 1024 * 0,true> { int V __attribute__ ((bitwidth(393 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<393 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<393 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(393 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<393 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<394 + 1024 * 0,true> { int V __attribute__ ((bitwidth(394 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<394 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<394 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(394 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<394 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<395 + 1024 * 0,true> { int V __attribute__ ((bitwidth(395 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<395 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<395 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(395 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<395 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<396 + 1024 * 0,true> { int V __attribute__ ((bitwidth(396 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<396 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<396 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(396 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<396 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<397 + 1024 * 0,true> { int V __attribute__ ((bitwidth(397 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<397 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<397 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(397 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<397 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<398 + 1024 * 0,true> { int V __attribute__ ((bitwidth(398 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<398 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<398 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(398 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<398 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<399 + 1024 * 0,true> { int V __attribute__ ((bitwidth(399 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<399 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<399 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(399 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<399 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<400 + 1024 * 0,true> { int V __attribute__ ((bitwidth(400 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<400 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<400 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(400 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<400 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<401 + 1024 * 0,true> { int V __attribute__ ((bitwidth(401 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<401 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<401 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(401 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<401 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<402 + 1024 * 0,true> { int V __attribute__ ((bitwidth(402 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<402 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<402 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(402 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<402 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<403 + 1024 * 0,true> { int V __attribute__ ((bitwidth(403 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<403 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<403 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(403 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<403 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<404 + 1024 * 0,true> { int V __attribute__ ((bitwidth(404 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<404 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<404 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(404 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<404 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<405 + 1024 * 0,true> { int V __attribute__ ((bitwidth(405 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<405 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<405 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(405 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<405 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<406 + 1024 * 0,true> { int V __attribute__ ((bitwidth(406 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<406 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<406 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(406 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<406 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<407 + 1024 * 0,true> { int V __attribute__ ((bitwidth(407 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<407 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<407 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(407 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<407 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<408 + 1024 * 0,true> { int V __attribute__ ((bitwidth(408 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<408 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<408 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(408 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<408 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<409 + 1024 * 0,true> { int V __attribute__ ((bitwidth(409 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<409 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<409 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(409 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<409 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<410 + 1024 * 0,true> { int V __attribute__ ((bitwidth(410 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<410 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<410 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(410 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<410 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<411 + 1024 * 0,true> { int V __attribute__ ((bitwidth(411 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<411 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<411 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(411 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<411 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<412 + 1024 * 0,true> { int V __attribute__ ((bitwidth(412 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<412 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<412 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(412 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<412 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<413 + 1024 * 0,true> { int V __attribute__ ((bitwidth(413 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<413 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<413 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(413 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<413 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<414 + 1024 * 0,true> { int V __attribute__ ((bitwidth(414 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<414 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<414 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(414 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<414 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<415 + 1024 * 0,true> { int V __attribute__ ((bitwidth(415 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<415 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<415 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(415 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<415 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<416 + 1024 * 0,true> { int V __attribute__ ((bitwidth(416 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<416 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<416 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(416 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<416 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<417 + 1024 * 0,true> { int V __attribute__ ((bitwidth(417 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<417 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<417 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(417 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<417 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<418 + 1024 * 0,true> { int V __attribute__ ((bitwidth(418 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<418 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<418 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(418 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<418 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<419 + 1024 * 0,true> { int V __attribute__ ((bitwidth(419 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<419 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<419 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(419 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<419 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<420 + 1024 * 0,true> { int V __attribute__ ((bitwidth(420 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<420 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<420 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(420 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<420 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<421 + 1024 * 0,true> { int V __attribute__ ((bitwidth(421 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<421 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<421 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(421 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<421 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<422 + 1024 * 0,true> { int V __attribute__ ((bitwidth(422 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<422 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<422 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(422 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<422 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<423 + 1024 * 0,true> { int V __attribute__ ((bitwidth(423 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<423 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<423 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(423 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<423 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<424 + 1024 * 0,true> { int V __attribute__ ((bitwidth(424 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<424 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<424 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(424 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<424 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<425 + 1024 * 0,true> { int V __attribute__ ((bitwidth(425 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<425 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<425 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(425 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<425 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<426 + 1024 * 0,true> { int V __attribute__ ((bitwidth(426 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<426 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<426 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(426 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<426 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<427 + 1024 * 0,true> { int V __attribute__ ((bitwidth(427 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<427 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<427 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(427 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<427 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<428 + 1024 * 0,true> { int V __attribute__ ((bitwidth(428 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<428 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<428 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(428 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<428 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<429 + 1024 * 0,true> { int V __attribute__ ((bitwidth(429 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<429 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<429 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(429 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<429 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<430 + 1024 * 0,true> { int V __attribute__ ((bitwidth(430 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<430 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<430 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(430 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<430 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<431 + 1024 * 0,true> { int V __attribute__ ((bitwidth(431 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<431 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<431 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(431 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<431 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<432 + 1024 * 0,true> { int V __attribute__ ((bitwidth(432 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<432 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<432 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(432 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<432 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<433 + 1024 * 0,true> { int V __attribute__ ((bitwidth(433 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<433 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<433 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(433 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<433 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<434 + 1024 * 0,true> { int V __attribute__ ((bitwidth(434 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<434 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<434 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(434 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<434 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<435 + 1024 * 0,true> { int V __attribute__ ((bitwidth(435 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<435 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<435 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(435 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<435 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<436 + 1024 * 0,true> { int V __attribute__ ((bitwidth(436 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<436 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<436 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(436 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<436 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<437 + 1024 * 0,true> { int V __attribute__ ((bitwidth(437 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<437 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<437 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(437 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<437 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<438 + 1024 * 0,true> { int V __attribute__ ((bitwidth(438 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<438 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<438 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(438 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<438 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<439 + 1024 * 0,true> { int V __attribute__ ((bitwidth(439 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<439 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<439 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(439 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<439 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<440 + 1024 * 0,true> { int V __attribute__ ((bitwidth(440 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<440 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<440 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(440 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<440 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<441 + 1024 * 0,true> { int V __attribute__ ((bitwidth(441 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<441 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<441 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(441 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<441 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<442 + 1024 * 0,true> { int V __attribute__ ((bitwidth(442 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<442 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<442 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(442 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<442 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<443 + 1024 * 0,true> { int V __attribute__ ((bitwidth(443 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<443 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<443 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(443 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<443 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<444 + 1024 * 0,true> { int V __attribute__ ((bitwidth(444 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<444 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<444 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(444 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<444 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<445 + 1024 * 0,true> { int V __attribute__ ((bitwidth(445 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<445 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<445 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(445 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<445 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<446 + 1024 * 0,true> { int V __attribute__ ((bitwidth(446 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<446 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<446 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(446 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<446 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<447 + 1024 * 0,true> { int V __attribute__ ((bitwidth(447 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<447 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<447 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(447 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<447 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<448 + 1024 * 0,true> { int V __attribute__ ((bitwidth(448 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<448 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<448 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(448 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<448 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<449 + 1024 * 0,true> { int V __attribute__ ((bitwidth(449 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<449 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<449 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(449 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<449 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<450 + 1024 * 0,true> { int V __attribute__ ((bitwidth(450 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<450 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<450 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(450 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<450 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<451 + 1024 * 0,true> { int V __attribute__ ((bitwidth(451 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<451 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<451 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(451 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<451 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<452 + 1024 * 0,true> { int V __attribute__ ((bitwidth(452 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<452 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<452 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(452 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<452 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<453 + 1024 * 0,true> { int V __attribute__ ((bitwidth(453 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<453 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<453 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(453 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<453 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<454 + 1024 * 0,true> { int V __attribute__ ((bitwidth(454 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<454 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<454 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(454 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<454 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<455 + 1024 * 0,true> { int V __attribute__ ((bitwidth(455 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<455 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<455 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(455 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<455 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<456 + 1024 * 0,true> { int V __attribute__ ((bitwidth(456 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<456 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<456 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(456 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<456 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<457 + 1024 * 0,true> { int V __attribute__ ((bitwidth(457 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<457 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<457 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(457 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<457 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<458 + 1024 * 0,true> { int V __attribute__ ((bitwidth(458 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<458 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<458 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(458 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<458 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<459 + 1024 * 0,true> { int V __attribute__ ((bitwidth(459 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<459 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<459 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(459 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<459 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<460 + 1024 * 0,true> { int V __attribute__ ((bitwidth(460 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<460 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<460 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(460 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<460 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<461 + 1024 * 0,true> { int V __attribute__ ((bitwidth(461 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<461 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<461 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(461 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<461 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<462 + 1024 * 0,true> { int V __attribute__ ((bitwidth(462 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<462 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<462 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(462 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<462 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<463 + 1024 * 0,true> { int V __attribute__ ((bitwidth(463 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<463 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<463 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(463 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<463 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<464 + 1024 * 0,true> { int V __attribute__ ((bitwidth(464 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<464 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<464 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(464 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<464 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<465 + 1024 * 0,true> { int V __attribute__ ((bitwidth(465 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<465 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<465 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(465 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<465 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<466 + 1024 * 0,true> { int V __attribute__ ((bitwidth(466 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<466 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<466 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(466 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<466 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<467 + 1024 * 0,true> { int V __attribute__ ((bitwidth(467 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<467 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<467 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(467 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<467 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<468 + 1024 * 0,true> { int V __attribute__ ((bitwidth(468 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<468 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<468 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(468 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<468 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<469 + 1024 * 0,true> { int V __attribute__ ((bitwidth(469 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<469 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<469 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(469 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<469 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<470 + 1024 * 0,true> { int V __attribute__ ((bitwidth(470 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<470 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<470 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(470 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<470 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<471 + 1024 * 0,true> { int V __attribute__ ((bitwidth(471 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<471 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<471 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(471 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<471 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<472 + 1024 * 0,true> { int V __attribute__ ((bitwidth(472 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<472 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<472 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(472 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<472 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<473 + 1024 * 0,true> { int V __attribute__ ((bitwidth(473 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<473 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<473 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(473 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<473 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<474 + 1024 * 0,true> { int V __attribute__ ((bitwidth(474 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<474 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<474 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(474 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<474 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<475 + 1024 * 0,true> { int V __attribute__ ((bitwidth(475 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<475 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<475 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(475 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<475 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<476 + 1024 * 0,true> { int V __attribute__ ((bitwidth(476 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<476 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<476 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(476 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<476 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<477 + 1024 * 0,true> { int V __attribute__ ((bitwidth(477 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<477 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<477 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(477 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<477 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<478 + 1024 * 0,true> { int V __attribute__ ((bitwidth(478 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<478 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<478 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(478 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<478 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<479 + 1024 * 0,true> { int V __attribute__ ((bitwidth(479 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<479 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<479 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(479 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<479 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<480 + 1024 * 0,true> { int V __attribute__ ((bitwidth(480 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<480 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<480 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(480 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<480 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<481 + 1024 * 0,true> { int V __attribute__ ((bitwidth(481 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<481 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<481 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(481 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<481 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<482 + 1024 * 0,true> { int V __attribute__ ((bitwidth(482 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<482 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<482 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(482 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<482 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<483 + 1024 * 0,true> { int V __attribute__ ((bitwidth(483 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<483 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<483 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(483 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<483 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<484 + 1024 * 0,true> { int V __attribute__ ((bitwidth(484 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<484 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<484 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(484 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<484 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<485 + 1024 * 0,true> { int V __attribute__ ((bitwidth(485 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<485 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<485 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(485 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<485 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<486 + 1024 * 0,true> { int V __attribute__ ((bitwidth(486 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<486 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<486 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(486 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<486 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<487 + 1024 * 0,true> { int V __attribute__ ((bitwidth(487 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<487 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<487 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(487 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<487 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<488 + 1024 * 0,true> { int V __attribute__ ((bitwidth(488 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<488 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<488 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(488 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<488 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<489 + 1024 * 0,true> { int V __attribute__ ((bitwidth(489 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<489 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<489 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(489 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<489 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<490 + 1024 * 0,true> { int V __attribute__ ((bitwidth(490 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<490 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<490 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(490 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<490 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<491 + 1024 * 0,true> { int V __attribute__ ((bitwidth(491 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<491 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<491 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(491 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<491 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<492 + 1024 * 0,true> { int V __attribute__ ((bitwidth(492 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<492 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<492 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(492 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<492 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<493 + 1024 * 0,true> { int V __attribute__ ((bitwidth(493 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<493 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<493 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(493 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<493 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<494 + 1024 * 0,true> { int V __attribute__ ((bitwidth(494 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<494 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<494 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(494 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<494 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<495 + 1024 * 0,true> { int V __attribute__ ((bitwidth(495 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<495 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<495 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(495 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<495 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<496 + 1024 * 0,true> { int V __attribute__ ((bitwidth(496 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<496 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<496 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(496 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<496 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<497 + 1024 * 0,true> { int V __attribute__ ((bitwidth(497 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<497 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<497 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(497 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<497 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<498 + 1024 * 0,true> { int V __attribute__ ((bitwidth(498 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<498 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<498 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(498 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<498 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<499 + 1024 * 0,true> { int V __attribute__ ((bitwidth(499 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<499 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<499 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(499 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<499 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<500 + 1024 * 0,true> { int V __attribute__ ((bitwidth(500 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<500 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<500 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(500 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<500 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<501 + 1024 * 0,true> { int V __attribute__ ((bitwidth(501 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<501 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<501 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(501 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<501 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<502 + 1024 * 0,true> { int V __attribute__ ((bitwidth(502 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<502 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<502 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(502 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<502 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<503 + 1024 * 0,true> { int V __attribute__ ((bitwidth(503 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<503 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<503 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(503 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<503 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<504 + 1024 * 0,true> { int V __attribute__ ((bitwidth(504 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<504 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<504 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(504 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<504 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<505 + 1024 * 0,true> { int V __attribute__ ((bitwidth(505 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<505 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<505 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(505 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<505 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<506 + 1024 * 0,true> { int V __attribute__ ((bitwidth(506 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<506 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<506 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(506 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<506 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<507 + 1024 * 0,true> { int V __attribute__ ((bitwidth(507 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<507 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<507 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(507 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<507 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<508 + 1024 * 0,true> { int V __attribute__ ((bitwidth(508 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<508 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<508 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(508 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<508 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<509 + 1024 * 0,true> { int V __attribute__ ((bitwidth(509 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<509 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<509 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(509 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<509 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<510 + 1024 * 0,true> { int V __attribute__ ((bitwidth(510 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<510 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<510 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(510 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<510 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<511 + 1024 * 0,true> { int V __attribute__ ((bitwidth(511 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<511 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<511 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(511 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<511 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<512 + 1024 * 0,true> { int V __attribute__ ((bitwidth(512 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<512 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<512 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(512 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<512 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<513 + 1024 * 0,true> { int V __attribute__ ((bitwidth(513 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<513 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<513 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(513 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<513 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<514 + 1024 * 0,true> { int V __attribute__ ((bitwidth(514 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<514 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<514 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(514 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<514 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<515 + 1024 * 0,true> { int V __attribute__ ((bitwidth(515 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<515 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<515 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(515 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<515 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<516 + 1024 * 0,true> { int V __attribute__ ((bitwidth(516 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<516 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<516 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(516 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<516 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<517 + 1024 * 0,true> { int V __attribute__ ((bitwidth(517 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<517 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<517 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(517 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<517 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<518 + 1024 * 0,true> { int V __attribute__ ((bitwidth(518 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<518 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<518 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(518 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<518 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<519 + 1024 * 0,true> { int V __attribute__ ((bitwidth(519 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<519 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<519 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(519 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<519 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<520 + 1024 * 0,true> { int V __attribute__ ((bitwidth(520 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<520 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<520 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(520 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<520 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<521 + 1024 * 0,true> { int V __attribute__ ((bitwidth(521 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<521 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<521 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(521 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<521 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<522 + 1024 * 0,true> { int V __attribute__ ((bitwidth(522 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<522 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<522 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(522 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<522 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<523 + 1024 * 0,true> { int V __attribute__ ((bitwidth(523 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<523 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<523 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(523 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<523 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<524 + 1024 * 0,true> { int V __attribute__ ((bitwidth(524 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<524 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<524 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(524 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<524 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<525 + 1024 * 0,true> { int V __attribute__ ((bitwidth(525 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<525 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<525 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(525 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<525 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<526 + 1024 * 0,true> { int V __attribute__ ((bitwidth(526 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<526 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<526 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(526 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<526 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<527 + 1024 * 0,true> { int V __attribute__ ((bitwidth(527 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<527 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<527 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(527 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<527 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<528 + 1024 * 0,true> { int V __attribute__ ((bitwidth(528 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<528 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<528 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(528 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<528 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<529 + 1024 * 0,true> { int V __attribute__ ((bitwidth(529 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<529 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<529 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(529 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<529 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<530 + 1024 * 0,true> { int V __attribute__ ((bitwidth(530 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<530 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<530 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(530 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<530 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<531 + 1024 * 0,true> { int V __attribute__ ((bitwidth(531 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<531 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<531 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(531 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<531 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<532 + 1024 * 0,true> { int V __attribute__ ((bitwidth(532 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<532 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<532 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(532 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<532 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<533 + 1024 * 0,true> { int V __attribute__ ((bitwidth(533 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<533 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<533 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(533 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<533 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<534 + 1024 * 0,true> { int V __attribute__ ((bitwidth(534 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<534 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<534 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(534 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<534 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<535 + 1024 * 0,true> { int V __attribute__ ((bitwidth(535 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<535 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<535 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(535 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<535 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<536 + 1024 * 0,true> { int V __attribute__ ((bitwidth(536 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<536 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<536 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(536 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<536 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<537 + 1024 * 0,true> { int V __attribute__ ((bitwidth(537 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<537 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<537 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(537 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<537 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<538 + 1024 * 0,true> { int V __attribute__ ((bitwidth(538 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<538 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<538 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(538 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<538 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<539 + 1024 * 0,true> { int V __attribute__ ((bitwidth(539 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<539 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<539 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(539 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<539 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<540 + 1024 * 0,true> { int V __attribute__ ((bitwidth(540 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<540 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<540 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(540 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<540 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<541 + 1024 * 0,true> { int V __attribute__ ((bitwidth(541 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<541 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<541 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(541 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<541 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<542 + 1024 * 0,true> { int V __attribute__ ((bitwidth(542 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<542 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<542 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(542 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<542 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<543 + 1024 * 0,true> { int V __attribute__ ((bitwidth(543 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<543 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<543 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(543 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<543 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<544 + 1024 * 0,true> { int V __attribute__ ((bitwidth(544 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<544 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<544 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(544 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<544 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<545 + 1024 * 0,true> { int V __attribute__ ((bitwidth(545 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<545 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<545 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(545 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<545 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<546 + 1024 * 0,true> { int V __attribute__ ((bitwidth(546 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<546 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<546 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(546 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<546 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<547 + 1024 * 0,true> { int V __attribute__ ((bitwidth(547 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<547 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<547 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(547 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<547 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<548 + 1024 * 0,true> { int V __attribute__ ((bitwidth(548 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<548 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<548 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(548 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<548 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<549 + 1024 * 0,true> { int V __attribute__ ((bitwidth(549 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<549 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<549 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(549 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<549 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<550 + 1024 * 0,true> { int V __attribute__ ((bitwidth(550 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<550 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<550 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(550 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<550 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<551 + 1024 * 0,true> { int V __attribute__ ((bitwidth(551 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<551 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<551 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(551 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<551 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<552 + 1024 * 0,true> { int V __attribute__ ((bitwidth(552 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<552 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<552 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(552 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<552 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<553 + 1024 * 0,true> { int V __attribute__ ((bitwidth(553 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<553 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<553 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(553 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<553 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<554 + 1024 * 0,true> { int V __attribute__ ((bitwidth(554 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<554 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<554 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(554 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<554 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<555 + 1024 * 0,true> { int V __attribute__ ((bitwidth(555 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<555 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<555 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(555 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<555 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<556 + 1024 * 0,true> { int V __attribute__ ((bitwidth(556 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<556 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<556 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(556 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<556 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<557 + 1024 * 0,true> { int V __attribute__ ((bitwidth(557 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<557 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<557 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(557 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<557 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<558 + 1024 * 0,true> { int V __attribute__ ((bitwidth(558 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<558 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<558 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(558 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<558 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<559 + 1024 * 0,true> { int V __attribute__ ((bitwidth(559 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<559 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<559 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(559 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<559 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<560 + 1024 * 0,true> { int V __attribute__ ((bitwidth(560 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<560 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<560 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(560 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<560 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<561 + 1024 * 0,true> { int V __attribute__ ((bitwidth(561 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<561 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<561 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(561 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<561 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<562 + 1024 * 0,true> { int V __attribute__ ((bitwidth(562 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<562 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<562 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(562 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<562 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<563 + 1024 * 0,true> { int V __attribute__ ((bitwidth(563 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<563 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<563 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(563 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<563 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<564 + 1024 * 0,true> { int V __attribute__ ((bitwidth(564 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<564 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<564 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(564 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<564 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<565 + 1024 * 0,true> { int V __attribute__ ((bitwidth(565 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<565 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<565 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(565 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<565 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<566 + 1024 * 0,true> { int V __attribute__ ((bitwidth(566 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<566 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<566 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(566 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<566 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<567 + 1024 * 0,true> { int V __attribute__ ((bitwidth(567 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<567 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<567 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(567 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<567 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<568 + 1024 * 0,true> { int V __attribute__ ((bitwidth(568 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<568 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<568 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(568 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<568 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<569 + 1024 * 0,true> { int V __attribute__ ((bitwidth(569 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<569 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<569 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(569 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<569 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<570 + 1024 * 0,true> { int V __attribute__ ((bitwidth(570 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<570 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<570 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(570 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<570 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<571 + 1024 * 0,true> { int V __attribute__ ((bitwidth(571 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<571 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<571 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(571 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<571 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<572 + 1024 * 0,true> { int V __attribute__ ((bitwidth(572 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<572 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<572 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(572 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<572 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<573 + 1024 * 0,true> { int V __attribute__ ((bitwidth(573 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<573 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<573 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(573 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<573 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<574 + 1024 * 0,true> { int V __attribute__ ((bitwidth(574 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<574 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<574 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(574 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<574 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<575 + 1024 * 0,true> { int V __attribute__ ((bitwidth(575 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<575 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<575 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(575 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<575 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<576 + 1024 * 0,true> { int V __attribute__ ((bitwidth(576 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<576 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<576 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(576 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<576 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<577 + 1024 * 0,true> { int V __attribute__ ((bitwidth(577 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<577 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<577 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(577 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<577 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<578 + 1024 * 0,true> { int V __attribute__ ((bitwidth(578 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<578 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<578 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(578 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<578 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<579 + 1024 * 0,true> { int V __attribute__ ((bitwidth(579 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<579 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<579 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(579 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<579 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<580 + 1024 * 0,true> { int V __attribute__ ((bitwidth(580 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<580 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<580 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(580 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<580 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<581 + 1024 * 0,true> { int V __attribute__ ((bitwidth(581 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<581 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<581 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(581 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<581 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<582 + 1024 * 0,true> { int V __attribute__ ((bitwidth(582 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<582 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<582 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(582 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<582 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<583 + 1024 * 0,true> { int V __attribute__ ((bitwidth(583 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<583 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<583 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(583 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<583 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<584 + 1024 * 0,true> { int V __attribute__ ((bitwidth(584 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<584 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<584 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(584 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<584 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<585 + 1024 * 0,true> { int V __attribute__ ((bitwidth(585 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<585 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<585 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(585 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<585 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<586 + 1024 * 0,true> { int V __attribute__ ((bitwidth(586 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<586 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<586 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(586 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<586 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<587 + 1024 * 0,true> { int V __attribute__ ((bitwidth(587 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<587 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<587 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(587 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<587 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<588 + 1024 * 0,true> { int V __attribute__ ((bitwidth(588 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<588 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<588 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(588 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<588 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<589 + 1024 * 0,true> { int V __attribute__ ((bitwidth(589 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<589 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<589 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(589 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<589 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<590 + 1024 * 0,true> { int V __attribute__ ((bitwidth(590 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<590 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<590 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(590 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<590 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<591 + 1024 * 0,true> { int V __attribute__ ((bitwidth(591 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<591 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<591 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(591 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<591 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<592 + 1024 * 0,true> { int V __attribute__ ((bitwidth(592 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<592 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<592 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(592 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<592 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<593 + 1024 * 0,true> { int V __attribute__ ((bitwidth(593 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<593 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<593 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(593 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<593 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<594 + 1024 * 0,true> { int V __attribute__ ((bitwidth(594 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<594 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<594 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(594 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<594 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<595 + 1024 * 0,true> { int V __attribute__ ((bitwidth(595 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<595 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<595 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(595 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<595 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<596 + 1024 * 0,true> { int V __attribute__ ((bitwidth(596 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<596 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<596 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(596 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<596 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<597 + 1024 * 0,true> { int V __attribute__ ((bitwidth(597 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<597 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<597 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(597 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<597 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<598 + 1024 * 0,true> { int V __attribute__ ((bitwidth(598 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<598 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<598 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(598 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<598 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<599 + 1024 * 0,true> { int V __attribute__ ((bitwidth(599 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<599 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<599 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(599 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<599 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<600 + 1024 * 0,true> { int V __attribute__ ((bitwidth(600 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<600 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<600 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(600 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<600 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<601 + 1024 * 0,true> { int V __attribute__ ((bitwidth(601 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<601 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<601 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(601 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<601 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<602 + 1024 * 0,true> { int V __attribute__ ((bitwidth(602 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<602 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<602 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(602 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<602 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<603 + 1024 * 0,true> { int V __attribute__ ((bitwidth(603 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<603 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<603 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(603 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<603 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<604 + 1024 * 0,true> { int V __attribute__ ((bitwidth(604 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<604 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<604 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(604 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<604 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<605 + 1024 * 0,true> { int V __attribute__ ((bitwidth(605 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<605 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<605 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(605 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<605 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<606 + 1024 * 0,true> { int V __attribute__ ((bitwidth(606 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<606 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<606 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(606 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<606 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<607 + 1024 * 0,true> { int V __attribute__ ((bitwidth(607 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<607 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<607 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(607 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<607 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<608 + 1024 * 0,true> { int V __attribute__ ((bitwidth(608 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<608 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<608 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(608 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<608 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<609 + 1024 * 0,true> { int V __attribute__ ((bitwidth(609 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<609 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<609 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(609 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<609 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<610 + 1024 * 0,true> { int V __attribute__ ((bitwidth(610 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<610 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<610 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(610 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<610 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<611 + 1024 * 0,true> { int V __attribute__ ((bitwidth(611 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<611 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<611 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(611 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<611 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<612 + 1024 * 0,true> { int V __attribute__ ((bitwidth(612 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<612 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<612 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(612 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<612 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<613 + 1024 * 0,true> { int V __attribute__ ((bitwidth(613 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<613 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<613 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(613 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<613 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<614 + 1024 * 0,true> { int V __attribute__ ((bitwidth(614 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<614 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<614 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(614 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<614 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<615 + 1024 * 0,true> { int V __attribute__ ((bitwidth(615 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<615 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<615 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(615 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<615 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<616 + 1024 * 0,true> { int V __attribute__ ((bitwidth(616 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<616 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<616 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(616 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<616 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<617 + 1024 * 0,true> { int V __attribute__ ((bitwidth(617 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<617 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<617 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(617 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<617 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<618 + 1024 * 0,true> { int V __attribute__ ((bitwidth(618 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<618 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<618 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(618 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<618 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<619 + 1024 * 0,true> { int V __attribute__ ((bitwidth(619 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<619 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<619 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(619 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<619 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<620 + 1024 * 0,true> { int V __attribute__ ((bitwidth(620 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<620 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<620 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(620 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<620 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<621 + 1024 * 0,true> { int V __attribute__ ((bitwidth(621 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<621 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<621 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(621 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<621 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<622 + 1024 * 0,true> { int V __attribute__ ((bitwidth(622 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<622 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<622 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(622 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<622 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<623 + 1024 * 0,true> { int V __attribute__ ((bitwidth(623 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<623 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<623 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(623 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<623 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<624 + 1024 * 0,true> { int V __attribute__ ((bitwidth(624 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<624 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<624 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(624 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<624 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<625 + 1024 * 0,true> { int V __attribute__ ((bitwidth(625 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<625 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<625 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(625 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<625 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<626 + 1024 * 0,true> { int V __attribute__ ((bitwidth(626 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<626 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<626 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(626 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<626 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<627 + 1024 * 0,true> { int V __attribute__ ((bitwidth(627 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<627 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<627 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(627 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<627 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<628 + 1024 * 0,true> { int V __attribute__ ((bitwidth(628 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<628 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<628 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(628 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<628 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<629 + 1024 * 0,true> { int V __attribute__ ((bitwidth(629 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<629 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<629 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(629 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<629 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<630 + 1024 * 0,true> { int V __attribute__ ((bitwidth(630 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<630 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<630 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(630 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<630 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<631 + 1024 * 0,true> { int V __attribute__ ((bitwidth(631 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<631 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<631 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(631 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<631 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<632 + 1024 * 0,true> { int V __attribute__ ((bitwidth(632 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<632 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<632 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(632 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<632 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<633 + 1024 * 0,true> { int V __attribute__ ((bitwidth(633 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<633 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<633 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(633 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<633 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<634 + 1024 * 0,true> { int V __attribute__ ((bitwidth(634 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<634 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<634 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(634 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<634 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<635 + 1024 * 0,true> { int V __attribute__ ((bitwidth(635 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<635 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<635 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(635 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<635 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<636 + 1024 * 0,true> { int V __attribute__ ((bitwidth(636 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<636 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<636 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(636 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<636 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<637 + 1024 * 0,true> { int V __attribute__ ((bitwidth(637 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<637 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<637 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(637 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<637 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<638 + 1024 * 0,true> { int V __attribute__ ((bitwidth(638 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<638 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<638 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(638 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<638 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<639 + 1024 * 0,true> { int V __attribute__ ((bitwidth(639 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<639 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<639 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(639 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<639 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<640 + 1024 * 0,true> { int V __attribute__ ((bitwidth(640 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<640 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<640 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(640 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<640 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<641 + 1024 * 0,true> { int V __attribute__ ((bitwidth(641 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<641 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<641 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(641 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<641 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<642 + 1024 * 0,true> { int V __attribute__ ((bitwidth(642 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<642 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<642 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(642 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<642 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<643 + 1024 * 0,true> { int V __attribute__ ((bitwidth(643 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<643 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<643 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(643 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<643 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<644 + 1024 * 0,true> { int V __attribute__ ((bitwidth(644 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<644 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<644 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(644 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<644 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<645 + 1024 * 0,true> { int V __attribute__ ((bitwidth(645 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<645 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<645 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(645 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<645 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<646 + 1024 * 0,true> { int V __attribute__ ((bitwidth(646 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<646 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<646 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(646 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<646 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<647 + 1024 * 0,true> { int V __attribute__ ((bitwidth(647 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<647 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<647 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(647 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<647 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<648 + 1024 * 0,true> { int V __attribute__ ((bitwidth(648 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<648 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<648 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(648 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<648 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<649 + 1024 * 0,true> { int V __attribute__ ((bitwidth(649 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<649 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<649 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(649 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<649 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<650 + 1024 * 0,true> { int V __attribute__ ((bitwidth(650 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<650 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<650 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(650 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<650 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<651 + 1024 * 0,true> { int V __attribute__ ((bitwidth(651 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<651 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<651 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(651 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<651 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<652 + 1024 * 0,true> { int V __attribute__ ((bitwidth(652 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<652 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<652 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(652 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<652 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<653 + 1024 * 0,true> { int V __attribute__ ((bitwidth(653 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<653 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<653 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(653 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<653 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<654 + 1024 * 0,true> { int V __attribute__ ((bitwidth(654 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<654 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<654 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(654 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<654 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<655 + 1024 * 0,true> { int V __attribute__ ((bitwidth(655 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<655 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<655 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(655 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<655 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<656 + 1024 * 0,true> { int V __attribute__ ((bitwidth(656 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<656 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<656 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(656 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<656 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<657 + 1024 * 0,true> { int V __attribute__ ((bitwidth(657 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<657 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<657 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(657 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<657 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<658 + 1024 * 0,true> { int V __attribute__ ((bitwidth(658 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<658 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<658 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(658 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<658 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<659 + 1024 * 0,true> { int V __attribute__ ((bitwidth(659 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<659 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<659 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(659 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<659 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<660 + 1024 * 0,true> { int V __attribute__ ((bitwidth(660 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<660 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<660 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(660 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<660 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<661 + 1024 * 0,true> { int V __attribute__ ((bitwidth(661 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<661 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<661 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(661 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<661 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<662 + 1024 * 0,true> { int V __attribute__ ((bitwidth(662 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<662 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<662 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(662 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<662 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<663 + 1024 * 0,true> { int V __attribute__ ((bitwidth(663 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<663 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<663 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(663 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<663 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<664 + 1024 * 0,true> { int V __attribute__ ((bitwidth(664 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<664 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<664 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(664 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<664 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<665 + 1024 * 0,true> { int V __attribute__ ((bitwidth(665 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<665 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<665 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(665 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<665 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<666 + 1024 * 0,true> { int V __attribute__ ((bitwidth(666 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<666 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<666 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(666 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<666 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<667 + 1024 * 0,true> { int V __attribute__ ((bitwidth(667 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<667 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<667 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(667 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<667 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<668 + 1024 * 0,true> { int V __attribute__ ((bitwidth(668 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<668 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<668 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(668 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<668 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<669 + 1024 * 0,true> { int V __attribute__ ((bitwidth(669 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<669 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<669 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(669 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<669 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<670 + 1024 * 0,true> { int V __attribute__ ((bitwidth(670 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<670 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<670 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(670 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<670 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<671 + 1024 * 0,true> { int V __attribute__ ((bitwidth(671 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<671 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<671 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(671 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<671 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<672 + 1024 * 0,true> { int V __attribute__ ((bitwidth(672 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<672 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<672 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(672 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<672 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<673 + 1024 * 0,true> { int V __attribute__ ((bitwidth(673 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<673 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<673 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(673 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<673 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<674 + 1024 * 0,true> { int V __attribute__ ((bitwidth(674 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<674 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<674 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(674 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<674 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<675 + 1024 * 0,true> { int V __attribute__ ((bitwidth(675 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<675 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<675 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(675 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<675 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<676 + 1024 * 0,true> { int V __attribute__ ((bitwidth(676 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<676 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<676 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(676 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<676 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<677 + 1024 * 0,true> { int V __attribute__ ((bitwidth(677 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<677 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<677 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(677 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<677 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<678 + 1024 * 0,true> { int V __attribute__ ((bitwidth(678 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<678 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<678 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(678 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<678 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<679 + 1024 * 0,true> { int V __attribute__ ((bitwidth(679 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<679 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<679 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(679 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<679 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<680 + 1024 * 0,true> { int V __attribute__ ((bitwidth(680 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<680 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<680 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(680 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<680 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<681 + 1024 * 0,true> { int V __attribute__ ((bitwidth(681 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<681 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<681 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(681 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<681 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<682 + 1024 * 0,true> { int V __attribute__ ((bitwidth(682 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<682 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<682 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(682 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<682 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<683 + 1024 * 0,true> { int V __attribute__ ((bitwidth(683 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<683 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<683 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(683 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<683 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<684 + 1024 * 0,true> { int V __attribute__ ((bitwidth(684 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<684 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<684 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(684 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<684 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<685 + 1024 * 0,true> { int V __attribute__ ((bitwidth(685 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<685 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<685 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(685 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<685 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<686 + 1024 * 0,true> { int V __attribute__ ((bitwidth(686 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<686 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<686 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(686 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<686 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<687 + 1024 * 0,true> { int V __attribute__ ((bitwidth(687 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<687 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<687 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(687 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<687 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<688 + 1024 * 0,true> { int V __attribute__ ((bitwidth(688 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<688 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<688 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(688 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<688 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<689 + 1024 * 0,true> { int V __attribute__ ((bitwidth(689 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<689 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<689 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(689 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<689 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<690 + 1024 * 0,true> { int V __attribute__ ((bitwidth(690 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<690 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<690 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(690 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<690 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<691 + 1024 * 0,true> { int V __attribute__ ((bitwidth(691 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<691 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<691 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(691 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<691 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<692 + 1024 * 0,true> { int V __attribute__ ((bitwidth(692 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<692 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<692 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(692 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<692 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<693 + 1024 * 0,true> { int V __attribute__ ((bitwidth(693 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<693 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<693 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(693 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<693 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<694 + 1024 * 0,true> { int V __attribute__ ((bitwidth(694 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<694 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<694 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(694 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<694 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<695 + 1024 * 0,true> { int V __attribute__ ((bitwidth(695 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<695 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<695 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(695 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<695 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<696 + 1024 * 0,true> { int V __attribute__ ((bitwidth(696 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<696 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<696 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(696 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<696 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<697 + 1024 * 0,true> { int V __attribute__ ((bitwidth(697 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<697 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<697 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(697 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<697 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<698 + 1024 * 0,true> { int V __attribute__ ((bitwidth(698 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<698 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<698 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(698 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<698 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<699 + 1024 * 0,true> { int V __attribute__ ((bitwidth(699 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<699 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<699 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(699 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<699 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<700 + 1024 * 0,true> { int V __attribute__ ((bitwidth(700 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<700 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<700 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(700 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<700 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<701 + 1024 * 0,true> { int V __attribute__ ((bitwidth(701 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<701 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<701 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(701 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<701 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<702 + 1024 * 0,true> { int V __attribute__ ((bitwidth(702 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<702 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<702 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(702 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<702 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<703 + 1024 * 0,true> { int V __attribute__ ((bitwidth(703 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<703 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<703 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(703 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<703 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<704 + 1024 * 0,true> { int V __attribute__ ((bitwidth(704 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<704 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<704 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(704 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<704 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<705 + 1024 * 0,true> { int V __attribute__ ((bitwidth(705 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<705 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<705 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(705 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<705 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<706 + 1024 * 0,true> { int V __attribute__ ((bitwidth(706 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<706 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<706 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(706 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<706 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<707 + 1024 * 0,true> { int V __attribute__ ((bitwidth(707 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<707 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<707 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(707 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<707 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<708 + 1024 * 0,true> { int V __attribute__ ((bitwidth(708 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<708 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<708 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(708 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<708 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<709 + 1024 * 0,true> { int V __attribute__ ((bitwidth(709 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<709 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<709 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(709 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<709 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<710 + 1024 * 0,true> { int V __attribute__ ((bitwidth(710 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<710 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<710 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(710 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<710 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<711 + 1024 * 0,true> { int V __attribute__ ((bitwidth(711 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<711 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<711 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(711 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<711 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<712 + 1024 * 0,true> { int V __attribute__ ((bitwidth(712 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<712 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<712 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(712 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<712 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<713 + 1024 * 0,true> { int V __attribute__ ((bitwidth(713 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<713 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<713 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(713 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<713 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<714 + 1024 * 0,true> { int V __attribute__ ((bitwidth(714 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<714 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<714 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(714 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<714 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<715 + 1024 * 0,true> { int V __attribute__ ((bitwidth(715 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<715 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<715 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(715 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<715 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<716 + 1024 * 0,true> { int V __attribute__ ((bitwidth(716 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<716 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<716 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(716 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<716 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<717 + 1024 * 0,true> { int V __attribute__ ((bitwidth(717 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<717 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<717 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(717 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<717 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<718 + 1024 * 0,true> { int V __attribute__ ((bitwidth(718 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<718 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<718 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(718 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<718 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<719 + 1024 * 0,true> { int V __attribute__ ((bitwidth(719 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<719 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<719 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(719 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<719 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<720 + 1024 * 0,true> { int V __attribute__ ((bitwidth(720 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<720 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<720 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(720 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<720 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<721 + 1024 * 0,true> { int V __attribute__ ((bitwidth(721 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<721 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<721 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(721 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<721 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<722 + 1024 * 0,true> { int V __attribute__ ((bitwidth(722 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<722 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<722 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(722 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<722 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<723 + 1024 * 0,true> { int V __attribute__ ((bitwidth(723 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<723 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<723 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(723 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<723 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<724 + 1024 * 0,true> { int V __attribute__ ((bitwidth(724 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<724 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<724 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(724 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<724 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<725 + 1024 * 0,true> { int V __attribute__ ((bitwidth(725 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<725 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<725 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(725 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<725 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<726 + 1024 * 0,true> { int V __attribute__ ((bitwidth(726 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<726 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<726 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(726 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<726 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<727 + 1024 * 0,true> { int V __attribute__ ((bitwidth(727 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<727 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<727 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(727 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<727 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<728 + 1024 * 0,true> { int V __attribute__ ((bitwidth(728 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<728 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<728 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(728 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<728 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<729 + 1024 * 0,true> { int V __attribute__ ((bitwidth(729 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<729 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<729 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(729 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<729 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<730 + 1024 * 0,true> { int V __attribute__ ((bitwidth(730 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<730 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<730 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(730 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<730 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<731 + 1024 * 0,true> { int V __attribute__ ((bitwidth(731 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<731 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<731 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(731 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<731 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<732 + 1024 * 0,true> { int V __attribute__ ((bitwidth(732 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<732 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<732 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(732 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<732 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<733 + 1024 * 0,true> { int V __attribute__ ((bitwidth(733 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<733 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<733 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(733 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<733 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<734 + 1024 * 0,true> { int V __attribute__ ((bitwidth(734 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<734 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<734 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(734 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<734 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<735 + 1024 * 0,true> { int V __attribute__ ((bitwidth(735 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<735 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<735 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(735 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<735 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<736 + 1024 * 0,true> { int V __attribute__ ((bitwidth(736 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<736 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<736 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(736 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<736 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<737 + 1024 * 0,true> { int V __attribute__ ((bitwidth(737 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<737 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<737 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(737 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<737 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<738 + 1024 * 0,true> { int V __attribute__ ((bitwidth(738 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<738 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<738 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(738 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<738 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<739 + 1024 * 0,true> { int V __attribute__ ((bitwidth(739 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<739 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<739 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(739 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<739 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<740 + 1024 * 0,true> { int V __attribute__ ((bitwidth(740 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<740 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<740 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(740 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<740 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<741 + 1024 * 0,true> { int V __attribute__ ((bitwidth(741 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<741 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<741 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(741 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<741 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<742 + 1024 * 0,true> { int V __attribute__ ((bitwidth(742 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<742 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<742 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(742 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<742 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<743 + 1024 * 0,true> { int V __attribute__ ((bitwidth(743 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<743 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<743 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(743 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<743 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<744 + 1024 * 0,true> { int V __attribute__ ((bitwidth(744 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<744 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<744 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(744 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<744 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<745 + 1024 * 0,true> { int V __attribute__ ((bitwidth(745 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<745 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<745 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(745 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<745 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<746 + 1024 * 0,true> { int V __attribute__ ((bitwidth(746 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<746 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<746 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(746 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<746 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<747 + 1024 * 0,true> { int V __attribute__ ((bitwidth(747 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<747 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<747 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(747 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<747 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<748 + 1024 * 0,true> { int V __attribute__ ((bitwidth(748 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<748 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<748 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(748 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<748 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<749 + 1024 * 0,true> { int V __attribute__ ((bitwidth(749 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<749 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<749 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(749 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<749 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<750 + 1024 * 0,true> { int V __attribute__ ((bitwidth(750 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<750 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<750 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(750 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<750 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<751 + 1024 * 0,true> { int V __attribute__ ((bitwidth(751 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<751 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<751 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(751 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<751 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<752 + 1024 * 0,true> { int V __attribute__ ((bitwidth(752 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<752 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<752 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(752 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<752 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<753 + 1024 * 0,true> { int V __attribute__ ((bitwidth(753 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<753 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<753 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(753 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<753 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<754 + 1024 * 0,true> { int V __attribute__ ((bitwidth(754 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<754 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<754 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(754 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<754 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<755 + 1024 * 0,true> { int V __attribute__ ((bitwidth(755 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<755 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<755 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(755 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<755 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<756 + 1024 * 0,true> { int V __attribute__ ((bitwidth(756 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<756 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<756 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(756 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<756 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<757 + 1024 * 0,true> { int V __attribute__ ((bitwidth(757 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<757 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<757 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(757 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<757 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<758 + 1024 * 0,true> { int V __attribute__ ((bitwidth(758 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<758 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<758 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(758 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<758 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<759 + 1024 * 0,true> { int V __attribute__ ((bitwidth(759 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<759 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<759 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(759 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<759 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<760 + 1024 * 0,true> { int V __attribute__ ((bitwidth(760 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<760 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<760 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(760 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<760 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<761 + 1024 * 0,true> { int V __attribute__ ((bitwidth(761 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<761 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<761 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(761 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<761 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<762 + 1024 * 0,true> { int V __attribute__ ((bitwidth(762 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<762 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<762 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(762 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<762 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<763 + 1024 * 0,true> { int V __attribute__ ((bitwidth(763 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<763 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<763 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(763 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<763 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<764 + 1024 * 0,true> { int V __attribute__ ((bitwidth(764 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<764 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<764 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(764 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<764 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<765 + 1024 * 0,true> { int V __attribute__ ((bitwidth(765 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<765 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<765 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(765 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<765 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<766 + 1024 * 0,true> { int V __attribute__ ((bitwidth(766 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<766 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<766 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(766 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<766 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<767 + 1024 * 0,true> { int V __attribute__ ((bitwidth(767 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<767 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<767 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(767 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<767 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<768 + 1024 * 0,true> { int V __attribute__ ((bitwidth(768 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<768 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<768 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(768 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<768 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<769 + 1024 * 0,true> { int V __attribute__ ((bitwidth(769 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<769 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<769 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(769 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<769 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<770 + 1024 * 0,true> { int V __attribute__ ((bitwidth(770 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<770 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<770 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(770 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<770 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<771 + 1024 * 0,true> { int V __attribute__ ((bitwidth(771 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<771 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<771 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(771 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<771 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<772 + 1024 * 0,true> { int V __attribute__ ((bitwidth(772 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<772 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<772 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(772 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<772 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<773 + 1024 * 0,true> { int V __attribute__ ((bitwidth(773 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<773 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<773 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(773 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<773 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<774 + 1024 * 0,true> { int V __attribute__ ((bitwidth(774 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<774 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<774 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(774 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<774 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<775 + 1024 * 0,true> { int V __attribute__ ((bitwidth(775 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<775 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<775 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(775 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<775 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<776 + 1024 * 0,true> { int V __attribute__ ((bitwidth(776 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<776 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<776 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(776 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<776 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<777 + 1024 * 0,true> { int V __attribute__ ((bitwidth(777 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<777 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<777 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(777 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<777 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<778 + 1024 * 0,true> { int V __attribute__ ((bitwidth(778 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<778 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<778 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(778 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<778 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<779 + 1024 * 0,true> { int V __attribute__ ((bitwidth(779 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<779 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<779 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(779 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<779 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<780 + 1024 * 0,true> { int V __attribute__ ((bitwidth(780 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<780 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<780 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(780 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<780 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<781 + 1024 * 0,true> { int V __attribute__ ((bitwidth(781 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<781 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<781 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(781 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<781 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<782 + 1024 * 0,true> { int V __attribute__ ((bitwidth(782 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<782 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<782 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(782 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<782 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<783 + 1024 * 0,true> { int V __attribute__ ((bitwidth(783 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<783 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<783 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(783 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<783 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<784 + 1024 * 0,true> { int V __attribute__ ((bitwidth(784 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<784 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<784 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(784 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<784 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<785 + 1024 * 0,true> { int V __attribute__ ((bitwidth(785 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<785 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<785 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(785 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<785 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<786 + 1024 * 0,true> { int V __attribute__ ((bitwidth(786 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<786 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<786 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(786 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<786 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<787 + 1024 * 0,true> { int V __attribute__ ((bitwidth(787 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<787 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<787 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(787 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<787 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<788 + 1024 * 0,true> { int V __attribute__ ((bitwidth(788 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<788 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<788 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(788 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<788 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<789 + 1024 * 0,true> { int V __attribute__ ((bitwidth(789 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<789 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<789 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(789 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<789 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<790 + 1024 * 0,true> { int V __attribute__ ((bitwidth(790 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<790 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<790 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(790 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<790 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<791 + 1024 * 0,true> { int V __attribute__ ((bitwidth(791 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<791 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<791 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(791 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<791 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<792 + 1024 * 0,true> { int V __attribute__ ((bitwidth(792 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<792 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<792 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(792 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<792 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<793 + 1024 * 0,true> { int V __attribute__ ((bitwidth(793 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<793 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<793 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(793 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<793 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<794 + 1024 * 0,true> { int V __attribute__ ((bitwidth(794 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<794 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<794 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(794 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<794 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<795 + 1024 * 0,true> { int V __attribute__ ((bitwidth(795 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<795 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<795 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(795 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<795 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<796 + 1024 * 0,true> { int V __attribute__ ((bitwidth(796 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<796 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<796 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(796 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<796 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<797 + 1024 * 0,true> { int V __attribute__ ((bitwidth(797 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<797 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<797 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(797 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<797 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<798 + 1024 * 0,true> { int V __attribute__ ((bitwidth(798 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<798 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<798 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(798 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<798 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<799 + 1024 * 0,true> { int V __attribute__ ((bitwidth(799 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<799 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<799 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(799 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<799 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<800 + 1024 * 0,true> { int V __attribute__ ((bitwidth(800 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<800 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<800 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(800 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<800 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<801 + 1024 * 0,true> { int V __attribute__ ((bitwidth(801 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<801 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<801 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(801 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<801 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<802 + 1024 * 0,true> { int V __attribute__ ((bitwidth(802 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<802 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<802 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(802 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<802 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<803 + 1024 * 0,true> { int V __attribute__ ((bitwidth(803 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<803 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<803 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(803 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<803 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<804 + 1024 * 0,true> { int V __attribute__ ((bitwidth(804 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<804 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<804 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(804 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<804 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<805 + 1024 * 0,true> { int V __attribute__ ((bitwidth(805 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<805 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<805 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(805 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<805 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<806 + 1024 * 0,true> { int V __attribute__ ((bitwidth(806 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<806 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<806 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(806 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<806 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<807 + 1024 * 0,true> { int V __attribute__ ((bitwidth(807 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<807 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<807 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(807 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<807 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<808 + 1024 * 0,true> { int V __attribute__ ((bitwidth(808 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<808 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<808 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(808 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<808 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<809 + 1024 * 0,true> { int V __attribute__ ((bitwidth(809 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<809 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<809 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(809 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<809 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<810 + 1024 * 0,true> { int V __attribute__ ((bitwidth(810 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<810 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<810 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(810 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<810 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<811 + 1024 * 0,true> { int V __attribute__ ((bitwidth(811 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<811 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<811 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(811 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<811 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<812 + 1024 * 0,true> { int V __attribute__ ((bitwidth(812 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<812 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<812 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(812 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<812 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<813 + 1024 * 0,true> { int V __attribute__ ((bitwidth(813 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<813 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<813 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(813 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<813 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<814 + 1024 * 0,true> { int V __attribute__ ((bitwidth(814 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<814 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<814 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(814 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<814 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<815 + 1024 * 0,true> { int V __attribute__ ((bitwidth(815 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<815 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<815 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(815 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<815 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<816 + 1024 * 0,true> { int V __attribute__ ((bitwidth(816 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<816 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<816 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(816 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<816 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<817 + 1024 * 0,true> { int V __attribute__ ((bitwidth(817 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<817 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<817 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(817 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<817 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<818 + 1024 * 0,true> { int V __attribute__ ((bitwidth(818 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<818 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<818 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(818 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<818 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<819 + 1024 * 0,true> { int V __attribute__ ((bitwidth(819 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<819 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<819 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(819 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<819 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<820 + 1024 * 0,true> { int V __attribute__ ((bitwidth(820 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<820 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<820 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(820 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<820 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<821 + 1024 * 0,true> { int V __attribute__ ((bitwidth(821 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<821 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<821 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(821 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<821 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<822 + 1024 * 0,true> { int V __attribute__ ((bitwidth(822 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<822 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<822 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(822 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<822 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<823 + 1024 * 0,true> { int V __attribute__ ((bitwidth(823 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<823 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<823 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(823 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<823 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<824 + 1024 * 0,true> { int V __attribute__ ((bitwidth(824 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<824 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<824 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(824 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<824 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<825 + 1024 * 0,true> { int V __attribute__ ((bitwidth(825 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<825 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<825 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(825 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<825 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<826 + 1024 * 0,true> { int V __attribute__ ((bitwidth(826 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<826 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<826 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(826 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<826 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<827 + 1024 * 0,true> { int V __attribute__ ((bitwidth(827 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<827 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<827 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(827 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<827 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<828 + 1024 * 0,true> { int V __attribute__ ((bitwidth(828 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<828 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<828 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(828 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<828 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<829 + 1024 * 0,true> { int V __attribute__ ((bitwidth(829 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<829 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<829 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(829 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<829 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<830 + 1024 * 0,true> { int V __attribute__ ((bitwidth(830 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<830 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<830 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(830 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<830 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<831 + 1024 * 0,true> { int V __attribute__ ((bitwidth(831 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<831 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<831 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(831 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<831 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<832 + 1024 * 0,true> { int V __attribute__ ((bitwidth(832 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<832 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<832 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(832 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<832 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<833 + 1024 * 0,true> { int V __attribute__ ((bitwidth(833 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<833 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<833 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(833 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<833 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<834 + 1024 * 0,true> { int V __attribute__ ((bitwidth(834 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<834 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<834 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(834 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<834 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<835 + 1024 * 0,true> { int V __attribute__ ((bitwidth(835 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<835 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<835 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(835 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<835 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<836 + 1024 * 0,true> { int V __attribute__ ((bitwidth(836 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<836 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<836 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(836 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<836 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<837 + 1024 * 0,true> { int V __attribute__ ((bitwidth(837 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<837 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<837 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(837 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<837 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<838 + 1024 * 0,true> { int V __attribute__ ((bitwidth(838 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<838 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<838 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(838 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<838 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<839 + 1024 * 0,true> { int V __attribute__ ((bitwidth(839 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<839 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<839 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(839 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<839 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<840 + 1024 * 0,true> { int V __attribute__ ((bitwidth(840 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<840 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<840 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(840 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<840 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<841 + 1024 * 0,true> { int V __attribute__ ((bitwidth(841 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<841 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<841 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(841 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<841 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<842 + 1024 * 0,true> { int V __attribute__ ((bitwidth(842 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<842 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<842 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(842 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<842 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<843 + 1024 * 0,true> { int V __attribute__ ((bitwidth(843 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<843 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<843 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(843 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<843 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<844 + 1024 * 0,true> { int V __attribute__ ((bitwidth(844 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<844 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<844 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(844 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<844 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<845 + 1024 * 0,true> { int V __attribute__ ((bitwidth(845 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<845 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<845 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(845 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<845 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<846 + 1024 * 0,true> { int V __attribute__ ((bitwidth(846 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<846 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<846 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(846 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<846 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<847 + 1024 * 0,true> { int V __attribute__ ((bitwidth(847 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<847 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<847 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(847 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<847 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<848 + 1024 * 0,true> { int V __attribute__ ((bitwidth(848 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<848 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<848 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(848 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<848 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<849 + 1024 * 0,true> { int V __attribute__ ((bitwidth(849 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<849 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<849 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(849 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<849 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<850 + 1024 * 0,true> { int V __attribute__ ((bitwidth(850 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<850 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<850 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(850 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<850 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<851 + 1024 * 0,true> { int V __attribute__ ((bitwidth(851 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<851 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<851 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(851 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<851 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<852 + 1024 * 0,true> { int V __attribute__ ((bitwidth(852 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<852 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<852 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(852 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<852 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<853 + 1024 * 0,true> { int V __attribute__ ((bitwidth(853 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<853 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<853 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(853 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<853 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<854 + 1024 * 0,true> { int V __attribute__ ((bitwidth(854 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<854 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<854 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(854 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<854 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<855 + 1024 * 0,true> { int V __attribute__ ((bitwidth(855 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<855 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<855 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(855 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<855 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<856 + 1024 * 0,true> { int V __attribute__ ((bitwidth(856 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<856 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<856 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(856 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<856 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<857 + 1024 * 0,true> { int V __attribute__ ((bitwidth(857 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<857 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<857 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(857 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<857 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<858 + 1024 * 0,true> { int V __attribute__ ((bitwidth(858 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<858 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<858 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(858 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<858 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<859 + 1024 * 0,true> { int V __attribute__ ((bitwidth(859 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<859 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<859 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(859 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<859 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<860 + 1024 * 0,true> { int V __attribute__ ((bitwidth(860 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<860 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<860 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(860 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<860 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<861 + 1024 * 0,true> { int V __attribute__ ((bitwidth(861 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<861 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<861 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(861 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<861 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<862 + 1024 * 0,true> { int V __attribute__ ((bitwidth(862 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<862 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<862 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(862 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<862 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<863 + 1024 * 0,true> { int V __attribute__ ((bitwidth(863 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<863 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<863 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(863 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<863 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<864 + 1024 * 0,true> { int V __attribute__ ((bitwidth(864 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<864 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<864 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(864 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<864 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<865 + 1024 * 0,true> { int V __attribute__ ((bitwidth(865 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<865 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<865 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(865 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<865 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<866 + 1024 * 0,true> { int V __attribute__ ((bitwidth(866 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<866 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<866 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(866 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<866 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<867 + 1024 * 0,true> { int V __attribute__ ((bitwidth(867 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<867 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<867 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(867 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<867 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<868 + 1024 * 0,true> { int V __attribute__ ((bitwidth(868 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<868 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<868 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(868 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<868 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<869 + 1024 * 0,true> { int V __attribute__ ((bitwidth(869 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<869 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<869 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(869 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<869 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<870 + 1024 * 0,true> { int V __attribute__ ((bitwidth(870 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<870 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<870 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(870 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<870 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<871 + 1024 * 0,true> { int V __attribute__ ((bitwidth(871 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<871 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<871 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(871 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<871 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<872 + 1024 * 0,true> { int V __attribute__ ((bitwidth(872 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<872 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<872 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(872 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<872 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<873 + 1024 * 0,true> { int V __attribute__ ((bitwidth(873 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<873 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<873 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(873 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<873 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<874 + 1024 * 0,true> { int V __attribute__ ((bitwidth(874 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<874 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<874 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(874 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<874 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<875 + 1024 * 0,true> { int V __attribute__ ((bitwidth(875 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<875 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<875 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(875 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<875 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<876 + 1024 * 0,true> { int V __attribute__ ((bitwidth(876 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<876 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<876 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(876 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<876 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<877 + 1024 * 0,true> { int V __attribute__ ((bitwidth(877 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<877 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<877 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(877 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<877 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<878 + 1024 * 0,true> { int V __attribute__ ((bitwidth(878 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<878 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<878 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(878 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<878 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<879 + 1024 * 0,true> { int V __attribute__ ((bitwidth(879 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<879 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<879 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(879 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<879 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<880 + 1024 * 0,true> { int V __attribute__ ((bitwidth(880 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<880 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<880 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(880 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<880 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<881 + 1024 * 0,true> { int V __attribute__ ((bitwidth(881 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<881 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<881 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(881 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<881 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<882 + 1024 * 0,true> { int V __attribute__ ((bitwidth(882 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<882 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<882 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(882 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<882 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<883 + 1024 * 0,true> { int V __attribute__ ((bitwidth(883 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<883 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<883 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(883 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<883 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<884 + 1024 * 0,true> { int V __attribute__ ((bitwidth(884 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<884 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<884 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(884 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<884 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<885 + 1024 * 0,true> { int V __attribute__ ((bitwidth(885 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<885 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<885 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(885 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<885 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<886 + 1024 * 0,true> { int V __attribute__ ((bitwidth(886 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<886 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<886 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(886 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<886 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<887 + 1024 * 0,true> { int V __attribute__ ((bitwidth(887 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<887 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<887 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(887 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<887 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<888 + 1024 * 0,true> { int V __attribute__ ((bitwidth(888 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<888 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<888 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(888 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<888 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<889 + 1024 * 0,true> { int V __attribute__ ((bitwidth(889 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<889 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<889 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(889 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<889 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<890 + 1024 * 0,true> { int V __attribute__ ((bitwidth(890 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<890 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<890 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(890 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<890 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<891 + 1024 * 0,true> { int V __attribute__ ((bitwidth(891 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<891 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<891 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(891 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<891 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<892 + 1024 * 0,true> { int V __attribute__ ((bitwidth(892 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<892 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<892 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(892 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<892 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<893 + 1024 * 0,true> { int V __attribute__ ((bitwidth(893 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<893 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<893 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(893 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<893 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<894 + 1024 * 0,true> { int V __attribute__ ((bitwidth(894 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<894 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<894 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(894 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<894 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<895 + 1024 * 0,true> { int V __attribute__ ((bitwidth(895 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<895 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<895 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(895 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<895 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<896 + 1024 * 0,true> { int V __attribute__ ((bitwidth(896 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<896 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<896 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(896 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<896 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<897 + 1024 * 0,true> { int V __attribute__ ((bitwidth(897 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<897 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<897 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(897 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<897 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<898 + 1024 * 0,true> { int V __attribute__ ((bitwidth(898 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<898 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<898 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(898 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<898 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<899 + 1024 * 0,true> { int V __attribute__ ((bitwidth(899 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<899 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<899 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(899 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<899 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<900 + 1024 * 0,true> { int V __attribute__ ((bitwidth(900 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<900 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<900 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(900 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<900 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<901 + 1024 * 0,true> { int V __attribute__ ((bitwidth(901 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<901 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<901 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(901 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<901 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<902 + 1024 * 0,true> { int V __attribute__ ((bitwidth(902 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<902 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<902 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(902 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<902 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<903 + 1024 * 0,true> { int V __attribute__ ((bitwidth(903 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<903 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<903 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(903 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<903 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<904 + 1024 * 0,true> { int V __attribute__ ((bitwidth(904 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<904 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<904 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(904 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<904 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<905 + 1024 * 0,true> { int V __attribute__ ((bitwidth(905 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<905 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<905 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(905 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<905 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<906 + 1024 * 0,true> { int V __attribute__ ((bitwidth(906 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<906 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<906 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(906 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<906 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<907 + 1024 * 0,true> { int V __attribute__ ((bitwidth(907 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<907 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<907 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(907 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<907 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<908 + 1024 * 0,true> { int V __attribute__ ((bitwidth(908 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<908 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<908 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(908 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<908 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<909 + 1024 * 0,true> { int V __attribute__ ((bitwidth(909 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<909 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<909 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(909 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<909 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<910 + 1024 * 0,true> { int V __attribute__ ((bitwidth(910 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<910 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<910 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(910 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<910 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<911 + 1024 * 0,true> { int V __attribute__ ((bitwidth(911 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<911 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<911 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(911 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<911 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<912 + 1024 * 0,true> { int V __attribute__ ((bitwidth(912 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<912 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<912 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(912 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<912 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<913 + 1024 * 0,true> { int V __attribute__ ((bitwidth(913 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<913 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<913 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(913 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<913 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<914 + 1024 * 0,true> { int V __attribute__ ((bitwidth(914 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<914 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<914 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(914 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<914 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<915 + 1024 * 0,true> { int V __attribute__ ((bitwidth(915 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<915 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<915 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(915 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<915 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<916 + 1024 * 0,true> { int V __attribute__ ((bitwidth(916 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<916 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<916 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(916 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<916 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<917 + 1024 * 0,true> { int V __attribute__ ((bitwidth(917 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<917 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<917 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(917 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<917 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<918 + 1024 * 0,true> { int V __attribute__ ((bitwidth(918 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<918 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<918 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(918 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<918 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<919 + 1024 * 0,true> { int V __attribute__ ((bitwidth(919 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<919 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<919 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(919 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<919 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<920 + 1024 * 0,true> { int V __attribute__ ((bitwidth(920 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<920 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<920 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(920 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<920 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<921 + 1024 * 0,true> { int V __attribute__ ((bitwidth(921 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<921 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<921 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(921 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<921 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<922 + 1024 * 0,true> { int V __attribute__ ((bitwidth(922 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<922 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<922 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(922 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<922 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<923 + 1024 * 0,true> { int V __attribute__ ((bitwidth(923 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<923 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<923 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(923 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<923 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<924 + 1024 * 0,true> { int V __attribute__ ((bitwidth(924 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<924 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<924 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(924 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<924 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<925 + 1024 * 0,true> { int V __attribute__ ((bitwidth(925 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<925 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<925 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(925 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<925 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<926 + 1024 * 0,true> { int V __attribute__ ((bitwidth(926 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<926 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<926 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(926 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<926 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<927 + 1024 * 0,true> { int V __attribute__ ((bitwidth(927 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<927 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<927 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(927 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<927 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<928 + 1024 * 0,true> { int V __attribute__ ((bitwidth(928 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<928 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<928 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(928 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<928 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<929 + 1024 * 0,true> { int V __attribute__ ((bitwidth(929 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<929 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<929 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(929 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<929 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<930 + 1024 * 0,true> { int V __attribute__ ((bitwidth(930 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<930 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<930 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(930 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<930 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<931 + 1024 * 0,true> { int V __attribute__ ((bitwidth(931 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<931 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<931 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(931 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<931 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<932 + 1024 * 0,true> { int V __attribute__ ((bitwidth(932 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<932 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<932 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(932 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<932 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<933 + 1024 * 0,true> { int V __attribute__ ((bitwidth(933 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<933 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<933 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(933 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<933 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<934 + 1024 * 0,true> { int V __attribute__ ((bitwidth(934 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<934 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<934 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(934 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<934 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<935 + 1024 * 0,true> { int V __attribute__ ((bitwidth(935 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<935 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<935 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(935 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<935 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<936 + 1024 * 0,true> { int V __attribute__ ((bitwidth(936 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<936 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<936 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(936 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<936 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<937 + 1024 * 0,true> { int V __attribute__ ((bitwidth(937 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<937 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<937 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(937 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<937 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<938 + 1024 * 0,true> { int V __attribute__ ((bitwidth(938 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<938 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<938 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(938 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<938 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<939 + 1024 * 0,true> { int V __attribute__ ((bitwidth(939 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<939 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<939 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(939 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<939 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<940 + 1024 * 0,true> { int V __attribute__ ((bitwidth(940 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<940 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<940 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(940 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<940 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<941 + 1024 * 0,true> { int V __attribute__ ((bitwidth(941 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<941 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<941 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(941 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<941 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<942 + 1024 * 0,true> { int V __attribute__ ((bitwidth(942 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<942 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<942 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(942 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<942 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<943 + 1024 * 0,true> { int V __attribute__ ((bitwidth(943 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<943 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<943 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(943 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<943 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<944 + 1024 * 0,true> { int V __attribute__ ((bitwidth(944 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<944 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<944 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(944 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<944 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<945 + 1024 * 0,true> { int V __attribute__ ((bitwidth(945 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<945 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<945 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(945 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<945 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<946 + 1024 * 0,true> { int V __attribute__ ((bitwidth(946 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<946 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<946 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(946 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<946 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<947 + 1024 * 0,true> { int V __attribute__ ((bitwidth(947 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<947 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<947 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(947 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<947 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<948 + 1024 * 0,true> { int V __attribute__ ((bitwidth(948 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<948 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<948 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(948 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<948 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<949 + 1024 * 0,true> { int V __attribute__ ((bitwidth(949 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<949 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<949 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(949 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<949 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<950 + 1024 * 0,true> { int V __attribute__ ((bitwidth(950 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<950 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<950 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(950 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<950 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<951 + 1024 * 0,true> { int V __attribute__ ((bitwidth(951 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<951 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<951 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(951 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<951 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<952 + 1024 * 0,true> { int V __attribute__ ((bitwidth(952 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<952 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<952 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(952 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<952 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<953 + 1024 * 0,true> { int V __attribute__ ((bitwidth(953 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<953 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<953 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(953 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<953 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<954 + 1024 * 0,true> { int V __attribute__ ((bitwidth(954 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<954 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<954 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(954 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<954 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<955 + 1024 * 0,true> { int V __attribute__ ((bitwidth(955 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<955 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<955 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(955 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<955 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<956 + 1024 * 0,true> { int V __attribute__ ((bitwidth(956 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<956 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<956 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(956 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<956 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<957 + 1024 * 0,true> { int V __attribute__ ((bitwidth(957 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<957 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<957 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(957 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<957 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<958 + 1024 * 0,true> { int V __attribute__ ((bitwidth(958 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<958 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<958 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(958 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<958 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<959 + 1024 * 0,true> { int V __attribute__ ((bitwidth(959 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<959 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<959 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(959 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<959 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<960 + 1024 * 0,true> { int V __attribute__ ((bitwidth(960 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<960 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<960 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(960 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<960 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<961 + 1024 * 0,true> { int V __attribute__ ((bitwidth(961 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<961 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<961 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(961 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<961 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<962 + 1024 * 0,true> { int V __attribute__ ((bitwidth(962 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<962 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<962 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(962 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<962 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<963 + 1024 * 0,true> { int V __attribute__ ((bitwidth(963 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<963 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<963 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(963 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<963 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<964 + 1024 * 0,true> { int V __attribute__ ((bitwidth(964 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<964 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<964 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(964 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<964 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<965 + 1024 * 0,true> { int V __attribute__ ((bitwidth(965 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<965 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<965 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(965 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<965 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<966 + 1024 * 0,true> { int V __attribute__ ((bitwidth(966 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<966 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<966 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(966 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<966 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<967 + 1024 * 0,true> { int V __attribute__ ((bitwidth(967 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<967 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<967 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(967 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<967 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<968 + 1024 * 0,true> { int V __attribute__ ((bitwidth(968 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<968 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<968 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(968 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<968 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<969 + 1024 * 0,true> { int V __attribute__ ((bitwidth(969 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<969 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<969 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(969 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<969 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<970 + 1024 * 0,true> { int V __attribute__ ((bitwidth(970 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<970 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<970 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(970 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<970 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<971 + 1024 * 0,true> { int V __attribute__ ((bitwidth(971 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<971 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<971 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(971 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<971 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<972 + 1024 * 0,true> { int V __attribute__ ((bitwidth(972 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<972 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<972 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(972 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<972 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<973 + 1024 * 0,true> { int V __attribute__ ((bitwidth(973 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<973 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<973 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(973 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<973 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<974 + 1024 * 0,true> { int V __attribute__ ((bitwidth(974 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<974 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<974 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(974 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<974 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<975 + 1024 * 0,true> { int V __attribute__ ((bitwidth(975 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<975 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<975 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(975 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<975 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<976 + 1024 * 0,true> { int V __attribute__ ((bitwidth(976 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<976 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<976 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(976 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<976 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<977 + 1024 * 0,true> { int V __attribute__ ((bitwidth(977 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<977 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<977 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(977 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<977 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<978 + 1024 * 0,true> { int V __attribute__ ((bitwidth(978 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<978 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<978 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(978 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<978 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<979 + 1024 * 0,true> { int V __attribute__ ((bitwidth(979 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<979 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<979 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(979 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<979 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<980 + 1024 * 0,true> { int V __attribute__ ((bitwidth(980 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<980 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<980 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(980 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<980 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<981 + 1024 * 0,true> { int V __attribute__ ((bitwidth(981 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<981 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<981 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(981 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<981 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<982 + 1024 * 0,true> { int V __attribute__ ((bitwidth(982 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<982 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<982 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(982 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<982 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<983 + 1024 * 0,true> { int V __attribute__ ((bitwidth(983 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<983 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<983 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(983 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<983 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<984 + 1024 * 0,true> { int V __attribute__ ((bitwidth(984 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<984 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<984 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(984 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<984 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<985 + 1024 * 0,true> { int V __attribute__ ((bitwidth(985 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<985 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<985 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(985 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<985 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<986 + 1024 * 0,true> { int V __attribute__ ((bitwidth(986 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<986 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<986 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(986 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<986 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<987 + 1024 * 0,true> { int V __attribute__ ((bitwidth(987 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<987 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<987 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(987 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<987 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<988 + 1024 * 0,true> { int V __attribute__ ((bitwidth(988 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<988 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<988 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(988 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<988 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<989 + 1024 * 0,true> { int V __attribute__ ((bitwidth(989 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<989 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<989 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(989 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<989 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<990 + 1024 * 0,true> { int V __attribute__ ((bitwidth(990 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<990 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<990 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(990 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<990 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<991 + 1024 * 0,true> { int V __attribute__ ((bitwidth(991 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<991 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<991 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(991 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<991 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<992 + 1024 * 0,true> { int V __attribute__ ((bitwidth(992 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<992 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<992 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(992 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<992 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<993 + 1024 * 0,true> { int V __attribute__ ((bitwidth(993 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<993 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<993 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(993 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<993 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<994 + 1024 * 0,true> { int V __attribute__ ((bitwidth(994 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<994 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<994 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(994 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<994 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<995 + 1024 * 0,true> { int V __attribute__ ((bitwidth(995 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<995 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<995 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(995 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<995 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<996 + 1024 * 0,true> { int V __attribute__ ((bitwidth(996 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<996 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<996 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(996 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<996 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<997 + 1024 * 0,true> { int V __attribute__ ((bitwidth(997 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<997 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<997 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(997 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<997 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<998 + 1024 * 0,true> { int V __attribute__ ((bitwidth(998 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<998 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<998 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(998 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<998 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<999 + 1024 * 0,true> { int V __attribute__ ((bitwidth(999 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<999 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<999 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(999 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<999 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1000 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1000 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1000 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1000 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1000 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1000 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1001 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1001 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1001 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1001 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1001 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1001 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1002 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1002 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1002 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1002 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1002 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1002 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1003 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1003 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1003 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1003 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1003 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1003 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1004 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1004 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1004 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1004 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1004 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1004 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1005 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1005 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1005 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1005 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1005 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1005 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1006 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1006 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1006 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1006 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1006 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1006 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1007 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1007 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1007 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1007 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1007 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1007 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1008 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1008 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1008 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1008 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1008 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1008 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1009 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1009 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1009 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1009 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1009 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1009 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1010 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1010 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1010 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1010 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1010 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1010 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1011 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1011 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1011 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1011 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1011 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1011 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1012 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1012 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1012 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1012 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1012 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1012 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1013 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1013 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1013 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1013 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1013 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1013 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1014 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1014 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1014 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1014 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1014 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1014 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1015 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1015 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1015 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1015 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1015 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1015 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1016 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1016 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1016 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1016 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1016 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1016 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1017 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1017 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1017 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1017 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1017 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1017 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1018 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1018 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1018 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1018 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1018 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1018 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1019 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1019 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1019 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1019 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1019 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1019 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1020 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1020 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1020 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1020 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1020 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1020 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1021 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1021 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1021 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1021 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1021 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1021 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1022 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1022 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1022 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1022 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1022 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1022 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1023 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1023 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1023 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1023 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1023 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1023 + 1024 * 0 , false>() { }; };
template<> struct ssdm_int<1024 + 1024 * 0,true> { int V __attribute__ ((bitwidth(1024 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1024 + 1024 * 0 ,true>() { }; }; template<> struct ssdm_int<1024 + 1024 * 0, false> { unsigned int V __attribute__ ((bitwidth(1024 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1024 + 1024 * 0 , false>() { }; };
#185 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_int_syn.h" 2
#603 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_int_syn.h"
enum BaseMode { SC_BIN=2, SC_OCT=8, SC_DEC=10, SC_HEX=16 };
#646 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_int_syn.h"
#1 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/etc/autopilot_ssdm_bits.h" 1
#647 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_int_syn.h" 2
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_W> struct ap_int;
template<int _AP_W1, typename _AP_T1, int _AP_W2, typename _AP_T2> struct ap_concat_ref;
enum ap_q_mode {
SC_RND,
SC_RND_ZERO,
SC_RND_MIN_INF,
SC_RND_INF,
SC_RND_CONV,
SC_TRN,
SC_TRN_ZERO
};
enum ap_o_mode {
SC_SAT,
SC_SAT_ZERO,
SC_SAT_SYM,
SC_WRAP,
SC_WRAP_SM
};
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;
template<int _AP_W1, typename _AP_T1, int _AP_W2, typename _AP_T2>
struct ap_concat_ref {
enum { _AP_WR = _AP_W1+_AP_W2, };
_AP_T1& mbv1;
_AP_T2& mbv2;
inline __attribute__((always_inline)) ap_concat_ref(const ap_concat_ref<_AP_W1, _AP_T1,
_AP_W2, _AP_T2>& ref):
mbv1(ref.mbv1), mbv2(ref.mbv2) {}
inline __attribute__((always_inline)) ap_concat_ref( _AP_T1& bv1, _AP_T2& bv2) : mbv1(bv1), mbv2(bv2) { }
template <int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_concat_ref& operator = (const ap_int_base<_AP_W3, _AP_S3>& val) {
ap_int_base<_AP_W1+_AP_W2, false> vval(val);
int W_ref1 = mbv1.length();
int W_ref2 = mbv2.length();
ap_int_base<_AP_W1,false> Part1;
Part1.V = ({ 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;
}
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);
}
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);
}
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);
}
template<int _AP_W3, int _AP_I3, bool _AP_S3,
ap_q_mode _AP_Q3, ap_o_mode _AP_O3, int _AP_N3>
inline __attribute__((always_inline)) ap_concat_ref& operator= (const af_range_ref<_AP_W3, _AP_I3, _AP_S3,
_AP_Q3, _AP_O3, _AP_N3>& val) {
return operator = ((const ap_int_base<_AP_W3, false>)(val));
}
template<int _AP_W3, int _AP_I3, bool _AP_S3,
ap_q_mode _AP_Q3, ap_o_mode _AP_O3, int _AP_N3>
inline __attribute__((always_inline)) ap_concat_ref& operator= (const ap_fixed_base<_AP_W3, _AP_I3, _AP_S3,
_AP_Q3, _AP_O3, _AP_N3>& val) {
return operator = (val.to_ap_int_base());
}
template<int _AP_W3, int _AP_I3, bool _AP_S3,
ap_q_mode _AP_Q3, ap_o_mode _AP_O3, int _AP_N3>
inline __attribute__((always_inline)) ap_concat_ref& operator= (const af_bit_ref<_AP_W3, _AP_I3, _AP_S3,
_AP_Q3, _AP_O3, _AP_N3>& val) {
return operator=((unsigned long long)(bool)(val));
}
inline __attribute__((always_inline)) operator ap_int_base<_AP_WR, false> () const {
return get();
}
inline __attribute__((always_inline)) operator unsigned long long () const {
return get().to_uint64();
}
template<int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_concat_ref<_AP_WR, ap_concat_ref, _AP_W3, ap_range_ref<_AP_W3, _AP_S3> >
operator, (const ap_range_ref<_AP_W3, _AP_S3>& a2) {
return ap_concat_ref<_AP_WR, ap_concat_ref,
_AP_W3, ap_range_ref<_AP_W3, _AP_S3> >(*this,
const_cast<ap_range_ref<_AP_W3, _AP_S3>& >(a2));
}
template<int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_concat_ref<_AP_WR, ap_concat_ref, _AP_W3, ap_int_base<_AP_W3, _AP_S3> >
operator, (ap_int_base<_AP_W3, _AP_S3>& a2) {
return ap_concat_ref<_AP_WR, ap_concat_ref,
_AP_W3, ap_int_base<_AP_W3, _AP_S3> >(*this, a2);
}
template<int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_concat_ref<_AP_WR, ap_concat_ref, _AP_W3, ap_int_base<_AP_W3, _AP_S3> >
operator, (volatile ap_int_base<_AP_W3, _AP_S3>& a2) {
return ap_concat_ref<_AP_WR, ap_concat_ref,
_AP_W3, ap_int_base<_AP_W3, _AP_S3> >(*this,
const_cast<ap_int_base<_AP_W3, _AP_S3>& >(a2));
}
template<int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_concat_ref<_AP_WR, ap_concat_ref, _AP_W3, ap_int_base<_AP_W3, _AP_S3> >
operator, (const ap_int_base<_AP_W3, _AP_S3>& a2) {
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, _AP_W3, ap_int_base<_AP_W3, _AP_S3> >
operator, (const volatile ap_int_base<_AP_W3, _AP_S3>& a2) {
ap_int_base<_AP_W3,_AP_S3> op(a2);
return ap_concat_ref<_AP_WR, ap_concat_ref,
_AP_W3, ap_int_base<_AP_W3, _AP_S3> >(*this,
const_cast<ap_int_base<_AP_W3, _AP_S3>& >(op));
}
template<int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_concat_ref<_AP_WR, ap_concat_ref, 1, ap_bit_ref<_AP_W3, _AP_S3> >
operator, (const ap_bit_ref<_AP_W3, _AP_S3>& a2) {
return ap_concat_ref<_AP_WR, ap_concat_ref,
1, ap_bit_ref<_AP_W3, _AP_S3> >(*this,
const_cast<ap_bit_ref<_AP_W3, _AP_S3>& >(a2));
}
template<int _AP_W3, typename _AP_T3, int _AP_W4, typename _AP_T4>
inline __attribute__((always_inline)) ap_concat_ref<_AP_WR, ap_concat_ref, _AP_W3+_AP_W4,
ap_concat_ref<_AP_W3,_AP_T3,_AP_W4,_AP_T4> >
operator, (const ap_concat_ref<_AP_W3,_AP_T3,_AP_W4,_AP_T4>& a2) {
return ap_concat_ref<_AP_WR, ap_concat_ref,
_AP_W3+_AP_W4, ap_concat_ref<_AP_W3,_AP_T3,_AP_W4,_AP_T4> >(
*this, const_cast<ap_concat_ref<_AP_W3,_AP_T3,
_AP_W4,_AP_T4>& >(a2));
}
template <int _AP_W3, int _AP_I3, bool _AP_S3, ap_q_mode _AP_Q3, ap_o_mode _AP_O3, int _AP_N3>
inline __attribute__((always_inline))
ap_concat_ref<_AP_WR, ap_concat_ref, _AP_W3, af_range_ref<_AP_W3, _AP_I3, _AP_S3, _AP_Q3, _AP_O3, _AP_N3> >
operator, (const af_range_ref<_AP_W3, _AP_I3, _AP_S3, _AP_Q3,
_AP_O3, _AP_N3> &a2) {
return ap_concat_ref<_AP_WR, ap_concat_ref, _AP_W3, af_range_ref<_AP_W3,
_AP_I3, _AP_S3, _AP_Q3, _AP_O3, _AP_N3> >(*this,
const_cast<af_range_ref< _AP_W3, _AP_I3, _AP_S3, _AP_Q3,
_AP_O3, _AP_N3>& >(a2));
}
template <int _AP_W3, int _AP_I3, bool _AP_S3, ap_q_mode _AP_Q3, ap_o_mode _AP_O3, int _AP_N3>
inline __attribute__((always_inline))
ap_concat_ref<_AP_WR, ap_concat_ref, 1, af_bit_ref<_AP_W3, _AP_I3, _AP_S3, _AP_Q3, _AP_O3, _AP_N3> >
operator, (const af_bit_ref<_AP_W3, _AP_I3, _AP_S3, _AP_Q3,
_AP_O3, _AP_N3> &a2) {
return ap_concat_ref<_AP_WR, ap_concat_ref, 1, af_bit_ref<_AP_W3,
_AP_I3, _AP_S3, _AP_Q3, _AP_O3, _AP_N3> >(*this,
const_cast<af_bit_ref<_AP_W3, _AP_I3, _AP_S3, _AP_Q3,
_AP_O3, _AP_N3>& >(a2));
}
template<int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_int_base<((_AP_WR) > (_AP_W3) ? (_AP_WR) : (_AP_W3)), _AP_S3>
operator & (const ap_int_base<_AP_W3,_AP_S3>& a2) {
return get() & a2;
}
template<int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_int_base<((_AP_WR) > (_AP_W3) ? (_AP_WR) : (_AP_W3)), _AP_S3>
operator | (const ap_int_base<_AP_W3,_AP_S3>& a2) {
return get() | a2;
}
template<int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_int_base<((_AP_WR) > (_AP_W3) ? (_AP_WR) : (_AP_W3)), _AP_S3>
operator ^ (const ap_int_base<_AP_W3,_AP_S3>& a2) {
return get() ^ a2;
}
#882 "/opt/Xilinx/Vivado/2017.3/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__; });
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__; });
return tmpVal;
}
template <int _AP_W3>
inline __attribute__((always_inline)) void set(const ap_int_base<_AP_W3, false>& val) {
ap_int_base<_AP_W1+_AP_W2, false> vval(val);
int W_ref1 = mbv1.length();
int W_ref2 = mbv2.length();
ap_int_base<_AP_W1,false> tmpVal1;
tmpVal1.V = ({ 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);
}
inline __attribute__((always_inline)) int length() const {
return mbv1.length() + mbv2.length();
}
};
#924 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_int_syn.h"
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;
public:
inline __attribute__((always_inline)) ap_range_ref(const ap_range_ref<_AP_W, _AP_S>& ref):
d_bv(ref.d_bv), l_index(ref.l_index), h_index(ref.h_index) {}
inline __attribute__((always_inline)) ap_range_ref(ap_int_base<_AP_W,_AP_S>* bv, int h, int l) :
d_bv(*bv), l_index(l), h_index(h) {
}
inline __attribute__((always_inline)) operator ap_int_base<_AP_W, false> () const {
ap_int_base<_AP_W,false> ret;
ret.V = ({ 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;
}
inline __attribute__((always_inline)) operator unsigned long long () const {
return to_uint64();
}
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;
}
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;
}
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);
}
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);
}
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_range_ref& operator= (const af_range_ref<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2>& val) {
return operator=((const ap_int_base<_AP_W2, false>)(val));
}
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_range_ref& operator= (const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2>& val) {
return operator=(val.to_ap_int_base());
}
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_range_ref& operator= (const af_bit_ref<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2>& val) {
return operator=((unsigned long long)(bool)(val));
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_range_ref& operator= (const ap_bit_ref<_AP_W2, _AP_S2>& val) {
return operator=((unsigned long long)(bool)(val));
}
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_range_ref& operator= (const ap_concat_ref<_AP_W2, _AP_T3, _AP_W3, _AP_T3>& val) {
return operator=((const ap_int_base<_AP_W2 + _AP_W3, false>)(val));
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W,ap_range_ref,_AP_W2,ap_range_ref<_AP_W2,_AP_S2> >
operator, (const ap_range_ref<_AP_W2,_AP_S2> &a2) {
return
ap_concat_ref<_AP_W, ap_range_ref, _AP_W2,
ap_range_ref<_AP_W2,_AP_S2> >(*this,
const_cast<ap_range_ref<_AP_W2, _AP_S2>& >(a2));
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W,ap_range_ref,_AP_W2,ap_int_base<_AP_W2,_AP_S2> >
operator, (ap_int_base<_AP_W2,_AP_S2> &a2) {
return
ap_concat_ref<_AP_W, ap_range_ref, _AP_W2, ap_int_base<_AP_W2,_AP_S2> >(*this, a2);
}
inline __attribute__((always_inline))
ap_concat_ref<_AP_W,ap_range_ref,_AP_W,ap_int_base<_AP_W,_AP_S> >
operator, (ap_int_base<_AP_W,_AP_S> &a2) {
return
ap_concat_ref<_AP_W, ap_range_ref, _AP_W, ap_int_base<_AP_W,_AP_S> >(*this, a2);
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W,ap_range_ref,_AP_W2,ap_int_base<_AP_W2,_AP_S2> >
operator, (volatile ap_int_base<_AP_W2,_AP_S2>& a2) {
return
ap_concat_ref<_AP_W, ap_range_ref, _AP_W2, ap_int_base<_AP_W2,_AP_S2> >(*this,
const_cast<ap_int_base<_AP_W2, _AP_S2>& >(a2));
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W,ap_range_ref,_AP_W2,ap_int_base<_AP_W2,_AP_S2> >
operator, (const ap_int_base<_AP_W2,_AP_S2>& a2) {
return
ap_concat_ref<_AP_W, ap_range_ref, _AP_W2, ap_int_base<_AP_W2,_AP_S2> >(*this,
const_cast<ap_int_base<_AP_W2, _AP_S2>& >(a2));
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W,ap_range_ref,_AP_W2,ap_int_base<_AP_W2,_AP_S2> >
operator, (const volatile ap_int_base<_AP_W2,_AP_S2>& a2) {
return
ap_concat_ref<_AP_W, ap_range_ref, _AP_W2,
ap_int_base<_AP_W2,_AP_S2> >(*this,
const_cast<ap_int_base<_AP_W2, _AP_S2>& >(a2));
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W,ap_range_ref,1,ap_bit_ref<_AP_W2,_AP_S2> >
operator, (const ap_bit_ref<_AP_W2,_AP_S2> &a2) {
return
ap_concat_ref<_AP_W, ap_range_ref, 1, ap_bit_ref<_AP_W2,_AP_S2> >(*this,
const_cast<ap_bit_ref<_AP_W2, _AP_S2>& >(a2));
}
template <int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_range_ref, _AP_W2+_AP_W3, ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >
operator, (const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> &a2) {
return ap_concat_ref<_AP_W, ap_range_ref, _AP_W2+_AP_W3,
ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >(*this,
const_cast<ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& >(a2));
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_range_ref, _AP_W2, af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> a2) {
return ap_concat_ref<_AP_W, ap_range_ref, _AP_W2, af_range_ref<_AP_W2,
_AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(*this,
const_cast<af_range_ref<_AP_W2,_AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2>& >(a2));
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_range_ref, 1, af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &a2) {
return ap_concat_ref<_AP_W, ap_range_ref, 1, af_bit_ref<_AP_W2,
_AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(*this,
const_cast<af_bit_ref<_AP_W2,_AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2>& >(a2));
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator == (const ap_range_ref<_AP_W2, _AP_S2>& op2) {
ap_int_base<_AP_W, false> lop(*this);
ap_int_base<_AP_W2, false> hop(op2);
return lop == hop;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator != (const ap_range_ref<_AP_W2, _AP_S2>& op2) {
return !(operator == (op2));
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator < (const ap_range_ref<_AP_W2, _AP_S2>& op2) {
ap_int_base<_AP_W, false> lop (*this);
ap_int_base<_AP_W2, false> hop (op2);
return lop < hop;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator <= (const ap_range_ref<_AP_W2, _AP_S2>& op2) {
ap_int_base<_AP_W, false> lop (*this);
ap_int_base<_AP_W2, false> hop (op2);
return lop <= hop;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator > (const ap_range_ref<_AP_W2, _AP_S2>& op2) {
return !(operator <= (op2));
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator >= (const ap_range_ref<_AP_W2, _AP_S2>& op2) {
return !(operator < (op2));
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_range_ref<_AP_W,_AP_S> & operator |= (const ap_range_ref<_AP_W2,_AP_S2> &op2) {
(this->d_bv).V |= (op2.d_bv).V;
return *this;
};
template<int _AP_W2>
inline __attribute__((always_inline)) ap_range_ref<_AP_W,_AP_S> & operator |= (const ap_int<_AP_W2> &op2) {
(this->d_bv).V |= op2.V;
return *this;
};
template<int _AP_W2>
inline __attribute__((always_inline)) ap_range_ref<_AP_W,_AP_S> & operator |= (const ap_uint<_AP_W2> &op2) {
(this->d_bv.V) |= op2.V;
return *this;
};
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_range_ref<_AP_W,_AP_S> & operator &= (const ap_range_ref<_AP_W2,_AP_S2> &op2) {
(this->d_bv).V &= (op2.d_bv).V;
return *this;
};
template<int _AP_W2>
inline __attribute__((always_inline)) ap_range_ref<_AP_W,_AP_S> & operator &= (const ap_int<_AP_W2> &op2) {
(this->d_bv).V &= op2.V;
return *this;
};
template<int _AP_W2>
inline __attribute__((always_inline)) ap_range_ref<_AP_W,_AP_S> & operator &= (const ap_uint<_AP_W2> &op2) {
(this->d_bv.V) &= op2.V;
return *this;
};
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_range_ref<_AP_W,_AP_S> & operator ^= (const ap_range_ref<_AP_W2,_AP_S2> &op2) {
(this->d_bv).V ^= (op2.d_bv).V;
return *this;
};
template<int _AP_W2>
inline __attribute__((always_inline)) ap_range_ref<_AP_W,_AP_S> & operator ^= (const ap_int<_AP_W2> &op2) {
(this->d_bv).V ^= op2.V;
return *this;
};
template<int _AP_W2>
inline __attribute__((always_inline)) ap_range_ref<_AP_W,_AP_S> & operator ^= (const ap_uint<_AP_W2> &op2) {
(this->d_bv.V) ^= op2.V;
return *this;
};
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__; });
}
inline __attribute__((always_inline)) int length() const {
return h_index >= l_index ? h_index - l_index + 1 : l_index - h_index + 1;
}
inline __attribute__((always_inline)) int to_int() const {
return (int)(({ 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;
}
};
template<int _AP_W, bool _AP_S>
struct ap_bit_ref {
ap_int_base<_AP_W, _AP_S>& d_bv;
int d_index;
public:
inline __attribute__((always_inline)) ap_bit_ref(const ap_bit_ref<_AP_W, _AP_S>& ref):
d_bv(ref.d_bv), d_index(ref.d_index) {}
inline __attribute__((always_inline)) ap_bit_ref(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); }); }
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;
}
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));
}
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>());
}
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);
}
inline __attribute__((always_inline)) ap_bit_ref& operator = (const ap_bit_ref<_AP_W,_AP_S>& val) {
return operator =((unsigned long long) (bool) val);
}
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_bit_ref& operator= (const af_range_ref<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2>& val) {
return operator=((const ap_int_base<_AP_W2, false>)(val));
}
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_bit_ref& operator= (const af_bit_ref<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2>& val) {
return operator=((unsigned long long)(bool)(val));
}
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_bit_ref& operator= (const ap_concat_ref<_AP_W2, _AP_T3, _AP_W3, _AP_T3>& val) {
return operator=((const ap_int_base<_AP_W2 + _AP_W3, false>)(val));
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<1, ap_bit_ref, _AP_W2, ap_int_base<_AP_W2,_AP_S2> >
operator, (ap_int_base<_AP_W2, _AP_S2>& a2) {
return ap_concat_ref<1, ap_bit_ref, _AP_W2, ap_int_base<_AP_W2,_AP_S2> >(*this, a2);
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<1, ap_bit_ref, _AP_W2, ap_int_base<_AP_W2,_AP_S2> >
operator, (volatile ap_int_base<_AP_W2, _AP_S2>& a2) {
return ap_concat_ref<1, ap_bit_ref, _AP_W2, ap_int_base<_AP_W2,_AP_S2>
>(*this, const_cast<ap_int_base<_AP_W2, _AP_S2>& >(a2));
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<1, ap_bit_ref, _AP_W2, ap_int_base<_AP_W2,_AP_S2> >
operator, (const ap_int_base<_AP_W2, _AP_S2>& a2) {
ap_int_base<_AP_W2,_AP_S2> op(a2);
return ap_concat_ref<1,ap_bit_ref,_AP_W2,ap_int_base<_AP_W2,
_AP_S2> >(*this, const_cast<ap_int_base<_AP_W2, _AP_S2>& >(op));
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<1, ap_bit_ref, _AP_W2, ap_int_base<_AP_W2,_AP_S2> >
operator, (const volatile ap_int_base<_AP_W2, _AP_S2>& a2) {
ap_int_base<_AP_W2,_AP_S2> op(a2);
return ap_concat_ref<1,ap_bit_ref,_AP_W2, ap_int_base<_AP_W2,_AP_S2>
>(*this, const_cast< ap_int_base<_AP_W2, _AP_S2>& >(op));
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<1, ap_bit_ref, _AP_W2, ap_range_ref<_AP_W2,_AP_S2> >
operator, (const ap_range_ref<_AP_W2, _AP_S2> &a2) {
return
ap_concat_ref<1, ap_bit_ref, _AP_W2, ap_range_ref<_AP_W2,
_AP_S2> >(*this, const_cast<ap_range_ref<_AP_W2, _AP_S2> &>(a2));
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<1, ap_bit_ref, 1, ap_bit_ref<_AP_W2,_AP_S2> >
operator, (const ap_bit_ref<_AP_W2, _AP_S2> &a2) {
return ap_concat_ref<1, ap_bit_ref, 1, ap_bit_ref<_AP_W2,_AP_S2> >(*this,
const_cast<ap_bit_ref<_AP_W2,_AP_S2>& >(a2));
}
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_concat_ref<1, ap_bit_ref, _AP_W2+_AP_W3, ap_concat_ref<_AP_W2,_AP_T2,_AP_W3,_AP_T3> >
operator, (const ap_concat_ref<_AP_W2,_AP_T2,_AP_W3,_AP_T3> &a2) {
return ap_concat_ref<1,ap_bit_ref,_AP_W2+_AP_W3,ap_concat_ref<_AP_W2,
_AP_T2,_AP_W3,_AP_T3> >(*this,
const_cast<ap_concat_ref<_AP_W2,_AP_T2,_AP_W3,_AP_T3> &>(a2));
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline))
ap_concat_ref<1, ap_bit_ref, _AP_W2, af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &a2) {
return ap_concat_ref<1, ap_bit_ref, _AP_W2, af_range_ref<_AP_W2,
_AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(*this,
const_cast<af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2>& >(a2));
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline))
ap_concat_ref<1, ap_bit_ref, 1, af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &a2) {
return ap_concat_ref<1, ap_bit_ref, 1, af_bit_ref<_AP_W2,
_AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(*this,
const_cast<af_bit_ref<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2>& >(a2));
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator == (const ap_bit_ref<_AP_W2, _AP_S2>& op) {
return get() == op.get();
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator != (const ap_bit_ref<_AP_W2, _AP_S2>& op) {
return get() != op.get();
}
inline __attribute__((always_inline)) bool get() const {
return ({ typeof(d_bv.V) __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 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); });
}
template <int _AP_W3>
inline __attribute__((always_inline)) void set(const ap_int_base<_AP_W3, false>& val) {
operator = (val);
}
inline __attribute__((always_inline)) bool operator ~() const {
bool bit = ({ typeof(d_bv.V) __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;
}
inline __attribute__((always_inline)) int length() const { return 1; }
};
template <int _AP_N, bool _AP_S> struct retval;
template <int _AP_N>
struct retval<_AP_N, true> {
typedef ap_slong Type;
};
template <int _AP_N>
struct retval<_AP_N, false> {
typedef ap_ulong Type;
};
template<> struct retval<1, true> {
typedef signed char Type;
};
template<> struct retval<1, false> {
typedef unsigned char Type;
};
template<> struct retval<2, true> {
typedef short Type;
};
template<> struct retval<2, false> {
typedef unsigned short Type;
};
template<> struct retval<3, true> {
typedef 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;
};
template<int _AP_W, bool _AP_S>
struct ap_int_base <_AP_W, _AP_S, true>: public ssdm_int<_AP_W,_AP_S> {
public:
typedef ssdm_int<_AP_W, _AP_S> Base;
typedef typename retval< (_AP_W + 7)/8, _AP_S>::Type RetType;
static const int width = _AP_W;
template<int _AP_W2, bool _AP_S2>
struct RType {
enum {
mult_w = _AP_W+_AP_W2,
mult_s = _AP_S||_AP_S2,
plus_w = ((_AP_W+(_AP_S2&&!_AP_S)) > (_AP_W2+(_AP_S&&!_AP_S2)) ? (_AP_W+(_AP_S2&&!_AP_S)) : (_AP_W2+(_AP_S&&!_AP_S2)))+1,
plus_s = _AP_S||_AP_S2,
minus_w = ((_AP_W+(_AP_S2&&!_AP_S)) > (_AP_W2+(_AP_S&&!_AP_S2)) ? (_AP_W+(_AP_S2&&!_AP_S)) : (_AP_W2+(_AP_S&&!_AP_S2)))+1,
minus_s = true,
div_w = _AP_W+_AP_S2,
div_s = _AP_S||_AP_S2,
mod_w = ((_AP_W) < (_AP_W2+(!_AP_S2&&_AP_S)) ? (_AP_W) : (_AP_W2+(!_AP_S2&&_AP_S))),
mod_s = _AP_S,
logic_w = ((_AP_W+(_AP_S2&&!_AP_S)) > (_AP_W2+(_AP_S&&!_AP_S2)) ? (_AP_W+(_AP_S2&&!_AP_S)) : (_AP_W2+(_AP_S&&!_AP_S2))),
logic_s = _AP_S||_AP_S2
};
typedef ap_int_base<mult_w, mult_s> mult;
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;
};
inline __attribute__((always_inline)) ap_int_base() {
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base(const ap_int_base<_AP_W2,_AP_S2> &op) { Base::V = op.V; }
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base(const volatile ap_int_base<_AP_W2,_AP_S2> &op) { Base::V = op.V; }
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(half 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; }
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_int_base(const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>& op) {
Base::V = op.to_ap_int_base().V;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base(const ap_range_ref<_AP_W2,_AP_S2>& ref) {
Base::V = ref.operator ap_int_base<_AP_W2, false>().V;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base(const ap_bit_ref<_AP_W2,_AP_S2>& ref) {
Base::V = ref.operator bool();
}
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_int_base(const ap_concat_ref<_AP_W2,_AP_T2,_AP_W3,_AP_T3>& ref) {
const ap_int_base<ap_concat_ref<_AP_W2,_AP_T2,_AP_W3,_AP_T3>::_AP_WR,false> tmp = ref.get();
Base::V = tmp.V;
}
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;
}
inline __attribute__((always_inline)) ap_int_base(const char* str, signed char radix) {_ssdm_SpecConstant(&width);
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;
}
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;
}
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_int_base(const af_bit_ref<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2> &val) {
Base::V = val.operator bool ();
}
inline __attribute__((always_inline)) ap_int_base read() volatile {
;
ap_int_base ret;
ret.V = Base::V;
return ret;
}
inline __attribute__((always_inline)) void write(const ap_int_base<_AP_W, _AP_S>& op2) volatile {
;
Base::V = op2.V;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) void operator = (const volatile ap_int_base<_AP_W2,_AP_S2>& op2) volatile {
Base::V = op2.V;
}
inline __attribute__((always_inline)) void operator = (const volatile ap_int_base<_AP_W, _AP_S>& op2) volatile {
Base::V = op2.V;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) void operator = (const ap_int_base<_AP_W2,_AP_S2>& op2) volatile {
Base::V = op2.V;
}
inline __attribute__((always_inline)) void operator = (const ap_int_base<_AP_W, _AP_S>& op2) volatile {
Base::V = op2.V;
}
#1622 "/opt/Xilinx/Vivado/2017.3/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;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base& operator = (const ap_int_base<_AP_W2,_AP_S2>& op2) {
Base::V = op2.V;
return *this;
}
inline __attribute__((always_inline)) ap_int_base& operator = (const volatile ap_int_base<_AP_W,_AP_S>& op2) {
Base::V = op2.V;
return *this;
}
inline __attribute__((always_inline)) ap_int_base& operator = (const ap_int_base<_AP_W,_AP_S>& op2) {
Base::V = op2.V;
return *this;
}
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;
}
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;
}
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; }
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base& operator = (const ap_bit_ref<_AP_W2, _AP_S2>& op2) {
Base::V = (bool) op2;
return *this;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base& operator = (const ap_range_ref<_AP_W2, _AP_S2>& op2) {
Base::V = (ap_int_base<_AP_W2, false>(op2)).V;
return *this;
}
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_int_base& operator = (const ap_concat_ref<_AP_W2,_AP_T2,_AP_W3,_AP_T3>& op2) {
Base::V = op2.get().V;
return *this;
}
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_int_base& operator = (const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
Base::V = op.to_ap_int_base().V;
return *this;
}
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_int_base& operator = (const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
Base::V = (bool) op;
return *this;
}
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_int_base& operator = (const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
Base::V = ((const ap_int_base<_AP_W2, false>)(op)).V;
return *this;
}
inline __attribute__((always_inline)) operator RetType() const { return (RetType)(Base::V); }
inline __attribute__((always_inline)) bool to_bool() const {return (bool)(Base::V);}
inline __attribute__((always_inline)) 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); }
#1741 "/opt/Xilinx/Vivado/2017.3/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; }
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;
}
inline __attribute__((always_inline)) bool iszero () const {
return Base::V == 0 ;
}
inline __attribute__((always_inline)) bool is_zero () const {
return Base::V == 0 ;
}
inline __attribute__((always_inline)) bool sign () const {
if (_AP_S && ({ typeof(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;
}
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__; });
}
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__; });
}
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); });
}
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__; });
}
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__; });
}
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;
}
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;
}
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__; });
}
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); });
}
inline __attribute__((always_inline)) void b_not() {
Base::V = ~Base::V;
}
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;
}
}
#1878 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_int_syn.h"
template<int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator *= ( const ap_int_base<_AP_W2,_AP_S2> &op2) { ; Base::V *= op2.V; return *this; }
template<int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator += ( const ap_int_base<_AP_W2,_AP_S2> &op2) { ; Base::V += op2.V; return *this; }
template<int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator -= ( const ap_int_base<_AP_W2,_AP_S2> &op2) { ; Base::V -= op2.V; return *this; }
template<int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator /= ( const ap_int_base<_AP_W2,_AP_S2> &op2) { ; Base::V /= op2.V; return *this; }
template<int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator %= ( const ap_int_base<_AP_W2,_AP_S2> &op2) { ; Base::V %= op2.V; return *this; }
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; }
inline __attribute__((always_inline)) ap_int_base& operator ++() {
operator+=((ap_int_base<1,false>) 1);
return *this;
}
inline __attribute__((always_inline)) ap_int_base& operator --() {
operator-=((ap_int_base<1,false>) 1);
return *this;
}
inline __attribute__((always_inline)) const 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;
}
inline __attribute__((always_inline)) ap_int_base operator +() const {
return *this;
}
inline __attribute__((always_inline)) bool operator ! () const {
return Base::V == 0;
}
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;
}
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;
}
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>());
}
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;
}
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>());
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator == ( const ap_int_base<_AP_W2,_AP_S2> &op2) const {
return Base::V == op2.V;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator != ( const ap_int_base<_AP_W2,_AP_S2> &op2) const {
return !(Base::V == op2.V);
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator < ( const ap_int_base<_AP_W2,_AP_S2> &op2) const {
return Base::V < op2.V;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator >= ( const ap_int_base<_AP_W2,_AP_S2> &op2) const {
return Base::V >= op2.V;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator > ( const ap_int_base<_AP_W2,_AP_S2> &op2) const {
return Base::V > op2.V;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator <= ( const ap_int_base<_AP_W2,_AP_S2> &op2) const {
return Base::V <= op2.V;
}
inline __attribute__((always_inline)) ap_range_ref<_AP_W,_AP_S>
range (int Hi, int Lo) {
;
return ap_range_ref<_AP_W,_AP_S>(this, Hi, Lo);
}
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);
}
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);
}
inline __attribute__((always_inline)) ap_range_ref<_AP_W,_AP_S>
operator () (int Hi, int Lo) const {
return this->range(Hi, Lo);
}
#2099 "/opt/Xilinx/Vivado/2017.3/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;
}
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();
}
inline __attribute__((always_inline)) ap_bit_ref<_AP_W,_AP_S> bit (int index) {
;
;
ap_bit_ref<_AP_W,_AP_S> bvh( this, index );
return bvh;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_bit_ref<_AP_W,_AP_S> bit (const ap_int_base<_AP_W2,_AP_S2> &index) {
;
;
ap_bit_ref<_AP_W,_AP_S> bvh( this, index.to_int() );
return bvh;
}
inline __attribute__((always_inline)) bool bit (int index) const {
;
;
ap_bit_ref<_AP_W,_AP_S> br(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();
}
#2162 "/opt/Xilinx/Vivado/2017.3/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));
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<_AP_W,ap_int_base,_AP_W2,ap_int_base<_AP_W2,_AP_S2> > concat(ap_int_base<_AP_W2,_AP_S2>& a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2,_AP_S2> >(*this, a2);
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_range_ref<_AP_W2, _AP_S2> >
operator, (const ap_range_ref<_AP_W2, _AP_S2> &a2) const {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2,
ap_range_ref<_AP_W2, _AP_S2> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this),
const_cast< ap_range_ref<_AP_W2, _AP_S2>& >(a2));
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_range_ref<_AP_W2, _AP_S2> >
operator, (ap_range_ref<_AP_W2, _AP_S2> &a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2,
ap_range_ref<_AP_W2, _AP_S2> >(*this, a2);
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator, (const ap_int_base<_AP_W2, _AP_S2>& a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2,
_AP_S2> >(*this,
const_cast<ap_int_base<_AP_W2, _AP_S2>& >(a2));
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator, (ap_int_base<_AP_W2, _AP_S2>& a2) const {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2,
_AP_S2> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this),
a2);
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator, (const ap_int_base<_AP_W2, _AP_S2>& a2) const {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2,
_AP_S2> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this),
const_cast<ap_int_base<_AP_W2, _AP_S2>& >(a2));
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator, (ap_int_base<_AP_W2, _AP_S2>& a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >(*this, a2);
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, 1, ap_bit_ref<_AP_W2, _AP_S2> >
operator, (const ap_bit_ref<_AP_W2, _AP_S2> &a2) const {
return ap_concat_ref<_AP_W, ap_int_base, 1, ap_bit_ref<_AP_W2,
_AP_S2> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this), const_cast<ap_bit_ref<_AP_W2, _AP_S2>& >(a2));
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, 1, ap_bit_ref<_AP_W2, _AP_S2> >
operator, (ap_bit_ref<_AP_W2, _AP_S2> &a2) {
return ap_concat_ref<_AP_W, ap_int_base, 1, ap_bit_ref<_AP_W2,
_AP_S2> >(*this, a2);
}
template <int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2+_AP_W3, ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >
operator, (const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> &a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2+_AP_W3,
ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this),
const_cast<ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& >(a2));
}
template <int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2+_AP_W3, ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >
operator, (ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> &a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2+_AP_W3,
ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >(*this, a2);
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &a2) const {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, af_range_ref<_AP_W2,
_AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this),
const_cast<af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& >(a2));
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, af_range_ref<_AP_W2,
_AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(*this, a2);
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, 1, af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &a2) const {
return ap_concat_ref<_AP_W, ap_int_base, 1, af_bit_ref<_AP_W2,
_AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this),
const_cast<af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& >(a2));
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, 1, af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &a2) {
return ap_concat_ref<_AP_W, ap_int_base, 1, af_bit_ref<_AP_W2,
_AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(*this, a2);
}
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_int_base<((_AP_W2+_AP_W3) > (_AP_W) ? (_AP_W2+_AP_W3) : (_AP_W)), _AP_S>
operator & (const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& a2) {
return *this & a2.get();
}
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_int_base<((_AP_W2+_AP_W3) > (_AP_W) ? (_AP_W2+_AP_W3) : (_AP_W)), _AP_S>
operator | (const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& a2) {
return *this | a2.get();
}
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_int_base<((_AP_W2+_AP_W3) > (_AP_W) ? (_AP_W2+_AP_W3) : (_AP_W)), _AP_S>
operator ^ (const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& a2) {
return *this ^ a2.get();
}
template <int _AP_W3>
inline __attribute__((always_inline)) void set(const ap_int_base<_AP_W3, false>& val) {
Base::V = val.V;
}
inline __attribute__((always_inline)) bool and_reduce() {
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__)); }));
}
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__)); }));
}
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 == SC_OCT || mode == SC_DEC) {
#2383 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_int_syn.h"
;
} else {
;
}
}
inline __attribute__((always_inline)) char* to_string(BaseMode mode, bool sign=false) const {
return 0;
}
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> {
public:
typedef ssdm_int<_AP_W, _AP_S> Base;
typedef typename retval<8, _AP_S>::Type RetType;
static const int width = _AP_W;
template<int _AP_W2, bool _AP_S2>
struct RType {
enum {
mult_w = _AP_W+_AP_W2,
mult_s = _AP_S||_AP_S2,
plus_w = ((_AP_W+(_AP_S2&&!_AP_S)) > (_AP_W2+(_AP_S&&!_AP_S2)) ? (_AP_W+(_AP_S2&&!_AP_S)) : (_AP_W2+(_AP_S&&!_AP_S2)))+1,
plus_s = _AP_S||_AP_S2,
minus_w = ((_AP_W+(_AP_S2&&!_AP_S)) > (_AP_W2+(_AP_S&&!_AP_S2)) ? (_AP_W+(_AP_S2&&!_AP_S)) : (_AP_W2+(_AP_S&&!_AP_S2)))+1,
minus_s = true,
div_w = _AP_W+_AP_S2,
div_s = _AP_S||_AP_S2,
mod_w = ((_AP_W) < (_AP_W2+(!_AP_S2&&_AP_S)) ? (_AP_W) : (_AP_W2+(!_AP_S2&&_AP_S))),
mod_s = _AP_S,
logic_w = ((_AP_W+(_AP_S2&&!_AP_S)) > (_AP_W2+(_AP_S&&!_AP_S2)) ? (_AP_W+(_AP_S2&&!_AP_S)) : (_AP_W2+(_AP_S&&!_AP_S2))),
logic_s = _AP_S||_AP_S2
};
typedef ap_int_base<mult_w, mult_s> mult;
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;
};
inline __attribute__((always_inline)) ap_int_base() {
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base(const ap_int_base<_AP_W2,_AP_S2> &op) { Base::V = op.V; }
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base(const volatile ap_int_base<_AP_W2,_AP_S2> &op) { Base::V = op.V; }
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(half 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; }
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_int_base(const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2>& op) {
Base::V = op.to_ap_int_base().V;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base(const ap_range_ref<_AP_W2,_AP_S2>& ref) {
Base::V = ref.operator ap_int_base<_AP_W2, false>().V;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base(const ap_bit_ref<_AP_W2,_AP_S2>& ref) {
Base::V = ref.operator bool();
}
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_int_base(const ap_concat_ref<_AP_W2,_AP_T2,_AP_W3,_AP_T3>& ref) {
const ap_int_base<ap_concat_ref<_AP_W2,_AP_T2,_AP_W3,_AP_T3>::_AP_WR,false> tmp = ref.get();
Base::V = tmp.V;
}
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;
}
inline __attribute__((always_inline)) ap_int_base(const char* str, signed char radix) {_ssdm_SpecConstant(&width);
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;
}
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;
}
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_int_base(const af_bit_ref<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2> &val) {
Base::V = val.operator bool ();
}
inline __attribute__((always_inline)) ap_int_base read() volatile {
;
ap_int_base ret;
ret.V = Base::V;
return ret;
}
inline __attribute__((always_inline)) void write(const ap_int_base<_AP_W, _AP_S>& op2) volatile {
;
Base::V = op2.V;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) void operator = (const volatile ap_int_base<_AP_W2,_AP_S2>& op2) volatile {
Base::V = op2.V;
}
inline __attribute__((always_inline)) void operator = (const volatile ap_int_base<_AP_W, _AP_S>& op2) volatile {
Base::V = op2.V;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) void operator = (const ap_int_base<_AP_W2,_AP_S2>& op2) volatile {
Base::V = op2.V;
}
inline __attribute__((always_inline)) void operator = (const ap_int_base<_AP_W, _AP_S>& op2) volatile {
Base::V = op2.V;
}
#2564 "/opt/Xilinx/Vivado/2017.3/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;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base& operator = (const ap_int_base<_AP_W2,_AP_S2>& op2) {
Base::V = op2.V;
return *this;
}
inline __attribute__((always_inline)) ap_int_base& operator = (const volatile ap_int_base<_AP_W,_AP_S>& op2) {
Base::V = op2.V;
return *this;
}
inline __attribute__((always_inline)) ap_int_base& operator = (const ap_int_base<_AP_W,_AP_S>& op2) {
Base::V = op2.V;
return *this;
}
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;
}
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;
}
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; }
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base& operator = (const ap_bit_ref<_AP_W2, _AP_S2>& op2) {
Base::V = (bool) op2;
return *this;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base& operator = (const ap_range_ref<_AP_W2, _AP_S2>& op2) {
Base::V = (ap_int_base<_AP_W2, false>(op2)).V;
return *this;
}
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_int_base& operator = (const ap_concat_ref<_AP_W2,_AP_T2,_AP_W3,_AP_T3>& op2) {
Base::V = op2.get().V;
return *this;
}
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_int_base& operator = (const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
Base::V = op.to_ap_int_base().V;
return *this;
}
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_int_base& operator = (const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
Base::V = (bool) op;
return *this;
}
template<int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_int_base& operator = (const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
Base::V = ((const ap_int_base<_AP_W2, false>)(op)).V;
return *this;
}
inline __attribute__((always_inline)) operator RetType() const { return (RetType)(Base::V); }
inline __attribute__((always_inline)) bool to_bool() const {return (bool)(Base::V);}
inline __attribute__((always_inline)) 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); }
#2683 "/opt/Xilinx/Vivado/2017.3/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; }
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;
}
inline __attribute__((always_inline)) bool iszero () const {
return Base::V == 0 ;
}
inline __attribute__((always_inline)) bool is_zero () const {
return Base::V == 0 ;
}
inline __attribute__((always_inline)) bool sign () const {
if (_AP_S && ({ typeof(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;
}
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__; });
}
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__; });
}
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); });
}
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__; });
}
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__; });
}
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;
}
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;
}
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__; });
}
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); });
}
inline __attribute__((always_inline)) void b_not() {
Base::V = ~Base::V;
}
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;
}
}
#2820 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_int_syn.h"
template<int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator *= ( const ap_int_base<_AP_W2,_AP_S2> &op2) { ; Base::V *= op2.V; return *this; }
template<int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator += ( const ap_int_base<_AP_W2,_AP_S2> &op2) { ; Base::V += op2.V; return *this; }
template<int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator -= ( const ap_int_base<_AP_W2,_AP_S2> &op2) { ; Base::V -= op2.V; return *this; }
template<int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator /= ( const ap_int_base<_AP_W2,_AP_S2> &op2) { ; Base::V /= op2.V; return *this; }
template<int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator %= ( const ap_int_base<_AP_W2,_AP_S2> &op2) { ; Base::V %= op2.V; return *this; }
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; }
inline __attribute__((always_inline)) ap_int_base& operator ++() {
operator+=((ap_int_base<1,false>) 1);
return *this;
}
inline __attribute__((always_inline)) ap_int_base& operator --() {
operator-=((ap_int_base<1,false>) 1);
return *this;
}
inline __attribute__((always_inline)) const 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;
}
inline __attribute__((always_inline)) ap_int_base operator +() const{
return *this;
}
inline __attribute__((always_inline)) typename RType<1,false>::minus operator -() const {
return ((ap_int_base<1,false>) 0) - *this;
}
inline __attribute__((always_inline)) bool operator ! () const {
return Base::V == 0;
}
inline __attribute__((always_inline)) 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;
}
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;
}
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>());
}
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;
}
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>());
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator == ( const ap_int_base<_AP_W2,_AP_S2> &op2) const {
return Base::V == op2.V;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator != ( const ap_int_base<_AP_W2,_AP_S2> &op2) const {
return !(Base::V == op2.V);
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator < ( const ap_int_base<_AP_W2,_AP_S2> &op2) const {
return Base::V < op2.V;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator >= ( const ap_int_base<_AP_W2,_AP_S2> &op2) const {
return Base::V >= op2.V;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator > ( const ap_int_base<_AP_W2,_AP_S2> &op2) const {
return Base::V > op2.V;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator <= ( const ap_int_base<_AP_W2,_AP_S2> &op2) const {
return Base::V <= op2.V;
}
inline __attribute__((always_inline)) ap_range_ref<_AP_W,_AP_S>
range (int Hi, int Lo) {
;
return ap_range_ref<_AP_W,_AP_S>(this, Hi, Lo);
}
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);
}
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);
}
inline __attribute__((always_inline)) ap_range_ref<_AP_W,_AP_S>
operator () (int Hi, int Lo) const {
return this->range(Hi, Lo);
}
#3046 "/opt/Xilinx/Vivado/2017.3/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;
}
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();
}
inline __attribute__((always_inline)) ap_bit_ref<_AP_W,_AP_S> bit (int index) {
;
;
ap_bit_ref<_AP_W,_AP_S> bvh( this, index );
return bvh;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_bit_ref<_AP_W,_AP_S> bit (const ap_int_base<_AP_W2,_AP_S2> &index) {
;
;
ap_bit_ref<_AP_W,_AP_S> bvh( this, index.to_int() );
return bvh;
}
inline __attribute__((always_inline)) bool bit (int index) const {
;
;
ap_bit_ref<_AP_W,_AP_S> br(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();
}
#3109 "/opt/Xilinx/Vivado/2017.3/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));
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<_AP_W,ap_int_base,_AP_W2,ap_int_base<_AP_W2,_AP_S2> > concat(ap_int_base<_AP_W2,_AP_S2>& a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2,_AP_S2> >(*this, a2);
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_range_ref<_AP_W2, _AP_S2> >
operator, (const ap_range_ref<_AP_W2, _AP_S2> &a2) const {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2,
ap_range_ref<_AP_W2, _AP_S2> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this),
const_cast< ap_range_ref<_AP_W2, _AP_S2>& >(a2));
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_range_ref<_AP_W2, _AP_S2> >
operator, (ap_range_ref<_AP_W2, _AP_S2> &a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2,
ap_range_ref<_AP_W2, _AP_S2> >(*this, a2);
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator, (const ap_int_base<_AP_W2, _AP_S2>& a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2,
_AP_S2> >(*this,
const_cast<ap_int_base<_AP_W2, _AP_S2>& >(a2));
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator, (ap_int_base<_AP_W2, _AP_S2>& a2) const {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2,
_AP_S2> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this),
a2);
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator, (const ap_int_base<_AP_W2, _AP_S2>& a2) const {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2,
_AP_S2> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this),
const_cast<ap_int_base<_AP_W2, _AP_S2>& >(a2));
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator, (ap_int_base<_AP_W2, _AP_S2>& a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >(*this, a2);
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, 1, ap_bit_ref<_AP_W2, _AP_S2> >
operator, (const ap_bit_ref<_AP_W2, _AP_S2> &a2) const {
return ap_concat_ref<_AP_W, ap_int_base, 1, ap_bit_ref<_AP_W2,
_AP_S2> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this), const_cast<ap_bit_ref<_AP_W2, _AP_S2>& >(a2));
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, 1, ap_bit_ref<_AP_W2, _AP_S2> >
operator, (ap_bit_ref<_AP_W2, _AP_S2> &a2) {
return ap_concat_ref<_AP_W, ap_int_base, 1, ap_bit_ref<_AP_W2,
_AP_S2> >(*this, a2);
}
template <int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2+_AP_W3, ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >
operator, (const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> &a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2+_AP_W3,
ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this),
const_cast<ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& >(a2));
}
template <int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2+_AP_W3, ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >
operator, (ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> &a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2+_AP_W3,
ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >(*this, a2);
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &a2) const {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, af_range_ref<_AP_W2,
_AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this),
const_cast<af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& >(a2));
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2, af_range_ref<_AP_W2,
_AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(*this, a2);
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, 1, af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &a2) const {
return ap_concat_ref<_AP_W, ap_int_base, 1, af_bit_ref<_AP_W2,
_AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(const_cast<ap_int_base<_AP_W, _AP_S>& >(*this),
const_cast<af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& >(a2));
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, 1, af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &a2) {
return ap_concat_ref<_AP_W, ap_int_base, 1, af_bit_ref<_AP_W2,
_AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(*this, a2);
}
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_int_base<((_AP_W2+_AP_W3) > (_AP_W) ? (_AP_W2+_AP_W3) : (_AP_W)), _AP_S>
operator & (const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& a2) {
return *this & a2.get();
}
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_int_base<((_AP_W2+_AP_W3) > (_AP_W) ? (_AP_W2+_AP_W3) : (_AP_W)), _AP_S>
operator | (const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& a2) {
return *this | a2.get();
}
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_int_base<((_AP_W2+_AP_W3) > (_AP_W) ? (_AP_W2+_AP_W3) : (_AP_W)), _AP_S>
operator ^ (const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& a2) {
return *this ^ a2.get();
}
template <int _AP_W3>
inline __attribute__((always_inline)) void set(const ap_int_base<_AP_W3, false>& val) {
Base::V = val.V;
}
inline __attribute__((always_inline)) bool and_reduce() {
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__)); }));
}
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__)); }));
}
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 == SC_OCT || mode == SC_DEC) {
#3330 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_int_syn.h"
;
} else {
;
}
}
inline __attribute__((always_inline)) char* to_string(BaseMode mode, bool sign=false) const {
return 0;
}
inline __attribute__((always_inline)) char* to_string(signed char mode, bool sign=false) const {
return to_string(BaseMode(mode), sign);
}
};
#3354 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_int_syn.h"
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) {
return os;
}
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) {
return in;
}
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) {
return os;
}
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) {
return in;
}
#3423 "/opt/Xilinx/Vivado/2017.3/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; }
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; }
#3458 "/opt/Xilinx/Vivado/2017.3/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; }
#3483 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_int_syn.h"
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) half operator * (half i_op, const ap_int_base<_AP_W,_AP_S> &op) { typename ap_int_base<_AP_W,_AP_S>::RetType op2 = op; return i_op * op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) half operator * (const ap_int_base<_AP_W,_AP_S> &op, half i_op) { typename ap_int_base<_AP_W,_AP_S>::RetType op2 = op; return i_op * op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) half operator / (half i_op, const ap_int_base<_AP_W,_AP_S> &op) { typename ap_int_base<_AP_W,_AP_S>::RetType op2 = op; return i_op / op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) half operator / (const ap_int_base<_AP_W,_AP_S> &op, half i_op) { typename ap_int_base<_AP_W,_AP_S>::RetType op2 = op; return i_op / op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) half operator + (half i_op, const ap_int_base<_AP_W,_AP_S> &op) { typename ap_int_base<_AP_W,_AP_S>::RetType op2 = op; return i_op + op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) half operator + (const ap_int_base<_AP_W,_AP_S> &op, half i_op) { typename ap_int_base<_AP_W,_AP_S>::RetType op2 = op; return i_op + op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) half operator - (half i_op, const ap_int_base<_AP_W,_AP_S> &op) { typename ap_int_base<_AP_W,_AP_S>::RetType op2 = op; return i_op - op2; } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) half operator - (const ap_int_base<_AP_W,_AP_S> &op, half i_op) { typename ap_int_base<_AP_W,_AP_S>::RetType op2 = op; return 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)) 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; }
#3517 "/opt/Xilinx/Vivado/2017.3/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)) typename ap_int_base<_AP_W,_AP_S>::template RType<1,false>::logic operator | (bool i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<1,false>(i_op) | (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<1,false>::logic operator | ( const ap_int_base<_AP_W,_AP_S> &op, bool i_op) { return op | ap_int_base<1,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<1,false>::logic operator ^ (bool i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<1,false>(i_op) ^ (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<1,false>::logic operator ^ ( const ap_int_base<_AP_W,_AP_S> &op, bool i_op) { return op ^ ap_int_base<1,false>(i_op); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,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)) 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)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::mult operator * (signed char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(i_op) * (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::mult operator * ( const ap_int_base<_AP_W,_AP_S> &op, signed char i_op) { return op * ap_int_base<8,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::plus operator + (signed char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(i_op) + (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::plus operator + ( const ap_int_base<_AP_W,_AP_S> &op, signed char i_op) { return op + ap_int_base<8,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::minus operator - (signed char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(i_op) - (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::minus operator - ( const ap_int_base<_AP_W,_AP_S> &op, signed char i_op) { return op - ap_int_base<8,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::div operator / (signed char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(i_op) / (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::div operator / ( const ap_int_base<_AP_W,_AP_S> &op, signed char i_op) { return op / ap_int_base<8,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::mod operator % (signed char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(i_op) % (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::mod operator % ( const ap_int_base<_AP_W,_AP_S> &op, signed char i_op) { return op % ap_int_base<8,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::logic operator & (signed char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(i_op) & (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::logic operator & ( const ap_int_base<_AP_W,_AP_S> &op, signed char i_op) { return op & ap_int_base<8,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::logic operator | (signed char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(i_op) | (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::logic operator | ( const ap_int_base<_AP_W,_AP_S> &op, signed char i_op) { return op | ap_int_base<8,true>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::logic operator ^ (signed char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(i_op) ^ (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,true>::logic operator ^ ( const ap_int_base<_AP_W,_AP_S> &op, signed char i_op) { return op ^ ap_int_base<8,true>(i_op); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::mult operator * (unsigned char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(i_op) * (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::mult operator * ( const ap_int_base<_AP_W,_AP_S> &op, unsigned char i_op) { return op * ap_int_base<8,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::plus operator + (unsigned char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(i_op) + (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::plus operator + ( const ap_int_base<_AP_W,_AP_S> &op, unsigned char i_op) { return op + ap_int_base<8,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::minus operator - (unsigned char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(i_op) - (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::minus operator - ( const ap_int_base<_AP_W,_AP_S> &op, unsigned char i_op) { return op - ap_int_base<8,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::div operator / (unsigned char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(i_op) / (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::div operator / ( const ap_int_base<_AP_W,_AP_S> &op, unsigned char i_op) { return op / ap_int_base<8,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::mod operator % (unsigned char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(i_op) % (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::mod operator % ( const ap_int_base<_AP_W,_AP_S> &op, unsigned char i_op) { return op % ap_int_base<8,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::logic operator & (unsigned char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(i_op) & (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::logic operator & ( const ap_int_base<_AP_W,_AP_S> &op, unsigned char i_op) { return op & ap_int_base<8,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::logic operator | (unsigned char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(i_op) | (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::logic operator | ( const ap_int_base<_AP_W,_AP_S> &op, unsigned char i_op) { return op | ap_int_base<8,false>(i_op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::logic operator ^ (unsigned char i_op, const ap_int_base<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(i_op) ^ (op); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<8,false>::logic operator ^ ( const ap_int_base<_AP_W,_AP_S> &op, unsigned char i_op) { return op ^ ap_int_base<8,false>(i_op); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,_AP_S>::template RType<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)) 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)) 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)) 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)) 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)) 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)) 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)) 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)) 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)) 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)) 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)) 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)) 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)) 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)) 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)) 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); }
#3553 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_int_syn.h"
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator == ( bool i_op, const ap_int_base<_AP_W,_AP_S, 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)) 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)) 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)) 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)) 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)) 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)) 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)) 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)) 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)) 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)) 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)) 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)); }
#3589 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_int_syn.h"
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W,_AP_S> &operator += ( ap_int_base<_AP_W,_AP_S> &op, bool op2) { return op.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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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_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)); }
#3629 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_int_syn.h"
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)) 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)) 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)) 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)) 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)) 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)) 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)) 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)) 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)) 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)) 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)) 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; }
#3683 "/opt/Xilinx/Vivado/2017.3/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; }
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>()); }
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)); }
#3739 "/opt/Xilinx/Vivado/2017.3/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; }
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)); }
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)); }
#3793 "/opt/Xilinx/Vivado/2017.3/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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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)); }
#3853 "/opt/Xilinx/Vivado/2017.3/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<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,true>::plus operator + ( const ap_range_ref<_AP_W,_AP_S> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)) + (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,true>::template RType<_AP_W,false>::plus operator + ( signed char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(op2) + (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,true>::minus operator - ( const ap_range_ref<_AP_W,_AP_S> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)) - (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,true>::template RType<_AP_W,false>::minus operator - ( signed char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(op2) - (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,true>::mult operator * ( const ap_range_ref<_AP_W,_AP_S> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)) * (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,true>::template RType<_AP_W,false>::mult operator * ( signed char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(op2) * (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,true>::div operator / ( const ap_range_ref<_AP_W,_AP_S> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)) / (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,true>::template RType<_AP_W,false>::div operator / ( signed char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(op2) / (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,true>::mod operator % ( const ap_range_ref<_AP_W,_AP_S> &op, signed char op2) { return (ap_int_base<_AP_W, false>(op)) % (ap_int_base<8,true>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,true>::template RType<_AP_W,false>::mod operator % ( signed char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,true>(op2) % (ap_int_base<_AP_W, false>(op)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,false>::plus operator + ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)) + (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,false>::template RType<_AP_W,false>::plus operator + ( unsigned char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(op2) + (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,false>::minus operator - ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)) - (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,false>::template RType<_AP_W,false>::minus operator - ( unsigned char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(op2) - (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,false>::mult operator * ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)) * (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,false>::template RType<_AP_W,false>::mult operator * ( unsigned char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(op2) * (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,false>::div operator / ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)) / (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,false>::template RType<_AP_W,false>::div operator / ( unsigned char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(op2) / (ap_int_base<_AP_W, false>(op)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<8,false>::mod operator % ( const ap_range_ref<_AP_W,_AP_S> &op, unsigned char op2) { return (ap_int_base<_AP_W, false>(op)) % (ap_int_base<8,false>(op2)); } template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<8,false>::template RType<_AP_W,false>::mod operator % ( unsigned char op2, const ap_range_ref<_AP_W,_AP_S> &op) { return ap_int_base<8,false>(op2) % (ap_int_base<_AP_W, false>(op)); }
template<int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W,false>::template RType<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,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<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,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<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,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,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,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)); }
#3878 "/opt/Xilinx/Vivado/2017.3/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>::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>::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>::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>::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>::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>::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>::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>::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)); }
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>::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)); }
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>::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)); }
#3903 "/opt/Xilinx/Vivado/2017.3/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)); }
#3948 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_int_syn.h"
template<int _AP_LW1,typename _AP_LT1,int _AP_LW2,typename _AP_LT2, int _AP_RW1,typename _AP_RT1,int _AP_RW2,typename _AP_RT2> inline __attribute__((always_inline)) typename ap_int_base<_AP_LW1+_AP_LW2,false>::template RType<_AP_RW1+_AP_RW2,false>::plus operator + (const ap_concat_ref<_AP_LW1,_AP_LT1,_AP_LW2,_AP_LT2>& lhs, const ap_concat_ref<_AP_RW1,_AP_RT1,_AP_RW2,_AP_RT2>& rhs) { return lhs.get() + rhs.get(); }
template<int _AP_LW1,typename _AP_LT1,int _AP_LW2,typename _AP_LT2, int _AP_RW1,typename _AP_RT1,int _AP_RW2,typename _AP_RT2> inline __attribute__((always_inline)) typename ap_int_base<_AP_LW1+_AP_LW2,false>::template RType<_AP_RW1+_AP_RW2,false>::minus operator - (const ap_concat_ref<_AP_LW1,_AP_LT1,_AP_LW2,_AP_LT2>& lhs, const ap_concat_ref<_AP_RW1,_AP_RT1,_AP_RW2,_AP_RT2>& rhs) { return lhs.get() - rhs.get(); }
template<int _AP_LW1,typename _AP_LT1,int _AP_LW2,typename _AP_LT2, int _AP_RW1,typename _AP_RT1,int _AP_RW2,typename _AP_RT2> inline __attribute__((always_inline)) typename ap_int_base<_AP_LW1+_AP_LW2,false>::template RType<_AP_RW1+_AP_RW2,false>::mult operator * (const ap_concat_ref<_AP_LW1,_AP_LT1,_AP_LW2,_AP_LT2>& lhs, const ap_concat_ref<_AP_RW1,_AP_RT1,_AP_RW2,_AP_RT2>& rhs) { return lhs.get() * rhs.get(); }
template<int _AP_LW1,typename _AP_LT1,int _AP_LW2,typename _AP_LT2, int _AP_RW1,typename _AP_RT1,int _AP_RW2,typename _AP_RT2> inline __attribute__((always_inline)) typename ap_int_base<_AP_LW1+_AP_LW2,false>::template RType<_AP_RW1+_AP_RW2,false>::div operator / (const ap_concat_ref<_AP_LW1,_AP_LT1,_AP_LW2,_AP_LT2>& lhs, const ap_concat_ref<_AP_RW1,_AP_RT1,_AP_RW2,_AP_RT2>& rhs) { return lhs.get() / rhs.get(); }
template<int _AP_LW1,typename _AP_LT1,int _AP_LW2,typename _AP_LT2, int _AP_RW1,typename _AP_RT1,int _AP_RW2,typename _AP_RT2> inline __attribute__((always_inline)) typename ap_int_base<_AP_LW1+_AP_LW2,false>::template RType<_AP_RW1+_AP_RW2,false>::mod operator % (const ap_concat_ref<_AP_LW1,_AP_LT1,_AP_LW2,_AP_LT2>& lhs, const ap_concat_ref<_AP_RW1,_AP_RT1,_AP_RW2,_AP_RT2>& rhs) { return lhs.get() % rhs.get(); }
template<int _AP_LW1,typename _AP_LT1,int _AP_LW2,typename _AP_LT2, int _AP_RW1,typename _AP_RT1,int _AP_RW2,typename _AP_RT2> inline __attribute__((always_inline)) typename ap_int_base<_AP_LW1+_AP_LW2,false>::template RType<_AP_RW1+_AP_RW2,false>::arg1 operator >> (const ap_concat_ref<_AP_LW1,_AP_LT1,_AP_LW2,_AP_LT2>& lhs, const ap_concat_ref<_AP_RW1,_AP_RT1,_AP_RW2,_AP_RT2>& rhs) { return lhs.get() >> rhs.get(); }
template<int _AP_LW1,typename _AP_LT1,int _AP_LW2,typename _AP_LT2, int _AP_RW1,typename _AP_RT1,int _AP_RW2,typename _AP_RT2> inline __attribute__((always_inline)) typename ap_int_base<_AP_LW1+_AP_LW2,false>::template RType<_AP_RW1+_AP_RW2,false>::arg1 operator << (const ap_concat_ref<_AP_LW1,_AP_LT1,_AP_LW2,_AP_LT2>& lhs, const ap_concat_ref<_AP_RW1,_AP_RT1,_AP_RW2,_AP_RT2>& rhs) { return lhs.get() << rhs.get(); }
template<int _AP_LW1,typename _AP_LT1,int _AP_LW2,typename _AP_LT2, int _AP_RW1,typename _AP_RT1,int _AP_RW2,typename _AP_RT2> inline __attribute__((always_inline)) typename ap_int_base<_AP_LW1+_AP_LW2,false>::template RType<_AP_RW1+_AP_RW2,false>::logic operator & (const ap_concat_ref<_AP_LW1,_AP_LT1,_AP_LW2,_AP_LT2>& lhs, const ap_concat_ref<_AP_RW1,_AP_RT1,_AP_RW2,_AP_RT2>& rhs) { return lhs.get() & rhs.get(); }
template<int _AP_LW1,typename _AP_LT1,int _AP_LW2,typename _AP_LT2, int _AP_RW1,typename _AP_RT1,int _AP_RW2,typename _AP_RT2> inline __attribute__((always_inline)) typename ap_int_base<_AP_LW1+_AP_LW2,false>::template RType<_AP_RW1+_AP_RW2,false>::logic operator | (const ap_concat_ref<_AP_LW1,_AP_LT1,_AP_LW2,_AP_LT2>& lhs, const ap_concat_ref<_AP_RW1,_AP_RT1,_AP_RW2,_AP_RT2>& rhs) { return lhs.get() | rhs.get(); }
template<int _AP_LW1,typename _AP_LT1,int _AP_LW2,typename _AP_LT2, int _AP_RW1,typename _AP_RT1,int _AP_RW2,typename _AP_RT2> inline __attribute__((always_inline)) typename ap_int_base<_AP_LW1+_AP_LW2,false>::template RType<_AP_RW1+_AP_RW2,false>::logic operator ^ (const ap_concat_ref<_AP_LW1,_AP_LT1,_AP_LW2,_AP_LT2>& lhs, const ap_concat_ref<_AP_RW1,_AP_RT1,_AP_RW2,_AP_RT2>& rhs) { return lhs.get() ^ rhs.get(); }
#4103 "/opt/Xilinx/Vivado/2017.3/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; }
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; }
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; }
#4129 "/opt/Xilinx/Vivado/2017.3/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); }
#62 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/ap_sc_dt.h" 2
#1 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_fixed_syn.h" 1
#87 "/opt/Xilinx/Vivado/2017.3/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>
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_bit_ref {
ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& d_bv;
int d_index;
public:
inline __attribute__((always_inline)) af_bit_ref(const af_bit_ref<_AP_W,_AP_I,_AP_S,
_AP_Q,_AP_O,_AP_N>&ref):
d_bv(ref.d_bv), d_index(ref.d_index) {}
inline __attribute__((always_inline)) af_bit_ref(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); }); }
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;
}
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());
}
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);
}
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);
}
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);
}
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));
}
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));
}
template<int _AP_W2, int _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<1, af_bit_ref, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator, (ap_int_base<_AP_W2, _AP_S2>& op) {
return ap_concat_ref<1, af_bit_ref, _AP_W2,
ap_int_base<_AP_W2, _AP_S2> >(*this, op);
}
template<int _AP_W2, int _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<1, af_bit_ref, 1, ap_bit_ref<_AP_W2, _AP_S2> >
operator, (const ap_bit_ref<_AP_W2, _AP_S2> &op) {
return ap_concat_ref<1, af_bit_ref, 1,
ap_bit_ref<_AP_W2, _AP_S2> >(*this,
const_cast<ap_bit_ref<_AP_W2, _AP_S2>& >(op));
}
template<int _AP_W2, int _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<1, af_bit_ref, _AP_W2, ap_range_ref<_AP_W2, _AP_S2> >
operator, (const ap_range_ref<_AP_W2, _AP_S2> &op) {
return ap_concat_ref<1, af_bit_ref, _AP_W2,
ap_range_ref<_AP_W2, _AP_S2> >(*this,
const_cast< ap_range_ref<_AP_W2, _AP_S2>& >(op));
}
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_concat_ref<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));
}
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));
}
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_concat_ref<1, af_bit_ref, 1,
af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &op) {
return ap_concat_ref<1, af_bit_ref, 1,
af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(*this,
const_cast<af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2>& >(op));
}
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) bool operator == (const af_bit_ref<_AP_W2, _AP_I2,
_AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
return get() == op.get();
}
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) bool operator != (const af_bit_ref<_AP_W2, _AP_I2,
_AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
return get() != op.get();
}
inline __attribute__((always_inline)) bool 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); });
}
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;
}
inline __attribute__((always_inline)) int length() const {
return 1;
}
};
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;
public:
inline __attribute__((always_inline)) af_range_ref(const af_range_ref<_AP_W,_AP_I,_AP_S,
_AP_Q,_AP_O, _AP_N>&ref):
d_bv(ref.d_bv), l_index(ref.l_index), h_index(ref.h_index) {}
inline __attribute__((always_inline)) af_range_ref(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) {
}
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;
}
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();
}
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; }
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;
}
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;
}
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) af_range_ref& operator= (const af_range_ref<_AP_W2,
_AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& val) {
ap_int_base<_AP_W2, false> tmp(val);
return operator=(tmp);
}
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) af_range_ref& operator= (const ap_fixed_base<_AP_W2,
_AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& val) {
return operator=(val.to_ap_int_base());
}
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);
}
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);
}
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));
}
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));
}
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));
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator == (const ap_range_ref<_AP_W2, _AP_S2>& op2) {
ap_int_base<_AP_W, false> lop (*this);
ap_int_base<_AP_W2, false> rop (op2);
return lop == rop;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator != (const ap_range_ref<_AP_W2, _AP_S2>& op2) {
return !(operator == (op2));
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator < (const ap_range_ref<_AP_W2, _AP_S2>& op2) {
ap_int_base<_AP_W, false> lop(*this);
ap_int_base<_AP_W2, false> rop(op2);
return lop < rop;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator <= (const ap_range_ref<_AP_W2, _AP_S2>& op2) {
ap_int_base<_AP_W, false> lop(*this);
ap_int_base<_AP_W2, false> rop(op2);
return lop <= rop;
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator > (const ap_range_ref<_AP_W2, _AP_S2>& op2) {
return !(operator <= (op2));
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator >= (const ap_range_ref<_AP_W2, _AP_S2>& op2) {
return !(operator < (op2));
}
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) bool operator == (const af_range_ref<_AP_W2, _AP_I2,
_AP_S2,_AP_Q2, _AP_O2, _AP_N2>& op2) {
ap_int_base<_AP_W, false> lop (*this);
ap_int_base<_AP_W2, false> rop (op2);
return lop == rop;
}
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) bool operator != (const af_range_ref<_AP_W2, _AP_I2,
_AP_S2,_AP_Q2, _AP_O2, _AP_N2>& op2) {
return !(operator == (op2));
}
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) bool operator < (const af_range_ref<_AP_W2, _AP_I2,
_AP_S2,_AP_Q2, _AP_O2, _AP_N2>& op2) {
ap_int_base<_AP_W, false> lop (*this);
ap_int_base<_AP_W2, false> rop (op2);
return lop < rop;
}
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) bool operator <= (const af_range_ref<_AP_W2, _AP_I2,
_AP_S2,_AP_Q2, _AP_O2, _AP_N2>& op2) {
ap_int_base<_AP_W, false> lop( *this);
ap_int_base<_AP_W2, false> rop (op2);
return lop <= rop;
}
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) bool operator > (const af_range_ref<_AP_W2, _AP_I2,
_AP_S2,_AP_Q2, _AP_O2, _AP_N2>& op2) {
return !(operator <= (op2));
}
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) bool operator >= (const af_range_ref<_AP_W2, _AP_I2,
_AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op2) {
return !(operator < (op2));
}
template <int _AP_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__; });
}
template<int _AP_W2, int _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<_AP_W, af_range_ref, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator, (ap_int_base<_AP_W2, _AP_S2>& op) {
return ap_concat_ref<_AP_W, af_range_ref, _AP_W2,
ap_int_base<_AP_W2, _AP_S2> >(*this, op);
}
template<int _AP_W2, int _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<_AP_W, af_range_ref, 1, ap_bit_ref<_AP_W2, _AP_S2> >
operator, (const ap_bit_ref<_AP_W2, _AP_S2> &op) {
return ap_concat_ref<_AP_W, af_range_ref, 1,
ap_bit_ref<_AP_W2, _AP_S2> >(*this,
const_cast<ap_bit_ref<_AP_W2, _AP_S2>& >(op));
}
template<int _AP_W2, int _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<_AP_W, af_range_ref, _AP_W2, ap_range_ref<_AP_W2, _AP_S2> >
operator, (const ap_range_ref<_AP_W2, _AP_S2> &op) {
return ap_concat_ref<_AP_W, af_range_ref, _AP_W2,
ap_range_ref<_AP_W2, _AP_S2> >(*this,
const_cast<ap_range_ref<_AP_W2, _AP_S2>& >(op));
}
template<int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_concat_ref<_AP_W, af_range_ref, _AP_W2 + _AP_W3,
ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >
operator, (const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& op) {
return ap_concat_ref<_AP_W, af_range_ref, _AP_W2 + _AP_W3,
ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >(*this,
const_cast<ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& >(op));
}
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_concat_ref<_AP_W, af_range_ref, _AP_W2,
af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &op) {
return ap_concat_ref<_AP_W, af_range_ref, _AP_W2,
af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(*this,
const_cast<af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2>& >(op));
}
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_concat_ref<_AP_W, af_range_ref, 1,
af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator, (const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2> &op) {
return ap_concat_ref<_AP_W, af_range_ref, 1,
af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(*this,
const_cast<af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2>& >(op));
}
inline __attribute__((always_inline)) int length() const {
return h_index >= l_index ? h_index - l_index + 1 : l_index - h_index + 1;
}
inline __attribute__((always_inline)) int to_int() const {
return (int)(({ 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__; }));
}
};
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> {
public:
typedef ssdm_int<_AP_W, _AP_S> Base;
static const int width = _AP_W;
static const int iwidth = _AP_I;
static const ap_q_mode qmode = _AP_Q;
static const ap_o_mode omode = _AP_O;
void overflow_adjust(bool underflow, bool overflow,bool lD, bool sign) {
_ssdm_InlineSelf(0, "");
if (!underflow && !overflow) return;
if (_AP_O==SC_WRAP) {
if (_AP_N == 0)
return;
if (_AP_S) {
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) {
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__; });
}
} else {
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__; });
}
} 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__; });
}
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__; });
}
} 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;
}
}
}
bool quantization_adjust(bool qb, bool r, bool s) {
_ssdm_InlineSelf(0, "");
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 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); }));
}
template<int _AP_W2, int _AP_I2, bool _AP_S2>
struct RType {
enum {
_AP_F=_AP_W-_AP_I,
F2=_AP_W2-_AP_I2,
mult_w = _AP_W+_AP_W2,
mult_i = _AP_I+_AP_I2,
mult_s = _AP_S||_AP_S2,
plus_w = ((_AP_I+(_AP_S2&&!_AP_S)) > (_AP_I2+(_AP_S&&!_AP_S2)) ? (_AP_I+(_AP_S2&&!_AP_S)) : (_AP_I2+(_AP_S&&!_AP_S2)))+1+((_AP_F) > (F2) ? (_AP_F) : (F2)),
plus_i = ((_AP_I+(_AP_S2&&!_AP_S)) > (_AP_I2+(_AP_S&&!_AP_S2)) ? (_AP_I+(_AP_S2&&!_AP_S)) : (_AP_I2+(_AP_S&&!_AP_S2)))+1,
plus_s = _AP_S||_AP_S2,
minus_w = ((_AP_I+(_AP_S2&&!_AP_S)) > (_AP_I2+(_AP_S&&!_AP_S2)) ? (_AP_I+(_AP_S2&&!_AP_S)) : (_AP_I2+(_AP_S&&!_AP_S2)))+1+((_AP_F) > (F2) ? (_AP_F) : (F2)),
minus_i = ((_AP_I+(_AP_S2&&!_AP_S)) > (_AP_I2+(_AP_S&&!_AP_S2)) ? (_AP_I+(_AP_S2&&!_AP_S)) : (_AP_I2+(_AP_S&&!_AP_S2)))+1,
minus_s = true,
div_w = _AP_W + ((_AP_W2 - _AP_I2) > (0) ? (_AP_W2 - _AP_I2) : (0)) + _AP_S2 + ((_AP_I2) > (0) ? (_AP_I2) : (0)),
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
};
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;
};
inline __attribute__((always_inline)) ap_fixed_base() {
;
}
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
ap_fixed_base (const ap_fixed_base<_AP_W2,_AP_I2,_AP_S2,_AP_Q2,_AP_O2, _AP_N2> &op) {
_ssdm_InlineSelf(0, "");
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;
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); });
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); });
bool qb = (F2-_AP_F > _AP_W2) ? _AP_S2 && signbit : qbit;
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;
carry = quantization_adjust(qb, r, _AP_S2 && signbit);
}
}
else {
Base::V = op.V;
if (sh_amt < _AP_W)
Base::V = Base::V << sh_amt;
else
Base::V = 0;
}
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)))) {
bool deleted_zeros = _AP_S2?true:!carry,
deleted_ones = true;
bool neg_src = isneg;
bool lD = false;
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); });
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);
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__; });
Range2_all_ones = Range2 == (all_ones >> pos2);
} else if (pos2 < 0)
Range2_all_ones = false;
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__; });
Range1_all_ones = Range1 == (all_ones >> pos1);
Range1_all_zeros = !Range1.V ;
} else if (pos2 == _AP_W2) {
Range1_all_ones = lD;
Range1_all_zeros = !lD;
} else if (pos1 < 0) {
Range1_all_zeros = !op.V;
Range1_all_ones = false;
}
deleted_zeros = deleted_zeros && (carry ? Range1_all_ones: Range1_all_zeros);
deleted_ones = carry ? Range2_all_ones &&
(pos1 < 0 || !lD): Range1_all_ones;
neg_src = isneg && !(carry&&Range1_all_ones);
} else
neg_src = isneg && newsignbit;
bool neg_trg = _AP_S && newsignbit;
bool overflow = (neg_trg || !deleted_zeros) && !isneg;
bool underflow = (!neg_trg || !deleted_ones) && neg_src;
if ((_AP_O == 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);
}
}
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);
}
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;
}
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; }
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; }
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;
}
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;
}
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);
}
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));
}
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));
}
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));
}
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));
}
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;
}
inline __attribute__((always_inline)) unsigned short halfToRawBits(half pf) const {
union {
unsigned short __L;
half __D;
} LD;
LD.__D = pf;
return LD.__L;
}
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;
}
inline __attribute__((always_inline)) float rawBitsToFloat (unsigned int pi) const {
union {
unsigned int __L;
float __D;
} LD;
LD.__L = pi;
return LD.__D;
}
inline __attribute__((always_inline)) half rawBitsToHalf (unsigned short pi) const {
union {
unsigned short __L;
half __D;
} LD;
LD.__L = pi;
return LD.__D;
}
ap_fixed_base(double d) {
_ssdm_InlineSelf(0, "");
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); });
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__; });
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__; });
;
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;
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)) {
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__; }) !=
0 : false;
carry = quantization_adjust(qb, r, isneg);
}
}
else {
Base::V = man.V;
if (sh_amt < _AP_W)
Base::V = Base::V << sh_amt;
else
Base::V = 0;
}
if ((_AP_O != 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)))) ) {
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 = (man.V >> pos1) & 1;
if (pos1 < _AP_W2 ) {
bool Range1_all_ones = true;
bool Range1_all_zeros = true;
bool Range2_all_ones = true;
ap_int_base<52 +2,false> Range2;
ap_int_base<52 +2,false> all_ones(-1);
if (pos2 >= 0 && pos2 < _AP_W2) {
Range2.V = man.V;
Range2.V >>= pos2;
Range2_all_ones = Range2 == (all_ones >> pos2);
} else if (pos2 < 0)
Range2_all_ones = false;
if (pos1 >= 0 && pos2 < _AP_W2) {
Range1_all_ones = Range2_all_ones && lD;
Range1_all_zeros = !Range2.V && !lD;
} else if (pos2 == _AP_W2) {
Range1_all_ones = lD;
Range1_all_zeros = !lD;
} else if (pos1 < 0) {
Range1_all_zeros = !man.V;
Range1_all_ones = false;
}
deleted_zeros = deleted_zeros && (carry ? Range1_all_ones: Range1_all_zeros);
deleted_ones = carry ? Range2_all_ones &&
( pos1 < 0 || !lD): Range1_all_ones;
neg_src=isneg && !(carry&&Range1_all_ones);
} else
neg_src = isneg && newsignbit;
bool neg_trg = _AP_S && newsignbit;
bool overflow = (neg_trg || !deleted_zeros) && !isneg;
bool underflow =(!neg_trg || !deleted_ones) && neg_src;
if ((_AP_O == 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);
}
}
}
inline __attribute__((always_inline)) ap_fixed_base(float d) {
*this = ap_fixed_base(double(d));
}
inline __attribute__((always_inline)) ap_fixed_base(half d) {_ssdm_SpecConstant(&omode);_ssdm_SpecConstant(&qmode);_ssdm_SpecConstant(&iwidth);_ssdm_SpecConstant(&width);
*this = ap_fixed_base(double(d));
}
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;
}
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;
}
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;
}
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;
}
inline __attribute__((always_inline)) ap_fixed_base& setBits(unsigned long long bv) {
Base::V = bv;
return *this;
}
static inline __attribute__((always_inline)) ap_fixed_base bitsToFixed(unsigned long long bv) {
ap_fixed_base Tmp;
Tmp.V = bv;
return Tmp;
}
inline __attribute__((always_inline)) ap_int_base<((_AP_I) > (1) ? (_AP_I) : (1)),_AP_S>
to_ap_int_base(bool Cnative = true) const {
ap_int_base<((_AP_I) > (1) ? (_AP_I) : (1)),_AP_S> ret(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__; });
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__; });
unsigned int shift = _AP_I - _AP_W;
ret.V <<= shift;
}
if (Cnative) {
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); })
&& (_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))
ret.V += 1;
} else {
}
return ret;
};
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) operator ap_int_base<_AP_W2,_AP_S2> () const {
return (ap_int_base<_AP_W2,_AP_S2>)to_ap_int_base();
}
inline __attribute__((always_inline)) 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();
}
double to_double() const {
_ssdm_InlineSelf(0, "");
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;
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__), 63, 63); __Result__; });
int j = _AP_W+_AP_S-1-tmp.countLeadingZeros();
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__; });
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;
}
}
float to_float() const {
_ssdm_InlineSelf(0, "");
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;
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();
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__; });
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());
}
}
inline __attribute__((always_inline)) half to_half() const {
_ssdm_InlineSelf(0, "");
if (_AP_W - _AP_I > 0 && _AP_W <= 64) {
if (!Base::V)
return 0;
half dp = Base::V;
ap_int_base<16,true> res;
res.V = halfToRawBits(dp);
ap_int_base<5, true> exp;
exp.V = ({ typeof(res.V) __Result__ = 0; typeof(res.V) __Val2__ = res.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 10, 14); __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__), 10, 14); __Result__; });
dp = rawBitsToHalf(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;
half dp = temp.V;
return dp;
} else {
if (!Base::V)
return 0;
ap_int_base<16,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;
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();
int exp = _AP_I-(_AP_W-j);
res.V = ({ typeof(res.V) __Result__ = 0; typeof(res.V) __Val2__ = res.V; typeof(exp + ((1<<(5 -1))-1)) __Repl2__ = exp + ((1<<(5 -1))-1); __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), 10, 14); __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, 10 - 1); __Result__; });
else {
ap_int_base<10,false> man;
man.V = ({ typeof(tmp.V) __Result__ = 0; typeof(tmp.V) __Val2__ = tmp.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), j > 10 ? j - 10 : 0, j - 1); __Result__; });
man.V <<= 10 > j ? 10 -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, 10 - 1); __Result__; });
}
return rawBitsToHalf(res.to_int());
}
}
inline __attribute__((always_inline)) operator double () const {
return to_double();
}
#1330 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_fixed_syn.h"
inline __attribute__((always_inline)) int length() const { return _AP_W; };
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;
}
}
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;
}
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;
ap_fixed_base<_AP_W + ((_AP_W2 - _AP_I2) > (0) ? (_AP_W2 - _AP_I2) : (0)) + ((_AP_I2) > (0) ? (_AP_I2) : (0)),
_AP_I, _AP_S> t(*this);
r.V = t.V / op2.V;
return r;
}
#1406 "/opt/Xilinx/Vivado/2017.3/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; }
#1424 "/opt/Xilinx/Vivado/2017.3/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; }
inline __attribute__((always_inline)) ap_fixed_base& operator ++() {
operator+=(ap_fixed_base<_AP_W-_AP_I+1,1,false>(1));
return *this;
}
inline __attribute__((always_inline)) ap_fixed_base& operator --() {
operator-=(ap_fixed_base<_AP_W-_AP_I+1,1,false>(1));
return *this;
}
inline __attribute__((always_inline)) const ap_fixed_base
operator ++(int) {
ap_fixed_base t(*this);
operator++();
return t;
}
inline __attribute__((always_inline)) const ap_fixed_base
operator --(int) {
ap_fixed_base t(*this);
operator--();
return t;
}
inline __attribute__((always_inline)) ap_fixed_base operator +() {
return *this;
}
inline __attribute__((always_inline)) ap_fixed_base<_AP_W + 1, _AP_I + 1, true> operator -() const {
ap_fixed_base<_AP_W + 1, _AP_I + 1, true> ret(*this);
ret.V = - ret.V;
return ret;
}
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;
}
inline __attribute__((always_inline)) bool operator !() const {
return Base::V == 0;
}
inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S> operator ~() const {
ap_fixed_base<_AP_W, _AP_I, _AP_S> ret;
ret.V=~Base::V;
return ret;
}
template<int _AP_SHIFT>
inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I + _AP_SHIFT, _AP_S> lshift () const {
ap_fixed_base<_AP_W, _AP_I + _AP_SHIFT, _AP_S> r;
r.V = Base::V;
return r;
}
template<int _AP_SHIFT>
inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I - _AP_SHIFT, _AP_S> rshift () const {
ap_fixed_base<_AP_W, _AP_I - _AP_SHIFT, _AP_S> r;
r.V = Base::V;
return r;
}
ap_fixed_base
operator << (int sh) const {
_ssdm_InlineSelf(0, "");
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;
if (sh == 0) return r;
if (isNeg && _AP_Q != SC_TRN) {
bool qb = false;
if (sh <= _AP_W)
qb = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), sh - 1, sh - 1); (bool)(__Result__ & 1); });
bool rb = false;
if (sh > 1 && sh <= _AP_W)
rb = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 0, sh - 2); __Result__; }) != 0;
else if (sh > _AP_W)
rb = Base::V != 0;
r.quantization_adjust(qb, rb, _AP_S &&
({ 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); }));
} else if (!isNeg && (_AP_O != SC_WRAP || _AP_N != 0)) {
bool neg_src = _AP_S && ({ 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); });
bool allones, allzeros;
ap_int_base<_AP_W, false> ones(-1);
if (sh <= _AP_W) {
ap_int_base<_AP_W,false> range1;
range1.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 - sh, _AP_W - 1); __Result__; });
allones = range1 == (ones >>(_AP_W - sh));
allzeros = range1 == 0;
} else {
allones = false;
allzeros = Base::V == 0;
}
bool overflow = !allzeros && !neg_src;
bool underflow =!allones && neg_src;
if ((_AP_O == SC_SAT_SYM) && _AP_S)
underflow |= neg_src && (_AP_W > 1 ? ({ typeof(r.V) __Result__ = 0; typeof(r.V) __Val2__ = r.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 0, _AP_W - 2); __Result__; }) == 0: true);
bool lD = false;
if (sh < _AP_W) lD = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W - sh -1, _AP_W - sh -1); (bool)(__Result__ & 1); });
r.overflow_adjust(underflow, overflow, lD, neg_src);
}
return r;
}
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);
}
ap_fixed_base
operator << (unsigned int sh) const {
_ssdm_InlineSelf(0, "");
ap_fixed_base r;
r.V = Base::V << sh;
if (sh == 0) return r;
if (_AP_O != SC_WRAP || _AP_N != 0) {
bool neg_src = _AP_S && ({ 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); });
bool allones, allzeros;
ap_int_base<_AP_W, false> ones(-1);
if (sh <= _AP_W) {
ap_int_base<_AP_W,false> range1;
range1.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 - sh, _AP_W - 1); __Result__; });
allones = range1 == (ones >> (_AP_W - sh));
allzeros = range1 == 0;
} else {
allones = false;
allzeros = Base::V == 0;
}
bool overflow = !allzeros && !neg_src;
bool underflow = !allones && neg_src;
if ((_AP_O == SC_SAT_SYM) && _AP_S)
underflow |= neg_src && (_AP_W > 1 ? ({ typeof(r.V) __Result__ = 0; typeof(r.V) __Val2__ = r.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 0, _AP_W - 2); __Result__; }) == 0: true);
bool lD = false;
if (sh < _AP_W) lD = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W - sh -1, _AP_W - sh -1); (bool)(__Result__ & 1); });
r.overflow_adjust(underflow, overflow, lD, neg_src);
}
return r;
}
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);
}
ap_fixed_base
operator >> (int sh) const {
_ssdm_InlineSelf(0, "");
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;
if (sh == 0) return r;
if (!isNeg && _AP_Q != SC_TRN) {
bool qb = false;
if (sh <= _AP_W)
qb = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), sh - 1, sh - 1); (bool)(__Result__ & 1); });
bool rb = false;
if (sh > 1 && sh <= _AP_W)
rb = ({ 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, sh - 2); __Result__; }) != 0;
else if (sh > _AP_W)
rb = Base::V != 0;
r.quantization_adjust(qb, rb, _AP_S && ({ 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); }));
} else if (isNeg && (_AP_O != SC_WRAP || _AP_N != 0)) {
bool neg_src = _AP_S && ({ 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); });
bool allones, allzeros;
ap_int_base<_AP_W, false> ones(-1);
if (sh <= _AP_W) {
ap_int_base<_AP_W,false> range1;
range1.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 - sh, _AP_W - 1); __Result__; });
allones = range1 == (ones >>(_AP_W - sh));
allzeros = range1 == 0;
} else {
allones = false;
allzeros = Base::V == 0;
}
bool overflow = !allzeros && !neg_src;
bool underflow =!allones && neg_src;
if ((_AP_O == SC_SAT_SYM) && _AP_S)
underflow |= neg_src && (_AP_W > 1 ? ({ typeof(r.V) __Result__ = 0; typeof(r.V) __Val2__ = r.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 0, _AP_W - 2); __Result__; }) == 0: true);
bool lD = false;
if (sh < _AP_W) lD = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W - sh -1, _AP_W - sh -1); (bool)(__Result__ & 1); });
r.overflow_adjust(underflow, overflow, lD, neg_src);
}
return r;
}
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);
}
ap_fixed_base
operator >> (unsigned sh) const {
_ssdm_InlineSelf(0, "");
ap_fixed_base r;
r.V = Base::V >> sh;
if (sh == 0) return r;
if ( _AP_Q != SC_TRN) {
bool qb = false;
if (sh <= _AP_W)
qb = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), sh - 1, sh - 1); (bool)(__Result__ & 1); });
bool rb = false;
if (sh > 1 && sh <= _AP_W)
rb = ({ 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, sh - 2); __Result__; }) != 0;
else if (sh > _AP_W)
rb = Base::V != 0;
r.quantization_adjust(qb, rb, _AP_S && ({ 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); }));
}
return r;
}
template<int _AP_W2>
inline __attribute__((always_inline)) ap_fixed_base
operator >> (const ap_int_base<_AP_W2,false>& op2) const {
unsigned int sh = op2.to_uint();
return operator >> (sh);
}
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_fixed_base
operator >> (const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2,
_AP_N2>& op2) {
return operator >> (op2.to_ap_int_base());
}
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_fixed_base
operator << (const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2,
_AP_N2>& op2) {
return operator << (op2.to_ap_int_base());
}
ap_fixed_base&
operator <<= (int sh) {
_ssdm_InlineSelf(0, "");
if (sh == 0) return *this;
bool isNeg = sh & 0x80000000;
sh = isNeg ? -sh : sh;
bool qb, rb, sb;
bool neg_src, allones, allzeros, lD;
if (isNeg && _AP_Q != SC_TRN) {
qb = false;
if (sh <= _AP_W)
qb = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), sh - 1, sh - 1); (bool)(__Result__ & 1); });
rb = false;
if (sh > 1 && sh <= _AP_W)
rb = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 0, sh - 2); __Result__; }) != 0;
else if (sh > _AP_W)
rb = Base::V != 0;
sb = _AP_S && ({ 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); });
} else if (!isNeg && (_AP_O != SC_WRAP || _AP_N != 0)) {
neg_src = _AP_S && ({ 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); });
ap_int_base<_AP_W, false> ones(-1);
if (sh <= _AP_W) {
ap_int_base<_AP_W,false> range1;
range1.V = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W - sh, _AP_W - 1); __Result__; });
allones = range1 == (ones >> (_AP_W -sh));
allzeros = range1 == 0;
} else {
allones = false;
allzeros = Base::V == 0;
}
lD = false;
if (sh < _AP_W) lD = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W - sh -1, _AP_W - sh -1); (bool)(__Result__ & 1); });
}
if (isNeg) Base::V >>= sh;
else Base::V <<= sh;
if (isNeg && _AP_Q != SC_TRN)
quantization_adjust(qb, rb, sb);
else if ( !isNeg && (_AP_O != SC_WRAP || _AP_N != 0)) {
bool overflow = !allzeros && !neg_src;
bool underflow = !allones && neg_src;
if ((_AP_O == SC_SAT_SYM) && _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);
}
return *this;
}
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);
}
ap_fixed_base&
operator <<= (unsigned int sh) {
_ssdm_InlineSelf(0, "");
if (sh == 0) return *this;
bool neg_src, allones,allzeros, lD;
if ( _AP_O != SC_WRAP || _AP_N != 0) {
neg_src = _AP_S && ({ 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); });
ap_int_base<_AP_W, false> ones(-1);
if (sh <= _AP_W) {
ap_int_base<_AP_W,false> range1;
range1.V = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W - sh, _AP_W - 1); __Result__; });
allones = range1 == (ones >> (_AP_W - sh));
allzeros = range1 == 0;
} else {
allones = false;
allzeros = Base::V == 0;
}
lD = false;
if (sh < _AP_W) lD = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W - sh -1, _AP_W - sh -1); (bool)(__Result__ & 1); });
}
Base::V <<= sh;
if ( _AP_O != SC_WRAP || _AP_N != 0) {
bool overflow = !allzeros && !neg_src;
bool underflow = !allones && neg_src;
if ((_AP_O == SC_SAT_SYM) && _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);
}
return *this;
}
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);
}
ap_fixed_base&
operator >>= (int sh) {
_ssdm_InlineSelf(0, "");
if (sh == 0) return *this;
bool isNeg = sh & 0x80000000;
sh = isNeg ? -sh : sh;
bool qb, rb, sb;
bool neg_src, allones,allzeros, lD;
if (!isNeg && _AP_Q != SC_TRN) {
qb = false;
if (sh <= _AP_W)
qb = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), sh - 1, sh - 1); (bool)(__Result__ & 1); });
rb = false;
if (sh > 1 && sh <= _AP_W)
rb = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 0, sh - 2); __Result__; }) != 0;
else if (sh > _AP_W)
rb = Base::V != 0;
sb = _AP_S && ({ 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); });
} else if (isNeg && (_AP_O != SC_WRAP || _AP_N != 0)) {
neg_src = _AP_S && ({ 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); });
ap_int_base<_AP_W, false> ones(-1);
if (sh <= _AP_W) {
ap_int_base<_AP_W,false> range1;
range1.V = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W - sh, _AP_W - 1); __Result__; });
allones = range1 == (ones >> (_AP_W - sh));
allzeros = range1 == 0;
} else {
allones = false;
allzeros = Base::V == 0;
}
lD = false;
if (sh < _AP_W) lD = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W - sh -1, _AP_W - sh -1); (bool)(__Result__ & 1); });
}
if (isNeg) Base::V <<= sh;
else Base::V >>= sh;
if (!isNeg && _AP_Q != SC_TRN)
quantization_adjust(qb, rb, sb);
else if (isNeg && (_AP_O != SC_WRAP || _AP_N != 0)) {
bool overflow = !allzeros && !neg_src;
bool underflow = !allones && neg_src;
if ((_AP_O == SC_SAT_SYM) && _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, isNeg);
}
return *this;
}
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);
}
ap_fixed_base&
operator >>= (unsigned int sh) {
_ssdm_InlineSelf(0, "");
if (sh == 0) return *this;
bool qb, rb, sb;
if ( _AP_Q != SC_TRN) {
qb = false;
if (sh <= _AP_W)
qb = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), sh - 1, sh - 1); (bool)(__Result__ & 1); });
rb = false;
if (sh > 1 && sh <= _AP_W)
rb = ({ typeof(Base::V) __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 0, sh - 2); __Result__; }) != 0;
else if (sh > _AP_W)
rb = Base::V != 0;
sb = _AP_S && ({ 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); });
}
Base::V >>= sh;
if ( _AP_Q != SC_TRN)
quantization_adjust(qb, rb, sb);
return *this;
}
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);
}
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_fixed_base&
operator >>= (const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2,
_AP_N2>& op2) {
return operator >>= (op2.to_ap_int_base());
}
template<int _AP_W2, int _AP_I2, bool _AP_S2,
ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_fixed_base&
operator <<= (const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2,
_AP_N2>& op2) {
return operator <<= (op2.to_ap_int_base());
}
#1959 "/opt/Xilinx/Vivado/2017.3/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; }
inline __attribute__((always_inline)) bool operator == (double d) const { return to_double() == d; }
inline __attribute__((always_inline)) bool operator != (double d) const { return to_double() != d; }
inline __attribute__((always_inline)) bool operator > (double d) const { return to_double() > d; }
inline __attribute__((always_inline)) bool operator >= (double d) const { return to_double() >= d; }
inline __attribute__((always_inline)) bool operator < (double d) const { return to_double() < d; }
inline __attribute__((always_inline)) bool operator <= (double d) const { return to_double() <= d; }
inline __attribute__((always_inline)) af_bit_ref<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N> operator[] (unsigned index) {
;
return af_bit_ref<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>(this, index);
}
template<int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) af_bit_ref<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N> operator [] (const ap_int_base<_AP_W2,_AP_S2>& index) {
;
;
return af_bit_ref<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>(this, index.to_int());
}
inline __attribute__((always_inline)) bool operator [] (unsigned index) const {
;
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); });
}
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);
}
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());
}
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); });
}
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);
}
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); });
}
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);
}
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); });
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
template<int _AP_W2, bool _AP_S2, int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) af_range_ref<_AP_W,_AP_I,_AP_S, _AP_Q, _AP_O, _AP_N>
operator () (const ap_int_base<_AP_W2, _AP_S2> &HiIdx,
const ap_int_base<_AP_W3, _AP_S3> &LoIdx) const {
int Hi = HiIdx.to_int();
int Lo = LoIdx.to_int();
return this->range(Hi, Lo);
}
inline __attribute__((always_inline)) 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);
}
inline __attribute__((always_inline)) af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>
range() {
return this->range(_AP_W - 1, 0);
}
inline __attribute__((always_inline)) af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>
range() const {
return this->range(_AP_W - 1, 0);
}
inline __attribute__((always_inline)) bool is_zero () const {
return Base::V == 0;
}
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;
}
inline __attribute__((always_inline)) int wl () const {
return _AP_W;
}
inline __attribute__((always_inline)) int iwl () const {
return _AP_I;
}
inline __attribute__((always_inline)) ap_q_mode q_mode () const {
return _AP_Q;
}
inline __attribute__((always_inline)) ap_o_mode o_mode () const {
return _AP_O;
}
inline __attribute__((always_inline)) int n_bits () const {
return _AP_N;
}
inline __attribute__((always_inline)) char* to_string(BaseMode mode) {
return 0;
}
inline __attribute__((always_inline)) char* to_string(signed char mode) {
return to_string(BaseMode(mode));
}
};
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q,
ap_o_mode _AP_O, int _AP_N>
inline __attribute__((always_inline)) void b_not(ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& ret,
const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) {
ret.V = ~ op.V;
}
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q,
ap_o_mode _AP_O, int _AP_N>
inline __attribute__((always_inline)) void b_and(ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& ret,
const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op1,
const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op2) {
ret.V = op1.V & op2.V;
}
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q,
ap_o_mode _AP_O, int _AP_N>
inline __attribute__((always_inline)) void b_or(ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& ret,
const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op1,
const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op2) {
ret.V = op1.V | op2.V;
}
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q,
ap_o_mode _AP_O, int _AP_N>
inline __attribute__((always_inline)) void b_xor(ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& ret,
const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op1,
const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op2) {
ret.V = op1.V ^ op2.V;
}
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q,
ap_o_mode _AP_O, int _AP_N, int _AP_W2, int _AP_I2,
bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) void neg(ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& ret,
const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
ap_fixed_base<_AP_W2+!_AP_S2, _AP_I2+!_AP_S2, true, _AP_Q2, _AP_O2, _AP_N2> Tmp;
Tmp.V = - op.V;
ret = Tmp;
}
template<int _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;
}
template<int _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;
}
#2232 "/opt/Xilinx/Vivado/2017.3/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; }
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; }
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; }
template<int _AP_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) {
return os;
}
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q,
ap_o_mode _AP_O, int _AP_N>
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) {
return in;
}
#2350 "/opt/Xilinx/Vivado/2017.3/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)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, 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)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, 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)); }
#2400 "/opt/Xilinx/Vivado/2017.3/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)); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator == ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator == ( ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator == ( const ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op) { return ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op).operator == (op); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator != ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator != ( ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator != ( const ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op) { return ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op).operator != (op); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator > ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator > ( ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator > ( const ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op) { return ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op).operator > (op); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator >= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator >= ( ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator >= ( const ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op) { return ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op).operator >= (op); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator < ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator < ( ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator < ( const ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op) { return ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op).operator < (op); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator <= ( const ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator <= ( ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator <= ( const ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op) { return ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op).operator <= (op); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& operator += ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator += (ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W2,_AP_S2>& operator += ( ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return i_op.operator += (op.to_ap_int_base()); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& operator -= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator -= (ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W2,_AP_S2>& operator -= ( ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return i_op.operator -= (op.to_ap_int_base()); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& operator *= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator *= (ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W2,_AP_S2>& operator *= ( ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return i_op.operator *= (op.to_ap_int_base()); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& operator /= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator /= (ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W2,_AP_S2>& operator /= ( ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return i_op.operator /= (op.to_ap_int_base()); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& operator &= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator &= (ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W2,_AP_S2>& operator &= ( ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return i_op.operator &= (op.to_ap_int_base()); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& operator |= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator |= (ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W2,_AP_S2>& operator |= ( ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return i_op.operator |= (op.to_ap_int_base()); }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& operator ^= ( ap_fixed_base<_AP_W, _AP_I,_AP_S,_AP_Q,_AP_O,_AP_N>& op, const ap_int_base<_AP_W2,_AP_S2>& i_op) { return op.operator ^= (ap_fixed_base<_AP_W2,_AP_W2,_AP_S2>(i_op)); } template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W2,_AP_S2>& operator ^= ( ap_int_base<_AP_W2,_AP_S2>& i_op, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N>& op) { return i_op.operator ^= (op.to_ap_int_base()); }
template<int _AP_W, int _AP_I, bool _AP_S,
ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N>
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);
}
#2485 "/opt/Xilinx/Vivado/2017.3/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)); }
template<int _AP_W, int _AP_I, 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)); }
template<int _AP_W, int _AP_I, 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)); }
#2525 "/opt/Xilinx/Vivado/2017.3/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)); }
#63 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/ap_sc_dt.h" 2
namespace _ap_sc_ {
namespace sc_dt {
enum sc_logic_value_t
{
Log_0 = 0,
Log_1,
Log_Z,
Log_X
};
typedef ::ap_slong int64;
typedef ::ap_ulong uint64;
template<int _SC_W, int _SC_I, ap_q_mode _SC_Q, ap_o_mode _SC_O, int _SC_N> struct sc_fixed;
template<int _SC_W, int _SC_I, ap_q_mode _SC_Q, ap_o_mode _SC_O, int _SC_N> struct sc_ufixed;
template<int _SC_W> struct sc_int;
template<int _SC_W> struct sc_uint;
template<int _SC_W> struct sc_bv;
struct sc_bit;
template <class T>
inline
const T
sc_min( const T& a, const T& b )
{
return ( ( a <= b ) ? a : b );
}
template <class T>
inline
const T
sc_max( const T& a, const T& b )
{
return ( ( a >= b ) ? a : b );
}
template <class T>
inline
const T
sc_abs( const T& a )
{
T z( a );
z = 0;
if( a >= z ) {
return a;
} else {
T c( a );
c = -a;
return c;
}
}
template<int _SC_W>
struct sc_int : ap_int_base<_SC_W,true> {
typedef ap_int_base<_SC_W,true> sc_int_base;
inline __attribute__((always_inline)) sc_int() : sc_int_base() { }
inline __attribute__((always_inline)) sc_int(const sc_int_base &op) { sc_int_base::V = op.V; }
inline __attribute__((always_inline)) sc_int(volatile sc_int_base &op) {
sc_int_base::V = op.V;
}
template<int _SC_W2, bool _SC_S2>
inline __attribute__((always_inline)) sc_int(const ap_int_base<_SC_W2, _SC_S2> &op) : sc_int_base(op) { }
template<bool _SC_S2>
inline __attribute__((always_inline)) sc_int(ap_int_base<_SC_W, _SC_S2> &op) : sc_int_base(op) { }
template<int _SC_W2, bool _SC_S2>
inline __attribute__((always_inline)) sc_int(const ap_range_ref< _SC_W2, _SC_S2>& ref) : sc_int_base(ref) {}
template<int _SC_W2, bool _SC_S2>
inline __attribute__((always_inline)) sc_int(const ap_bit_ref< _SC_W2, _SC_S2>& ref) : sc_int_base(ref) {}
template<int _SC_W2, typename _SC_T2, int _SC_W3, typename _SC_T3>
inline __attribute__((always_inline)) sc_int(const ap_concat_ref<_SC_W2, _SC_T2, _SC_W3, _SC_T3>& ref) : sc_int_base(ref) {}
template <int _SC_W2, int _SC_I2, bool _SC_S2, ap_q_mode _SC_Q2, ap_o_mode _SC_O2, int _SC_N2 >
inline __attribute__((always_inline)) sc_int(const ap_fixed_base<_SC_W2, _SC_I2, _SC_S2, _SC_Q2, _SC_O2, _SC_N2>& op2) {
sc_int_base::V = (op2.to_ap_int_base(false)).V; }
template <int _SC_W2, int _SC_I2, bool _SC_S2, ap_q_mode _SC_Q2, ap_o_mode _SC_O2, int _SC_N2 >
inline __attribute__((always_inline)) sc_int(const af_bit_ref<_SC_W2, _SC_I2, _SC_S2, _SC_Q2, _SC_O2, _SC_N2>& op2) {
sc_int_base::V = (bool)op2;
}
template <int _SC_W2, int _SC_I2, bool _SC_S2, ap_q_mode _SC_Q2, ap_o_mode _SC_O2, int _SC_N2 >
inline __attribute__((always_inline)) sc_int(const af_range_ref<_SC_W2, _SC_I2, _SC_S2, _SC_Q2, _SC_O2, _SC_N2>& op2) {
sc_int_base::V = (op2.operator ap_int_base<_SC_W2, false>()).V;
}
template<int _SC_W2>
inline __attribute__((always_inline)) sc_int(const sc_int<_SC_W2> &op) {
sc_int_base::V = op.V; }
template<int _SC_W2>
inline __attribute__((always_inline)) sc_int(const sc_uint<_SC_W2> &op) {
sc_int_base::V = op.V; }
template<int _SC_W2>
inline __attribute__((always_inline)) sc_int(const sc_bv<_SC_W2> &op) {
sc_int_base::V = op.V; }
template<int _SC_W2, int _SC_I2, ap_q_mode _SC_Q2, ap_o_mode _SC_O2, int _SC_N2>
inline __attribute__((always_inline)) sc_int(const sc_fixed<_SC_W2, _SC_I2, _SC_Q2, _SC_O2,_SC_N2>& op) {
sc_int_base::V = op.to_ap_int_base(false).V; }
template<int _SC_W2, int _SC_I2, ap_q_mode _SC_Q2, ap_o_mode _SC_O2, int _SC_N2>
inline __attribute__((always_inline)) sc_int(const sc_ufixed<_SC_W2, _SC_I2, _SC_Q2, _SC_O2, _SC_N2>& op) {
sc_int_base::V = op.to_ap_int_base(false).V; }
inline __attribute__((always_inline)) sc_int(bool v) : sc_int_base(v) { }
inline __attribute__((always_inline)) sc_int(signed char v) : sc_int_base(v) { }
inline __attribute__((always_inline)) sc_int(unsigned char v) : sc_int_base(v) { }
inline __attribute__((always_inline)) sc_int(short v) : sc_int_base(v) { }
inline __attribute__((always_inline)) sc_int(unsigned short v) : sc_int_base(v) { }
inline __attribute__((always_inline)) sc_int(int v) : sc_int_base(v) { }
inline __attribute__((always_inline)) sc_int(unsigned int v) : sc_int_base(v) { }
inline __attribute__((always_inline)) sc_int(long v) : sc_int_base(v) { }
inline __attribute__((always_inline)) sc_int(unsigned long v) : sc_int_base(v) { }
inline __attribute__((always_inline)) sc_int(ap_slong v) : sc_int_base(v) { }
inline __attribute__((always_inline)) sc_int(ap_ulong v) : sc_int_base(v) { }
inline __attribute__((always_inline)) sc_int(double v) : sc_int_base(v) { }
inline __attribute__((always_inline)) sc_int(const char* v) : sc_int_base(v, 10) {}
#224 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/ap_sc_dt.h"
inline __attribute__((always_inline)) void operator = (const sc_int& op2) volatile {
sc_int_base::V = op2.V;
}
inline __attribute__((always_inline)) void operator = (const volatile sc_int& op2) volatile {
sc_int_base::V = op2.V;
}
inline __attribute__((always_inline)) sc_int& operator = (const volatile sc_int& op2) {
sc_int_base::V = op2.V;
return *this;
}
inline __attribute__((always_inline)) sc_int& operator = (const sc_int& op2) {
sc_int_base::V = op2.V;
return *this;
}
#249 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/ap_sc_dt.h"
template<int _SC_W2, int _SC_I2, ap_q_mode _SC_Q2, ap_o_mode _SC_O2, int _SC_N2>
inline __attribute__((always_inline)) sc_int& operator = (const sc_fixed<_SC_W2, _SC_I2, _SC_Q2, _SC_O2, _SC_N2>& op) {
sc_int_base::V = sc_int< _SC_W>((ap_fixed_base<_SC_W2, _SC_I2,true, _SC_Q2, _SC_O2, _SC_N2>)op).V;
return *this;
}
template<int _SC_W2, int _SC_I2, ap_q_mode _SC_Q2, ap_o_mode _SC_O2, int _SC_N2>
inline __attribute__((always_inline)) sc_int& operator = (const sc_ufixed<_SC_W2, _SC_I2, _SC_Q2, _SC_O2, _SC_N2>& op) {
sc_int_base::V = sc_int< _SC_W>((ap_fixed_base< _SC_W2, _SC_I2, false, _SC_Q2, _SC_O2, _SC_N2>)op).V;
return *this;
}
};
template<int _SC_W>
struct sc_uint : ap_int_base<_SC_W,false> {
typedef ap_int_base<_SC_W,false> sc_uint_base;
inline __attribute__((always_inline)) sc_uint() : sc_uint_base() { }
inline __attribute__((always_inline)) sc_uint(const sc_uint_base &op) { sc_uint_base::V = op.V; }
inline __attribute__((always_inline)) sc_uint(volatile sc_uint_base &op) {
sc_uint_base::V =op.V;
}
template<int _SC_W2, bool _SC_S2>
inline __attribute__((always_inline)) sc_uint(const ap_int_base<_SC_W2, _SC_S2> &op) : sc_uint_base(op) { }
template<bool _SC_S2>
inline __attribute__((always_inline)) sc_uint(ap_int_base<_SC_W, _SC_S2> &op) : sc_uint_base(op) { }
template<int _SC_W2, bool _SC_S2>
inline __attribute__((always_inline)) sc_uint(const ap_range_ref<_SC_W2, _SC_S2>& ref) : sc_uint_base(ref) {}
template<int _SC_W2, bool _SC_S2>
inline __attribute__((always_inline)) sc_uint(const ap_bit_ref< _SC_W2, _SC_S2>& ref) : sc_uint_base(ref) {}
template<int _SC_W2, typename _SC_T2, int _SC_W3, typename _SC_T3>
inline __attribute__((always_inline)) sc_uint(const ap_concat_ref<_SC_W2, _SC_T2, _SC_W3, _SC_T3>& ref) : sc_uint_base(ref) {}
template <int _SC_W2, int _SC_I2, bool _SC_S2, ap_q_mode _SC_Q2, ap_o_mode _SC_O2 , int _SC_N2>
inline __attribute__((always_inline)) sc_uint(const ap_fixed_base<_SC_W2, _SC_I2, _SC_S2, _SC_Q2, _SC_O2, _SC_N2>& op2) {
sc_uint_base::V = (op2.to_ap_int_base(false)).V;
}
template<int _SC_W2>
inline __attribute__((always_inline)) sc_uint(const sc_int< _SC_W2> &op) {
sc_uint_base::V = op.V; }
template<int _SC_W2>
inline __attribute__((always_inline)) sc_uint(const sc_uint< _SC_W2> &op) {
sc_uint_base::V = op.V; }
template<int _SC_W2>
inline __attribute__((always_inline)) sc_uint(const sc_bv< _SC_W2> &op) {
sc_uint_base::V = op.V; }
template<int _SC_W2, int _SC_I2, ap_q_mode _SC_Q2, ap_o_mode _SC_O2, int _SC_N2>
inline __attribute__((always_inline)) sc_uint(const sc_fixed< _SC_W2, _SC_I2, _SC_Q2, _SC_O2, _SC_N2>& op) {
sc_uint_base::V = op.to_ap_int_base(false).V; }
template<int _SC_W2, int _SC_I2, ap_q_mode _SC_Q2, ap_o_mode _SC_O2, int _SC_N2>
inline __attribute__((always_inline)) sc_uint(const sc_ufixed<_SC_W2, _SC_I2, _SC_Q2, _SC_O2, _SC_N2>& op) {
sc_uint_base::V = op.to_ap_int_base(false).V; }
template <int _SC_W2, int _SC_I2, bool _SC_S2, ap_q_mode _SC_Q2, ap_o_mode _SC_O2, int _SC_N2 >
inline __attribute__((always_inline)) sc_uint(const af_bit_ref<_SC_W2, _SC_I2, _SC_S2, _SC_Q2, _SC_O2, _SC_N2>& op2) {
sc_uint_base::V = (bool)op2;
}
template <int _SC_W2, int _SC_I2, bool _SC_S2, ap_q_mode _SC_Q2, ap_o_mode _SC_O2, int _SC_N2 >
inline __attribute__((always_inline)) sc_uint(const af_range_ref<_SC_W2, _SC_I2, _SC_S2, _SC_Q2, _SC_O2, _SC_N2>& op2) {
sc_uint_base::V = (op2.operator ap_int_base<_SC_W2, false>()).V;
}
inline __attribute__((always_inline)) sc_uint(bool v) : sc_uint_base(v) { }
inline __attribute__((always_inline)) sc_uint(signed char v) : sc_uint_base(v) { }
inline __attribute__((always_inline)) sc_uint(unsigned char v) : sc_uint_base(v) { }
inline __attribute__((always_inline)) sc_uint(short v) : sc_uint_base(v) { }
inline __attribute__((always_inline)) sc_uint(unsigned short v) : sc_uint_base(v) { }
inline __attribute__((always_inline)) sc_uint(int v) : sc_uint_base(v) { }
inline __attribute__((always_inline)) sc_uint(unsigned int v) : sc_uint_base(v) { }
inline __attribute__((always_inline)) sc_uint(long v) : sc_uint_base(v) { }
inline __attribute__((always_inline)) sc_uint(unsigned long v) : sc_uint_base(v) { }
inline __attribute__((always_inline)) sc_uint(ap_slong v) : sc_uint_base(v) { }
inline __attribute__((always_inline)) sc_uint(ap_ulong v) : sc_uint_base(v) { }
inline __attribute__((always_inline)) sc_uint(double v) : sc_uint_base(v) { }
inline __attribute__((always_inline)) sc_uint(const char* v) : sc_uint_base(v, 10) { }
#364 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/ap_sc_dt.h"
inline __attribute__((always_inline)) void operator = (const sc_uint& op2) volatile {
sc_uint_base::V =op2.V;
}
inline __attribute__((always_inline)) void operator = (const volatile sc_uint& op2) volatile {
sc_uint_base::V = sc_uint<_SC_W>(op2).V;
}
inline __attribute__((always_inline)) sc_uint& operator = (const volatile sc_uint& op2) {
sc_uint_base::V = op2.V;
return *this;
}
inline __attribute__((always_inline)) sc_uint& operator = (const sc_uint& op2) {
sc_uint_base::V = op2.V;
return *this;
}
#389 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/ap_sc_dt.h"
};
template<int _SC_W>
struct sc_bigint : ap_int_base<_SC_W,true> {
typedef ap_int_base<_SC_W,true> sc_int;
inline __attribute__((always_inline)) sc_bigint() : sc_int() { }
inline __attribute__((always_inline)) sc_bigint(const sc_int &op) { sc_int::V = op.V; }
inline __attribute__((always_inline)) sc_bigint(volatile sc_int &op) {
sc_int::V = op.V;
}
template<int _SC_W2, bool _SC_S2>
inline __attribute__((always_inline)) sc_bigint(const ap_int_base<_SC_W2, _SC_S2> &op) : sc_int(op) { }
template<bool _SC_S2>
inline __attribute__((always_inline)) sc_bigint(ap_int_base<_SC_W, _SC_S2> &op) : sc_int(op) { }
template<int _SC_W2, bool _SC_S2>
inline __attribute__((always_inline)) sc_bigint(const ap_range_ref< _SC_W2, _SC_S2>& ref) : sc_int(ref) {}
template<int _SC_W2, bool _SC_S2>
inline __attribute__((always_inline)) sc_bigint(const ap_bit_ref< _SC_W2, _SC_S2>& ref) : sc_int(ref) {}
template<int _SC_W2, typename _SC_T2, int _SC_W3, typename _SC_T3>
inline __attribute__((always_inline)) sc_bigint(const ap_concat_ref<_SC_W2, _SC_T2, _SC_W3, _SC_T3>& ref) : sc_int(ref) {}
template <int _SC_W2, int _SC_I2, bool _SC_S2, ap_q_mode _SC_Q2, ap_o_mode _SC_O2, int _SC_N2 >
inline __attribute__((always_inline)) sc_bigint(const ap_fixed_base<_SC_W2, _SC_I2, _SC_S2, _SC_Q2, _SC_O2, _SC_N2>& op2) {
sc_int::V = (op2.to_ap_int_base(false)).V; }
template <int _SC_W2, int _SC_I2, bool _SC_S2, ap_q_mode _SC_Q2, ap_o_mode _SC_O2, int _SC_N2 >
inline __attribute__((always_inline)) sc_bigint(const af_bit_ref<_SC_W2, _SC_I2, _SC_S2, _SC_Q2, _SC_O2, _SC_N2>& op2) {
sc_int::V = (bool)op2;
}
template <int _SC_W2, int _SC_I2, bool _SC_S2, ap_q_mode _SC_Q2, ap_o_mode _SC_O2, int _SC_N2 >
inline __attribute__((always_inline)) sc_bigint(const af_range_ref<_SC_W2, _SC_I2, _SC_S2, _SC_Q2, _SC_O2, _SC_N2>& op2) {
sc_int::V = (op2.operator ap_int_base<_SC_W2, false>()).V;
}
template<int _SC_W2>
inline __attribute__((always_inline)) sc_bigint(const sc_bigint<_SC_W2> &op) {
sc_int::V = op.V; }
template<int _SC_W2>
inline __attribute__((always_inline)) sc_bigint(const sc_uint<_SC_W2> &op) {
sc_int::V = op.V; }
template<int _SC_W2>
inline __attribute__((always_inline)) sc_bigint(const sc_bv<_SC_W2> &op) {
sc_int::V = op.V; }
template<int _SC_W2, int _SC_I2, ap_q_mode _SC_Q2, ap_o_mode _SC_O2, int _SC_N2>
inline __attribute__((always_inline)) sc_bigint(const sc_fixed<_SC_W2, _SC_I2, _SC_Q2, _SC_O2,_SC_N2>& op) {
sc_int::V = op.to_ap_int_base(false).V; }
template<int _SC_W2, int _SC_I2, ap_q_mode _SC_Q2, ap_o_mode _SC_O2, int _SC_N2>
inline __attribute__((always_inline)) sc_bigint(const sc_ufixed<_SC_W2, _SC_I2, _SC_Q2, _SC_O2, _SC_N2>& op) {
sc_int::V = op.to_ap_int_base(false).V; }
inline __attribute__((always_inline)) sc_bigint(bool v) : sc_int(v) { }
inline __attribute__((always_inline)) sc_bigint(signed char v) : sc_int(v) { }
inline __attribute__((always_inline)) sc_bigint(unsigned char v) : sc_int(v) { }
inline __attribute__((always_inline)) sc_bigint(short v) : sc_int(v) { }
inline __attribute__((always_inline)) sc_bigint(unsigned short v) : sc_int(v) { }
inline __attribute__((always_inline)) sc_bigint(int v) : sc_int(v) { }
inline __attribute__((always_inline)) sc_bigint(unsigned int v) : sc_int(v) { }
inline __attribute__((always_inline)) sc_bigint(long v) : sc_int(v) { }
inline __attribute__((always_inline)) sc_bigint(unsigned long v) : sc_int(v) { }
inline __attribute__((always_inline)) sc_bigint(ap_slong v) : sc_int(v) { }
inline __attribute__((always_inline)) sc_bigint(ap_ulong v) : sc_int(v) { }
inline __attribute__((always_inline)) sc_bigint(double v) : sc_int(v) { }
inline __attribute__((always_inline)) sc_bigint(const char* v) : sc_int(v, 10) {}
#490 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/ap_sc_dt.h"
inline __attribute__((always_inline)) void operator = (const sc_bigint& op2) volatile {
sc_int::V = op2.V;
}
inline __attribute__((always_inline)) void operator = (const volatile sc_bigint& op2) volatile {
sc_int::V = op2.V;
}
inline __attribute__((always_inline)) sc_bigint& operator = (const volatile sc_bigint& op2) {
sc_int::V = op2.V;
return *this;
}
inline __attribute__((always_inline)) sc_bigint& operator = (const sc_bigint& op2) {
sc_int::V = op2.V;
return *this;
}
#515 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/ap_sc_dt.h"
template<int _SC_W2, int _SC_I2, ap_q_mode _SC_Q2, ap_o_mode _SC_O2, int _SC_N2>
inline __attribute__((always_inline)) sc_bigint& operator = (const sc_fixed<_SC_W2, _SC_I2, _SC_Q2, _SC_O2, _SC_N2>& op) {
sc_int::V = sc_bigint< _SC_W>((ap_fixed_base<_SC_W2, _SC_I2,true, _SC_Q2, _SC_O2, _SC_N2>)op).V;
return *this;
}
template<int _SC_W2, int _SC_I2, ap_q_mode _SC_Q2, ap_o_mode _SC_O2, int _SC_N2>
inline __attribute__((always_inline)) sc_bigint& operator = (const sc_ufixed<_SC_W2, _SC_I2, _SC_Q2, _SC_O2, _SC_N2>& op) {
sc_int::V = sc_bigint< _SC_W>((ap_fixed_base< _SC_W2, _SC_I2, false, _SC_Q2, _SC_O2, _SC_N2>)op).V;
return *this;
}
};
template<int _SC_W>
struct sc_biguint : ap_int_base<_SC_W,false> {
typedef ap_int_base<_SC_W,false> sc_uint;
inline __attribute__((always_inline)) sc_biguint() : sc_uint() { }
inline __attribute__((always_inline)) sc_biguint(const sc_uint &op) { sc_uint::V = op.V; }
inline __attribute__((always_inline)) sc_biguint(volatile sc_uint &op) {
sc_uint::V =op.V;
}
template<int _SC_W2, bool _SC_S2>
inline __attribute__((always_inline)) sc_biguint(const ap_int_base<_SC_W2, _SC_S2> &op) : sc_uint(op) { }
template<bool _SC_S2>
inline __attribute__((always_inline)) sc_biguint(ap_int_base<_SC_W, _SC_S2> &op) : sc_uint(op) { }
template<int _SC_W2, bool _SC_S2>
inline __attribute__((always_inline)) sc_biguint(const ap_range_ref<_SC_W2, _SC_S2>& ref) : sc_uint(ref) {}
template<int _SC_W2, bool _SC_S2>
inline __attribute__((always_inline)) sc_biguint(const ap_bit_ref< _SC_W2, _SC_S2>& ref) : sc_uint(ref) {}
template<int _SC_W2, typename _SC_T2, int _SC_W3, typename _SC_T3>
inline __attribute__((always_inline)) sc_biguint(const ap_concat_ref<_SC_W2, _SC_T2, _SC_W3, _SC_T3>& ref) : sc_uint(ref) {}
template <int _SC_W2, int _SC_I2, bool _SC_S2, ap_q_mode _SC_Q2, ap_o_mode _SC_O2 , int _SC_N2>
inline __attribute__((always_inline)) sc_biguint(const ap_fixed_base<_SC_W2, _SC_I2, _SC_S2, _SC_Q2, _SC_O2, _SC_N2>& op2) {
sc_uint::V = (op2.to_ap_int_base(false)).V;
}
template<int _SC_W2>
inline __attribute__((always_inline)) sc_biguint(const sc_int< _SC_W2> &op) {
sc_uint::V = op.V; }
template<int _SC_W2>
inline __attribute__((always_inline)) sc_biguint(const sc_biguint< _SC_W2> &op) {
sc_uint::V = op.V; }
template<int _SC_W2>
inline __attribute__((always_inline)) sc_biguint(const sc_bv< _SC_W2> &op) {
sc_uint::V = op.V; }
template<int _SC_W2, int _SC_I2, ap_q_mode _SC_Q2, ap_o_mode _SC_O2, int _SC_N2>
inline __attribute__((always_inline)) sc_biguint(const sc_fixed< _SC_W2, _SC_I2, _SC_Q2, _SC_O2, _SC_N2>& op) {
sc_uint::V = op.to_ap_int_base(false).V; }
template<int _SC_W2, int _SC_I2, ap_q_mode _SC_Q2, ap_o_mode _SC_O2, int _SC_N2>
inline __attribute__((always_inline)) sc_biguint(const sc_ufixed<_SC_W2, _SC_I2, _SC_Q2, _SC_O2, _SC_N2>& op) {
sc_uint::V = op.to_ap_int_base(false).V; }
template <int _SC_W2, int _SC_I2, bool _SC_S2, ap_q_mode _SC_Q2, ap_o_mode _SC_O2, int _SC_N2 >
inline __attribute__((always_inline)) sc_biguint(const af_bit_ref<_SC_W2, _SC_I2, _SC_S2, _SC_Q2, _SC_O2, _SC_N2>& op2) {
sc_uint::V = (bool)op2;
}
template <int _SC_W2, int _SC_I2, bool _SC_S2, ap_q_mode _SC_Q2, ap_o_mode _SC_O2, int _SC_N2 >
inline __attribute__((always_inline)) sc_biguint(const af_range_ref<_SC_W2, _SC_I2, _SC_S2, _SC_Q2, _SC_O2, _SC_N2>& op2) {
sc_uint::V = (op2.operator ap_int_base<_SC_W2, false>()).V;
}
inline __attribute__((always_inline)) sc_biguint(bool v) : sc_uint(v) { }
inline __attribute__((always_inline)) sc_biguint(signed char v) : sc_uint(v) { }
inline __attribute__((always_inline)) sc_biguint(unsigned char v) : sc_uint(v) { }
inline __attribute__((always_inline)) sc_biguint(short v) : sc_uint(v) { }
inline __attribute__((always_inline)) sc_biguint(unsigned short v) : sc_uint(v) { }
inline __attribute__((always_inline)) sc_biguint(int v) : sc_uint(v) { }
inline __attribute__((always_inline)) sc_biguint(unsigned int v) : sc_uint(v) { }
inline __attribute__((always_inline)) sc_biguint(long v) : sc_uint(v) { }
inline __attribute__((always_inline)) sc_biguint(unsigned long v) : sc_uint(v) { }
inline __attribute__((always_inline)) sc_biguint(ap_slong v) : sc_uint(v) { }
inline __attribute__((always_inline)) sc_biguint(ap_ulong v) : sc_uint(v) { }
inline __attribute__((always_inline)) sc_biguint(double v) : sc_uint(v) { }
inline __attribute__((always_inline)) sc_biguint(const char* v) : sc_uint(v, 10) { }
#627 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/ap_sc_dt.h"
inline __attribute__((always_inline)) void operator = (const sc_biguint& op2) volatile {
sc_uint::V =op2.V;
}
inline __attribute__((always_inline)) void operator = (const volatile sc_biguint& op2) volatile {
sc_uint::V = sc_biguint<_SC_W>(op2).V;
}
inline __attribute__((always_inline)) sc_biguint& operator = (const volatile sc_biguint& op2) {
sc_uint::V = op2.V;
return *this;
}
inline __attribute__((always_inline)) sc_biguint& operator = (const sc_biguint& op2) {
sc_uint::V = op2.V;
return *this;
}
#652 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/ap_sc_dt.h"
};
template<int _SC_W>
struct sc_bv : ap_int_base<_SC_W,false> {
typedef ap_int_base<_SC_W,false> sc_bv_base;
inline __attribute__((always_inline)) sc_bv() : sc_bv_base() { }
inline __attribute__((always_inline)) sc_bv(const sc_bv_base &op) { sc_bv_base::V = op.V; }
inline __attribute__((always_inline)) sc_bv(volatile sc_bv_base &op) {
sc_bv_base::V =op.V;
}
template<int _SC_W2, bool _SC_S2>
inline __attribute__((always_inline)) sc_bv(const ap_int_base<_SC_W2, _SC_S2> &op) : sc_bv_base(op) { }
template<bool _SC_S2>
inline __attribute__((always_inline)) sc_bv(ap_int_base<_SC_W, _SC_S2> &op) : sc_bv_base(op) { }
template<int _SC_W2, bool _SC_S2>
inline __attribute__((always_inline)) sc_bv(const ap_range_ref<_SC_W2, _SC_S2>& ref) : sc_bv_base(ref) {}
template<int _SC_W2, bool _SC_S2>
inline __attribute__((always_inline)) sc_bv(const ap_bit_ref< _SC_W2, _SC_S2>& ref) : sc_bv_base(ref) {}
template<int _SC_W2, typename _SC_T2, int _SC_W3, typename _SC_T3>
inline __attribute__((always_inline)) sc_bv(const ap_concat_ref<_SC_W2, _SC_T2, _SC_W3, _SC_T3>& ref) : sc_bv_base(ref) {}
template <int _SC_W2, int _SC_I2, bool _SC_S2, ap_q_mode _SC_Q2, ap_o_mode _SC_O2 , int _SC_N2>
inline __attribute__((always_inline)) sc_bv(const ap_fixed_base<_SC_W2, _SC_I2, _SC_S2, _SC_Q2, _SC_O2, _SC_N2>& op2) {
sc_bv_base::V = (op2.to_ap_int_base(false)).V;
}
template<int _SC_W2>
inline __attribute__((always_inline)) sc_bv(const sc_int< _SC_W2> &op) {
sc_bv_base::V = op.V; }
template<int _SC_W2>
inline __attribute__((always_inline)) sc_bv(const sc_bv< _SC_W2> &op) {
sc_bv_base::V = op.V; }
template<int _SC_W2>
inline __attribute__((always_inline)) sc_bv(const sc_uint< _SC_W2> &op) {
sc_bv_base::V = op.V; }
template<int _SC_W2, int _SC_I2, ap_q_mode _SC_Q2, ap_o_mode _SC_O2, int _SC_N2>
inline __attribute__((always_inline)) sc_bv(const sc_fixed< _SC_W2, _SC_I2, _SC_Q2, _SC_O2, _SC_N2>& op) {
sc_bv_base::V = op.to_ap_int_base(false).V; }
template<int _SC_W2, int _SC_I2, ap_q_mode _SC_Q2, ap_o_mode _SC_O2, int _SC_N2>
inline __attribute__((always_inline)) sc_bv(const sc_ufixed<_SC_W2, _SC_I2, _SC_Q2, _SC_O2, _SC_N2>& op) {
sc_bv_base::V = op.to_ap_int_base(false).V; }
template <int _SC_W2, int _SC_I2, bool _SC_S2, ap_q_mode _SC_Q2, ap_o_mode _SC_O2, int _SC_N2 >
inline __attribute__((always_inline)) sc_bv(const af_bit_ref<_SC_W2, _SC_I2, _SC_S2, _SC_Q2, _SC_O2, _SC_N2>& op2) {
sc_bv_base::V = (bool)op2;
}
template <int _SC_W2, int _SC_I2, bool _SC_S2, ap_q_mode _SC_Q2, ap_o_mode _SC_O2, int _SC_N2 >
inline __attribute__((always_inline)) sc_bv(const af_range_ref<_SC_W2, _SC_I2, _SC_S2, _SC_Q2, _SC_O2, _SC_N2>& op2) {
sc_bv_base::V = (op2.operator ap_int_base<_SC_W2, false>()).V;
}
inline __attribute__((always_inline)) sc_bv(bool v) : sc_bv_base(v) { }
inline __attribute__((always_inline)) sc_bv(signed char v) : sc_bv_base(v) { }
inline __attribute__((always_inline)) sc_bv(unsigned char v) : sc_bv_base(v) { }
inline __attribute__((always_inline)) sc_bv(short v) : sc_bv_base(v) { }
inline __attribute__((always_inline)) sc_bv(unsigned short v) : sc_bv_base(v) { }
inline __attribute__((always_inline)) sc_bv(int v) : sc_bv_base(v) { }
inline __attribute__((always_inline)) sc_bv(unsigned int v) : sc_bv_base(v) { }
inline __attribute__((always_inline)) sc_bv(long v) : sc_bv_base(v) { }
inline __attribute__((always_inline)) sc_bv(unsigned long v) : sc_bv_base(v) { }
inline __attribute__((always_inline)) sc_bv(ap_slong v) : sc_bv_base(v) { }
inline __attribute__((always_inline)) sc_bv(ap_ulong v) : sc_bv_base(v) { }
inline __attribute__((always_inline)) sc_bv(double v) : sc_bv_base(v) { }
inline __attribute__((always_inline)) sc_bv(const char* v) : sc_bv_base(v, 2) { }
#752 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/ap_sc_dt.h"
inline __attribute__((always_inline)) void operator = (const sc_bv& op2) volatile {
sc_bv_base::V =op2.V;
}
inline __attribute__((always_inline)) void operator = (const volatile sc_bv& op2) volatile {
sc_bv_base::V = sc_bv<_SC_W>(op2).V;
}
inline __attribute__((always_inline)) sc_bv& operator = (const volatile sc_bv& op2) {
sc_bv_base::V = op2.V;
return *this;
}
inline __attribute__((always_inline)) sc_bv& operator = (const sc_bv& op2) {
sc_bv_base::V = op2.V;
return *this;
}
#777 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/ap_sc_dt.h"
};
struct sc_bit : ap_int_base<1,false> {
typedef ap_int_base<1,false> sc_bit_base;
inline __attribute__((always_inline)) sc_bit() : sc_bit_base() { }
inline __attribute__((always_inline)) sc_bit(bool v) : sc_bit_base(v) { }
inline __attribute__((always_inline)) sc_bit(signed char v) : sc_bit_base(v) { }
inline __attribute__((always_inline)) sc_bit(unsigned char v) : sc_bit_base(v) { }
inline __attribute__((always_inline)) sc_bit(short v) : sc_bit_base(v) { }
inline __attribute__((always_inline)) sc_bit(unsigned short v) : sc_bit_base(v) { }
inline __attribute__((always_inline)) sc_bit(int v) : sc_bit_base(v) { }
inline __attribute__((always_inline)) sc_bit(unsigned int v) : sc_bit_base(v) { }
inline __attribute__((always_inline)) sc_bit(long v) : sc_bit_base(v) { }
inline __attribute__((always_inline)) sc_bit(unsigned long v) : sc_bit_base(v) { }
inline __attribute__((always_inline)) sc_bit(ap_slong v) : sc_bit_base(v) { }
inline __attribute__((always_inline)) sc_bit(ap_ulong v) : sc_bit_base(v) { }
template<int _SC_W>
inline __attribute__((always_inline)) sc_bit(const sc_int<_SC_W>& op ) {
sc_bit_base::V = op.V;
}
template<int _SC_W>
inline __attribute__((always_inline)) sc_bit(const sc_uint<_SC_W>& op ) {
sc_bit_base::V = op.V;
}
template<int _SC_W>
inline __attribute__((always_inline)) sc_bit(const sc_bv<_SC_W>& op ) {
sc_bit_base::V = op.V;
}
template<int _SC_W, bool _SC_S>
inline __attribute__((always_inline)) sc_bit(const ap_int_base<_SC_W, _SC_S>& op ) {
sc_bit_base::V = op.V;
}
inline __attribute__((always_inline)) sc_bit(const sc_bit &op) {
sc_bit_base::V = op.V;
}
inline __attribute__((always_inline)) sc_bit(const volatile sc_bit &op) {
sc_bit_base::V = op.V;
}
inline __attribute__((always_inline)) sc_bit(char v) {
sc_bit_base::V = (v=='0') ? 0 : 1;
}
#846 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/ap_sc_dt.h"
inline __attribute__((always_inline)) void operator = (const sc_bit& op2) volatile {
sc_bit_base::V = op2.V;
}
inline __attribute__((always_inline)) void operator = (const volatile sc_bit& op2) volatile {
sc_bit_base::V = op2.V;
}
inline __attribute__((always_inline)) sc_bit& operator = (const volatile sc_bit& op2) {
sc_bit_base::V = op2.V;
return *this;
}
inline __attribute__((always_inline)) sc_bit& operator = (const sc_bit& op2) {
sc_bit_base::V = op2.V;
return *this;
}
#869 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/ap_sc_dt.h"
inline __attribute__((always_inline)) bool to_bool() {
return sc_bit_base::V;
}
};
typedef sc_bit sc_logic;
template<int _SC_W>
struct sc_lv : ap_int_base<_SC_W,false> {
typedef ap_int_base<_SC_W,false> sc_lv_base;
inline __attribute__((always_inline)) sc_lv() : sc_lv_base() { }
inline __attribute__((always_inline)) sc_lv(const sc_lv_base &op) { sc_lv_base::V = op.V; }
inline __attribute__((always_inline)) sc_lv(volatile sc_lv_base &op) {
sc_lv_base::V =op.V;
}
template<int _SC_W2, bool _SC_S2>
inline __attribute__((always_inline)) sc_lv(const ap_int_base<_SC_W2, _SC_S2> &op) : sc_lv_base(op) { }
template<bool _SC_S2>
inline __attribute__((always_inline)) sc_lv(ap_int_base<_SC_W, _SC_S2> &op) : sc_lv_base(op) { }
template<int _SC_W2, bool _SC_S2>
inline __attribute__((always_inline)) sc_lv(const ap_range_ref<_SC_W2, _SC_S2>& ref) : sc_lv_base(ref) {}
template<int _SC_W2, bool _SC_S2>
inline __attribute__((always_inline)) sc_lv(const ap_bit_ref< _SC_W2, _SC_S2>& ref) : sc_lv_base(ref) {}
template<int _SC_W2, typename _SC_T2, int _SC_W3, typename _SC_T3>
inline __attribute__((always_inline)) sc_lv(const ap_concat_ref<_SC_W2, _SC_T2, _SC_W3, _SC_T3>& ref) : sc_lv_base(ref) {}
template <int _SC_W2, int _SC_I2, bool _SC_S2, ap_q_mode _SC_Q2, ap_o_mode _SC_O2 , int _SC_N2>
inline __attribute__((always_inline)) sc_lv(const ap_fixed_base<_SC_W2, _SC_I2, _SC_S2, _SC_Q2, _SC_O2, _SC_N2>& op2) {
sc_lv_base::V = (op2.to_ap_int_base(false)).V;
}
template<int _SC_W2>
inline __attribute__((always_inline)) sc_lv(const sc_int< _SC_W2> &op) {
sc_lv_base::V = op.V; }
template<int _SC_W2>
inline __attribute__((always_inline)) sc_lv(const sc_lv< _SC_W2> &op) {
sc_lv_base::V = op.V; }
template<int _SC_W2>
inline __attribute__((always_inline)) sc_lv(const sc_uint< _SC_W2> &op) {
sc_lv_base::V = op.V; }
template<int _SC_W2, int _SC_I2, ap_q_mode _SC_Q2, ap_o_mode _SC_O2, int _SC_N2>
inline __attribute__((always_inline)) sc_lv(const sc_fixed< _SC_W2, _SC_I2, _SC_Q2, _SC_O2, _SC_N2>& op) {
sc_lv_base::V = op.to_ap_int_base(false).V; }
template<int _SC_W2, int _SC_I2, ap_q_mode _SC_Q2, ap_o_mode _SC_O2, int _SC_N2>
inline __attribute__((always_inline)) sc_lv(const sc_ufixed<_SC_W2, _SC_I2, _SC_Q2, _SC_O2, _SC_N2>& op) {
sc_lv_base::V = op.to_ap_int_base(false).V; }
template <int _SC_W2, int _SC_I2, bool _SC_S2, ap_q_mode _SC_Q2, ap_o_mode _SC_O2, int _SC_N2 >
inline __attribute__((always_inline)) sc_lv(const af_bit_ref<_SC_W2, _SC_I2, _SC_S2, _SC_Q2, _SC_O2, _SC_N2>& op2) {
sc_lv_base::V = (bool)op2;
}
template <int _SC_W2, int _SC_I2, bool _SC_S2, ap_q_mode _SC_Q2, ap_o_mode _SC_O2, int _SC_N2 >
inline __attribute__((always_inline)) sc_lv(const af_range_ref<_SC_W2, _SC_I2, _SC_S2, _SC_Q2, _SC_O2, _SC_N2>& op2) {
sc_lv_base::V = (op2.operator ap_int_base<_SC_W2, false>()).V;
}
inline __attribute__((always_inline)) sc_lv(bool v) : sc_lv_base(v) { }
inline __attribute__((always_inline)) sc_lv(signed char v) : sc_lv_base(v) { }
inline __attribute__((always_inline)) sc_lv(unsigned char v) : sc_lv_base(v) { }
inline __attribute__((always_inline)) sc_lv(short v) : sc_lv_base(v) { }
inline __attribute__((always_inline)) sc_lv(unsigned short v) : sc_lv_base(v) { }
inline __attribute__((always_inline)) sc_lv(int v) : sc_lv_base(v) { }
inline __attribute__((always_inline)) sc_lv(unsigned int v) : sc_lv_base(v) { }
inline __attribute__((always_inline)) sc_lv(long v) : sc_lv_base(v) { }
inline __attribute__((always_inline)) sc_lv(unsigned long v) : sc_lv_base(v) { }
inline __attribute__((always_inline)) sc_lv(ap_slong v) : sc_lv_base(v) { }
inline __attribute__((always_inline)) sc_lv(ap_ulong v) : sc_lv_base(v) { }
inline __attribute__((always_inline)) sc_lv(double v) : sc_lv_base(v) { }
inline __attribute__((always_inline)) sc_lv(const char* v) : sc_lv_base(v, 2) { }
#975 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/ap_sc_dt.h"
inline __attribute__((always_inline)) void operator = (const sc_lv& op2) volatile {
sc_lv_base::V =op2.V;
}
inline __attribute__((always_inline)) void operator = (const volatile sc_lv& op2) volatile {
sc_lv_base::V = sc_lv<_SC_W>(op2).V;
}
inline __attribute__((always_inline)) sc_lv& operator = (const volatile sc_lv& op2) {
sc_lv_base::V = op2.V;
return *this;
}
inline __attribute__((always_inline)) sc_lv& operator = (const sc_lv& op2) {
sc_lv_base::V = op2.V;
return *this;
}
#1000 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/ap_sc_dt.h"
};
typedef ap_q_mode sc_q_mode;
typedef ap_o_mode sc_o_mode;
const int SC_BUILTIN_WL_ = 32;
const int SC_BUILTIN_IWL_ = 32;
const sc_q_mode SC_BUILTIN_Q_MODE_ = SC_TRN;
const sc_o_mode SC_BUILTIN_O_MODE_ = SC_WRAP;
const int SC_BUILTIN_N_BITS_ = 0;
const int SC_DEFAULT_WL_ = SC_BUILTIN_WL_;
const int SC_DEFAULT_IWL_ = SC_BUILTIN_IWL_;
const sc_q_mode SC_DEFAULT_Q_MODE_ = SC_BUILTIN_Q_MODE_;
const sc_o_mode SC_DEFAULT_O_MODE_ = SC_BUILTIN_O_MODE_;
const int SC_DEFAULT_N_BITS_ = SC_BUILTIN_N_BITS_;
template<int _SC_W, int _SC_I,
sc_q_mode _SC_Q = SC_DEFAULT_Q_MODE_,
sc_o_mode _SC_O = SC_DEFAULT_O_MODE_, int _SC_N = SC_DEFAULT_N_BITS_>
struct sc_fixed : ap_fixed_base<_SC_W,_SC_I,true,_SC_Q,_SC_O, _SC_N> {
typedef ap_fixed_base<_SC_W,_SC_I,true,_SC_Q,_SC_O, _SC_N> sc_fixed_base;
inline __attribute__((always_inline)) sc_fixed() : sc_fixed_base() { }
template<int _SC_W2,int _SC_I2, bool _SC_S2, sc_q_mode _SC_Q2, sc_o_mode _SC_O2, int _SC_N2>
inline __attribute__((always_inline)) sc_fixed(const ap_fixed_base<_SC_W2, _SC_I2, _SC_S2, _SC_Q2, _SC_O2, _SC_N2> &op) :
sc_fixed_base(op) { }
template<typename _SC_T>
inline __attribute__((always_inline)) sc_fixed(_SC_T v) : sc_fixed_base(v) { }
};
template<int _SC_W, int _SC_I,
sc_q_mode _SC_Q = SC_DEFAULT_Q_MODE_,
sc_o_mode _SC_O = SC_DEFAULT_O_MODE_, int _SC_N = SC_DEFAULT_N_BITS_>
struct sc_ufixed : ap_fixed_base<_SC_W,_SC_I,false,_SC_Q,_SC_O, _SC_N> {
typedef ap_fixed_base<_SC_W,_SC_I,false,_SC_Q,_SC_O, _SC_N> sc_ufixed_base;
inline __attribute__((always_inline)) sc_ufixed() : sc_ufixed_base() { }
template<int _SC_W2,int _SC_I2, bool _SC_S2, sc_q_mode _SC_Q2, sc_o_mode _SC_O2, int _SC_N2>
inline __attribute__((always_inline)) sc_ufixed(const ap_fixed_base<_SC_W2, _SC_I2, _SC_S2, _SC_Q2, _SC_O2, _SC_N2> &op) :
sc_ufixed_base(op) { }
template<typename T>
inline __attribute__((always_inline)) sc_ufixed(T v) : sc_ufixed_base(v) { }
};
}
}
using namespace _ap_sc_;
using namespace sc_dt;
using sc_dt::sc_bit;
using sc_dt::sc_logic;
using sc_dt::sc_bv;
using sc_dt::sc_lv;
using sc_dt::int64;
using sc_dt::uint64;
using sc_dt::sc_int;
using sc_dt::sc_bigint;
using sc_dt::sc_uint;
using sc_dt::sc_biguint;
using sc_dt::sc_int;
using sc_dt::sc_int;
using sc_dt::sc_uint;
using sc_dt::sc_uint;
typedef void****** __ap_sc_dt_end__;
#51 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/ap_systemc.h" 2
#1 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/ap_sc_core.h" 1
#60 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/ap_sc_core.h"
typedef void****** __ap_sc_core_begin__;
extern "C" void _ssdm_op_Wait(...);
extern "C" void _ssdm_op_SpecPort(...);
extern "C" void _ssdm_op_SpecExt(...);
typedef bool _uint1_;
#98 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/ap_sc_core.h"
template<typename T1>
inline __attribute__((always_inline)) T1 _ssdm_op_READ(volatile T1& P);
template<int W, bool S>
inline __attribute__((always_inline)) ap_int_base<W,S> _ssdm_op_READ(volatile ap_int_base<W,S>& P);
template<int W>
inline __attribute__((always_inline)) sc_int<W> _ssdm_op_READ(volatile sc_int<W>& P);
template<int W>
inline __attribute__((always_inline)) sc_uint<W> _ssdm_op_READ(volatile sc_uint<W>& P);
template<typename T1, typename T2>
inline __attribute__((always_inline)) void _ssdm_op_WRITE(volatile T1& P, const T2& val);
template<int W, bool S, typename T2>
inline __attribute__((always_inline)) void _ssdm_op_WRITE(volatile ap_int_base<W,S>& P, const T2& val);
template<int W, typename T2>
inline __attribute__((always_inline)) void _ssdm_op_WRITE(volatile sc_int<W>& P, const T2& val);
template<int W, typename T2>
inline __attribute__((always_inline)) void _ssdm_op_WRITE(volatile sc_uint<W>& P, const T2& val);
#125 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/ap_sc_core.h"
template<> inline __attribute__((always_inline)) sc_bit _ssdm_op_READ<sc_bit>(volatile sc_bit& P); template<typename T2> inline __attribute__((always_inline)) void _ssdm_op_WRITE(volatile sc_bit& P, const T2& val);
template<> inline __attribute__((always_inline)) bool _ssdm_op_READ<bool>(volatile bool& P); template<typename T2> inline __attribute__((always_inline)) void _ssdm_op_WRITE(volatile bool& P, const T2& val);
template<> inline __attribute__((always_inline)) char _ssdm_op_READ<char>(volatile char& P); template<typename T2> inline __attribute__((always_inline)) void _ssdm_op_WRITE(volatile char& P, const T2& val);
template<> inline __attribute__((always_inline)) signed char _ssdm_op_READ<signed char>(volatile signed char& P); template<typename T2> inline __attribute__((always_inline)) void _ssdm_op_WRITE(volatile signed char& P, const T2& val);
template<> inline __attribute__((always_inline)) unsigned char _ssdm_op_READ<unsigned char>(volatile unsigned char& P); template<typename T2> inline __attribute__((always_inline)) void _ssdm_op_WRITE(volatile unsigned char& P, const T2& val);
template<> inline __attribute__((always_inline)) short _ssdm_op_READ<short>(volatile short& P); template<typename T2> inline __attribute__((always_inline)) void _ssdm_op_WRITE(volatile short& P, const T2& val);
template<> inline __attribute__((always_inline)) unsigned short _ssdm_op_READ<unsigned short>(volatile unsigned short& P); template<typename T2> inline __attribute__((always_inline)) void _ssdm_op_WRITE(volatile unsigned short& P, const T2& val);
template<> inline __attribute__((always_inline)) int _ssdm_op_READ<int>(volatile int& P); template<typename T2> inline __attribute__((always_inline)) void _ssdm_op_WRITE(volatile int& P, const T2& val);
template<> inline __attribute__((always_inline)) unsigned int _ssdm_op_READ<unsigned int>(volatile unsigned int& P); template<typename T2> inline __attribute__((always_inline)) void _ssdm_op_WRITE(volatile unsigned int& P, const T2& val);
template<> inline __attribute__((always_inline)) long _ssdm_op_READ<long>(volatile long& P); template<typename T2> inline __attribute__((always_inline)) void _ssdm_op_WRITE(volatile long& P, const T2& val);
template<> inline __attribute__((always_inline)) unsigned long _ssdm_op_READ<unsigned long>(volatile unsigned long& P); template<typename T2> inline __attribute__((always_inline)) void _ssdm_op_WRITE(volatile unsigned long& P, const T2& val);
template<> inline __attribute__((always_inline)) ap_slong _ssdm_op_READ<ap_slong>(volatile ap_slong& P); template<typename T2> inline __attribute__((always_inline)) void _ssdm_op_WRITE(volatile ap_slong& P, const T2& val);
template<> inline __attribute__((always_inline)) ap_ulong _ssdm_op_READ<ap_ulong>(volatile ap_ulong& P); template<typename T2> inline __attribute__((always_inline)) void _ssdm_op_WRITE(volatile ap_ulong& P, const T2& val);
template<typename T>
inline __attribute__((always_inline)) bool _ssdm_op_TLM_CAN_GET(volatile T& P);
template<typename T>
inline __attribute__((always_inline)) bool _ssdm_op_TLM_CAN_PUT(volatile T& P);
namespace _ap_sc_ {
namespace sc_core {
class sc_interface { public: inline __attribute__((always_inline)) sc_interface() { } };
class sc_prim_channel { };
template<class T>
class sc_signal_in_if : public sc_interface {
public:
volatile T Val;
public:
inline __attribute__((always_inline)) sc_signal_in_if() { }
inline __attribute__((always_inline)) T read() { T tmp = _ssdm_op_READ(Val); return tmp; }
inline __attribute__((always_inline)) T read() const {
T tmp;
_ssdm_op_IfRead(&Val, &tmp);
return tmp;
}
operator const T () { return this->read(); }
operator const T () const { return this->read(); }
};
template<class T>
class sc_signal_inout_if : public sc_signal_in_if<T> {
public:
typedef sc_signal_in_if<T> Base;
public:
inline __attribute__((always_inline)) sc_signal_inout_if() { }
sc_signal_inout_if& operator = (const sc_signal_inout_if<T>& v) {
write(v);
return *this;
}
template<class _T2>
inline __attribute__((always_inline)) void write(const _T2& v2) {
T v = v2;
_ssdm_op_WRITE(Base::Val, v);
}
template<class _T2>
inline __attribute__((always_inline)) sc_signal_inout_if& operator = (const _T2& v2) {
write(v2);
return *this;
}
};
#211 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/ap_sc_core.h"
template<class T>
class sc_fifo_in_if : public sc_interface {
public:
volatile T Val;
inline __attribute__((always_inline)) sc_fifo_in_if(const char* name_ = "") {
_ssdm_op_SpecInterface(this, "ap_fifo", 0, 0, "", 0, 0, "", "", "", 0, 0, 0, 0, "", "");
_ssdm_op_SpecPort("", _ssdm_tlm_fifo_in, "", name_, 0, 0, this);
}
inline __attribute__((always_inline)) T read() { T tmp = _ssdm_op_READ(Val); return tmp; }
inline __attribute__((always_inline)) void read(T &t) { t = read(); }
inline __attribute__((always_inline)) bool nb_read(T &t) {
return ({ _uint1_ __emptyn; typeof(t) tmpV; __emptyn = _ssdm_op_IfNbRead(&*this, &tmpV); if(__emptyn) t = tmpV; __emptyn; });
}
inline __attribute__((always_inline)) bool num_available() const {
return _ssdm_op_TLM_CAN_GET(Val);
}
};
template<class T>
class sc_fifo_out_if : public sc_interface {
public:
volatile T Val;
inline __attribute__((always_inline)) sc_fifo_out_if(const char* name_ = "") {
_ssdm_op_SpecInterface(this, "ap_fifo", 0, 0,"", 0, 0, "", "", "", 0, 0, 0, 0, "", "");
_ssdm_op_SpecPort("", _ssdm_tlm_fifo_out, "", name_, 0, 0, this);
}
inline __attribute__((always_inline)) void write(const T &t ) { _ssdm_op_WRITE(Val, t); }
inline __attribute__((always_inline)) bool nb_write( const T &t ) {
return ({ _uint1_ __fulln; __fulln = _ssdm_op_IfNbWrite(&*this, &t); __fulln; });
}
inline __attribute__((always_inline)) bool num_free() const {
return _ssdm_op_TLM_CAN_PUT(Val);
}
};
class sc_signal_bool_deval {
public:
sc_signal_bool_deval& operator == (bool ) const;
};
class sc_port_base { public: inline __attribute__((always_inline)) sc_port_base() { } };
template<class IF>
class sc_port_b : public sc_port_base {
public:
IF m_if;
public:
inline __attribute__((always_inline)) sc_port_b() : m_if() { }
inline __attribute__((always_inline)) explicit sc_port_b( const char* name_ ) : m_if() {
_ssdm_op_SpecExt("name", name_, this);
}
inline __attribute__((always_inline)) void bind( IF& interface_ ) {
_ssdm_op_SpecPortMap(this, &interface_);
}
inline __attribute__((always_inline)) void operator () ( IF& interface_ ) { bind(interface_); }
inline __attribute__((always_inline)) void bind( sc_prim_channel& ic__ ) {
_ssdm_op_SpecPortMap(this, &ic__);
}
inline __attribute__((always_inline)) void operator () ( sc_prim_channel& ic__ ) { bind(ic__); }
inline __attribute__((always_inline)) void bind ( sc_port_b& parent_ ) { bind(parent_.m_if); }
inline __attribute__((always_inline)) void operator () ( sc_port_b& parent_ ) { bind(parent_); }
inline __attribute__((always_inline)) IF* operator -> () { return &m_if; }
};
template <class IF, int N = 1>
class sc_port : public sc_port_b<IF>
{
typedef sc_port_b<IF> base_type;
typedef sc_port<IF,N> this_type;
public:
inline __attribute__((always_inline)) sc_port() : base_type() { }
inline __attribute__((always_inline)) explicit sc_port( const char* name_ ) : base_type(name_) { }
};
template<class T>
class sc_signal : public sc_signal_inout_if<T> {
public:
typedef sc_signal_inout_if<T> Base;
public:
inline __attribute__((always_inline)) sc_signal() { }
inline __attribute__((always_inline)) explicit sc_signal( const char* name_ ) { }
inline __attribute__((always_inline)) sc_signal& operator = ( const T& v) {
_ssdm_op_WRITE(Base::Base::Val, v);
return *this;
}
};
template <class T>
class sc_in : public sc_port_b<sc_signal_in_if<T> > {
public:
typedef T data_type;
typedef sc_port_b<sc_signal_in_if<T> > Base;
public:
inline __attribute__((always_inline)) sc_in() { }
inline __attribute__((always_inline)) explicit sc_in( const char* name_ ) {
_ssdm_op_SpecPort("", 0, "", name_, 0, 0, this);
}
inline __attribute__((always_inline)) data_type read() { return Base::m_if.read(); }
inline __attribute__((always_inline)) const data_type read() const { return Base::m_if.read(); }
operator const data_type& () const {
return const_cast<sc_in>(this)->read();
}
operator const data_type () {
return this->read();
}
};
class sc_event;
typedef void* sc_event_finder;
template<>
class sc_in<bool> : public sc_port_b<sc_signal_in_if<bool> > {
public:
typedef bool data_type;
typedef sc_port_b<sc_signal_in_if<bool> > Base;
public:
inline __attribute__((always_inline)) void pos() const { }
inline __attribute__((always_inline)) void neg() const { }
inline __attribute__((always_inline)) sc_in<bool>() { }
inline __attribute__((always_inline)) explicit sc_in<bool>( const char* name_ ) {
_ssdm_op_SpecPort("", 0, "", name_, 0, 0, this);
}
inline __attribute__((always_inline)) bool read() { return Base::m_if.read(); }
operator const bool () { return Base::m_if.read(); }
const sc_signal_bool_deval& delayed() const;
};
typedef sc_in<bool> sc_in_clk;
template<>
class sc_in<sc_logic> : public sc_port_b<sc_signal_in_if<sc_logic> > {
public:
typedef sc_logic data_type;
typedef sc_port_b<sc_signal_in_if<sc_logic> > Base;
public:
inline __attribute__((always_inline)) void pos() const {
}
inline __attribute__((always_inline)) void neg() const {
}
inline __attribute__((always_inline)) sc_in<sc_logic>() { }
inline __attribute__((always_inline)) explicit sc_in<sc_logic>( const char* name_ ) {
_ssdm_op_SpecPort("", 0, "", name_, 0, 0, this);
}
inline __attribute__((always_inline)) sc_logic read() { return Base::m_if.read(); }
operator const sc_logic () { return Base::m_if.read(); }
inline __attribute__((always_inline)) const void delayed() const { }
};
template <class _T>
class sc_inout : public sc_port_b<sc_signal_inout_if<_T> > {
typedef sc_port_b<sc_signal_inout_if<_T> > Base;
typedef _T data_type;
public:
inline __attribute__((always_inline)) sc_inout() { }
inline __attribute__((always_inline)) explicit sc_inout( const char* name_ ) {
_ssdm_op_SpecPort("", 1, "", name_, 0, 0, this);
}
inline __attribute__((always_inline)) void write(const _T& v) { Base::m_if.write(v); }
template<typename _T2>
inline __attribute__((always_inline)) void operator = ( const _T2& v) { Base::m_if.write(_T(v)); }
inline __attribute__((always_inline)) data_type read() { return Base::m_if.read(); }
operator const data_type& () const {
return const_cast<sc_inout>(this)->read();
}
operator const data_type () { return this->read(); }
};
template <class _T>
class sc_out : public sc_inout<_T> {
typedef sc_port_b<sc_signal_inout_if<_T> > Base;
public:
inline __attribute__((always_inline)) sc_out() { }
inline __attribute__((always_inline)) explicit sc_out( const char* name_ ) : sc_inout<_T>(name_) { }
template<typename _T2>
inline __attribute__((always_inline)) void operator = ( const _T2& v) { Base::m_if.write(_T(v)); }
template<typename _T2>
inline __attribute__((always_inline)) void operator = ( const sc_signal<_T2>& v) { Base::m_if.write(_T(v.read())); }
};
template <class T>
class sc_fifo : public sc_interface, public sc_prim_channel {
public:
volatile T Val;
inline __attribute__((always_inline)) explicit sc_fifo( int size_ = 1 ) {
_ssdm_op_SpecChannel("", _ssdm_sc_fifo, "", "sc_fifo_chn", size_, size_, this, this);
_ssdm_op_SpecInterface(this, "ap_fifo", 0, 0, "", 0, 0, "", "", "", 0, 0, 0, 0, "", "");
}
inline __attribute__((always_inline)) explicit sc_fifo( const char* name_, int size_ = 1 ) {
_ssdm_op_SpecChannel("", _ssdm_sc_fifo, "", name_, size_, size_, this, this);
_ssdm_op_SpecInterface(this, "ap_fifo", 0, 0, "", 0, 0, "", "", "", 0, 0, 0, 0, "", "");
}
inline __attribute__((always_inline)) T read() { T tmp = _ssdm_op_READ(Val); return tmp; }
inline __attribute__((always_inline)) void read(T &t) { t = this->read(); }
inline __attribute__((always_inline)) bool nb_read(T &t) {
return ({ _uint1_ __emptyn; typeof(t) tmpV; __emptyn = _ssdm_op_IfNbRead(&*this, &tmpV); if(__emptyn) t = tmpV; __emptyn; });
}
inline __attribute__((always_inline)) void write(const T& t) { _ssdm_op_WRITE(Val, t); }
inline __attribute__((always_inline)) bool nb_write(const T &t ) {
return ({ _uint1_ __fulln; __fulln = _ssdm_op_IfNbWrite(&*this, &t); __fulln; });
}
inline __attribute__((always_inline)) bool num_available() const {
return _ssdm_op_TLM_CAN_GET(Val);
}
inline __attribute__((always_inline)) bool num_free() const {
return _ssdm_op_TLM_CAN_PUT(Val);
}
};
template <class T>
class sc_fifo_in : public sc_port_b<sc_fifo_in_if<T> > {
typedef sc_port_b<sc_fifo_in_if<T> > Base;
public:
explicit sc_fifo_in() { }
explicit sc_fifo_in( const char* name_){ }
inline __attribute__((always_inline)) T read() { return Base::m_if.read(); }
inline __attribute__((always_inline)) void read(T &t) { Base::m_if.read(t); }
inline __attribute__((always_inline)) bool nb_read(T &t) { return Base::m_if.nb_read(t); }
inline __attribute__((always_inline)) bool num_available() { return Base::m_if.num_available(); }
};
template <class T>
class sc_fifo_out : public sc_port_b<sc_fifo_out_if<T> > {
typedef sc_port_b<sc_fifo_out_if<T> > Base;
public:
explicit sc_fifo_out() { }
explicit sc_fifo_out( const char* name_) { }
inline __attribute__((always_inline)) void write(const T& v) { Base::m_if.write(v); }
inline __attribute__((always_inline)) bool nb_write(const T& v) { return Base::m_if.nb_write(v); }
inline __attribute__((always_inline)) bool num_free() { return Base::m_if.num_free(); }
};
struct sc_bind_proxy
{
sc_interface* iface;
sc_port_base* port;
sc_bind_proxy();
sc_bind_proxy( sc_interface& );
sc_bind_proxy( sc_port_base& );
};
extern const sc_bind_proxy SC_BIND_PROXY_NIL;
class sc_process_host { };
class sc_process_base;
class sc_method_process;
typedef class sc_method_process* sc_method_handle;
class sc_cthread_process;
typedef class sc_cthread_process* sc_cthread_handle;
class sc_thread_process;
typedef class sc_thread_process* sc_thread_handle;
class sc_module;
typedef void (sc_process_host::*SC_ENTRY_FUNC)();
class sc_simcontext
{
public:
sc_method_handle register_method_process( const char* name,
SC_ENTRY_FUNC fn,
sc_module* );
sc_thread_handle register_thread_process( const char* name,
SC_ENTRY_FUNC fn,
sc_module* );
sc_cthread_handle register_cthread_process( const char* name,
SC_ENTRY_FUNC fn,
sc_module* );
};
class sc_sensitive {
public:
sc_sensitive& operator << ( sc_method_handle );
sc_sensitive& operator << ( sc_thread_handle );
sc_sensitive& operator () ( const sc_interface& );
sc_sensitive& operator () ( const sc_port_base& );
sc_sensitive& operator () ( sc_event_finder& );
sc_sensitive& operator () ( sc_cthread_handle, sc_event_finder& );
sc_sensitive& operator << ( const sc_interface& );
sc_sensitive& operator << ( const sc_port_base& );
sc_sensitive& operator << ( sc_event_finder& );
typedef sc_signal_in_if<bool> in_if_b_type;
typedef sc_signal_in_if<sc_dt::sc_logic> in_if_l_type;
typedef sc_in<bool> in_port_b_type;
typedef sc_in<sc_dt::sc_logic> in_port_l_type;
sc_sensitive& operator () ( sc_cthread_handle, const in_if_b_type& );
sc_sensitive& operator () ( sc_cthread_handle, const in_if_l_type& );
sc_sensitive& operator () ( sc_cthread_handle, const in_port_b_type& );
sc_sensitive& operator () ( sc_cthread_handle, const in_port_l_type& );
};
class sc_sensitive_pos : public sc_sensitive { };
class sc_sensitive_neg : public sc_sensitive { };
class sc_module_name
{
public:
sc_module_name( const char* ) {};
sc_module_name( const sc_module_name& ) {};
};
class sc_module : public sc_process_host {
public:
sc_module( const char* nm );
sc_module( const sc_module_name& nm );
sc_module();
sc_module& operator << ( sc_interface& );
sc_module& operator << ( sc_port_base& );
sc_module& operator , ( sc_interface& interface_ )
{ return operator << ( interface_ ); }
sc_module& operator , ( sc_port_base& port_ )
{ return operator << ( port_ ); }
protected:
void reset_signal_is( const sc_in<bool>& port, bool level );
void reset_signal_is( const sc_signal<bool>& sig, bool level );
void wait();
void halt();
void wait( int n );
void wait_until( const sc_signal_bool_deval& s );
void watching( const sc_signal_bool_deval& s );
sc_sensitive sensitive;
sc_sensitive_pos sensitive_pos;
sc_sensitive_neg sensitive_neg;
public:
sc_simcontext* sc_get_curr_simcontext();
sc_simcontext* simcontext();
void defunct() { }
void operator () ( const sc_bind_proxy& p001,
const sc_bind_proxy& p002 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p003 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p004 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p005 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p006 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p007 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p008 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p009 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p010 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p011 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p012 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p013 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p014 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p015 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p016 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p017 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p018 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p019 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p020 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p021 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p022 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p023 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p024 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p025 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p026 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p027 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p028 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p029 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p030 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p031 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p032 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p033 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p034 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p035 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p036 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p037 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p038 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p039 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p040 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p041 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p042 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p043 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p044 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p045 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p046 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p047 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p048 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p049 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p050 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p051 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p052 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p053 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p054 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p055 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p056 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p057 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p058 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p059 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p060 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p061 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p062 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p063 = SC_BIND_PROXY_NIL,
const sc_bind_proxy& p064 = SC_BIND_PROXY_NIL );
};
#799 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/ap_sc_core.h"
typedef sc_module sc_channel;
typedef sc_module sc_behavior;
inline __attribute__((always_inline)) void wait(int n=1) {
if (n <= 1) { _ssdm_op_Wait(1); return; }
for (int i = 0; i < n; ++i) {
#pragma AUTOPILOT unroll complete
_ssdm_op_Wait(1);
}
}
class sc_trace_file { sc_trace_file(){} };
}
}
using namespace _ap_sc_;
#833 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/ap_sc_core.h"
template<typename T>
inline __attribute__((always_inline)) T _ssdm_op_READ(sc_core::sc_in<T>& P) {
return P.read();
}
template<typename T1, typename T2>
inline __attribute__((always_inline)) void _ssdm_op_WRITE(sc_core::sc_out<T1>& P, const T2& val) {
T1 valInt = val;
P.write(valInt);
}
template<typename T>
inline __attribute__((always_inline)) T _ssdm_op_READ(sc_core::sc_fifo<T>& P) {
return P.read();
}
template<typename T1, typename T2>
inline __attribute__((always_inline)) void _ssdm_op_WRITE(sc_core::sc_fifo<T1>& P, const T2& val) {
P.write(val);
}
template<typename T>
inline __attribute__((always_inline)) T _ssdm_op_READ(sc_core::sc_fifo_in<T>& P) {
return P.read();
}
template<typename T1, typename T2>
inline __attribute__((always_inline)) void _ssdm_op_WRITE(sc_core::sc_fifo_out<T1>& P, const T2& val) {
P.write(val);
}
typedef void****** __ap_sc_core_end__;
#52 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/ap_systemc.h" 2
#1 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/ap_sc_extras.h" 1
#60 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/ap_sc_extras.h"
template<typename T1, typename T2>
inline __attribute__((always_inline)) void _ssdm_op_WRITE(volatile T1& P, const T2& val) {
T1 tmp = val;
_ssdm_op_IfWrite(&P, &tmp);
}
template<typename T1>
inline __attribute__((always_inline)) T1 _ssdm_op_READ(volatile T1& P) {
T1 val;
_ssdm_op_IfRead(&P, &val);
return val;
}
template<int W, bool S, typename T2>
inline __attribute__((always_inline)) void _ssdm_op_WRITE(volatile ap_int_base<W,S>& P, const T2& val) {
ap_int_base<W,S> valInt(val);
P.write(valInt);
}
template<int W, bool S>
inline __attribute__((always_inline)) ap_int_base<W,S> _ssdm_op_READ(volatile ap_int_base<W,S>& P) {
ap_int_base<W,S> val;
val = P.read(); return val;
}
template<int W, typename T2>
inline __attribute__((always_inline)) void _ssdm_op_WRITE(volatile sc_int<W>& P, const T2& val) {
sc_int<W> valInt = val;
P.write(valInt);
}
template<int W>
inline __attribute__((always_inline)) sc_int<W> _ssdm_op_READ(volatile sc_int<W>& P) {
sc_int<W> val; val = P; return val;
}
template<int W, typename T2>
inline __attribute__((always_inline)) void _ssdm_op_WRITE(volatile sc_uint<W>& P, const T2& val) { P = val; }
template<int W>
inline __attribute__((always_inline)) sc_uint<W> _ssdm_op_READ(volatile sc_uint<W>& P) {
sc_uint<W> val; val = P; return val;
}
template<typename T>
inline __attribute__((always_inline)) bool _ssdm_op_TLM_FIFO_NB_GET(volatile T& P, T& Val) {
T Tmp;
_uint1_ __emptyn = _ssdm_op_IfNbRead(&P, &Tmp);
Val = __emptyn ? Tmp : Val;
return __emptyn;
}
template<typename T, typename T2>
inline __attribute__((always_inline)) bool _ssdm_op_TLM_FIFO_NB_PUT(volatile T& P, T2& Val) {
T Tmp = Val;
_uint1_ __ssdm_ret = _ssdm_op_IfNbWrite(&P, &Tmp);
return __ssdm_ret;
}
template<typename T>
inline __attribute__((always_inline)) T _ssdm_op_TLM_FIFO_PEEK(volatile T& P) {
T Tmp;
_ssdm_op_IfRead(&P, &Tmp, 1);
return Tmp;
}
template<typename T, typename T2>
inline __attribute__((always_inline)) bool _ssdm_op_TLM_FIFO_NB_PEEK(volatile T& P, T2& Val) {
_uint1_ __ssdm_ret = _ssdm_op_IfNbRead(&P, &Val, 1);
return __ssdm_ret;
}
template<typename T>
inline __attribute__((always_inline)) bool _ssdm_op_TLM_CAN_GET(volatile T& P) {
return _ssdm_op_IfCanRead(&P);
}
template<typename T>
inline __attribute__((always_inline)) bool _ssdm_op_TLM_CAN_PUT(volatile T& P) {
return _ssdm_op_IfCanWrite(&P);
}
#164 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/ap_sc_extras.h"
template<> inline __attribute__((always_inline)) sc_bit _ssdm_op_READ<sc_bit>(volatile sc_bit& P) { return P; } template<typename T2> inline __attribute__((always_inline)) void _ssdm_op_WRITE(volatile sc_bit& P, const T2& val) { P = val; }
template<> inline __attribute__((always_inline)) bool _ssdm_op_READ<bool>(volatile bool& P) { return P; } template<typename T2> inline __attribute__((always_inline)) void _ssdm_op_WRITE(volatile bool& P, const T2& val) { P = val; }
template<> inline __attribute__((always_inline)) char _ssdm_op_READ<char>(volatile char& P) { return P; } template<typename T2> inline __attribute__((always_inline)) void _ssdm_op_WRITE(volatile char& P, const T2& val) { P = val; }
template<> inline __attribute__((always_inline)) signed char _ssdm_op_READ<signed char>(volatile signed char& P) { return P; } template<typename T2> inline __attribute__((always_inline)) void _ssdm_op_WRITE(volatile signed char& P, const T2& val) { P = val; }
template<> inline __attribute__((always_inline)) unsigned char _ssdm_op_READ<unsigned char>(volatile unsigned char& P) { return P; } template<typename T2> inline __attribute__((always_inline)) void _ssdm_op_WRITE(volatile unsigned char& P, const T2& val) { P = val; }
template<> inline __attribute__((always_inline)) short _ssdm_op_READ<short>(volatile short& P) { return P; } template<typename T2> inline __attribute__((always_inline)) void _ssdm_op_WRITE(volatile short& P, const T2& val) { P = val; }
template<> inline __attribute__((always_inline)) unsigned short _ssdm_op_READ<unsigned short>(volatile unsigned short& P) { return P; } template<typename T2> inline __attribute__((always_inline)) void _ssdm_op_WRITE(volatile unsigned short& P, const T2& val) { P = val; }
template<> inline __attribute__((always_inline)) int _ssdm_op_READ<int>(volatile int& P) { return P; } template<typename T2> inline __attribute__((always_inline)) void _ssdm_op_WRITE(volatile int& P, const T2& val) { P = val; }
template<> inline __attribute__((always_inline)) unsigned int _ssdm_op_READ<unsigned int>(volatile unsigned int& P) { return P; } template<typename T2> inline __attribute__((always_inline)) void _ssdm_op_WRITE(volatile unsigned int& P, const T2& val) { P = val; }
template<> inline __attribute__((always_inline)) long _ssdm_op_READ<long>(volatile long& P) { return P; } template<typename T2> inline __attribute__((always_inline)) void _ssdm_op_WRITE(volatile long& P, const T2& val) { P = val; }
template<> inline __attribute__((always_inline)) unsigned long _ssdm_op_READ<unsigned long>(volatile unsigned long& P) { return P; } template<typename T2> inline __attribute__((always_inline)) void _ssdm_op_WRITE(volatile unsigned long& P, const T2& val) { P = val; }
template<> inline __attribute__((always_inline)) ap_slong _ssdm_op_READ<ap_slong>(volatile ap_slong& P) { return P; } template<typename T2> inline __attribute__((always_inline)) void _ssdm_op_WRITE(volatile ap_slong& P, const T2& val) { P = val; }
template<> inline __attribute__((always_inline)) ap_ulong _ssdm_op_READ<ap_ulong>(volatile ap_ulong& P) { return P; } template<typename T2> inline __attribute__((always_inline)) void _ssdm_op_WRITE(volatile ap_ulong& P, const T2& val) { P = val; }
#186 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/ap_sc_extras.h"
template<int _AP_W, bool _AP_S>
inline void sc_trace( sc_core::sc_trace_file *tf, const ap_int_base<_AP_W,_AP_S> &op,
const std::string& n )
{ }
template<int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N>
inline void sc_trace( sc_core::sc_trace_file *tf, const ap_fixed_base<_AP_W,_AP_I,_AP_S,_AP_Q,_AP_O, _AP_N> &op,
const std::string& n )
{ }
inline void sc_trace( sc_core::sc_trace_file *tf, const bool &op, const std::string& n )
{ }
inline void sc_trace( sc_core::sc_trace_file *tf, const char &op, const std::string& n )
{ }
inline void sc_trace( sc_core::sc_trace_file *tf, const unsigned char &op, const std::string& n )
{ }
inline void sc_trace( sc_core::sc_trace_file *tf, const short &op, const std::string& n )
{ }
inline void sc_trace( sc_core::sc_trace_file *tf, const unsigned short &op, const std::string& n )
{ }
inline void sc_trace( sc_core::sc_trace_file *tf, const int &op, const std::string& n )
{ }
inline void sc_trace( sc_core::sc_trace_file *tf, const unsigned int &op, const std::string& n )
{ }
inline void sc_trace( sc_core::sc_trace_file *tf, const long &op, const std::string& n )
{ }
inline void sc_trace( sc_core::sc_trace_file *tf, const unsigned long &op, const std::string& n )
{ }
inline void sc_trace( sc_core::sc_trace_file *tf, const long long &op, const std::string& n )
{ }
inline void sc_trace( sc_core::sc_trace_file *tf, const unsigned long long &op, const std::string& n )
{ }
class sc_time
{
public:
sc_time() {}
sc_time(const sc_time&) {}
};
inline std::ostream& operator << (std::ostream &os, const sc_time&x) {
return os;
}
#54 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/ap_systemc.h" 2
#191 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/ap_systemc.h"
using namespace sc_core;
using ::sc_core::wait;
#293 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/ap_systemc.h"
typedef void****** __ap_sc_end__;
#pragma AUTOESL_INC systemc.h end
#2 "/opt/Xilinx/Vivado/2017.3/common/technology/autopilot/ap_sysc/systemc.h" 2
#15 "./counter.h" 2
struct simple_counter : ::sc_core::sc_module {
sc_in <bool> start, clk, reset;
sc_in <sc_uint<10> > final;
sc_out <bool> count_out;
sc_uint <32> aux;
bool saida;
void counting();
typedef simple_counter SC_CURRENT_USER_MODULE; simple_counter( ::sc_core::sc_module_name ) {
{ ::sc_core::sc_cthread_process* counting_handle = simcontext()->register_cthread_process("counting", (void (::sc_core::sc_process_host::*)())(&SC_CURRENT_USER_MODULE::counting), this ); sensitive.operator() ( counting_handle, clk.pos() ); };
watching(reset.delayed() == true);
}
};
#13 "counter.cpp" 2
void simple_counter::counting(){
aux = 0;
saida = false;
count_out.write(false);
wait();
while(true){
if(start.read()){
aux = aux + 1;
if(aux == final.read()){
aux = 0;
if (saida == true){
saida = false;
}else{
saida = true;
}
count_out.write(saida);
}
}
wait();
}
}
| [
"jpalexandroni@hotmail.com"
] | jpalexandroni@hotmail.com |
272c8deb7ce422db8ccbdac64f1b98b1fe209284 | 9caf1b4b3a52866d9febf3c6078973c4e9687d9b | /StockMetadata.cpp | 6929359fd748a945fc306bb8b7146c43cf4d9f3a | [] | no_license | danielkoh/quantserver | 78e4d17489622e7bd6c1acc723ad91f66524da4a | b71375dece0e96e8cf77b58aaa30152a80982dc3 | refs/heads/master | 2021-01-22T02:53:27.569899 | 2012-05-27T14:31:33 | 2012-05-27T14:31:33 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,185 | cpp | #include "StockMetadata.h"
#include <boost/lexical_cast.hpp>
#include <chaiscript/utility/utility.hpp>
using namespace quantserver;
ScriptManager& StockMetadata::chai(ScriptManager& scriptManager)
{
chaiscript::ModulePtr m = chaiscript::ModulePtr(new chaiscript::Module());
CHAISCRIPT_CLASS( m,
StockMetadata,
(StockMetadata())
(StockMetadata(const StockMetadata&)),
((symbol))
((name))
((eps))
((epsEstimate))
((epsEstimateNextYr))
((ebitda))
((pe_ratio))
((peg_ratio))
((ps_ratio))
((bookValue))
((outstandingShares))
((targetPrice))
((marketCap))
((dividendYield))
((dividendPerShare))
((bid))
((ask))
);
scriptManager.engine().add(m) ;
return scriptManager ;
}
PtrStringVector StockMetadata::getRequiredItems()
{
PtrStringVector vec(new std::vector<std::string>()) ;
vec->push_back(std::string("symbol"));
vec->push_back(std::string("error"));
vec->push_back(std::string("name"));
vec->push_back(std::string("eps"));
vec->push_back(std::string("epsEstimate"));
vec->push_back(std::string("epsEstimateNextYr"));
vec->push_back(std::string("ebitda"));
vec->push_back(std::string("P/E_Ratio"));
vec->push_back(std::string("PEG_Ratio"));
vec->push_back(std::string("PS_Ratio"));
vec->push_back(std::string("bookValue"));
vec->push_back(std::string("outstandingShares"));
vec->push_back(std::string("targetPrice"));
vec->push_back(std::string("marketCap"));
vec->push_back(std::string("dividendYield"));
vec->push_back(std::string("dividendPerShare"));
vec->push_back(std::string("bid"));
vec->push_back(std::string("ask"));
return vec;
}
StockMetadata::StockMetadata(void)
{
_symbol = "" ;
_name = "" ;
_eps = 0.0;
_epsEstimate = 0.0 ;
_epsEstimateNextYr = 0.0;
_ebitda = 0.0 ;
_pe_ratio = 0.0;
_peg_ratio = 0.0;
_ps_ratio = 0.0;
_bookValue = 0.0;
_outstandingShares = 0.0;
_targetPrice = 0.0;
_marketCap = 0.0;
_bid = 0.0;
_ask = 0.0;
}
StockMetadata::StockMetadata(std::string& s , PtrStringVector& data)
{
_symbol = s ;
//Index 1 is error indicator
int start = 2 ;
_name = data->at(start++);
_eps = parseValAt(data , start++);
_epsEstimate = parseValAt(data , start++);
_epsEstimateNextYr = parseValAt(data , start++);
_ebitda = parseValAt(data , start++);
_pe_ratio = parseValAt(data , start++);
_peg_ratio = parseValAt(data , start++);
_ps_ratio = parseValAt(data , start++);
_bookValue = parseValAt(data , start++);
_outstandingShares = 0.0; parseValAt(data , start++);
_targetPrice = parseValAt(data , start++);
_marketCap = parseValAt(data , start++);
_dividendYield = parseValAt(data , start++);
_dividendPerShare = parseValAt(data , start++);
_dividendPerShare = parseValAt(data , start++);
_dividendPerShare = parseValAt(data , 16);
}
BIGDECIMAL StockMetadata::parseValAt(PtrStringVector& data , int i)
{
if(i < data->size())
{
std::string& str = data->at(i);
if(str.length() > 0 )
{
try
{
return boost::lexical_cast<BIGDECIMAL>(str);
}
catch(boost::bad_lexical_cast& )
{
return ERROR_VAL ;
}
}
}
return ERROR_VAL ;
}
StockMetadata::~StockMetadata(void)
{
}
const std::string& StockMetadata::symbol(){return _symbol;}
const std::string& StockMetadata::name(){return _name;}
BIGDECIMAL StockMetadata::eps(){return _eps;}
BIGDECIMAL StockMetadata::epsEstimate(){return _epsEstimate;}
BIGDECIMAL StockMetadata::epsEstimateNextYr(){return _epsEstimateNextYr;}
BIGDECIMAL StockMetadata::ebitda(){return _ebitda;}
BIGDECIMAL StockMetadata::pe_ratio(){return _pe_ratio;}
BIGDECIMAL StockMetadata::ps_ratio(){return _ps_ratio;}
BIGDECIMAL StockMetadata::peg_ratio(){return _peg_ratio;}
BIGDECIMAL StockMetadata::bookValue(){return _bookValue;}
BIGDECIMAL StockMetadata::outstandingShares(){return _outstandingShares;}
BIGDECIMAL StockMetadata::targetPrice(){return _targetPrice;}
BIGDECIMAL StockMetadata::marketCap(){return _marketCap;}
BIGDECIMAL StockMetadata::dividendYield(){return _dividendYield;}
BIGDECIMAL StockMetadata::dividendPerShare(){return _dividendPerShare;}
BIGDECIMAL StockMetadata::bid(){return _bid;}
BIGDECIMAL StockMetadata::ask(){return _ask;} | [
"daniel.wkoh@yahoo.com.sg"
] | daniel.wkoh@yahoo.com.sg |
b354a834b507a604dceef37291bdd5c2279be26c | 3d301646a75881b311d7d0e8a9173205d5f82e6f | /doom/src/m_menu.h | 52284ef567759e9764b28f8cf952ea39dda3118a | [
"MIT",
"GPL-2.0-only"
] | permissive | mfkiwl/riscvtool | 6f19e610af093569a5423aea9161ef982b4311b3 | 5d4294d334731e100764d216ae5aa0c4bd10082e | refs/heads/main | 2023-06-15T22:45:44.095020 | 2021-07-17T19:04:43 | 2021-07-17T19:04:43 | 354,146,924 | 0 | 0 | MIT | 2021-04-02T22:24:04 | 2021-04-02T22:24:04 | null | UTF-8 | C++ | false | false | 1,770 | h | // Emacs style mode select -*- C++ -*-
//-----------------------------------------------------------------------------
//
// $Id:$
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// DESCRIPTION:
// Menu widget stuff, episode selection and such.
//
//-----------------------------------------------------------------------------
#ifndef __M_MENU__
#define __M_MENU__
#include "d_event.h"
//
// MENUS
//
// Called by main loop,
// saves config file and calls I_Quit when user exits.
// Even when the menu is not displayed,
// this can resize the view and change game parameters.
// Does all the real work of the menu interaction.
boolean M_Responder (event_t *ev);
// Called by main loop,
// only used for menu (skull cursor) animation.
void M_Ticker (void);
// Called by main loop,
// draws the menus directly into the screen buffer.
void M_Drawer (void);
// Called by D_DoomMain,
// loads the config file.
void M_Init (void);
// Called by intro code to force menu up upon a keypress,
// does nothing if menu is already up.
void M_StartControlPanel (void);
#endif
//-----------------------------------------------------------------------------
//
// $Log:$
//
//-----------------------------------------------------------------------------
| [
"ecilasun@me.com"
] | ecilasun@me.com |
31a0429852b249470563685f2630080f8432f452 | 574632cb2f6877bb00d7029595cb9bf98e89279e | /_P168_ThermOLED.ino | 8214ca90d851c8734f67354fcf8744a450f7389d | [] | no_license | theGressier/ESPEasyPluginPlayground | edf3a2410e711bf15da05ff0f612a4877034471c | 466d6fbaf2ae2c7bf41d9fae824cdc6060852b68 | refs/heads/master | 2020-07-15T21:03:10.347612 | 2019-11-08T18:48:32 | 2019-11-08T18:48:32 | 205,648,234 | 1 | 0 | null | 2019-09-01T08:19:08 | 2019-09-01T08:14:52 | C++ | UTF-8 | C++ | false | false | 30,650 | ino | /*##########################################################################################
##################### Plugin 168: OLED SSD1306 display for Thermostat ####################
##########################################################################################
This is a modification to Plugin_036 with graphics library provided from squix78 github
https://github.com/squix78/esp8266-oled-ssd1306
Features :
- Displays and use current temperature from specified Device/Value (can be a Dummy for example)
- Displays and maintains setpoint value
- on power down/up this plugin maintains and reloads RELAY and SETPOINT values from SPIFFS
- Supports 3 buttons, LEFT, RIGHT and MODE selection (MODE button cycles modes below,
LEFT/RIGHT increases-decreases setpoint OR timeout (Mode sensitive)
- one output relay need to be specified, currently only HIGH level active supported
- 3 mode is available:
- 0 or X: set relay permanently off no matter what
- 1 or A: set relay ON if current temperature below setpoint, and set OFF when
temperature+hysteresis reached - comparison made at setted Plugin interval (AUTO MODE)
- 2 or M: set relay ON for specified time in minutes (MANUAL ON MODE), after timeout, mode switch to "A"
List of commands :
- oledframedcmd,[OLED_STATUS] Inherited command from P036 status can be:
[off/on/low/med/high]
- thermo,setpoint,[target_temperature] Target setpoint, only used in Mode "A"
- thermo,heating,[RELAY_STATUS] Manually forcing relay status [off/on]
- thermo,mode,[MODE],[TIMEOUT] Set to either mode X/A/M, if M selected,
then TIMEOUT can be specified in minutes
Command Examples :
- /control?cmd=thermo,setpoint,23 Set target setpoint to 23 Celsius
- /control?cmd=thermo,mode,1 Set mode to AUTOMATIC so it starts to maintain setpoint temperature
- /control?cmd=thermo,mode,2,5 Starts pre-heat for 5 minute, does not care about TEMP, then go to AUTO mode after timeout
- /control?cmd=thermo,mode,0 Switch heating off, absolutely do nothing until further notice
------------------------------------------------------------------------------------------
Copyleft Nagy Sándor 2018 - https://bitekmindenhol.blog.hu/
------------------------------------------------------------------------------------------
*/
#define PLUGIN_168
#define PLUGIN_ID_168 168
#define PLUGIN_NAME_168 "Display - OLED SSD1306/SH1106 Thermo"
#define PLUGIN_VALUENAME1_168 "setpoint"
#define PLUGIN_VALUENAME2_168 "heating"
#define PLUGIN_VALUENAME3_168 "mode"
#define PLUGIN_VALUENAME4_168 "timeout"
#define P168_Nlines 1
#define P168_Nchars 32
#define P168_CONTRAST_OFF 1
#define P168_CONTRAST_LOW 64
#define P168_CONTRAST_MED 0xCF
#define P168_CONTRAST_HIGH 0xFF
#include "SSD1306.h"
#include "SH1106Wire.h"
#include "Dialog_Plain_12_font.h"
#include "Dialog_Plain_18_font.h"
const char flameimg[] PROGMEM = {
0x00, 0x20, 0x00,
0x00, 0x70, 0x00,
0x00, 0x78, 0x00,
0x00, 0x7c, 0x00,
0x00, 0x7c, 0x00,
0x80, 0x7f, 0x00,
0xc0, 0xff, 0x00,
0xc0, 0xff, 0x00,
0xe0, 0xff, 0x04,
0xe0, 0xff, 0x05,
0xf0, 0xff, 0x0f,
0xf0, 0xff, 0x0f,
0xf8, 0xff, 0x0f,
0xf8, 0xff, 0x1f,
0xf8, 0xff, 0x1f,
0xf8, 0xff, 0x3f,
0xf8, 0xff, 0x3f,
0xf8, 0xf3, 0x3f,
0xf8, 0xf1, 0x3f,
0xf8, 0xf1, 0x3f,
0xf8, 0xe1, 0x3f,
0xf0, 0x21, 0x3f,
0xf0, 0x01, 0x1f,
0xe0, 0x01, 0x0f,
0xc0, 0x01, 0x0f,
0x80, 0x01, 0x07,
0x00, 0x03, 0x01
};
#define P168_WIFI_STATE_UNSET -2
#define P168_WIFI_STATE_NOT_CONNECTED -1
float Plugin_168_prev_temp = 99;
float Plugin_168_prev_setpoint;
float Plugin_168_prev_timeout;
byte Plugin_168_prev_heating;
byte Plugin_168_prev_mode;
byte Plugin_168_taskindex;
byte Plugin_168_varindex;
byte Plugin_168_changed;
boolean Plugin_168_init = false;
unsigned long Plugin_168_lastsavetime = 0;
byte Plugin_168_saveneeded = 0;
static unsigned long Plugin_168_buttons[3];
static int8_t P168_lastWiFiState = P168_WIFI_STATE_UNSET;
// Instantiate display here - does not work to do this within the INIT call
OLEDDisplay *P168_display = NULL;
char P168_deviceTemplate[P168_Nlines][P168_Nchars];
boolean Plugin_168(byte function, struct EventStruct *event, String& string)
{
boolean success = false;
switch (function)
{
case PLUGIN_DEVICE_ADD:
{
Device[++deviceCount].Number = PLUGIN_ID_168;
Device[deviceCount].Type = DEVICE_TYPE_I2C;
Device[deviceCount].VType = SENSOR_TYPE_QUAD;
Device[deviceCount].Ports = 0;
Device[deviceCount].PullUpOption = false;
Device[deviceCount].InverseLogicOption = false;
Device[deviceCount].FormulaOption = true;
Device[deviceCount].ValueCount = 4;
Device[deviceCount].SendDataOption = true;
Device[deviceCount].TimerOption = true;
Device[deviceCount].TimerOptional = false;
Device[deviceCount].GlobalSyncOption = true;
break;
}
case PLUGIN_GET_DEVICENAME:
{
string = F(PLUGIN_NAME_168);
break;
}
case PLUGIN_GET_DEVICEVALUENAMES:
{
strcpy_P(ExtraTaskSettings.TaskDeviceValueNames[0], PSTR(PLUGIN_VALUENAME1_168));
strcpy_P(ExtraTaskSettings.TaskDeviceValueNames[1], PSTR(PLUGIN_VALUENAME2_168));
strcpy_P(ExtraTaskSettings.TaskDeviceValueNames[2], PSTR(PLUGIN_VALUENAME3_168));
strcpy_P(ExtraTaskSettings.TaskDeviceValueNames[3], PSTR(PLUGIN_VALUENAME4_168));
break;
}
case PLUGIN_WEBFORM_LOAD:
{
byte choice5 = Settings.TaskDevicePluginConfig[event->TaskIndex][2];
String options5[2];
options5[0] = F("SSD1306");
options5[1] = F("SH1106");
int optionValues5[2] = { 1, 2 };
addFormSelector(F("Controller"), F("plugin_168_controler"), 2, options5, optionValues5, choice5);
byte choice0 = Settings.TaskDevicePluginConfig[event->TaskIndex][0];
int optionValues0[2];
optionValues0[0] = 0x3C;
optionValues0[1] = 0x3D;
addFormSelectorI2C(F("plugin_168_adr"), 2, optionValues0, choice0);
byte choice1 = Settings.TaskDevicePluginConfig[event->TaskIndex][1];
String options1[2];
options1[0] = F("Normal");
options1[1] = F("Rotated");
int optionValues1[2] = { 1, 2 };
addFormSelector(F("Rotation"), F("plugin_168_rotate"), 2, options1, optionValues1, choice1);
LoadCustomTaskSettings(event->TaskIndex, (byte*)&P168_deviceTemplate, sizeof(P168_deviceTemplate));
for (byte varNr = 0; varNr < P168_Nlines; varNr++)
{
if (varNr == 0) {
addFormTextBox(String(F("Temperature source ")), String(F("Plugin_168_template")) + (varNr + 1), P168_deviceTemplate[varNr], P168_Nchars);
} else {
addFormTextBox(String(F("Line ")) + (varNr + 1), String(F("Plugin_168_template")) + (varNr + 1), P168_deviceTemplate[varNr], P168_Nchars);
}
}
addFormPinSelect(F("Button left"), F("taskdevicepin1"), Settings.TaskDevicePin1[event->TaskIndex]);
addFormPinSelect(F("Button right"), F("taskdevicepin2"), Settings.TaskDevicePin2[event->TaskIndex]);
addFormPinSelect(F("Button mode"), F("taskdevicepin3"), Settings.TaskDevicePin3[event->TaskIndex]);
addFormPinSelect(F("Relay"), F("heatrelay"), Settings.TaskDevicePluginConfig[event->TaskIndex][4]);
byte choice6 = Settings.TaskDevicePluginConfig[event->TaskIndex][3];
if (choice6 == 0) choice6 = P168_CONTRAST_HIGH;
String options6[3];
options6[0] = F("Low");
options6[1] = F("Medium");
options6[2] = F("High");
int optionValues6[3];
optionValues6[0] = P168_CONTRAST_LOW;
optionValues6[1] = P168_CONTRAST_MED;
optionValues6[2] = P168_CONTRAST_HIGH;
addFormSelector(F("Contrast"), F("plugin_168_contrast"), 3, options6, optionValues6, choice6);
byte choice4 = (Settings.TaskDevicePluginConfigFloat[event->TaskIndex][0] * 10);
String options4[3];
options4[0] = F("0.2");
options4[1] = F("0.5");
options4[2] = F("1");
int optionValues4[3];
optionValues4[0] = 2;
optionValues4[1] = 5;
optionValues4[2] = 10;
addFormSelector(F("Hysteresis"), F("plugin_168_hyst"), 3, options4, optionValues4, choice4);
success = true;
break;
}
case PLUGIN_WEBFORM_SAVE:
{
Settings.TaskDevicePluginConfig[event->TaskIndex][0] = getFormItemInt(F("plugin_168_adr"));
Settings.TaskDevicePluginConfig[event->TaskIndex][1] = getFormItemInt(F("plugin_168_rotate"));
Settings.TaskDevicePluginConfig[event->TaskIndex][2] = getFormItemInt(F("plugin_168_controler"));
Settings.TaskDevicePluginConfig[event->TaskIndex][3] = getFormItemInt(F("plugin_168_contrast"));
Settings.TaskDevicePluginConfig[event->TaskIndex][4] = getFormItemInt(F("heatrelay"));
Settings.TaskDevicePluginConfigFloat[event->TaskIndex][0] = (getFormItemInt(F("plugin_168_hyst")) / 10.0);
String argName;
for (byte varNr = 0; varNr < P168_Nlines; varNr++)
{
argName = F("Plugin_168_template");
argName += varNr + 1;
strncpy(P168_deviceTemplate[varNr], WebServer.arg(argName).c_str(), sizeof(P168_deviceTemplate[varNr]));
}
SaveCustomTaskSettings(event->TaskIndex, (byte*)&P168_deviceTemplate, sizeof(P168_deviceTemplate));
success = true;
break;
}
case PLUGIN_INIT:
{
P168_lastWiFiState = P168_WIFI_STATE_UNSET;
// Load the custom settings from flash
LoadCustomTaskSettings(event->TaskIndex, (byte*)&P168_deviceTemplate, sizeof(P168_deviceTemplate));
// Init the display and turn it on
if (P168_display)
{
P168_display->end();
delete P168_display;
}
Plugin_168_taskindex = event->TaskIndex;
Plugin_168_varindex = event->BaseVarIndex;
uint8_t OLED_address = Settings.TaskDevicePluginConfig[event->TaskIndex][0];
if (Settings.TaskDevicePluginConfig[event->TaskIndex][2] == 1) {
P168_display = new SSD1306Wire(OLED_address, Settings.Pin_i2c_sda, Settings.Pin_i2c_scl);
} else {
P168_display = new SH1106Wire(OLED_address, Settings.Pin_i2c_sda, Settings.Pin_i2c_scl);
}
P168_display->init(); // call to local override of init function
P168_display->displayOn();
uint8_t OLED_contrast = Settings.TaskDevicePluginConfig[event->TaskIndex][3];
P168_setContrast(OLED_contrast);
String logstr = F("Thermo : Btn L:");
logstr += Settings.TaskDevicePin1[event->TaskIndex];
logstr += F("R:");
logstr += Settings.TaskDevicePin2[event->TaskIndex];
logstr += F("M:");
logstr += Settings.TaskDevicePin3[event->TaskIndex];
addLog(LOG_LEVEL_INFO, logstr);
if (Settings.TaskDevicePin1[event->TaskIndex] != -1)
{
pinMode(Settings.TaskDevicePin1[event->TaskIndex], INPUT_PULLUP);
}
if (Settings.TaskDevicePin2[event->TaskIndex] != -1)
{
pinMode(Settings.TaskDevicePin2[event->TaskIndex], INPUT_PULLUP);
}
if (Settings.TaskDevicePin3[event->TaskIndex] != -1)
{
pinMode(Settings.TaskDevicePin3[event->TaskIndex], INPUT_PULLUP);
}
Plugin_168_prev_temp = 99;
if (SPIFFS.exists("thermo.dat"))
{
fs::File f = SPIFFS.open("thermo.dat", "r");
if (f)
{
f.read( ((uint8_t *)&UserVar[event->BaseVarIndex] + 0), 16 );
f.close();
}
}
Plugin_168_lastsavetime = millis();
if (UserVar[event->BaseVarIndex] < 1) {
UserVar[event->BaseVarIndex] = 19; // setpoint
UserVar[event->BaseVarIndex + 2] = 1; // mode (X=0,A=1,M=2)
}
//UserVar[event->BaseVarIndex + 1] = 0; // heating (0=off,1=heating in progress)
//UserVar[event->BaseVarIndex + 3] = 0; // timeout (manual on for minutes)
if (Settings.TaskDevicePluginConfig[event->TaskIndex][4] != -1)
{
//pinMode(Settings.TaskDevicePluginConfig[event->TaskIndex][4], OUTPUT);
P168_setHeatRelay(byte(UserVar[event->BaseVarIndex + 1]));
}
logstr = F("Thermo : Starting status S:");
logstr += String(UserVar[event->BaseVarIndex]);
logstr += F(", R:");
logstr += String(UserVar[event->BaseVarIndex + 1]);
addLog(LOG_LEVEL_INFO, logstr);
Plugin_168_changed = 1;
Plugin_168_buttons[0] = 0; Plugin_168_buttons[1] = 0; Plugin_168_buttons[2] = 0;
// flip screen if required
if (Settings.TaskDevicePluginConfig[event->TaskIndex][1] == 2) P168_display->flipScreenVertically();
// Display the device name, logo, time and wifi
P168_display_header();
P168_display_page();
P168_display->display();
Plugin_168_init = true;
success = true;
break;
}
case PLUGIN_EXIT:
{
if (P168_display)
{
P168_display->end();
delete P168_display;
P168_display = NULL;
}
break;
}
case PLUGIN_TEN_PER_SECOND:
{
unsigned long current_time;
if (Plugin_168_init){
if (Settings.TaskDevicePin1[event->TaskIndex] != -1)
{
if (!digitalRead(Settings.TaskDevicePin1[event->TaskIndex]))
{
current_time = millis();
if (Plugin_168_buttons[0] + 300 < current_time) {
Plugin_168_buttons[0] = current_time;
switch (int(UserVar[event->BaseVarIndex + 2])) {
case 0: { // off mode, no func
break;
}
case 1: { // auto mode, setpoint dec
P168_setSetpoint(F("-0.5"));
break;
}
case 2: { // manual on mode, timer dec
UserVar[event->BaseVarIndex + 3] = UserVar[event->BaseVarIndex + 3] - 300;
if (UserVar[event->BaseVarIndex + 3] < 0) {
UserVar[event->BaseVarIndex + 3] = 5400;
}
Plugin_168_prev_timeout = 32768;
Plugin_168_changed = 1;
break;
}
}
}
}
}
if (Settings.TaskDevicePin2[event->TaskIndex] != -1)
{
if (!digitalRead(Settings.TaskDevicePin2[event->TaskIndex]))
{
current_time = millis();
if (Plugin_168_buttons[1] + 300 < current_time) {
Plugin_168_buttons[1] = current_time;
switch (int(UserVar[event->BaseVarIndex + 2])) {
case 0: { // off mode, no func
break;
}
case 1: { // auto mode, setpoint inc
P168_setSetpoint(F("+0.5"));
break;
}
case 2: { // manual on mode, timer dec
UserVar[event->BaseVarIndex + 3] = UserVar[event->BaseVarIndex + 3] + 300;
if (UserVar[event->BaseVarIndex + 3] > 5400) {
UserVar[event->BaseVarIndex + 3] = 60;
}
Plugin_168_prev_timeout = 32768;
Plugin_168_changed = 1;
break;
}
}
}
}
}
if (Settings.TaskDevicePin3[event->TaskIndex] != -1)
{
if (!digitalRead(Settings.TaskDevicePin3[event->TaskIndex]))
{
current_time = millis();
if (Plugin_168_buttons[2] + 300 < current_time) {
Plugin_168_buttons[2] = current_time;
switch (int(UserVar[event->BaseVarIndex + 2])) {
case 0: { // off mode, next
P168_setMode(F("a"), F("0"));
break;
}
case 1: { // auto mode, next
P168_setMode(F("m"), F("5"));
break;
}
case 2: { // manual on mode, next
P168_setMode(F("x"), F("0"));
break;
}
}
}
}
}
}
break;
}
// Switch off display after displayTimer seconds
case PLUGIN_ONCE_A_SECOND:
{
if (Plugin_168_init){
if (P168_display && P168_display_wifibars()) {
// WiFi symbol was updated.
P168_display->display();
}
if (UserVar[event->BaseVarIndex + 2] == 2) { // manual timeout
if (UserVar[event->BaseVarIndex + 3] > 0) {
UserVar[event->BaseVarIndex + 3] = UserVar[event->BaseVarIndex + 3] - 1;
P168_display_timeout();
} else {
UserVar[event->BaseVarIndex + 3] = 0;
P168_setMode(F("a"), F("0")); //heater to auto
P168_display_setpoint_temp(1);
}
}
if (Plugin_168_changed == 1) {
sendData(event);
Plugin_168_saveneeded = 1;
Plugin_168_changed = 0;
}
if (Plugin_168_saveneeded == 1) {
if ((Plugin_168_lastsavetime+30000) < millis()) {
Plugin_168_saveneeded = 0;
Plugin_168_lastsavetime = millis();
fs::File f = SPIFFS.open("thermo.dat", "w");
if (f)
{
f.write( ((uint8_t *)&UserVar[event->BaseVarIndex] + 0), 16 );
f.close();
flashCount();
}
String logstr = F("Thermo : Save UserVars to SPIFFS");
addLog(LOG_LEVEL_INFO, logstr);
}}
success = true;
}
break;
}
case PLUGIN_READ:
{
if (Plugin_168_init){
// Update display
P168_display_header();
if (UserVar[event->BaseVarIndex + 2] == 1) {
String atempstr2 = P168_deviceTemplate[0];
String atempstr = parseTemplate(atempstr2, 20);
atempstr.trim();
if ((atempstr.length() > 0) && (Plugin_168_prev_temp != 99)) { // do not switch until the first temperature data arrives
float atemp = atempstr.toFloat();
if (atemp != 0.0) {
if ((UserVar[event->BaseVarIndex] > atemp) && (UserVar[event->BaseVarIndex + 1] < 1))
{
P168_setHeater(F("1"));
Plugin_168_changed = 1;
} else if (((((float)atemp - (float)Settings.TaskDevicePluginConfigFloat[event->TaskIndex][0]) >= (float)UserVar[event->BaseVarIndex])) && (UserVar[event->BaseVarIndex + 1] > 0)) {
P168_setHeater(F("0"));
Plugin_168_changed = 1;
} else {
P168_display_heat();
}
}
} else {
P168_display_heat();
}
}
P168_display_current_temp();
P168_display_timeout();
P168_display->display();
success = true;
}
break;
}
case PLUGIN_WRITE:
{
String command = parseString(string, 1);
String subcommand = parseString(string, 2);
String logstr = "";
if (Plugin_168_init){
if (command == F("oledframedcmd"))
{
success = true;
if (subcommand == F("off"))
P168_setContrast(P168_CONTRAST_OFF);
else if (subcommand == F("on"))
P168_display->displayOn();
else if (subcommand == F("low"))
P168_setContrast(P168_CONTRAST_LOW);
else if (subcommand == F("med"))
P168_setContrast(P168_CONTRAST_MED);
else if (subcommand == F("high"))
P168_setContrast(P168_CONTRAST_HIGH);
logstr = F("\nOk");
SendStatus(event->Source, logstr);
}
if (command == F("thermo"))
{
success = true;
String par1 = parseString(string, 3);
if (subcommand == F("setpoint"))
P168_setSetpoint(par1);
else if (subcommand == F("heating")) {
P168_setHeater(par1); Plugin_168_changed = 1;
}
else if (subcommand == F("mode"))
P168_setMode(par1, parseString(string, 4));
logstr = F("\nOk");
SendStatus(event->Source, logstr);
}}
break;
}
}
return success;
}
// Set the display contrast
// really low brightness & contrast: contrast = 10, precharge = 5, comdetect = 0
// normal brightness & contrast: contrast = 100
void P168_setContrast(uint8_t OLED_contrast) {
char contrast = 100;
char precharge = 241;
char comdetect = 64;
switch (OLED_contrast) {
case P168_CONTRAST_OFF:
if (P168_display) {
P168_display->displayOff();
}
return;
case P168_CONTRAST_LOW:
contrast = 10; precharge = 5; comdetect = 0;
break;
case P168_CONTRAST_MED:
contrast = P168_CONTRAST_MED; precharge = 0x1F; comdetect = 64;
break;
case P168_CONTRAST_HIGH:
default:
contrast = P168_CONTRAST_HIGH; precharge = 241; comdetect = 64;
break;
}
if (P168_display) {
P168_display->displayOn();
P168_display->setContrast(contrast, precharge, comdetect);
}
}
void P168_display_header() {
static boolean showWiFiName = true;
if (showWiFiName && (wifiStatus == ESPEASY_WIFI_SERVICES_INITIALIZED) ) {
String newString = WiFi.SSID();
newString.trim();
P168_display_title(newString);
} else {
String dtime = "%sysname%";
String newString = parseTemplate(dtime, 10);
newString.trim();
P168_display_title(newString);
}
showWiFiName = !showWiFiName;
// Display time and wifibars both clear area below, so paint them after the title.
P168_display_time();
P168_display_wifibars();
}
void P168_display_time() {
String dtime = "%systime%";
String newString = parseTemplate(dtime, 10);
P168_display->setTextAlignment(TEXT_ALIGN_LEFT);
P168_display->setFont(Dialog_plain_12);
P168_display->setColor(BLACK);
P168_display->fillRect(0, 0, 28, 13);
P168_display->setColor(WHITE);
P168_display->drawString(0, 0, newString.substring(0, 5));
}
void P168_display_title(String& title) {
P168_display->setTextAlignment(TEXT_ALIGN_CENTER);
P168_display->setFont(Dialog_plain_12);
P168_display->setColor(BLACK);
P168_display->fillRect(0, 0, 128, 15); // Underscores use a extra lines, clear also.
P168_display->setColor(WHITE);
P168_display->drawString(64, 0, title);
}
//Draw Signal Strength Bars, return true when there was an update.
bool P168_display_wifibars() {
const bool connected = wifiStatus == ESPEASY_WIFI_SERVICES_INITIALIZED;
const int nbars_filled = (WiFi.RSSI() + 100) / 8;
const int newState = connected ? nbars_filled : P168_WIFI_STATE_UNSET;
if (newState == P168_lastWiFiState)
return false; // nothing to do.
int x = 105;
int y = 0;
int size_x = 15;
int size_y = 10;
int nbars = 5;
int16_t width = (size_x / nbars);
size_x = width * nbars - 1; // Correct for round errors.
// x,y are the x,y locations
// sizex,sizey are the sizes (should be a multiple of the number of bars)
// nbars is the number of bars and nbars_filled is the number of filled bars.
// We leave a 1 pixel gap between bars
P168_display->setColor(BLACK);
P168_display->fillRect(x , y, size_x, size_y);
P168_display->setColor(WHITE);
if (wifiStatus == ESPEASY_WIFI_SERVICES_INITIALIZED) {
for (byte ibar = 0; ibar < nbars; ibar++) {
int16_t height = size_y * (ibar + 1) / nbars;
int16_t xpos = x + ibar * width;
int16_t ypos = y + size_y - height;
if (ibar <= nbars_filled) {
// Fill complete bar
P168_display->fillRect(xpos, ypos, width - 1, height);
} else {
// Only draw top and bottom.
P168_display->fillRect(xpos, ypos, width - 1, 1);
P168_display->fillRect(xpos, y + size_y - 1, width - 1, 1);
}
}
} else {
// Draw a not connected sign.
}
return true;
}
void P168_display_current_temp() {
String tmpString = P168_deviceTemplate[0];
String atempstr = parseTemplate(tmpString, 20);
atempstr.trim();
if (atempstr.length() > 0) {
float atemp = atempstr.toFloat();
atemp = (round(atemp * 10)) / 10.0;
if (Plugin_168_prev_temp != atemp) {
P168_display->setColor(BLACK);
P168_display->fillRect(3, 19, 47, 25);
P168_display->setColor(WHITE);
tmpString = toString(atemp, 1);
P168_display->setFont(ArialMT_Plain_24);
P168_display->drawString(3, 19, tmpString.substring(0, 5));
Plugin_168_prev_temp = atemp;
}
}
}
void P168_display_setpoint_temp(byte force) {
if (UserVar[Plugin_168_varindex + 2] == 1) {
float stemp = (round(UserVar[Plugin_168_varindex] * 10)) / 10.0;
if ((Plugin_168_prev_setpoint != stemp) || (force == 1)) {
P168_display->setColor(BLACK);
P168_display->fillRect(86, 35, 41, 21);
P168_display->setColor(WHITE);
String tmpString = toString(stemp, 1);
P168_display->setFont(Dialog_plain_18);
P168_display->drawString(86, 35, tmpString.substring(0, 5));
Plugin_168_prev_setpoint = stemp;
Plugin_168_changed = 1;
}
}
}
void P168_display_timeout() {
if (UserVar[Plugin_168_varindex + 2] == 2) {
if (Plugin_168_prev_timeout >= (UserVar[Plugin_168_varindex + 3] + 60)) {
float timeinmin = UserVar[Plugin_168_varindex + 3] / 60;
String thour = toString(((int)(timeinmin / 60) ), 0);
thour += F(":");
String thour2 = toString(((int)timeinmin % 60), 0);
if (thour2.length() < 2) {
thour += "0" + thour2;
} else {
thour += thour2;
}
P168_display->setColor(BLACK);
P168_display->fillRect(86, 35, 41, 21);
P168_display->setColor(WHITE);
P168_display->setFont(Dialog_plain_18);
P168_display->drawString(86, 35, thour.substring(0, 5));
Plugin_168_prev_timeout = UserVar[Plugin_168_varindex + 3];
}
}
}
void P168_display_mode() {
if (Plugin_168_prev_mode != UserVar[Plugin_168_varindex + 2]) {
String tmpString = F("");
switch (int(UserVar[Plugin_168_varindex + 2]))
{
case 0:
{
tmpString = F("X");
break;
}
case 1:
{
tmpString = F("A");
break;
}
case 2:
{
tmpString = F("M");
break;
}
}
P168_display->setColor(BLACK);
P168_display->fillRect(61, 49, 12, 17);
P168_display->setColor(WHITE);
P168_display->setFont(ArialMT_Plain_16);
P168_display->drawString(61, 49, tmpString.substring(0, 5));
Plugin_168_prev_mode = UserVar[Plugin_168_varindex + 2];
}
}
void P168_display_heat() {
if (Plugin_168_prev_heating != UserVar[Plugin_168_varindex + 1]) {
P168_display->setColor(BLACK);
P168_display->fillRect(54, 19, 24, 27);
P168_display->setColor(WHITE);
if (UserVar[Plugin_168_varindex + 1] == 1) {
P168_display->drawXbm(54, 19, 24, 27, flameimg);
}
Plugin_168_prev_heating = UserVar[Plugin_168_varindex + 1];
}
}
void P168_display_page() {
// init with full clear
P168_display->setColor(BLACK);
P168_display->fillRect(0, 15, 128, 49);
P168_display->setColor(WHITE);
Plugin_168_prev_temp = 99;
Plugin_168_prev_setpoint = 0;
Plugin_168_prev_heating = 255;
Plugin_168_prev_mode = 255;
Plugin_168_prev_timeout = 32768;
P168_display->setFont(Dialog_plain_12);
P168_display->setTextAlignment(TEXT_ALIGN_LEFT);
String tstr = "{D}C";
String newString = parseTemplate(tstr, 10);
P168_display->drawString(18, 46, newString.substring(0, 5));
P168_display_heat();
P168_display->drawHorizontalLine(0, 15, 128);
P168_display->drawVerticalLine(52, 14, 49);
P168_display->drawCircle(107, 47, 26);
P168_display->drawHorizontalLine(78, 47, 8);
P168_display->drawVerticalLine(107, 19, 10);
P168_display_mode();
P168_display_setpoint_temp(0);
P168_display_current_temp();
}
void P168_setSetpoint(String sptemp) {
float stemp = (round(UserVar[Plugin_168_varindex] * 10)) / 10.0;
if ((sptemp.charAt(0) == '+') || (sptemp.charAt(0) == 'p')) {
stemp = stemp + sptemp.substring(1).toFloat();
} else if ((sptemp.charAt(0) == '-') || (sptemp.charAt(0) == 'm')) {
stemp = stemp - sptemp.substring(1).toFloat();
} else {
stemp = sptemp.toFloat();
}
UserVar[Plugin_168_varindex] = stemp;
P168_display_setpoint_temp(0);
}
void P168_setHeatRelay(byte state) {
uint8_t relaypin = Settings.TaskDevicePluginConfig[Plugin_168_taskindex][4];
String logstr = F("Thermo : Set Relay");
logstr += relaypin;
logstr += F("=");
logstr += state;
addLog(LOG_LEVEL_INFO, logstr);
if (relaypin != -1) {
pinMode(relaypin, OUTPUT);
digitalWrite(relaypin, state);
}
}
void P168_setHeater(String heater) {
if ((heater == "1") || (heater == "on")) {
UserVar[Plugin_168_varindex + 1] = 1;
P168_setHeatRelay(HIGH);
} else if ((heater == "0") || (heater == "off")) {
UserVar[Plugin_168_varindex + 1] = 0;
P168_setHeatRelay(LOW);
} else if (UserVar[Plugin_168_varindex + 1] == 0) {
UserVar[Plugin_168_varindex + 1] = 1;
P168_setHeatRelay(HIGH);
} else {
UserVar[Plugin_168_varindex + 1] = 0;
P168_setHeatRelay(LOW);
}
P168_display_heat();
}
void P168_setMode(String amode, String atimeout) {
if ((amode == "0") || (amode == "x")) {
UserVar[Plugin_168_varindex + 2] = 0;
P168_setHeater(F("0"));
P168_display->setColor(BLACK);
P168_display->fillRect(86, 35, 41, 21);
Plugin_168_prev_setpoint = 0;
} else if ((amode == "1") || (amode == "a")) {
UserVar[Plugin_168_varindex + 2] = 1;
P168_display_setpoint_temp(1);
} else if ((amode == "2") || (amode == "m")) {
UserVar[Plugin_168_varindex + 2] = 2;
UserVar[Plugin_168_varindex + 3] = (atimeout.toFloat() * 60);
Plugin_168_prev_timeout = 32768;
P168_display_timeout();
P168_setHeater(F("1"));
} else {
UserVar[Plugin_168_varindex + 2] = 0;
}
Plugin_168_changed = 1;
P168_display_mode();
}
| [
"lwolf@freemail.hu"
] | lwolf@freemail.hu |
85802036447d6ef7fb8b00951286611e64a8fa44 | 23d2ea6e9e4a2fd97b01454d04fa6e5df91795da | /SnowMan/src/Material.cpp | ff262294413ab34ca76285cdc28996e825816c69 | [] | no_license | Hariamy/CG | 4fa14900579e7052775664cef23ea65c63b8ad9f | 3dc0aaa2fdc2c8d6c2c6d889e5703e78c102a051 | refs/heads/master | 2020-03-30T08:12:08.525332 | 2018-12-08T18:28:09 | 2018-12-08T18:28:09 | 150,997,438 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 754 | cpp | #include "../header/Material.h"
Material::Material(double Kamb[3], double Kdif[3], double Kesp[3], int m){
this->m = m;
this->Kamb[0] = Kamb[0];
this->Kamb[1] = Kamb[1];
this->Kamb[2] = Kamb[2];
this->Kdif[0] = Kdif[0];
this->Kdif[1] = Kdif[1];
this->Kdif[2] = Kdif[2];
this->Kesp[0] = Kesp[0];
this->Kesp[1] = Kesp[1];
this->Kesp[2] = Kesp[2];
}
void Material::getKamb(double Kamb[3]){
Kamb[0] = this->Kamb[0];
Kamb[1] = this->Kamb[1];
Kamb[2] = this->Kamb[2];
}
void Material::getKdif(double Kdif[3]){
Kdif[0] = this->Kdif[0];
Kdif[1] = this->Kdif[1];
Kdif[2] = this->Kdif[2];
}
void Material::getKesp(double Kesp[3]){
Kesp[0] = this->Kesp[0];
Kesp[1] = this->Kesp[1];
Kesp[2] = this->Kesp[2];
}
int Material::getM(){ return m; } | [
"hariamymv@hotmail.com"
] | hariamymv@hotmail.com |
a29634401cef490b3e5c29a7cf623e69729727f6 | 511cef6e888936da5cc34f6e9a8e14b609462e46 | /src/vkdevice.cpp | ca546b5947f967314986290c844b25137a8d146a | [] | no_license | theblackunknown-experiments/vkplaygrounds | b9af2d6eff86f837f8f1398e82c94a3ab8584f59 | f07b29aa2b2f6c98960dee3d5c7d541071ccb72e | refs/heads/master | 2023-02-23T12:18:01.986933 | 2020-11-15T22:46:40 | 2020-11-15T22:46:40 | 264,190,141 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 261 | cpp | #include "./vkdevice.hpp"
#include "./vkphysicaldevice.hpp"
#include <vulkan/vulkan_core.h>
namespace blk
{
VkResult Device::create()
{
auto result = vkCreateDevice(*mPhysicalDevice, &mInfo, nullptr, &mDevice);
CHECK(result);
return result;
}
}
| [
"andrea.machizaud@gmail.com"
] | andrea.machizaud@gmail.com |
9e09e0396a2ce7f061597bc9d7da724029b431f8 | 9ab863a47b01a9e64a02e960e529e7ee8a380c81 | /http/client/WebSocketClient.cpp | d3cc13f7ff1d9c18e21683867a70dcb009923c22 | [
"BSD-3-Clause"
] | permissive | wjz051/libhv | def033cb948dcfd7046db43a072a9123bf8cd78c | eda5a2a842a993ac02b8d128010a03836cd4e598 | refs/heads/master | 2023-03-04T17:50:37.786267 | 2021-02-25T07:31:43 | 2021-02-25T07:31:43 | 316,459,046 | 0 | 0 | BSD-3-Clause | 2021-02-25T07:31:44 | 2020-11-27T09:39:06 | null | UTF-8 | C++ | false | false | 5,803 | cpp | #include "WebSocketClient.h"
#include "http_parser.h" // for http_parser_url
#include "base64.h"
#include "hlog.h"
namespace hv {
WebSocketClient::WebSocketClient()
: TcpClientTmpl<WebSocketChannel>()
{
state = WS_CLOSED;
}
WebSocketClient::~WebSocketClient() {
close();
}
/*
* ParseUrl => createsocket => start =>
* TCP::onConnection => websocket_handshake => WS::onopen =>
* TCP::onMessage => WebSocketParser => WS::onmessage =>
* TCP::onConnection => WS::onclose
*/
int WebSocketClient::open(const char* _url) {
close();
// ParseUrl
if (_url) {
if (strncmp(_url, "ws", 2) != 0) {
url = "ws://";
url += _url;
} else {
url = _url;
}
}
hlogi("%s", url.c_str());
http_parser_url parser;
http_parser_url_init(&parser);
http_parser_parse_url(url.c_str(), url.size(), 0, &parser);
// scheme
bool wss = !strncmp(url.c_str(), "wss", 3);
// host
std::string host = "127.0.0.1";
if (parser.field_set & (1<<UF_HOST)) {
host = url.substr(parser.field_data[UF_HOST].off, parser.field_data[UF_HOST].len);
}
// port
int port = parser.port ? parser.port : wss ? DEFAULT_HTTPS_PORT : DEFAULT_HTTP_PORT;
// path
std::string path = "/";
if (parser.field_set & (1<<UF_PATH)) {
path = url.c_str() + parser.field_data[UF_PATH].off;
}
int connfd = createsocket(port, host.c_str());
if (connfd < 0) {
return connfd;
}
if (wss) {
withTLS();
}
onConnection = [this](const WebSocketChannelPtr& channel) {
if (channel->isConnected()) {
state = CONNECTED;
// websocket_handshake
http_req_.reset(new HttpRequest);
http_req_->method = HTTP_GET;
// ws => http
http_req_->url = "http" + url.substr(2, -1);
http_req_->headers["Connection"] = "Upgrade";
http_req_->headers["Upgrade"] = "websocket";
// generate SEC_WEBSOCKET_KEY
unsigned char rand_key[16] = {0};
int *p = (int*)rand_key;
for (int i = 0; i < 4; ++i, ++p) {
*p = rand();
}
char ws_key[32] = {0};
base64_encode(rand_key, 16, ws_key);
http_req_->headers[SEC_WEBSOCKET_KEY] = ws_key;
http_req_->headers[SEC_WEBSOCKET_VERSION] = "13";
std::string http_msg = http_req_->Dump(true, true);
// printf("%s", http_msg.c_str());
// NOTE: not use WebSocketChannel::send
channel->write(http_msg);
state = WS_UPGRADING;
// prepare HttpParser
http_parser_.reset(HttpParser::New(HTTP_CLIENT, HTTP_V1));
http_resp_.reset(new HttpResponse);
http_parser_->InitResponse(http_resp_.get());
} else {
state = WS_CLOSED;
if (onclose) onclose();
}
};
onMessage = [this](const WebSocketChannelPtr& channel, Buffer* buf) {
if (state == WS_UPGRADING) {
int nparse = http_parser_->FeedRecvData((const char*)buf->data(), buf->size());
if (nparse != buf->size()) {
hloge("http parse error!");
channel->close();
return;
}
if (http_parser_->IsComplete()) {
if (http_resp_->status_code != HTTP_STATUS_SWITCHING_PROTOCOLS) {
hloge("server side not support websockt!");
channel->close();
return;
}
std::string ws_key = http_req_->GetHeader(SEC_WEBSOCKET_KEY);
char ws_accept[32] = {0};
ws_encode_key(ws_key.c_str(), ws_accept);
std::string ws_accept2 = http_resp_->GetHeader(SEC_WEBSOCKET_ACCEPT);
if (strcmp(ws_accept, ws_accept2.c_str()) != 0) {
hloge("Sec-WebSocket-Accept not match!");
channel->close();
return;
}
ws_parser_.reset(new WebSocketParser);
// websocket_onmessage
ws_parser_->onMessage = [this, &channel](int opcode, const std::string& msg) {
switch (opcode) {
case WS_OPCODE_CLOSE:
channel->close();
break;
case WS_OPCODE_PING:
{
// printf("recv ping\n");
// printf("send pong\n");
channel->write(WS_CLIENT_PONG_FRAME, WS_CLIENT_MIN_FRAME_SIZE);
break;
}
case WS_OPCODE_PONG:
// printf("recv pong\n");
break;
case WS_OPCODE_TEXT:
case WS_OPCODE_BINARY:
if (onmessage) onmessage(msg);
break;
default:
break;
}
};
state = WS_OPENED;
if (onopen) onopen();
}
} else {
int nparse = ws_parser_->FeedRecvData((const char*)buf->data(), buf->size());
if (nparse != buf->size()) {
hloge("websocket parse error!");
channel->close();
return;
}
}
};
state = CONNECTING;
start();
return 0;
}
int WebSocketClient::close() {
if (channel == NULL) return -1;
channel->close();
stop();
state = WS_CLOSED;
return 0;
}
int WebSocketClient::send(const std::string& msg) {
if (channel == NULL) return -1;
return channel->send(msg);
}
}
| [
"ithewei@163.com"
] | ithewei@163.com |
8125e3b49900c53b3bf8197c4944b6f95c1fa88d | e870a980c4b10dcd26f5456b23d5d62490b6281f | /Chapter 6/source/cingolf.cpp | 6f11324501d90d6e5d000b5e2dbee27f0ed8d2e9 | [] | no_license | Jack-lss/C-_Primer_Plus | 041d464d5523bb5645de177d90fe5565bd71fc7d | 3daa6657f316bfbf5747810900a7fa5bf32ebed3 | refs/heads/master | 2022-11-27T22:10:58.062919 | 2020-08-11T14:09:53 | 2020-08-11T14:09:53 | 277,744,103 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 854 | cpp | // cingolf.cpp -- non-numeric input skipped
#include <iostream>
const int Max = 5;
int main()
{
using namespace std;
// get data
int golf[Max];
cout << "Please enter your golf scores.\n";
cout << "You must enter " << Max << " rounds.\n";
int i;
for (i = 0; i < Max; i++)
{
cout << "round #" << i + 1 << ": ";
while (!(cin >> golf[i]))
{
cin.clear(); // reset input
while (cin.get() != '\n')
continue; // get rid of bad input
cout << "Please enter a number: ";
}
}
// calculate average
double total = 0.0;
for (i = 0; i < Max; i++)
total += golf[i];
// report results
cout << total / Max << " = average score " << Max << " rounds\n";
// cin.get();
// cin.get();
system("pause");
return 0;
}
| [
"1349916452@qq.com"
] | 1349916452@qq.com |
dedf0e05d0f23679fc7070316eb741ce141df928 | a186d7c63d5ccc74238dec82307a10454f92e499 | /Source/BansheeCore/Source/BsMultiRenderTexture.cpp | e39455ac61b78aa8cab0a5061e0307a93244a261 | [] | no_license | venscn/BansheeEngine | 9f48b89838fbab15c6bf73fc8f296ef3d538dc49 | e1daf513a521e59b702001da920165d23b4b9f50 | refs/heads/master | 2020-04-06T06:49:38.631456 | 2016-07-28T12:10:44 | 2016-07-28T12:10:44 | 64,410,616 | 2 | 0 | null | 2016-07-28T16:17:46 | 2016-07-28T16:17:44 | null | UTF-8 | C++ | false | false | 9,602 | cpp | //********************************** Banshee Engine (www.banshee3d.com) **************************************************//
//**************** Copyright (c) 2016 Marko Pintera (marko.pintera@gmail.com). All rights reserved. **********************//
#include "BsMultiRenderTexture.h"
#include "BsTexture.h"
#include "BsException.h"
#include "BsDebug.h"
#include "BsCoreThread.h"
#include "BsTextureManager.h"
#include "BsFrameAlloc.h"
#include "BsResources.h"
namespace BansheeEngine
{
MultiRenderTextureProperties::MultiRenderTextureProperties(const MULTI_RENDER_TEXTURE_DESC& desc)
{
for (size_t i = 0; i < desc.colorSurfaces.size(); i++)
{
HTexture texture = desc.colorSurfaces[i].texture;
if (texture != nullptr)
{
const TextureProperties& texProps = texture->getProperties();
construct(&texProps);
break;
}
}
}
MultiRenderTextureProperties::MultiRenderTextureProperties(const MULTI_RENDER_TEXTURE_CORE_DESC& desc)
{
for (size_t i = 0; i < desc.colorSurfaces.size(); i++)
{
SPtr<TextureCore> texture = desc.colorSurfaces[i].texture;
if (texture != nullptr)
{
const TextureProperties& texProps = texture->getProperties();
construct(&texProps);
break;
}
}
}
void MultiRenderTextureProperties::construct(const TextureProperties* props)
{
if (props == nullptr)
return;
mWidth = props->getWidth();
mHeight = props->getHeight();
mColorDepth = PixelUtil::getNumElemBits(props->getFormat());
mActive = true;
mHwGamma = props->isHardwareGammaEnabled();
mMultisampleCount = props->getMultisampleCount();
mIsWindow = false;
mRequiresTextureFlipping = requiresTextureFlipping();
}
MultiRenderTextureCore::MultiRenderTextureCore(const MULTI_RENDER_TEXTURE_CORE_DESC& desc)
:mDesc(desc)
{ }
MultiRenderTextureCore::~MultiRenderTextureCore()
{
for (auto iter = mColorSurfaces.begin(); iter != mColorSurfaces.end(); ++iter)
{
if (*iter != nullptr)
TextureCore::releaseView(*iter);
}
if (mDepthStencilSurface != nullptr)
TextureCore::releaseView(mDepthStencilSurface);
}
void MultiRenderTextureCore::initialize()
{
RenderTargetCore::initialize();
mColorSurfaces.resize(BS_MAX_MULTIPLE_RENDER_TARGETS);
for (size_t i = 0; i < mDesc.colorSurfaces.size(); i++)
{
if (mDesc.colorSurfaces[i].texture != nullptr)
{
if (i >= BS_MAX_MULTIPLE_RENDER_TARGETS)
{
LOGWRN("Render texture index is larger than the maximum number of supported render targets. Index: " + toString((int)i) +
". Max. number of render targets: " + toString(BS_MAX_MULTIPLE_RENDER_TARGETS));
continue;
}
SPtr<TextureCore> texture = mDesc.colorSurfaces[i].texture;
if (texture->getProperties().getUsage() != TU_RENDERTARGET)
BS_EXCEPT(InvalidParametersException, "Provided texture is not created with render target usage.");
mColorSurfaces[i] = TextureCore::requestView(texture, mDesc.colorSurfaces[i].mipLevel, 1,
mDesc.colorSurfaces[i].face, mDesc.colorSurfaces[i].numFaces, GVU_RENDERTARGET);
}
}
if (mDesc.depthStencilSurface.texture != nullptr)
{
SPtr<TextureCore> texture = mDesc.depthStencilSurface.texture;
if (texture->getProperties().getUsage() != TU_DEPTHSTENCIL)
BS_EXCEPT(InvalidParametersException, "Provided texture is not created with depth stencil usage.");
mDepthStencilSurface = TextureCore::requestView(texture, mDesc.depthStencilSurface.mipLevel, 1,
mDesc.depthStencilSurface.face, 0, GVU_DEPTHSTENCIL);
}
throwIfBuffersDontMatch();
}
void MultiRenderTextureCore::syncToCore(const CoreSyncData& data)
{
MultiRenderTextureProperties& props = const_cast<MultiRenderTextureProperties&>(getProperties());
props = data.getData<MultiRenderTextureProperties>();
}
const MultiRenderTextureProperties& MultiRenderTextureCore::getProperties() const
{
return static_cast<const MultiRenderTextureProperties&>(getPropertiesInternal());
}
void MultiRenderTextureCore::throwIfBuffersDontMatch() const
{
SPtr<TextureView> firstSurfaceDesc = nullptr;
for(size_t i = 0; i < mColorSurfaces.size(); i++)
{
if(mColorSurfaces[i] == nullptr)
continue;
if(firstSurfaceDesc == nullptr)
{
firstSurfaceDesc = mColorSurfaces[i];
continue;
}
const TextureProperties& curTexProps = mColorSurfaces[i]->getTexture()->getProperties();
const TextureProperties& firstTexProps = firstSurfaceDesc->getTexture()->getProperties();
if (curTexProps.getWidth() != firstTexProps.getWidth() ||
curTexProps.getHeight() != firstTexProps.getHeight() ||
curTexProps.getMultisampleCount() != firstTexProps.getMultisampleCount())
{
String errorInfo = "\nWidth: " + toString(curTexProps.getWidth()) + "/" + toString(firstTexProps.getWidth());
errorInfo += "\nHeight: " + toString(curTexProps.getHeight()) + "/" + toString(firstTexProps.getHeight());
errorInfo += "\nMultisample Count: " + toString(curTexProps.getMultisampleCount()) + "/" + toString(firstTexProps.getMultisampleCount());
BS_EXCEPT(InvalidParametersException, "Provided texture and depth stencil buffer don't match!" + errorInfo);
}
}
if (firstSurfaceDesc != nullptr)
{
const TextureProperties& firstTexProps = firstSurfaceDesc->getTexture()->getProperties();
if (firstTexProps.getTextureType() != TEX_TYPE_2D)
BS_EXCEPT(NotImplementedException, "Render textures are currently only implemented for 2D surfaces.");
UINT32 numSlices;
if (firstTexProps.getTextureType() == TEX_TYPE_3D)
numSlices = firstTexProps.getDepth();
else
numSlices = firstTexProps.getNumFaces();
if ((firstSurfaceDesc->getFirstArraySlice() + firstSurfaceDesc->getNumArraySlices()) > numSlices)
{
BS_EXCEPT(InvalidParametersException, "Provided number of faces is out of range. Face: " +
toString(firstSurfaceDesc->getFirstArraySlice() + firstSurfaceDesc->getNumArraySlices()) + ". Max num faces: " + toString(numSlices));
}
if (firstSurfaceDesc->getMostDetailedMip() > firstTexProps.getNumMipmaps())
{
BS_EXCEPT(InvalidParametersException, "Provided number of mip maps is out of range. Mip level: " +
toString(firstSurfaceDesc->getMostDetailedMip()) + ". Max num mipmaps: " + toString(firstTexProps.getNumMipmaps()));
}
if (mDepthStencilSurface == nullptr)
return;
const TextureProperties& depthTexProps = mDepthStencilSurface->getTexture()->getProperties();
if (depthTexProps.getWidth() != firstTexProps.getWidth() ||
depthTexProps.getHeight() != firstTexProps.getHeight() ||
depthTexProps.getMultisampleCount() != firstTexProps.getMultisampleCount())
{
String errorInfo = "\nWidth: " + toString(depthTexProps.getWidth()) + "/" + toString(firstTexProps.getWidth());
errorInfo += "\nHeight: " + toString(depthTexProps.getHeight()) + "/" + toString(firstTexProps.getHeight());
errorInfo += "\nMultisample Count: " + toString(depthTexProps.getMultisampleCount()) + "/" + toString(firstTexProps.getMultisampleCount());
BS_EXCEPT(InvalidParametersException, "Provided texture and depth stencil buffer don't match!" + errorInfo);
}
}
}
void MultiRenderTextureCore::copyToMemory(PixelData &dst, FrameBuffer buffer)
{
BS_EXCEPT(InternalErrorException,"The method or operation is not implemented.");
}
MultiRenderTexture::MultiRenderTexture(const MULTI_RENDER_TEXTURE_DESC& desc)
:mDesc(desc)
{
for (UINT32 i = 0; i < (UINT32)desc.colorSurfaces.size(); i++)
{
if (desc.colorSurfaces[i].texture != nullptr)
mBindableColorTex.push_back(desc.colorSurfaces[i].texture);
}
if (desc.depthStencilSurface.texture != nullptr)
mBindableDepthStencilTex = desc.depthStencilSurface.texture;
}
SPtr<CoreObjectCore> MultiRenderTexture::createCore() const
{
MULTI_RENDER_TEXTURE_CORE_DESC coreDesc;
for (auto& colorSurface : mDesc.colorSurfaces)
{
RENDER_SURFACE_CORE_DESC surfaceDesc;
if (colorSurface.texture.isLoaded())
surfaceDesc.texture = colorSurface.texture->getCore();
surfaceDesc.face = colorSurface.face;
surfaceDesc.numFaces = colorSurface.numFaces;
surfaceDesc.mipLevel = colorSurface.mipLevel;
coreDesc.colorSurfaces.push_back(surfaceDesc);
}
if (mDesc.depthStencilSurface.texture.isLoaded())
coreDesc.depthStencilSurface.texture = mDesc.depthStencilSurface.texture->getCore();
coreDesc.depthStencilSurface.face = mDesc.depthStencilSurface.face;
coreDesc.depthStencilSurface.numFaces = mDesc.depthStencilSurface.numFaces;
coreDesc.depthStencilSurface.mipLevel = mDesc.depthStencilSurface.mipLevel;
return TextureCoreManager::instance().createMultiRenderTextureInternal(coreDesc);
}
SPtr<MultiRenderTextureCore> MultiRenderTexture::getCore() const
{
return std::static_pointer_cast<MultiRenderTextureCore>(mCoreSpecific);
}
SPtr<MultiRenderTexture> MultiRenderTexture::create(const MULTI_RENDER_TEXTURE_DESC& desc)
{
return TextureManager::instance().createMultiRenderTexture(desc);
}
CoreSyncData MultiRenderTexture::syncToCore(FrameAlloc* allocator)
{
UINT32 size = sizeof(MultiRenderTextureProperties);
UINT8* buffer = allocator->alloc(size);
MultiRenderTextureProperties& props = const_cast<MultiRenderTextureProperties&>(getProperties());
memcpy(buffer, (void*)&props, size);
return CoreSyncData(buffer, size);
}
const MultiRenderTextureProperties& MultiRenderTexture::getProperties() const
{
return static_cast<const MultiRenderTextureProperties&>(getPropertiesInternal());
}
UINT32 MultiRenderTexture::getColorSurfaceCount() const
{
return (UINT32)mDesc.colorSurfaces.size();
}
} | [
"bearishsun@gmail.com"
] | bearishsun@gmail.com |
ebfcd16fc494385cb2cb3f1912baa6351912d7bc | 660d24ccf42b88deef7db394ec35ef38d54fcaaa | /vehicle_server/BTVehicleServer.h | 6c9de884b970bbe1d92cc9d9c50f919848f98f9c | [] | no_license | byingyang/rc-vehicle-management-system | b66fe542e19997c132f46b85fd202e892ee6707d | 718b2f28265f85fb7cb6f0de3e23bc919e543d0d | refs/heads/master | 2021-05-27T17:10:40.077171 | 2011-07-15T03:51:24 | 2011-07-15T03:51:24 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,219 | h | #ifndef BTVEHICLESERVER_H
#define BTVEHICLESERVER_H
#include <boost/thread.hpp>
#include <boost/bind.hpp>
#include <boost/asio.hpp>
#include <string>
#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>
#include "BTVehicle.h"
#include "connection.h"
class BTVehicleServer : private boost::noncopyable {
public:
// Construct the server to listen on the specified TCP address and port
explicit BTVehicleServer(const char *, const char *, std::size_t);
// Run the server's io_service loop.
void run();
// Stop the server.
void stop();
// Add a vehicle
bool AddVehicle(boost::shared_ptr<BTVehicle> v);
private:
// Handle completion of an asynchronous accept operation.
void handle_accept(const boost::system::error_code& e);
// The number of threads that will call io_service::run().
std::size_t thread_pool_size;
// The io_service used to perform asynchronous operations.
boost::asio::io_service io_service;
// Acceptor used to listen for incoming connections.
boost::asio::ip::tcp::acceptor acceptor;
// The next connection to be accepted.
connection_ptr new_connection;
// The session controller
SessionController session_controller;
};
#endif | [
"brad@bradyinger.com"
] | brad@bradyinger.com |
d6f53d410403640aa313190df8873d8aab0dc66a | eaf5c173ec669b26c95f7babad40306f2c7ea459 | /arc086/arc086_b.cpp | a12b7834331a78bdfb4cbfdf34f41b883f910e46 | [] | no_license | rikuTanide/atcoder_endeavor | 657cc3ba7fbf361355376a014e3e49317fe96def | 6b5dc43474d5183d8eecb8cb13bf45087c7ed195 | refs/heads/master | 2023-02-02T11:49:06.679743 | 2020-12-21T04:51:10 | 2020-12-21T04:51:10 | 318,676,396 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,916 | cpp | #include <bits/stdc++.h>
#include <cmath>
const double PI = 3.14159265358979323846;
using namespace std;
typedef long long ll;
const double EPS = 1e-9;
#define rep(i, n) for (int i = 0; i < (n); ++i)
//typedef pair<ll, ll> P;
typedef pair<ll, ll> P;
const ll INF = 10e17;
#define cmin(x, y) x = min(x, y)
#define cmax(x, y) x = max(x, y)
#define ret() return 0;
std::istream &operator>>(std::istream &in, set<int> &o) {
ll a;
in >> a;
o.insert(a);
return in;
}
std::istream &operator>>(std::istream &in, queue<int> &o) {
ll a;
in >> a;
o.push(a);
return in;
}
bool contain(set<int> &s, int a) { return s.find(a) != s.end(); }
//ifstream myfile("C:\\Users\\riku\\Downloads\\0_00.txt");
//ofstream outfile("log.txt");
//outfile << setw(6) << setfill('0') << prefecture << setw(6) << setfill('0') << rank << endl;
// std::cout << std::bitset<8>(9);
const int mod = 1000000007;
//const ll mod = 1e10;
typedef priority_queue<string, vector<string>, greater<string> > PQ_ASK;
int main() {
int n;
cin >> n;
vector<ll> numbers(n);
rep(i, n)cin >> numbers[i];
auto ma_it = max_element(numbers.begin(), numbers.end());
ll ma = *ma_it;
int ma_i = distance(numbers.begin(), ma_it);
auto mi_it = min_element(numbers.begin(), numbers.end());
ll mi = *mi_it;
int mi_i = distance(numbers.begin(), mi_it);
vector<P> ans;
if (ma + mi >= 0) {
rep(i, n) {
if (numbers[i] < 0) ans.push_back(P(ma_i, i));
}
for (int i = 1; i < n; i++) {
ans.push_back(P(i - 1, i));
}
} else {
rep(i, n) {
if (numbers[i] > 0) ans.push_back(P(mi_i, i));
}
for (int i = n - 2; i >= 0; i--) {
ans.push_back(P(i + 1, i));
}
}
cout << ans.size() << endl;
for (P p : ans) {
printf("%lld %lld\n", p.first + 1, p.second + 1);
}
}
| [
"riku@tanide.net"
] | riku@tanide.net |
80140772fbd28d7d8cc5b792e7bb0526e6987b5c | afc481e5cbea560d5b9d9080c38e4fd11169cfc8 | /src/slg/engines/rtpathocl/rtpathocl.cpp | 32c19f1d0f870602ba4bfb6a23b60c8cf9c5fdd9 | [
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | thatguy3444/LuxCore | a1cde895db2ccc688be89689d6aa039a7fec8765 | 1657a2865bd82ee4a8cace6b0605a2871e8d6449 | refs/heads/master | 2020-03-22T20:42:10.375101 | 2018-07-20T04:23:12 | 2018-07-20T04:23:12 | 140,623,765 | 0 | 0 | null | 2018-07-11T20:17:41 | 2018-07-11T20:17:40 | null | UTF-8 | C++ | false | false | 8,700 | cpp | /***************************************************************************
* Copyright 1998-2018 by authors (see AUTHORS.txt) *
* *
* This file is part of LuxCoreRender. *
* *
* 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. *
***************************************************************************/
#if !defined(LUXRAYS_DISABLE_OPENCL)
#include "slg/slg.h"
#include "slg/engines/rtpathocl/rtpathocl.h"
using namespace std;
using namespace luxrays;
using namespace slg;
//------------------------------------------------------------------------------
// RTPathOCLRenderEngine
//------------------------------------------------------------------------------
RTPathOCLRenderEngine::RTPathOCLRenderEngine(const RenderConfig *rcfg, Film *flm, boost::mutex *flmMutex) :
TilePathOCLRenderEngine(rcfg, flm, flmMutex, false) {
if (nativeRenderThreadCount > 0)
throw runtime_error("opencl.native.threads.count must be 0 for RTPATHOCL");
frameBarrier = new boost::barrier(renderOCLThreads.size() + 1);
frameStartTime = 0.f;
frameTime = 0.f;
// Disable denoiser statistics collection
film->GetDenoiser().SetEnabled(false);
}
RTPathOCLRenderEngine::~RTPathOCLRenderEngine() {
delete frameBarrier;
}
PathOCLBaseOCLRenderThread *RTPathOCLRenderEngine::CreateOCLThread(const u_int index,
OpenCLIntersectionDevice *device) {
return new RTPathOCLRenderThread(index, device, this);
}
void RTPathOCLRenderEngine::StartLockLess() {
//--------------------------------------------------------------------------
// Rendering parameters
//--------------------------------------------------------------------------
const Properties &cfg = renderConfig->cfg;
previewResolutionReduction = RoundUpPow2(Min(Max(1, cfg.Get(GetDefaultProps().Get("rtpath.resolutionreduction.preview")).Get<int>()), 64));
previewResolutionReductionStep = Min(Max(1, cfg.Get(GetDefaultProps().Get("rtpath.resolutionreduction.preview.step")).Get<int>()), 64);
resolutionReduction = RoundUpPow2(Min(Max(1, cfg.Get(GetDefaultProps().Get("rtpath.resolutionreduction")).Get<int>()), 64));
TilePathOCLRenderEngine::StartLockLess();
// Force to use only 1 tile for each device
maxTilePerDevice = 1;
tileRepository->enableRenderingDonePrint = false;
frameCounter = 0;
// To synchronize the start of all threads
frameBarrier->wait();
}
void RTPathOCLRenderEngine::StopLockLess() {
frameBarrier->wait();
frameBarrier->wait();
// All render threads are now suspended and I can set the interrupt signal
for (size_t i = 0; i < renderOCLThreads.size(); ++i)
((RTPathOCLRenderThread *)renderOCLThreads[i])->renderThread->interrupt();
frameBarrier->wait();
// Render threads will now detect the interruption
TilePathOCLRenderEngine::StopLockLess();
}
void RTPathOCLRenderEngine::EndSceneEdit(const EditActionList &editActions) {
const bool requireSync = editActions.HasAnyAction() && !editActions.HasOnly(CAMERA_EDIT);
if (requireSync) {
// This is required to move the rendering thread forward
frameBarrier->wait();
}
// While threads splat their tiles on the film I can finish the scene edit
TilePathOCLRenderEngine::EndSceneEdit(editActions);
updateActions.AddActions(editActions.GetActions());
frameCounter = 0;
if (requireSync) {
// This is required to move the rendering thread forward
frameBarrier->wait();
// Re-initialize the tile queue for the next frame
tileRepository->Restart(film, frameCounter);
frameBarrier->wait();
}
}
// A fast path for film resize
void RTPathOCLRenderEngine::BeginFilmEdit() {
frameBarrier->wait();
frameBarrier->wait();
// All render threads are now suspended and I can set the interrupt signal
for (size_t i = 0; i < renderOCLThreads.size(); ++i)
((RTPathOCLRenderThread *)renderOCLThreads[i])->renderThread->interrupt();
frameBarrier->wait();
// Render threads will now detect the interruption
for (size_t i = 0; i < renderOCLThreads.size(); ++i)
renderOCLThreads[i]->Stop();
}
// A fast path for film resize
void RTPathOCLRenderEngine::EndFilmEdit(Film *flm) {
// Update the film pointer
film = flm;
InitFilm();
// Disable denoiser statistics collection
film->GetDenoiser().SetEnabled(false);
frameCounter = 0;
// Create a tile repository based on the new film
InitTileRepository();
tileRepository->enableRenderingDonePrint = false;
// The camera has been updated too
EditActionList a;
a.AddActions(CAMERA_EDIT);
compiledScene->Recompile(a);
// Re-start all rendering threads
for (size_t i = 0; i < renderOCLThreads.size(); ++i)
renderOCLThreads[i]->Start();
// To synchronize the start of all threads
frameBarrier->wait();
}
void RTPathOCLRenderEngine::UpdateFilmLockLess() {
// Nothing to do: the display thread is in charge of updating the film
}
void RTPathOCLRenderEngine::WaitNewFrame() {
// Avoid to move forward rendering threads if I'm in pause
if (!pauseMode) {
// Threads do the rendering
frameBarrier->wait();
// Threads splat their tiles on the film
frameBarrier->wait();
// Re-initialize the tile queue for the next frame
tileRepository->Restart(film, frameCounter++);
frameBarrier->wait();
// Update the statistics
UpdateCounters();
const double currentTime = WallClockTime();
frameTime = currentTime - frameStartTime;
frameStartTime = currentTime;
}
}
//------------------------------------------------------------------------------
// Static methods used by RenderEngineRegistry
//------------------------------------------------------------------------------
Properties RTPathOCLRenderEngine::ToProperties(const Properties &cfg) {
return TilePathOCLRenderEngine::ToProperties(cfg) <<
//------------------------------------------------------------------
// Overwrite some TilePathOCLRenderEngine property
//------------------------------------------------------------------
cfg.Get(GetDefaultProps().Get("renderengine.type")) <<
cfg.Get(GetDefaultProps().Get("path.pathdepth.total")) <<
cfg.Get(GetDefaultProps().Get("path.pathdepth.diffuse")) <<
cfg.Get(GetDefaultProps().Get("path.pathdepth.glossy")) <<
cfg.Get(GetDefaultProps().Get("path.pathdepth.specular")) <<
cfg.Get(GetDefaultProps().Get("tilepath.sampling.aa.size")) <<
cfg.Get(GetDefaultProps().Get("tilepathocl.devices.maxtiles")) <<
//------------------------------------------------------------------
cfg.Get(GetDefaultProps().Get("rtpath.resolutionreduction.preview")) <<
cfg.Get(GetDefaultProps().Get("rtpath.resolutionreduction.preview.step")) <<
cfg.Get(GetDefaultProps().Get("rtpath.resolutionreduction"));
}
RenderEngine *RTPathOCLRenderEngine::FromProperties(const RenderConfig *rcfg, Film *flm, boost::mutex *flmMutex) {
return new RTPathOCLRenderEngine(rcfg, flm, flmMutex);
}
const Properties &RTPathOCLRenderEngine::GetDefaultProps() {
static Properties props = Properties() <<
TilePathOCLRenderEngine::GetDefaultProps() <<
//------------------------------------------------------------------
// Overwrite some TilePathOCLRenderEngine property
//------------------------------------------------------------------
Property("renderengine.type")(GetObjectTag()) <<
Property("path.pathdepth.total")(5) <<
Property("path.pathdepth.diffuse")(3) <<
Property("path.pathdepth.glossy")(3) <<
Property("path.pathdepth.specular")(3) <<
Property("tilepath.sampling.aa.size")(1) <<
Property("tilepathocl.devices.maxtiles")(1) <<
//------------------------------------------------------------------
Property("rtpath.resolutionreduction.preview")(4) <<
Property("rtpath.resolutionreduction.preview.step")(8) <<
Property("rtpath.resolutionreduction")(4);
return props;
}
#endif
| [
"dade916@gmail.com"
] | dade916@gmail.com |
27c37d7d323c50754fcde3ef14bc608972164cef | f7adcd94e16aa2414c24e14e17976a2b84d0c503 | /EECS600-Homework/ps4/joints_controller/src/joint1_commander.cpp | 1d502120d3b567e61631bde5bc65fd33babddd09 | [] | no_license | Hark0616/ros-learning | f448682a6d6ad8642aa48fa270c97a086401a7a6 | 0860f24e0f4083f4fd58ad160389a8a56c2924cd | refs/heads/master | 2021-12-07T12:05:38.047292 | 2015-12-01T03:13:35 | 2015-12-01T03:13:35 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,637 | cpp | #include <ros/ros.h>
#include <std_msgs/Float64.h>
#include <math.h>
#include <sstream>
double PI = 3.1415926;
int main(int argc, char **argv) {
ros::init(argc, argv, "joint1_commander"); // name of this node will be "minimal_"
ros::NodeHandle n; // two lines to create a publisher object that can talk to ROS
ros::Publisher pub = n.advertise<std_msgs::Float64>("jnt1_pos_cmd", 1000);
// the "1000" argument says to use a buffer size of 1000; could make larger, if expect network backups
std_msgs::Float64 jnt1_position; //create a variable of type "Float64",
// as defined in: /opt/ros/indigo/share/std_msgs
// any message published on a ROS topic must have a pre-defined format,
// so subscribers know how to interpret the serialized data transmission
double amplitude = 0.5;
double frequency = 20.0;
int i = 0;
ros::Rate naptime(10.0); //create a ros object from the ros “Rate” class;
//set the sleep timer for 1Hz repetition rate (arg is in units of Hz)
// do work here in infinite loop (desired for this example), but terminate if detect ROS has faulted
while (ros::ok())
{
// this loop has no sleep timer, and thus it will consume excessive CPU time
// expect one core to be 100% dedicated (wastefully) to this small task
jnt1_position.data = 0.9 + amplitude*sin(frequency*PI/180*i); //phase increment by frequency*PI/180 radius each iteration
i++;
ROS_INFO("Sending data %f", jnt1_position.data);
pub.publish(jnt1_position); // publish the value--of type Float64--
naptime.sleep();
}
}
| [
"xpharry123@hotmail.com"
] | xpharry123@hotmail.com |
a904694d78daaffd8b78f2b301303dc5f5f31dd1 | 9b79ccd797ea338ac70d2dc457c06cc95b66e0b1 | /96-Unique_Binary_Search_Trees/main.cpp | d88e7a51eba99ec481febf988975474c67857776 | [] | no_license | mosqd/leetcode | b3629c47ff80f2752d4fa4af9fa58890641fc464 | d44f48d3b89b5b22f78f0ebb363a4e4a72ebc777 | refs/heads/master | 2021-07-26T00:14:17.338268 | 2021-07-12T12:41:22 | 2021-07-12T12:41:22 | 225,331,992 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 712 | cpp | /**
Given n, how many structurally unique BST's (binary search trees) that store values 1 ... n?
Example:
Input: 3
Output: 5
Explanation:
Given n = 3, there are a total of 5 unique BST's:
1 3 3 2 1
\ / / / \ \
3 2 1 1 3 2
/ / \ \
2 1 2 3
*/
class Solution {
public:
int numTrees(int n) {
int *dp = new int[n+1];
memset(dp, 0, sizeof(int)*(n+1));
dp[0] = dp[1] = 1;
for (int i = 2; i <=n; i++) {
for (int j = 0; j < i; j++) {
dp[i] += dp[j] * dp[i-1-j];
}
}
return dp[n];
}
};
| [
"TryCatch.exe@gmail.com"
] | TryCatch.exe@gmail.com |
196ceb9221d18342a2eeb7d23ea2c08e4439333f | 489ab1c1e550e6c1a700c242826d9651d795bef0 | /src/View/CImageButton.cpp | 45c80767f68e2578e52ffad2f1a24e183be04d88 | [] | no_license | hjqqq/Forever | 1eea9257160fa4a94f1646261a651af899603e55 | b685d7af1667de389833d677d25ca0395416d771 | refs/heads/master | 2021-01-17T11:48:45.886631 | 2013-03-09T09:46:57 | 2013-03-09T09:46:57 | null | 0 | 0 | null | null | null | null | WINDOWS-1252 | C++ | false | false | 3,684 | cpp | /** This source file is part of Forever
* Copyright(c) 2012-2013 The DCI's Forever Team
*
* @file CImageButton.cpp
* @author Darren Chen (³¯²±¥a)
* @email darren.z32@msa.hinet.net
* @date 2013/02/03 */
#ifdef _GAMEENGINE_3D_
#include "CImageButton.h"
#include <OgreOverlayManager.h>
CImageButton::CImageButton() : m_pPanel(NULL),
m_pTextArea(NULL),
m_bTextVisible(false)
{
}
CImageButton::~CImageButton()
{
if(m_pTextArea != NULL) {
delete m_pTextArea;
m_pTextArea = NULL;
}
if(m_pPanel != NULL) {
Ogre::OverlayManager::getSingleton().destroyOverlayElement(m_pPanel);
m_pPanel = NULL;
}
}
void CImageButton::init(COverlayUI *pUI, int _x, int _y, int _w, int _h, int _id)
{
CFButton::init (_x, _y, _w, _h, _id) ;
static int inImageButton = 0;
char name[256];
memset(name, 0, sizeof(name));
sprintf(name, "CImageButton::%d", inImageButton++);
m_pPanel = (Ogre::PanelOverlayElement *)Ogre::OverlayManager::getSingleton().createOverlayElement("Panel", name);
m_pPanel->setMetricsMode(Ogre::GMM_PIXELS);
m_pPanel->setPosition((Ogre::Real)_x, (Ogre::Real)_y);
m_pPanel->setDimensions((Ogre::Real)_w, (Ogre::Real)_h);
m_pPanel->show();
if(pUI != NULL)
pUI->getOverlayContainer()->addChild(m_pPanel);
}
void CImageButton::setImage(std::string st)
{
if(m_materialName != st) {
m_materialName = st;
m_pPanel->setMaterialName(st);
}
}
void CImageButton::setWidth(float width)
{
m_pPanel->setWidth(width);
}
void CImageButton::setTextVisible(bool visible)
{
m_bTextVisible = visible;
if(m_bTextVisible == true) {
m_pTextArea = new CTextAreaOgre();
m_pTextArea->init(NULL, 0, 0, w, h);
m_pTextArea->setFont(10);
m_pPanel->addChild(m_pTextArea->getOverlayElement());
}
else {
if(m_pTextArea != NULL) {
m_pPanel->removeChild(m_pTextArea->getOverlayElement()->getName());
delete m_pTextArea;
m_pTextArea = NULL;
}
}
}
void CImageButton::setText(std::string text, float r, float g, float b)
{
if(m_pTextArea != NULL)
m_pTextArea->setText(text, r, g, b);
}
void CImageButton::setTextHorizontalAlignment(Alignment alignment)
{
if(m_pTextArea != NULL) {
switch(alignment) {
case H_LEFT:
m_pTextArea->setHorizontalAlignment(CTextAreaOgre::H_LEFT);
break;
case H_CENTER:
m_pTextArea->setHorizontalAlignment(CTextAreaOgre::H_CENTER);
break;
case H_RIGHT:
m_pTextArea->setHorizontalAlignment(CTextAreaOgre::H_RIGHT);
break;
}
}
}
void CImageButton::setTextVerticalAlignment(Alignment alignment)
{
if(m_pTextArea != NULL) {
switch(alignment) {
case V_TOP:
m_pTextArea->setVerticalAlignment(CTextAreaOgre::V_TOP);
break;
case V_CENTER:
m_pTextArea->setVerticalAlignment(CTextAreaOgre::V_CENTER);
break;
case V_BOTTOM:
m_pTextArea->setVerticalAlignment(CTextAreaOgre::V_BOTTOM);
break;
}
}
}
void CImageButton::setPosition(int x, int y)
{
m_pPanel->setPosition((Ogre::Real)x, (Ogre::Real)y);
}
void CImageButton::setSize(int width, int height)
{
this->w = width;
this->h = height;
m_pPanel->setDimensions((Ogre::Real)width, (Ogre::Real)height);
}
Ogre::PanelOverlayElement* CImageButton::getImage()
{
return m_pPanel;
}
void CImageButton::addChild(Ogre::OverlayElement *pElement)
{
if(pElement != NULL)
m_pPanel->addChild(pElement);
}
#endif // #ifdef _GAMEENGINE_3D_ | [
"darren.z32@msa.hinet.net"
] | darren.z32@msa.hinet.net |
7f849dcfa4dac425e9c1fe1323755ab6081625f4 | 6bb45234fe96618d7e1cc0e64a3e0d0220ae8153 | /6_term/translation/boolean/main.cpp | e00f5821d79793db58f38cfba386bc58d90fccbd | [] | no_license | artemohanjanyan/university | 032f94862a22066070ca777063d13fc51adfc08b | 1a6b0406798e1aa862227751f7a0b9d81f0f1068 | refs/heads/master | 2022-07-19T18:59:17.177990 | 2019-06-03T15:06:09 | 2019-06-03T22:27:01 | 58,167,891 | 6 | 4 | null | 2022-07-07T20:58:25 | 2016-05-05T23:55:37 | C++ | UTF-8 | C++ | false | false | 6,040 | cpp | #include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <algorithm>
#include <stdexcept>
enum class token_type
{
IMPL, OR, XOR, AND, NOT,
VAR, LPAREN, RPAREN, END
};
struct token
{
token_type type_;
std::string str_;
token(token_type type, std::string str)
: type_{type}
, str_{std::move(str)}
{ }
};
bool str_cmp(std::string const &str, size_t str_i, std::string const &other)
{
return str_i + other.size() <= str.size() &&
std::equal(other.begin(), other.end(), str.begin() + str_i);
}
void skip_spaces(std::string const *str, size_t *i)
{
while (*i < str->size() && isspace(str->at(*i)))
++*i;
}
std::vector<token> tokenize(std::string const &str)
{
std::vector<token> const special_tokens =
{{token_type::IMPL, "impl"},
{token_type::OR, "or"},
{token_type::XOR, "xor"},
{token_type::AND, "and"},
{token_type::NOT, "not"},
{token_type::LPAREN, "("},
{token_type::RPAREN, ")"}};
std::vector<token> tokens;
size_t i = 0;
skip_spaces(&str, &i);
while (i < str.size())
{
bool is_special = false;
for (auto const &special : special_tokens)
if (str_cmp(str, i, special.str_))
{
tokens.push_back(special);
i += special.str_.size();
is_special = true;
break;
}
if (!is_special)
{
if (isalpha(str[i]))
{
tokens.emplace_back(token_type::VAR, std::string{str[i]});
++i;
}
else
throw std::runtime_error{std::string("unknown char ") + str[i]};
}
skip_spaces(&str, &i);
}
tokens.emplace_back(token_type::END, "");
return tokens;
}
struct node
{
std::string str_;
std::vector<node> children_;
node(std::string str)
: str_{str}
{ }
};
struct parser
{
std::vector<token> const *tokens_;
size_t i;
parser(std::vector<token> const *tokens)
: tokens_{tokens}
{
i = 0;
}
void consume(token_type const &type)
{
if (tokens_->at(i).type_ != type)
throw std::runtime_error{"unexpected token"};
++i;
}
node parse_i()
{
node res{"IMPL"};
switch (tokens_->at(i).type_)
{
case token_type::VAR:
case token_type::NOT:
case token_type::LPAREN:
res.children_.push_back(parse_d());
res.children_.push_back(parse_i1());
break;
default:
throw std::runtime_error{"unexpected token"};
}
return res;
}
node parse_i1()
{
node res{"IMPL'"};
switch (tokens_->at(i).type_)
{
case token_type::IMPL:
res.children_.emplace_back(tokens_->at(i).str_);
consume(tokens_->at(i).type_);
res.children_.push_back(parse_d());
res.children_.push_back(parse_i1());
break;
case token_type::RPAREN:
case token_type::END:
break;
default:
throw std::runtime_error{"unexpected token"};
}
return res;
}
node parse_d()
{
node res{"OR"};
switch (tokens_->at(i).type_)
{
case token_type::VAR:
case token_type::NOT:
case token_type::LPAREN:
res.children_.push_back(parse_c());
res.children_.push_back(parse_d1());
break;
default:
throw std::runtime_error{"unexpected token"};
}
return res;
}
node parse_d1()
{
node res{"OR'"};
switch (tokens_->at(i).type_)
{
case token_type::OR:
case token_type::XOR:
res.children_.emplace_back(tokens_->at(i).str_);
consume(tokens_->at(i).type_);
res.children_.push_back(parse_c());
res.children_.push_back(parse_d1());
break;
case token_type::IMPL:
case token_type::RPAREN:
case token_type::END:
break;
default:
throw std::runtime_error{"unexpected token"};
}
return res;
}
node parse_c()
{
node res{"AND"};
switch (tokens_->at(i).type_)
{
case token_type::VAR:
case token_type::NOT:
case token_type::LPAREN:
res.children_.push_back(parse_u());
res.children_.push_back(parse_c1());
break;
default:
throw std::runtime_error{"unexpected token"};
}
return res;
}
node parse_c1()
{
node res{"AND'"};
switch (tokens_->at(i).type_)
{
case token_type::AND:
res.children_.emplace_back(tokens_->at(i).str_);
consume(tokens_->at(i).type_);
res.children_.push_back(parse_u());
res.children_.push_back(parse_c1());
break;
case token_type::IMPL:
case token_type::OR:
case token_type::XOR:
case token_type::RPAREN:
case token_type::END:
break;
default:
throw std::runtime_error{"unexpected token"};
}
return res;
}
node parse_u()
{
node res{"UNARY"};
switch (tokens_->at(i).type_)
{
case token_type::VAR:
res.children_.emplace_back(tokens_->at(i).str_);
consume(tokens_->at(i).type_);
break;
case token_type::NOT:
consume(tokens_->at(i).type_);
res.children_.push_back(parse_u());
break;
case token_type::LPAREN:
consume(token_type::LPAREN);
res.children_.emplace_back("(");
res.children_.push_back(parse_i());
consume(token_type::RPAREN);
res.children_.emplace_back(")");
break;
default:
throw std::runtime_error{"unexpected token"};
}
return res;
}
node parse()
{
auto res = parse_i();
consume(token_type::END);
return res;
}
};
void print_node(std::ostream &out, node const &n, size_t depth = 0)
{
for (size_t i = 0; i < depth; ++i)
out << " ";
out << n.str_ << "\n";
for (auto const &child : n.children_)
print_node(out, child, depth + 1);
}
size_t graph_node(std::ostream &out, node const &n, size_t i = 0)
{
size_t n_i = i;
if (n_i == 0)
out << "digraph G {\n";
for (auto const &child : n.children_)
{
size_t child_i = ++i;
i = graph_node(out, child, i);
out << n_i << " -> " << child_i << "\n";
}
out << n_i << " " << "[ label = \"" << n.str_ << "\" ] \n";
if (n_i == 0)
out << "}\n";
return i;
}
int main(int argc, char **argv)
{
try
{
std::string s;
std::getline(std::cin, s);
auto tokens = tokenize(s);
node n = parser(&tokens).parse();
print_node(std::cout, n);
if (argc > 1)
{
std::ofstream graph(argv[1]);
graph_node(graph, n);
}
}
catch (std::exception const &e)
{
std::cout << e.what() << "\n";
return 1;
}
return 0;
}
| [
"artemohanjanyan@gmail.com"
] | artemohanjanyan@gmail.com |
bd323be25175d9c6bc338b78711e750229d36e38 | aa1dedd2d356d64f08f97f7591f92cee6af313c7 | /CPPGeneralTransform/Triangle.h | 9c5928aed8e35ed8928550f814868d21396c86b6 | [] | no_license | mjw18/RayTracingResearch | 8909d14444590aae216ca9a1bf17983277d552af | 2397bf0ab2ed4a1a9b1b2ae205eeb03cc1c34ea3 | refs/heads/master | 2021-01-10T06:45:54.888693 | 2016-04-06T21:37:45 | 2016-04-06T21:37:45 | 55,642,379 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,889 | h | /*
*
* Triangle object abstract class.
* Defualt Constructor generates a tirangle with random vertiecs
* Overloaded constructor generates a triangle with specific vertices
* Intersect and do nothing methods are overridden by subclasses,
* these return -1 to indicate misuse of abstract triangle object*
*
* Triangle vertices and vectors are stored as double arrays
*
* Accessor and mutators are passed number for specifc edge
* ie) getEdge(1) returns EdgeVector 1
*
*/
#pragma once
#include <iostream>
#include "Ray.h"
#include "Config.h"
class Triangle
{
public:
//Default constructor generates random triangle
Triangle();
//This constructor allows for specific trianle contruction by passing vertex arrays
Triangle(double* V1, double* V2, double* V3);
~Triangle();
//Virtual intersect and dummy methods
//Return -1 for class misuse
virtual int intersect(Ray* ray) { return -1; };
virtual int doNothing(Ray* ray) { return -1; };
//printing of results
virtual void printRes() {};
// Mutator function
void setEdge(int index);
void setNorm();
// Accessor funtions
//Passing in 1 returns edge 1 etc
double* getEdge(int index);
double* getNorm();
//1 retrns first vertex etc
double* getVertex(int index);
//Debug printing
void printTriangle()
{
std::cout << "Triangle: \n";
std::printf("%f, %f, %f\n", m_v1[0], m_v1[1], m_v1[2]);
std::printf("%f, %f, %f\n", m_v2[0], m_v2[1], m_v2[2]);
std::printf("%f, %f, %f\n", m_v3[0], m_v3[1], m_v3[2]);
}
virtual void printInverse(){};
protected:
//vertices
double m_v1[3];
double m_v2[3];
double m_v3[3];
//preprocessed information
double m_e1[3];
double m_e2[3];
double m_n[3];
/* Set world coordinates */
const double xL = -PIC_WIDTH / 2;
const double yT = PIC_HEIGHT / 2;
/* Set pixel dimension */
const double w = PIC_WIDTH / (float)ROW;
const double h = PIC_HEIGHT / (float)COL;
};
| [
"mjw18@geneseo.edu"
] | mjw18@geneseo.edu |
3bcc6a60102364f8292b8bcdae1ad83ff05439e8 | c322279e4155ca257a4a78c4130efbac2ae1380a | /剑指offer/Task66_multiply.cpp | 8475cf7739c28277e147d893c773f80c85fe09ac | [] | no_license | xieliang555/leetcode | 43c87087ad358ca1a3faa7e74e3849e55052a00e | 09f6ff8e34ac9db6c59b0e2c244a2ba93b0ae8ed | refs/heads/master | 2020-06-27T06:06:21.642472 | 2019-08-30T07:14:20 | 2019-08-30T07:14:20 | 199,864,278 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 555 | cpp | #include<vector>
#include<iostream>
using namespace std;
vector<int> multiply(const vector<int>& A){
if(A.empty()) return vector<int>();
vector<int> B(A.size());
vector<int> C(A.size(),1);
vector<int> D(A.size(),1);
for(int i=1;i<A.size();i++){
C[i]=A[i-1]*C[i-1];
}
for(int i=A.size()-2;i>=0;i--){
D[i]=A[i+1]*D[i+1];
}
for(int i=0;i<A.size();i++){
B[i]=C[i]*D[i];
}
return B;
}
int main(int argc, char const *argv[])
{
vector<int> A={1,2,3,4};
vector<int> B=multiply(A);
for(int i=0;i<B.size();i++)
cout<<B[i]<<' ';
return 0;
} | [
"xieliang555@gmail.com"
] | xieliang555@gmail.com |
51d78616af04fa950ca8a9871c031af5ddb8ab1a | 225b746b76dc23274e4143e404bc9059006aac00 | /Algorithm/Algorithm/game.cpp | c917deb27f3b0ab74d7a8a00ceb7584c6de8e3ad | [] | no_license | leejuy1140/Algorithm | bdb73934e62c7434009d1333af10e109982386ab | 15711de869289267386afb47e4007337797b5394 | refs/heads/master | 2020-04-19T16:32:31.449348 | 2019-06-06T03:05:02 | 2019-06-06T03:05:02 | 141,662,861 | 0 | 0 | null | null | null | null | UHC | C++ | false | false | 1,318 | cpp | #include <stdio.h>
#include <algorithm>
#include <utility>
using namespace std;
const int MAX = 1001;
int n, score[MAX];
pair<int, int> dp[MAX][MAX];
/* dp[i][j]: score[i] ~ score[j] 최선을 다한 수빈과 선웅의 점수.
T(i, j) = min(T(i, j-1), T(i+1, j)) */
pair<int, int> game(int s, int e, int turn)
{
if (s == e)
{
if (turn % 2) return dp[s][e] = make_pair(score[s], 0);
else return dp[s][e] = make_pair(0, score[s]);
}
pair<int, int> ret1 = dp[s + 1][e];
pair<int, int> ret2 = dp[s][e - 1];
if (ret1.first == 0 && ret1.second == 0) ret1 = game(s + 1, e, turn + 1);
if (ret2.first == 0 && ret2.second == 0) ret2 = game(s, e - 1, turn + 1);
if (turn % 2) // 수빈 차례라면, 선웅 점수 합의 최소 선택
{
if (ret1.second < ret2.second)
return dp[s][e] = make_pair(ret1.first + score[s], ret1.second);
else
return dp[s][e] = make_pair(ret2.first + score[e], ret2.second);
}
else
{
if (ret1.first < ret2.first)
return dp[s][e] = make_pair(ret1.first, ret1.second + score[s]);
else
return dp[s][e] = make_pair(ret2.first, ret2.second + score[e]);
}
}
int main()
{
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d", &score[i]);
pair<int, int> result = game(1, n, 1);
printf("%d %d\n", result.first, result.second);
return 0;
} | [
"leejuy1140@gmail.com"
] | leejuy1140@gmail.com |
38170274e520b2aa1ac43f35882b27c9ec5bebcc | e09bc647f4a730d2bf4eba403c8d289c1c70bfb4 | /src/mapcoord.h | 93791ca7fd69b75b082538fca8d0ce51d50e3711 | [] | no_license | RossDynamics/Newmanv3.1 | a4d06db18998558356d43ce913edf8422473d818 | 58133e7559a6271b0bf98e48bcc2b6795bf0e331 | refs/heads/master | 2021-01-19T22:54:20.227376 | 2018-01-11T19:54:22 | 2018-01-11T19:54:22 | 88,888,542 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 490 | h | // mapcoord.h
//
// Header file for the coordmap module
//
// Author: Philip Du Toit
// Rev 1.0
//
#ifndef _MAPCOORD_H_
#define _MAPCOORD_H_
#include <cmath>
#include <iostream>
using namespace std;
#include "macros.h"
extern double TBP_mu;
extern double TBP_ecc;
extern int TBP_Ordinate;
extern int TBP_VDirection;
extern int DNA_N;
// Function Prototypes:
void MapCoordToIntegrationSpace(double *X, double t);
void MapIntegrationSpaceToCoord(double *X, double t);
#endif
| [
"pnolan1986@gmail.com"
] | pnolan1986@gmail.com |
a825056f12c5782202750cd44f0e103e9563845a | 7e686824108f22f095a89860b235cc1267e6d32f | /src/test/script_P2PK_tests.cpp | b1221deff22f535615bc56dc12db2089c3cd9853 | [
"MIT"
] | permissive | alleck/Splendid | 2aace2cf675233c3c435c4eab4aedf8b32f23347 | 8ea29bda381628f954d1699a38a70c3ae3506ed9 | refs/heads/main | 2023-03-20T11:20:13.567687 | 2021-02-22T21:56:34 | 2021-02-22T21:56:34 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,412 | cpp | // Copyright (c) 2012-2015 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "script/script.h"
#include "test/test_splendid.h"
#include <boost/test/unit_test.hpp>
using namespace std;
BOOST_FIXTURE_TEST_SUITE(script_P2PK_tests, BasicTestingSetup)
BOOST_AUTO_TEST_CASE(ispaytopublickey_test)
{
BOOST_TEST_MESSAGE("Running IsPayToPublicKey Test");
// Test CScript::IsPayToPublicKey()
static const unsigned char p2pkcompressedeven[] = {
0x41, 0x02, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, OP_CHECKSIG
};
BOOST_CHECK(CScript(p2pkcompressedeven, p2pkcompressedeven + sizeof(p2pkcompressedeven)).IsPayToPublicKey());
static const unsigned char p2pkcompressedodd[] = {
0x41, 0x03, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, OP_CHECKSIG
};
BOOST_CHECK(CScript(p2pkcompressedodd, p2pkcompressedodd + sizeof(p2pkcompressedodd)).IsPayToPublicKey());
static const unsigned char p2pkuncompressed[] = {
0x41, 0x04, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, OP_CHECKSIG
};
BOOST_CHECK(CScript(p2pkuncompressed, p2pkuncompressed + sizeof(p2pkuncompressed)).IsPayToPublicKey());
static const unsigned char missingop[] = {
0x41, 0x02, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
BOOST_CHECK(!CScript(missingop, missingop + sizeof(missingop)).IsPayToPublicKey());
static const unsigned char wrongop[] = {
0x41, 0x02, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, OP_EQUALVERIFY
};
BOOST_CHECK(!CScript(wrongop, wrongop + sizeof(wrongop)).IsPayToPublicKey());
static const unsigned char tooshort[] = {
0x41, 0x02, 0, 0, OP_CHECKSIG
};
BOOST_CHECK(!CScript(tooshort, tooshort + sizeof(tooshort)).IsPayToPublicKey());
}
BOOST_AUTO_TEST_SUITE_END()
| [
"79376856+SplendidProject@users.noreply.github.com"
] | 79376856+SplendidProject@users.noreply.github.com |
eba15b26f137a0f1110314acab77182b49217629 | eba2fadea4972b682edce710300ea280a210eee2 | /leetcode/twoPointersANDslidingWindow/838.PushDominoes.cc | e7ec1518c16d20be81dc4ce0028a865c5835034b | [] | no_license | seesealonely/leetcode | 33b876968f08a0ddd00adc714d03ad6e4c0bfae9 | 1a371f3ad438bb70bf7a685843097535f5fc1c5d | refs/heads/master | 2023-08-30T21:22:07.456531 | 2023-08-30T20:15:49 | 2023-08-30T20:15:49 | 87,525,147 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,415 | cc | /*
There are n dominoes in a line, and we place each domino vertically upright. In the beginning, we simultaneously push some of the dominoes either to the left or to the right.
After each second, each domino that is falling to the left pushes the adjacent domino on the left. Similarly, the dominoes falling to the right push their adjacent dominoes standing on the right.
When a vertical domino has dominoes falling on it from both sides, it stays still due to the balance of the forces.
For the purposes of this question, we will consider that a falling domino expends no additional force to a falling or already fallen domino.
You are given a string dominoes representing the initial state where:
dominoes[i] = 'L', if the ith domino has been pushed to the left,
dominoes[i] = 'R', if the ith domino has been pushed to the right, and
dominoes[i] = '.', if the ith domino has not been pushed.
Return a string representing the final state.
Example 1:
Input: dominoes = "RR.L"
Output: "RR.L"
Explanation: The first domino expends no additional force on the second domino.
Example 2:
Input: dominoes = ".L.R...LR..L.."
Output: "LL.RR.LLRRLL.."
Constraints:
n == dominoes.length
1 <= n <= 105
dominoes[i] is either 'L', 'R', or '.'.
*/
#include"838.PushDominoes.h"
int main()
{
Solution s;
cout<<s.pushDominoes("RR.L")<<endl;
cout<<s.pushDominoes(".L.R...LR..L..")<<endl;
return 0;
}
| [
"seesealonely@gmail.com"
] | seesealonely@gmail.com |
d99c6c4e10f43dca22550cc0500a9ab15b9f0605 | f9ab8ba66b788976e3268fa01482ed77ef0ad289 | /SobelTest/src/SobelTrying.hpp | 96724ebd5c9e1f58e95602066d23cbd34aa57316 | [] | no_license | ztomlord/ImageProcessing | 815880f8266ca8269cf46d9e96fc5e86aa461e0c | 9be1cd26a47ff5a07efe56fb8bd964f8a9a1a30e | refs/heads/master | 2021-01-15T23:45:22.429567 | 2015-07-10T13:17:21 | 2015-07-10T13:17:21 | 38,881,153 | 0 | 0 | null | 2015-07-10T13:12:41 | 2015-07-10T13:12:41 | null | UTF-8 | C++ | false | false | 9,019 | hpp | /*
* IEEE@UIC
* VISION HEADER
*
*/
#ifndef SOBLETRYING_HPP_
#define SOBLETRYING_HPP_
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include "bmp2rgb.hpp"
using namespace std;
const int ROWS = 480;
const int COLS = 480;
const int MAX_BUFF = ROWS * COLS;
//Global pointers
char *b1; // img1 raw data buff1
char *b2; // img2 raw data buff2
char **input1; // grayed img1
char **input2; // grayed img2
char **dfram1; // delta fram2 gen1
char **dframe2; // delta frame gen2
inline RGBTRIPLE** alloc2D(int row,int col)
{
RGBTRIPLE **multi_dim;
multi_dim = (RGBTRIPLE**)malloc(col * row *sizeof(RGBTRIPLE));
for (int k = 0; k < ROWS; k++)
multi_dim[k] = (RGBTRIPLE*)malloc(col * sizeof(RGBTRIPLE));
return multi_dim;
}
inline int FindMedian(char **buff)
{
/*
* ToDo How to find median with pixels?
*
*
*/
char tmp = 0;
int cp = 0;
int count = 0;
char ch = 0;
char* tbuff;
tbuff = (char*)malloc(sizeof(char) * MAX_BUFF);
//move from 2d array into single buffers
for (int i = 0; i < ROWS; i++)
{
for (int j = 0; j < COLS; j++)
{
tbuff[cp] = buff[ROWS][COLS];
cp++;
}
}
//ascending order sorting
for(int i = 0; i < MAX_BUFF; i++)
{
for(int j = 0; j < MAX_BUFF - i; j++)
{
if(tbuff[j] > tbuff[j+1])
{
tmp = tbuff[j];
tbuff[j] = tbuff[j+1];
tbuff[j+1] = tmp;
}
}
}
//do not use until rgb buf is created
return 0;
}
inline char* fillBuffer(string inFileName)
{
char* tbuff;
tbuff = (char*)malloc(sizeof(char) * MAX_BUFF);
FILE *fp;
fp = fopen(inFileName.c_str(), "r");
if(fp != NULL)
{
while ((fgets(tbuff, sizeof(tbuff), fp)) != NULL)
{
//printf("%s", tbuff);
}
fclose(fp);
}
return tbuff;
}
inline char** readInput(char *buff)
{
printf("%s",buff);
char **RedB;
char **output;
int MatVal = 0;
int cp = 0;
int ch;
//Inititialize Arrays
RedB = (char**)malloc(sizeof(char *) * ROWS);
for (int k = 0; k < ROWS; k++)
RedB[k] = (char*)malloc(sizeof(char) * COLS);
output = (char**)malloc(sizeof(char *) * ROWS);
for (int k = 0; k < ROWS; k++)
output[k] = (char*)malloc(sizeof(char) * COLS);
//cout<<"allocated arrays"<<endl;
for (int i = 0; i < ROWS; i++)
{
for (int j = 0; j < COLS; j++)
{
while (true)
{
ch = buff[cp];
if ((48 <= ch) && (ch <= 57))
{
MatVal = (MatVal * 10) + ch;
//cout<<" MatVal -> "<< MatVal << endl;
}
else
{
RedB[i][j] = MatVal;
//cout<< (char)MatVal << endl;
MatVal = 0;
cp++;
if (ch == 10 || ch == 20 || ch == 3 || ch == 32)
{
cp++;
}
break;
}
cp++;
}
output[i][j] = RedB[i][j];
}
}
for(int i = 0; i < ROWS; i++)
for(int j = 0; j < COLS; j++)
if( output[i][j] != NULL)
cout<<"i: "<< i <<" j: "<< j <<" output: "<< output[i][j] << endl;
free(RedB);
return output;
}
inline RGBTRIPLE** DeltaFrameGeneration(RGBTRIPLE** in1, RGBTRIPLE** in2)
{
/*
* Delta Frame generation is two images squashed together after being grayed out.
* Any pixel that stands out i.e moves will stand out after this transformation.
* Two picures that are identical will be the difference of zero on all RGB
*/
RGBTRIPLE **seg;
seg = alloc2D(ROWS,COLS);
RGBTRIPLE **seg1;
seg1 = alloc2D(ROWS,COLS);
for (int i = 0; i < ROWS; i++)
{
for (int j = 0; j < COLS; j++)
{
//double check this shit
seg[i][j].rgbtRed = in1[i][j].rgbtRed - in2[i][j].rgbtRed;
seg[i][j].rgbtGreen = in1[i][j].rgbtGreen - in2[i][j].rgbtGreen;
seg[i][j].rgbtBlue = in1[i][j].rgbtBlue - in2[i][j].rgbtBlue;
if(seg[i][j].rgbtRed > 20 || seg[i][j].rgbtGreen > 20 || seg[i][j].rgbtBlue > 20)
{
/*
* After gray scale conversion on both images we take the difference of the images
* and purify the image of the constants.
*
*/
if(seg[i][j].rgbtRed > 20)
seg1[i][j].rgbtRed = 255;
if (seg[i][j].rgbtGreen > 20)
seg1[i][j].rgbtGreen = 255;
if(seg[i][j].rgbtBlue > 20)
seg1[i][j].rgbtBlue = 255;
}
else
{
seg1[i][j].rgbtRed = 0;
seg1[i][j].rgbtBlue = 0;
seg1[i][j].rgbtGreen = 0;
}
}
}
free(seg);
return seg1;
}
inline char **MedianFilter(char **seg)
{
int bbr = 0;
char **firstfilter;
firstfilter = (char**)malloc(sizeof(char *) * ROWS);
for (int k = 0; k < ROWS; k++)
firstfilter[k] = (char*)malloc(sizeof(char) * COLS);
for (int i = 0; i < ROWS; i++)
{
for (int j = 0; j < COLS; j++)
{
if( i != 0 || j != 0 || i != ROWS || j != COLS )
bbr = FindMedian(seg);
firstfilter[i][j] = bbr;
}
}
free(seg);
return firstfilter;
}
inline char **Thresholding(char **filter)
{
char **EdgeImage;
EdgeImage = (char**)malloc(sizeof(char *) * ROWS);
for (int k = 0; k < ROWS; k++)
EdgeImage[k] = (char*)malloc(sizeof(char) * COLS);
for (int i = 0; i < ROWS; i++)
{
for (int j = 0; j < COLS; j++)
{
if(filter[i][j] > 40)
filter[i][j] = 255;
else
filter[i][j] = 0;
EdgeImage[i][j] = 255;
}
}
return EdgeImage;
}
inline char **EdgeDetection(char **filter)
{
char **EdgeImage;
EdgeImage = (char**)malloc(sizeof(char *) * ROWS);
for (int k = 0; k < ROWS; k++)
EdgeImage[k] = (char*)malloc(sizeof(char) * COLS);
for (int i = 0; i < ROWS; i++)
{
for (int j = 0; j < COLS; j++)
{
if( i == 0 && j == 0)
{
if(filter[j][i+1] && filter[j+1][i+1] &&
filter[j+1][i] == 255)
EdgeImage[j][i] = 0;
}
else if(i == 0 && j == ROWS)
{
if(filter[j+1][i] && filter[j+1][i-1] &&
filter[j][i-1] == 255)
EdgeImage[j][i] = 0;
}
else if(i == ROWS && j == 0)
{
if(filter[j-1][i] && filter[j-1][i+1] &&
filter[j][i+1] == 255)
EdgeImage[j][i] = 0;
}
else if(i == ROWS && j == ROWS)
{
if(filter[j-1][i-1] && filter[j][i-1] &&
filter[j-1][i] == 225)
EdgeImage[j][i] = 0;
}
else if(i == 1)
{
if(filter[j][j-1] && filter[j+1][i-1] &&
filter[j+1][i] && filter[j+1][i+1] &&
filter[j][i+1] == 255)
EdgeImage[j][i] = 0;
}
else if(i == ROWS)
{
if(filter[j-1][i-1] && filter[j+1][i-1] &&
filter[j+1][i] && filter[j-1][i] &&
filter[j][i-1] == 255)
EdgeImage[j][i] = 0;
}
else if(j == 1)
{
if(filter[j][i-1] && filter[j-1][i-1] &&
filter[j-1][i] && filter[j-1][i+1] &&
filter[j][i+1] == 255)
EdgeImage[j][i] = 0;
}
else{
if(filter[j-1][i-1] && filter[j+1][i-1] &&
filter[j+1][i] && filter[j+1][i+1] &&
filter[j][i-1] && filter[j-1][i] == 255)
EdgeImage[j][i] = 0;
}
}
}
return EdgeImage;
}
inline char** EnchanceImage(char **in1,char **in2)
{
char **seg;
seg = (char**)malloc(sizeof(char *) * ROWS);
for (int k = 0; k < ROWS; k++)
seg[k] = (char*)malloc(sizeof(char) * COLS);
char **store;
store = (char**)malloc(sizeof(char *) * ROWS);
for (int k = 0; k < ROWS; k++)
store[k] = (char*)malloc(sizeof(char) * COLS);
for (int i = 0; i < ROWS; i++)
{
for (int j = 0; j < COLS; j++)
{
seg[i][j] = in1[i][j] - in2[i][j];
//Not sure if this is correct check document
if(seg[i][j] == 1)
store[i][j] = seg[i][j];
}
}
free(seg);
return store;
}
inline RGBTRIPLE** ToGrayScale(RGBTRIPLE **rgbmap)
{
double L = 0;
RGBTRIPLE **graymap;
graymap = alloc2D(ROWS,COLS);
for (int i = 0; i < ROWS; i++)
{
for (int j = 0; j < COLS; j++)
{
L = 0.2126 * rgbmap[i][j].rgbtRed + 0.7152 * rgbmap[i][j].rgbtGreen + 0.0722 * rgbmap[i][j].rgbtBlue;
graymap[i][j].rgbtRed = (unsigned char)(L+0.5);
graymap[i][j].rgbtGreen = (unsigned char)(L+0.5);
graymap[i][j].rgbtBlue = (unsigned char)(L+0.5);
}
}
return graymap;
}
inline RGBTRIPLE** ConvertTo2D(RGBTRIPLE *rgbmap)
{
// int ofs = 0;
// RGBTRIPLE temp;
RGBTRIPLE **multi_dim;
multi_dim = alloc2D(ROWS,COLS);
int px = 0;
for (int i = 0; i < ROWS; i++)
{
for (int j = 0; j < COLS; j++)
{
//ofs = (j * ROWS) + i;
multi_dim[i][j].rgbtRed = rgbmap[px].rgbtRed;
multi_dim[i][j].rgbtBlue = rgbmap[px].rgbtBlue;
multi_dim[i][j].rgbtGreen = rgbmap[px].rgbtGreen;
//printf("i-j[%d-%d] ,ofs[%d] R:%d , B:%d , G:%d\n",i,j,ofs,multi_dim[i][j].rgbtRed,multi_dim[i][j].rgbtBlue,multi_dim[i][j].rgbtGreen);
px++;
}
}
return multi_dim;
}
inline void sobel_printf(RGBTRIPLE ** rgbmap){
/*
* w pamieci MJ
* karabin pow pw
*
*/
for (int i = 0; i < ROWS; i++)
{
for (int j = 0; j < COLS; j++)
{
printf("i-j[%d-%d] R:%d , B:%d , G:%d\n",i,j,rgbmap[i][j].rgbtRed,rgbmap[i][j].rgbtBlue,rgbmap[i][j].rgbtGreen);
}
}
}
#endif /* SOBLETRYING_HPP_ */
| [
"pnowak5@uic.edu"
] | pnowak5@uic.edu |
d6d07a938cfcd6588917a98e42344e7b69f6915d | 3ff09d54a770d08005ab641585b8a598768fedcf | /LiteCppDB/LiteCppDB/AesEncryption.cpp | 5f55865009d54383ccc1af7c62d99bc499948fa6 | [
"MIT"
] | permissive | pnadan/LiteCppDB | 7aef860ed6bb053d6ed89387d3bf0246117159ee | cb17db1ea6d82e0c1e669b4d70271dcf9c03d1a2 | refs/heads/master | 2021-01-21T12:58:14.384036 | 2018-04-30T07:55:03 | 2018-04-30T07:55:03 | 102,109,111 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 44 | cpp | #include "stdafx.h"
namespace LiteCppDB
{
} | [
"pna42@hotmail.com"
] | pna42@hotmail.com |
853d235b25c67356a68238233c09756b338c0ae1 | 5fb4409abe9e4796c8dc17cc51233c779b9e24bc | /app/src/main/cpp/wechat/zxing/common/reedsolomon/genericgfpoly.cpp | cef4d5965bce79f8423be64bf597c02cdc0c8481 | [] | no_license | BlackSuns/LearningAndroidOpenCV | 6be52f71cd9f3a1d5546da31f71c04064f0c7cac | 79dc25e383c740c73cae67f36027abf13ab17922 | refs/heads/master | 2023-07-10T02:08:10.923992 | 2021-08-09T02:09:19 | 2021-08-09T02:09:34 | 297,529,216 | 0 | 0 | null | 2021-08-09T14:06:05 | 2020-09-22T03:52:46 | C++ | UTF-8 | C++ | false | false | 8,995 | cpp | // This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html.
//
// Tencent is pleased to support the open source community by making WeChat QRCode available.
// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
//
// Modified from ZXing. Copyright ZXing authors.
// Licensed under the Apache License, Version 2.0 (the "License").
#include "../../../precomp.hpp"
#include "genericgfpoly.hpp"
#include "genericgf.hpp"
using zxing::ArrayRef;
using zxing::ErrorHandler;
using zxing::GenericGFPoly;
using zxing::Ref;
// VC++
using zxing::GenericGF;
GenericGFPoly::GenericGFPoly(GenericGF &field, ArrayRef<int> coefficients,
ErrorHandler &err_handler)
: field_(field) {
if (coefficients->size() == 0) {
err_handler = IllegalArgumentErrorHandler("need coefficients");
return;
}
int coefficientsLength = coefficients->size();
if (coefficientsLength > 1 && coefficients[0] == 0) {
// Leading term must be non-zero for anything except the constant
// polynomial "0"
int firstNonZero = 1;
while (firstNonZero < coefficientsLength && coefficients[firstNonZero] == 0) {
firstNonZero++;
}
if (firstNonZero == coefficientsLength) {
coefficients_ = field.getZero()->getCoefficients();
} else {
coefficients_ = ArrayRef<int>(new Array<int>(coefficientsLength - firstNonZero));
for (int i = 0; i < (int) coefficients_->size(); i++) {
coefficients_[i] = coefficients[i + firstNonZero];
}
}
} else {
coefficients_ = coefficients;
}
}
ArrayRef<int> GenericGFPoly::getCoefficients() { return coefficients_; }
int GenericGFPoly::getDegree() { return coefficients_->size() - 1; }
bool GenericGFPoly::isZero() { return coefficients_[0] == 0; }
int GenericGFPoly::getCoefficient(int degree) {
return coefficients_[coefficients_->size() - 1 - degree];
}
int GenericGFPoly::evaluateAt(int a) {
if (a == 0) {
// Just return the x^0 coefficient
return getCoefficient(0);
}
int size = coefficients_->size();
if (a == 1) {
// Just the sum of the coefficients
int result = 0;
for (int i = 0; i < size; i++) {
result = GenericGF::addOrSubtract(result, coefficients_[i]);
}
return result;
}
int result = coefficients_[0];
for (int i = 1; i < size; i++) {
result = GenericGF::addOrSubtract(field_.multiply(a, result), coefficients_[i]);
}
return result;
}
Ref<GenericGFPoly> GenericGFPoly::addOrSubtract(Ref<zxing::GenericGFPoly> other,
ErrorHandler &err_handler) {
if (!(&field_ == &other->field_)) {
err_handler =
IllegalArgumentErrorHandler("GenericGFPolys do not have same GenericGF field");
return Ref<GenericGFPoly>();
}
if (isZero()) {
return other;
}
if (other->isZero()) {
return Ref<GenericGFPoly>(this);
}
ArrayRef<int> smallerCoefficients = coefficients_;
ArrayRef<int> largerCoefficients = other->getCoefficients();
if (smallerCoefficients->size() > largerCoefficients->size()) {
ArrayRef<int> temp = smallerCoefficients;
smallerCoefficients = largerCoefficients;
largerCoefficients = temp;
}
ArrayRef<int> sumDiff(new Array<int>(largerCoefficients->size()));
int lengthDiff = largerCoefficients->size() - smallerCoefficients->size();
// Copy high-order terms only found in higher-degree polynomial's
// coefficients
for (int i = 0; i < lengthDiff; i++) {
sumDiff[i] = largerCoefficients[i];
}
for (int i = lengthDiff; i < (int) largerCoefficients->size(); i++) {
sumDiff[i] =
GenericGF::addOrSubtract(smallerCoefficients[i - lengthDiff],
largerCoefficients[i]);
}
// return Ref<GenericGFPoly>(new GenericGFPoly(field_, sumDiff));
Ref<GenericGFPoly> gfpoly(new GenericGFPoly(field_, sumDiff, err_handler));
if (err_handler.ErrCode()) return Ref<GenericGFPoly>();
return gfpoly;
}
Ref<GenericGFPoly> GenericGFPoly::multiply(Ref<zxing::GenericGFPoly> other,
ErrorHandler &err_handler) {
if (!(&field_ == &other->field_)) {
err_handler =
IllegalArgumentErrorHandler("GenericGFPolys do not have same GenericGF field");
return Ref<GenericGFPoly>();
}
if (isZero() || other->isZero()) {
return field_.getZero();
}
ArrayRef<int> aCoefficients = coefficients_;
int aLength = aCoefficients->size();
ArrayRef<int> bCoefficients = other->getCoefficients();
int bLength = bCoefficients->size();
ArrayRef<int> product(new Array<int>(aLength + bLength - 1));
for (int i = 0; i < aLength; i++) {
int aCoeff = aCoefficients[i];
for (int j = 0; j < bLength; j++) {
product[i + j] =
GenericGF::addOrSubtract(product[i + j],
field_.multiply(aCoeff, bCoefficients[j]));
}
}
// return Ref<GenericGFPoly>(new GenericGFPoly(field_, product));
Ref<GenericGFPoly> gfpoly(new GenericGFPoly(field_, product, err_handler));
if (err_handler.ErrCode()) return Ref<GenericGFPoly>();
return gfpoly;
}
Ref<GenericGFPoly> GenericGFPoly::multiply(int scalar, ErrorHandler &err_handler) {
if (scalar == 0) {
return field_.getZero();
}
if (scalar == 1) {
return Ref<GenericGFPoly>(this);
}
int size = coefficients_->size();
ArrayRef<int> product(new Array<int>(size));
for (int i = 0; i < size; i++) {
product[i] = field_.multiply(coefficients_[i], scalar);
}
// return Ref<GenericGFPoly>(new GenericGFPoly(field_, product));
Ref<GenericGFPoly> gfpoly(new GenericGFPoly(field_, product, err_handler));
if (err_handler.ErrCode()) return Ref<GenericGFPoly>();
return gfpoly;
}
Ref<GenericGFPoly> GenericGFPoly::multiplyByMonomial(int degree, int coefficient,
ErrorHandler &err_handler) {
if (degree < 0) {
err_handler = IllegalArgumentErrorHandler("degree must not be less then 0");
return Ref<GenericGFPoly>();
}
if (coefficient == 0) {
return field_.getZero();
}
int size = coefficients_->size();
ArrayRef<int> product(new Array<int>(size + degree));
for (int i = 0; i < size; i++) {
product[i] = field_.multiply(coefficients_[i], coefficient);
}
// return Ref<GenericGFPoly>(new GenericGFPoly(field_, product));
Ref<GenericGFPoly> gfpoly(new GenericGFPoly(field_, product, err_handler));
if (err_handler.ErrCode()) return Ref<GenericGFPoly>();
return gfpoly;
}
std::vector<Ref<GenericGFPoly>> GenericGFPoly::divide(Ref<GenericGFPoly> other,
ErrorHandler &err_handler) {
if (!(&field_ == &other->field_)) {
err_handler =
IllegalArgumentErrorHandler("GenericGFPolys do not have same GenericGF field");
return std::vector<Ref<GenericGFPoly>>();
}
if (other->isZero()) {
err_handler = IllegalArgumentErrorHandler("divide by 0");
return std::vector<Ref<GenericGFPoly>>();
}
Ref<GenericGFPoly> quotient = field_.getZero();
Ref<GenericGFPoly> remainder = Ref<GenericGFPoly>(this);
int denominatorLeadingTerm = other->getCoefficient(other->getDegree());
int inverseDenominatorLeadingTerm = field_.inverse(denominatorLeadingTerm, err_handler);
if (err_handler.ErrCode()) return std::vector<Ref<GenericGFPoly>>();
while (remainder->getDegree() >= other->getDegree() && !remainder->isZero()) {
int degreeDifference = remainder->getDegree() - other->getDegree();
int scale = field_.multiply(remainder->getCoefficient(remainder->getDegree()),
inverseDenominatorLeadingTerm);
Ref<GenericGFPoly> term = other->multiplyByMonomial(degreeDifference, scale, err_handler);
if (err_handler.ErrCode()) return std::vector<Ref<GenericGFPoly>>();
Ref<GenericGFPoly> iterationQuotiont =
field_.buildMonomial(degreeDifference, scale, err_handler);
if (err_handler.ErrCode()) return std::vector<Ref<GenericGFPoly>>();
quotient = quotient->addOrSubtract(iterationQuotiont, err_handler);
remainder = remainder->addOrSubtract(term, err_handler);
if (err_handler.ErrCode()) return std::vector<Ref<GenericGFPoly>>();
}
std::vector<Ref<GenericGFPoly>> returnValue(2);
returnValue[0] = quotient;
returnValue[1] = remainder;
return returnValue;
}
| [
"onlyloveyd@gmail.com"
] | onlyloveyd@gmail.com |
1b1acc35c7d6162bebda6588a96e9862ef1870de | 879fb3581f03b5c17dd90c68b45751712fbcd671 | /lib/wrap_dtlib_cpp/filterbank.h | af201c91f53b4fbcbb8999ec333281cf23ccc495 | [] | no_license | ivilab/kjb | 9f970e1ce16188f72f0edb34394e474ca83a9f2b | 238be8bc3c9018d4365741e56310067a52b715f9 | refs/heads/master | 2020-06-14T07:33:17.166805 | 2019-07-30T16:47:29 | 2019-07-30T16:47:29 | 194,946,614 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,166 | h | /////////////////////////////////////////////////////////////////////////////
// filterbank.h - filterbank convolution class
// Author: Doron Tal
// Date created: April, 2000
#ifndef _FILTERBANK_H
#define _FILTERBANK_H
#include "wrap_dtlib_cpp/img.h"
#include "wrap_dtlib_cpp/gausskernel.h"
// 'KERNEL_SIDE_FACTOR' is how much we multiply the largest sigma of our
// filterbank gaussians by in order to get the Kernel side. FWHM is 2.35
// sigma, so use 3.0 to be safe (but 3.0 is multiplied by sqrt(2) to get
// diagonal cases right..)
#define KERNEL_SIDE_FACTOR 4.2426f
namespace DTLib {
// filterbank class 'CFilterbank':
// after constructing it and setting it up with Setup(..), it's
// ready to perform convolutions using Convolve().
// Separating the setup stage from convolution stage allows us
// to perform repetitive convolutions without the setup overhead.
class CFilterbank
{
public:
CFilterbank();
~CFilterbank();
// returns the number of kernels
inline int nKernels() { return m_nKernels; }
// returns a pointer to a vector of pointers to float images,
// which are the kernels ***TODO***: change this to use a
// CImgVec object instead.
inline vector<CImg<float>*>* pvecKernels() { return &m_vecKernels; }
///////////////////////////////////////////////////////////////////////
// sets up the kernels
bool Setup(const int nGaussScales,
const int nGaussOrientations,
const float GaussSigmaY,
const float GaussX2YSigmaRatio,
const int nDOGScales,
const float DOGExcitSigma,
const float DOGInhibSigmaRatio1,
const float DOGInhibSigmaRatio2);
///////////////////////////////////////////////////////////////////////
// convolutions with input image 'InImg'. The results are returned
// in the image sequence 'OutSeq', where elongated kernels come
// first (outer loop over scales, inner loop over orientations,
// inner loop over phase, so there are
// m_nGaussScales*m_nGaussOrientations*2 frames for the oriented
// Gaussian convolutions, plus m_nDOGScales frames for the isotropic
// DOG convolutions. scale and orientations are always increasing
// in the loops above.
void Convolve(CImg<float> &InImg, CImgVec<float> &OutConvVec);
///////////////////////////////////////////////////////////////////////
// END OF INTERFACE
///////////////////////////////////////////////////////////////////////
protected:
int m_nKernels;
vector<CImg<float>*> m_vecKernels;
// input parameters:
int m_nGaussScales;
int m_nGaussOrientations;
float m_GaussSigmaY;
float m_GaussX2YSigmaRatio;
int m_nDOGScales;
float m_DOGExcitSigma;
float m_DOGInhibSigmaRatio1;
float m_DOGInhibSigmaRatio2;
private:
void FreeMemory();
};
} // namespace DTLib {
#endif /* #ifndef _FILTERBANK_H */
| [
"52473452+ivilab-sync@users.noreply.github.com"
] | 52473452+ivilab-sync@users.noreply.github.com |
42ab03bf94b63d06b34af92d160208a047309a1e | 2b53d73fbc40783b095f29e7cfb5b9b76a94b78d | /Algorithm/약수 진법변환.cpp | ec9563fad3cb6567fc76922feeaf748a7603f09b | [] | no_license | bananabeat/UC-Algorithm | c4ecb126237e92bfeec023115b7e45de135b2c51 | e4de57b000e75ce38efa36e1588637fb88b3c820 | refs/heads/master | 2018-09-19T20:21:35.484005 | 2018-06-06T09:36:23 | 2018-06-06T09:36:23 | 103,009,409 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,037 | cpp | //
// 약수 진법변환.cpp
// Algorithm
//
// Created by Seungsoo on 5/24/18.
// Copyright © 2018 Seungsoo. All rights reserved.
//
#include <algorithm>
#include <iostream>
#include <vector>
#include <stack>
#include <sstream>
#include <string.h>
#include <cstring>
#include <string>
using namespace std;
int main() {
int input; cin >> input;
std::string ans = "";
while(input != 0) {
if((input % 16) < 10) {
stringstream ss; ss << input % 16;
string tmp = ss.str();
ans = tmp + ans;
input /= 16;
}
else {
string str(1, ((input % 16) + 87));
ans = str + ans;
input /= 16;
}
}
cout << ans << endl;
return 0;
}
#include <iostream>
using namespace std;
int main() {
int input;
cin >> input;
for(int i = 1; i <= input; i++) {
if(input % i == 0) {
cout << i << " ";
}
}
cout << endl;
return 0;
}
| [
"nonestrike@gmail.com"
] | nonestrike@gmail.com |
73c285c6f49681dec2fb38a9d9f0ff5f68419960 | affa60abae8383cc3c3298c3ed14cc7091710179 | /src/cuda/SiPixel_convertiti/Framework/EDProducer.h | 1f644f219a54a59df6f952a6dc18ec52b6b16d0a | [
"Apache-2.0"
] | permissive | lauracappelli/pixeltrack-standalone-test-oneapi | 40dfa08fa49d353bab280aaf0ab8023369202c0e | 5832b6680ea0327f124afcfac801addbea458203 | refs/heads/master | 2022-12-22T04:01:27.280446 | 2020-09-17T16:05:51 | 2020-09-17T16:05:51 | 291,729,954 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,388 | h | #ifndef EDProducerBase_h
#define EDProducerBase_h
#include "WaitingTaskWithArenaHolder.h"
namespace edm {
class Event;
class EventSetup;
class EDProducer {
public:
EDProducer() = default;
virtual ~EDProducer() = default;
bool hasAcquire() const { return false; }
void doAcquire(Event const& event, EventSetup const& eventSetup, WaitingTaskWithArenaHolder holder) {}
void doProduce(Event& event, EventSetup const& eventSetup) { produce(event, eventSetup); }
virtual void produce(Event& event, EventSetup const& eventSetup) = 0;
void doEndJob() { endJob(); }
virtual void endJob() {}
private:
};
class EDProducerExternalWork {
public:
EDProducerExternalWork() = default;
virtual ~EDProducerExternalWork() = default;
bool hasAcquire() const { return true; }
void doAcquire(Event const& event, EventSetup const& eventSetup, WaitingTaskWithArenaHolder holder) {
acquire(event, eventSetup, std::move(holder));
}
void doProduce(Event& event, EventSetup const& eventSetup) { produce(event, eventSetup); }
virtual void acquire(Event const& event, EventSetup const& eventSetup, WaitingTaskWithArenaHolder holder) = 0;
virtual void produce(Event& event, EventSetup const& eventSetup) = 0;
void doEndJob() { endJob(); }
virtual void endJob() {}
private:
};
} // namespace edm
#endif
| [
"viola.cavallini@student.unife.it"
] | viola.cavallini@student.unife.it |
771fdc32377c8c75b8baa201d3a887836e87a417 | 6d5eb938a16dcc6c9fa9845ace22b0c439029f81 | /test/key_param_output.cpp | b3a6082c6aec786acecf0daaf6e8224a2bef36ef | [] | no_license | subrahmanyaman/hostsetup | 988b6efd33466b5dc44c6b9c9da16cfd5b046c5e | 1848c734b032f5d66b3030b3536d61dab38ccad8 | refs/heads/main | 2023-07-28T16:55:34.593307 | 2021-09-14T09:25:09 | 2021-09-14T09:25:09 | 406,303,070 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,171 | cpp | /*
* Copyright (C) 2020 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.
*/
#include "key_param_output.h"
#include <iomanip>
#include "keymint_tags.h"
namespace keymaster::javacard::test {
using ::std::endl;
using ::std::ostream;
ostream& operator<<(ostream& os, const ::std::vector<KeyParameter>& set) {
if (set.size() == 0) {
os << "(Empty)" << endl;
} else {
os << "\n";
for (const auto& elem : set) os << elem << endl;
}
return os;
}
ostream& operator<<(ostream& os, const KeyParameter& param) {
return os << param.toString();
}
} // namespace keymaster::javacard::test
| [
"subrahmanyaman@google.com"
] | subrahmanyaman@google.com |
f41270e3e1232481a841b9866f39179304e82e8f | 755fc53a1c6d88e88cd9eb890bd077ca0738fb51 | /expconf-xml/src/TMrbXia_DGF_4C.cxx | cce74323e3e0389bf49978ceb6aa3e192af31170 | [] | no_license | flueke/marabou | bf9ed463c59ad106a9d8b36c60a880a5caa79920 | 2f54e181be6f6488c019dc924fe0e40f7adc10b9 | refs/heads/master | 2023-07-06T16:15:52.030497 | 2019-01-08T09:33:00 | 2019-01-08T09:33:00 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 30,830 | cxx | //__________________________________________________[C++ CLASS IMPLEMENTATION]
//////////////////////////////////////////////////////////////////////////////
// Name: expconf/src/TMrbXia_DGF_4C.cxx
// Purpose: MARaBOU configuration: Xia ADCs
// Description: Implements class methods to handle modules of type XIA DGF-4C
// Keywords:
// Author: R. Lutter
// Mailto: <a href=mailto:rudi.lutter@physik.uni-muenchen.de>R. Lutter</a>
// Revision: $Id: TMrbXia_DGF_4C.cxx,v 1.1 2008-03-05 12:37:17 Rudolf.Lutter Exp $
// Date:
//////////////////////////////////////////////////////////////////////////////
namespace std {} using namespace std;
#include <cstdlib>
#include <iostream>
#include <sstream>
#include <iomanip>
#include <fstream>
#include "TDirectory.h"
#include "TEnv.h"
#include "TMrbNamedX.h"
#include "TMrbLofNamedX.h"
#include "TMrbLogger.h"
#include "TMrbSystem.h"
#include "TMrbConfig.h"
#include "TMrbCamacChannel.h"
#include "TMrbCamacRegister.h"
#include "TMrbXia_DGF_4C.h"
#include "SetColor.h"
extern TMrbConfig * gMrbConfig;
extern TMrbLogger * gMrbLog;
ClassImp(TMrbXia_DGF_4C)
static Bool_t printRelease = kTRUE;
TMrbXia_DGF_4C::TMrbXia_DGF_4C(const Char_t * ModuleName, const Char_t * ModulePosition) :
TMrbCamacModule(ModuleName, "Xia_DGF_4C", ModulePosition, 0, 4, 1 << 16) {
//__________________________________________________________________[C++ CTOR]
//////////////////////////////////////////////////////////////////////////////
// Name: TMrbXia_DGF_4C
// Purpose: Create a module of type Xia 4418/V
// Arguments: Char_t * ModuleName -- name of camac module
// Char_t * ModulePosition -- B.C.N for this module
// Results: --
// Exceptions:
// Description: Creates a camac module of type Xia 4418/V.
// Keywords:
//////////////////////////////////////////////////////////////////////////////
TString codeFile;
UInt_t mTypeBits;
TString mType;
TString xiaRelString;
TString dspFormat;
if (gMrbLog == NULL) gMrbLog = new TMrbLogger();
if (!this->IsZombie()) {
if (gMrbConfig == NULL) {
gMrbLog->Err() << "No config defined" << endl;
gMrbLog->Flush(this->ClassName());
this->MakeZombie();
} else if (gMrbConfig->FindModule(ModuleName)) {
gMrbLog->Err() << ModuleName << ": Module name already in use" << endl;
gMrbLog->Flush(this->ClassName());
this->MakeZombie();
} else {
SetTitle("Xia DGF-4C Digital Gamma Finder"); // store module type
mTypeBits = TMrbConfig::kModuleCamac | TMrbConfig::kModuleListMode;
mType = gMrbConfig->GetLofModuleTypes()->Pattern2String(mType, mTypeBits);
fModuleType.Set(mTypeBits, mType.Data());
xiaRelString = gEnv->GetValue("TMrbDGF.XiaRelease", "");
if (xiaRelString.CompareTo("v1.0") == 0) fRelease = 100;
else if (xiaRelString.CompareTo("v2.0") == 0) fRelease = 200;
else if (xiaRelString.CompareTo("v2.70") == 0) fRelease = 270;
else fRelease = 0;
dspFormat = gEnv->GetValue("TMrbDGF.DSPCode", "");
fDSPLoadedFromBinary = (dspFormat.Index(".bin", 0) >= 0);
if (fDSPLoadedFromBinary) dspFormat = "binary"; else dspFormat = "ascii/exe";
if (printRelease) {
gMrbLog->Out() << "Generating code for XIA Release "
<< xiaRelString << " (" << gEnv->GetValue("TMrbDGF.XiaDate", "") << ") ("
<< dspFormat << ")" << endl;
gMrbLog->Flush(this->ClassName(), "", setblue);
}
printRelease = kFALSE;
if (!this->ReadNameTable()) {
gMrbLog->Err() << ModuleName << ": No param names found" << endl;
gMrbLog->Flush(this->ClassName());
this->MakeZombie();
} else {
codeFile = fModuleID.GetName();
codeFile += ".code";
if (LoadCodeTemplates(codeFile)) {
this->DefineRegisters();
this->SetBlockReadout(); // block mode only
gMrbConfig->AddModule(this); // append to list of modules
gDirectory->Append(this);
fMaxEvents = 1;
fTraceLength = 40;
fRunTask = 0x100;
fSwitchBusTerm = kFALSE;
fSwitchBusIndiv = gEnv->GetValue("TMrbDGF.TerminateSwitchBusIndividually", kFALSE);
fSwitchBusTermIfMaster = gEnv->GetValue("TMrbDGF.TerminateSwitchBusIfMaster", kTRUE);
fSynchWait = 1;
fActivateUserPSA = kFALSE;
fInSynch = 0;
} else {
this->MakeZombie();
}
}
}
}
}
void TMrbXia_DGF_4C::DefineRegisters() {
//________________________________________________________________[C++ METHOD]
//////////////////////////////////////////////////////////////////////////////
// Name: TMrbXia_DGF_4C::DefineRegisters
// Purpose: Define module registers
// Arguments: --
// Results: --
// Exceptions:
// Description: Defines status, common threshold, lower & upper thresholds, and offset.
// Keywords:
//////////////////////////////////////////////////////////////////////////////
}
Bool_t TMrbXia_DGF_4C::MakeReadoutCode(ofstream & RdoStrm, TMrbConfig::EMrbModuleTag TagIndex) {
//________________________________________________________________[C++ METHOD]
//////////////////////////////////////////////////////////////////////////////
// Name: TMrbXia_DGF_4C::MakeReadoutCode
// Purpose: Write a piece of code for a DGF module
// Arguments: ofstream & RdoStrm -- file output stream
// EMrbModuleTag TagIndex -- index of tag word taken from template file
// Results: kTRUE/kFALSE
// Exceptions:
// Description: Writes code for readout of a DGF-4C module.
// Keywords:
//////////////////////////////////////////////////////////////////////////////
TString mnemoLC, mnemoUC;
TString moduleNameUC;
TString sPath, sSubdir, seg;
TString pos;
if (!fCodeTemplates.FindCode(TagIndex)) {
gMrbLog->Err() << "No code loaded for tag "
<< gMrbConfig->fLofModuleTags.FindByIndex(TagIndex)->GetName() << endl;
gMrbLog->Flush(this->ClassName(), "MakeReadoutCode");
return(kFALSE);
}
moduleNameUC = this->GetName();
moduleNameUC(0,1).ToUpper();
mnemoLC = this->GetMnemonic();
mnemoUC = mnemoLC;
mnemoUC.ToUpper();
switch (TagIndex) {
case TMrbConfig::kModuleDefs:
case TMrbConfig::kModuleInitCommonCode:
fCodeTemplates.InitializeCode();
fCodeTemplates.Substitute("$moduleName", this->GetName());
fCodeTemplates.Substitute("$moduleTitle", this->GetTitle());
fCodeTemplates.Substitute("$mnemoLC", mnemoLC);
fCodeTemplates.Substitute("$mnemoUC", mnemoUC);
fCodeTemplates.Substitute("$modulePosition", this->GetPosition());
fCodeTemplates.WriteCode(RdoStrm);
break;
case TMrbConfig::kModuleInitModule:
fCodeTemplates.InitializeCode("%A%");
fCodeTemplates.Substitute("$moduleNameLC", this->GetName());
fCodeTemplates.Substitute("$moduleNameUC", moduleNameUC.Data());
fCodeTemplates.Substitute("$moduleTitle", this->GetTitle());
fCodeTemplates.Substitute("$mnemoLC", mnemoLC);
fCodeTemplates.Substitute("$mnemoUC", mnemoUC);
fCodeTemplates.Substitute("$modulePosition", this->GetPosition());
fCodeTemplates.WriteCode(RdoStrm);
fCodeTemplates.InitializeCode("%B%");
sPath = gSystem->ExpandPathName(gEnv->GetValue("TMrbDGF.SettingsPath", "../dgfSettings"));
if (sPath.Index("./", 0) == 0) {
sPath = sPath(1, sPath.Length() - 1);
sPath.Prepend(gSystem->WorkingDirectory());
}
if (!sPath.EndsWith("/")) sPath += "/";
sSubdir = gSystem->ExpandPathName(gEnv->GetValue("TMrbDGF.SettingsSubdir", ""));
if (!sSubdir.IsNull()) {
if (!sSubdir.EndsWith("/")) sSubdir += "/";
sPath += sSubdir;
}
seg = this->GetClusterSegments();
if (fSwitchBusIndiv) {
fCodeTemplates.Substitute("$switchBusTerm", fSwitchBusTerm ? "TRUE" : "FALSE");
} else if (fSwitchBusTermIfMaster) {
fCodeTemplates.Substitute("$switchBusTerm", (seg.Index("c", 0) >= 0) ? "TRUE" : "FALSE");
} else {
fCodeTemplates.Substitute("$switchBusTerm", (seg.Index("c", 0) >= 0) ? "FALSE" : "TRUE");
}
fCodeTemplates.Substitute("$settingsPath", sPath.Data());
fCodeTemplates.Substitute("$moduleNameLC", this->GetName());
fCodeTemplates.Substitute("$moduleNameUC", moduleNameUC.Data());
fCodeTemplates.Substitute("$moduleTitle", this->GetTitle());
fCodeTemplates.Substitute("$mnemoLC", mnemoLC);
fCodeTemplates.Substitute("$mnemoUC", mnemoUC);
fCodeTemplates.Substitute("$moduleNumber", this->GetSerial());
fCodeTemplates.Substitute("$maxEvents", this->GetMaxEvents());
fCodeTemplates.Substitute("$traceLength", this->GetTraceLength());
fCodeTemplates.Substitute("$activatePSA", this->UserPSAIsActive() ? 1 : 0);
fCodeTemplates.Substitute("$runTask", this->GetRunTask(), 16);
fCodeTemplates.Substitute("$synchWait", this->GetSynchWait());
fCodeTemplates.Substitute("$inSynch", this->GetInSynch());
fCodeTemplates.WriteCode(RdoStrm);
break;
case TMrbConfig::kModuleReadModule:
if (this->GetRelease() == 100) fCodeTemplates.InitializeCode("%R==1.0%");
else fCodeTemplates.InitializeCode("%R>=2.0%");
fCodeTemplates.Substitute("$moduleNameLC", this->GetName());
fCodeTemplates.Substitute("$moduleNameUC", moduleNameUC.Data());
fCodeTemplates.Substitute("$moduleTitle", this->GetTitle());
fCodeTemplates.Substitute("$modulePosition", this->GetPosition());
fCodeTemplates.Substitute("$mnemoLC", mnemoLC);
fCodeTemplates.Substitute("$mnemoUC", mnemoUC);
fCodeTemplates.Substitute("$moduleNumber", this->GetSerial());
fCodeTemplates.WriteCode(RdoStrm);
break;
case TMrbConfig::kModuleClearModule:
case TMrbConfig::kModuleFinishReadout:
case TMrbConfig::kModuleStartAcquisition:
case TMrbConfig::kModuleStopAcquisition:
case TMrbConfig::kModuleStartAcquisitionGroup:
case TMrbConfig::kModuleStopAcquisitionGroup:
case TMrbConfig::kModuleUtilities:
case TMrbConfig::kModuleDefineGlobals:
case TMrbConfig::kModuleDefineGlobalsOnce:
case TMrbConfig::kModuleDefineLocalVarsInit:
case TMrbConfig::kModuleDefineLocalVarsReadout:
case TMrbConfig::kModuleDefinePrototypes:
fCodeTemplates.InitializeCode();
fCodeTemplates.Substitute("$moduleNameLC", this->GetName());
fCodeTemplates.Substitute("$moduleNameUC", moduleNameUC.Data());
fCodeTemplates.Substitute("$moduleTitle", this->GetTitle());
fCodeTemplates.Substitute("$mnemoLC", mnemoLC);
fCodeTemplates.Substitute("$mnemoUC", mnemoUC);
fCodeTemplates.Substitute("$modulePosition", this->GetPosition());
fCodeTemplates.Substitute("$nofModules", gMrbConfig->GetNofModules());
fCodeTemplates.Substitute("$runTask", this->GetRunTask(), 16);
fCodeTemplates.WriteCode(RdoStrm);
break;
}
return(kTRUE);
}
Bool_t TMrbXia_DGF_4C::MakeReadoutCode(ofstream & RdoStrm, TMrbConfig::EMrbModuleTag TagIndex,
TMrbCamacChannel * Channel,
Int_t Value) {
//________________________________________________________________[C++ METHOD]
//////////////////////////////////////////////////////////////////////////////
// Name: TMrbXia_DGF_4C::MakeReadoutCode
// Purpose: Write a piece of code for a DGF module
// Arguments: ofstream & RdoStrm -- file output stream
// EMrbModuleTag TagIndex -- index of tag word taken from template file
// TMrbCamacChannel * Channel -- channel
// Int_t Value -- value to be set
// Results: kTRUE/kFALSE
// Exceptions:
// Description: Writes code for readout of a DGF-4C module.
// Keywords:
//////////////////////////////////////////////////////////////////////////////
TString mnemoLC, mnemoUC;
TString moduleNameUC;
moduleNameUC = this->GetName();
moduleNameUC(0,1).ToUpper();
mnemoLC = this->GetMnemonic();
mnemoUC = mnemoLC;
mnemoUC.ToUpper();
if (!fCodeTemplates.FindCode(TagIndex)) {
gMrbLog->Err() << "No code loaded for tag "
<< gMrbConfig->fLofModuleTags.FindByIndex(TagIndex)->GetName() << endl;
gMrbLog->Flush(this->ClassName(), "MakeReadoutCode");
return(kFALSE);
}
switch (TagIndex) {
case TMrbConfig::kModuleInitChannel:
break;
case TMrbConfig::kModuleWriteSubaddr:
fCodeTemplates.InitializeCode();
fCodeTemplates.Substitute("$moduleNameLC", this->GetName());
fCodeTemplates.Substitute("$moduleNameUC", moduleNameUC.Data());
fCodeTemplates.Substitute("$mnemoLC", mnemoLC);
fCodeTemplates.Substitute("$mnemoUC", mnemoUC);
fCodeTemplates.Substitute("$chnName", Channel->GetName());
fCodeTemplates.Substitute("$chnNo", Channel->GetAddr());
fCodeTemplates.Substitute("$subaddr", Channel->GetAddr() + 1);
fCodeTemplates.WriteCode(RdoStrm);
break;
case TMrbConfig::kModuleSetupReadout:
case TMrbConfig::kModuleReadChannel:
case TMrbConfig::kModuleIncrementChannel:
case TMrbConfig::kModuleSkipChannels:
case TMrbConfig::kModuleStoreData:
fCodeTemplates.InitializeCode();
fCodeTemplates.Substitute("$moduleNameLC", this->GetName());
fCodeTemplates.Substitute("$moduleNameUC", moduleNameUC.Data());
fCodeTemplates.Substitute("$mnemoLC", mnemoLC);
fCodeTemplates.Substitute("$mnemoUC", mnemoUC);
fCodeTemplates.Substitute("$chnName", Channel->GetName());
fCodeTemplates.Substitute("$chnNo", Channel->GetAddr());
fCodeTemplates.Substitute("$data", Value);
fCodeTemplates.WriteCode(RdoStrm);
break;
}
return(kTRUE);
}
Bool_t TMrbXia_DGF_4C::CheckSubeventType(TMrbSubevent * Subevent) const {
//________________________________________________________________[C++ METHOD]
//////////////////////////////////////////////////////////////////////////////
// Name: TMrbXia_DGF_4C::CheckSubeventType
// Purpose: Check if calling subevent is applicable
// Arguments:
// Results: kTRUE/kFALSE
// Exceptions:
// Description: Makes sure that a subevent of type [10,2x] (DGF)
// is calling.
// Keywords:
//////////////////////////////////////////////////////////////////////////////
TMrbSubevent *sevt;
sevt = Subevent;
if (sevt->GetType() != 10) return(kFALSE);
if (sevt->GetSubtype() == 32) return(kTRUE);
if (sevt->GetSubtype() < 21 || sevt->GetSubtype() > 29) return(kFALSE);
else return(kTRUE);
}
Bool_t TMrbXia_DGF_4C::ReadNameTable() {
//________________________________________________________________[C++ METHOD]
//////////////////////////////////////////////////////////////////////////////
// Name: TMrbDGFData::ReadNameTable
// Purpose: Read param names from file
// Arguments: --
// Results: kTRUE/kFALSE
// Exceptions:
// Description: Reads param names and offsets from file.
// Keywords:
//////////////////////////////////////////////////////////////////////////////
Int_t pOffset;
TString pName;
TMrbNamedX * pKey;
ifstream param;
Int_t nofParams;
TString dataPath;
TString paramFile;
TString pLine;
TString charU;
Int_t numU;
dataPath = gEnv->GetValue("TMrbDGF.LoadPath", ".:$(MARABOU)/data/xiadgf");
gSystem->ExpandPathName(dataPath);
paramFile = gEnv->GetValue("TMrbDGF.ParamNames", "");
if (paramFile.Length() == 0) {
gMrbLog->Err() << "File name missing" << endl;
gMrbLog->Flush(this->ClassName(), "ReadNameTable");
return(kFALSE);
}
TString fileSpec;
TMrbSystem ux;
ux.Which(fileSpec, dataPath.Data(), paramFile.Data());
if (fileSpec.IsNull()) {
gMrbLog->Err() << "No such file - " << paramFile << ", searched on \"" << dataPath << "\"" << endl;
gMrbLog->Flush(this->ClassName(), "ReadNameTable");
return(kFALSE);
}
paramFile = fileSpec;
param.open(paramFile, ios::in);
if (!param.good()) {
gMrbLog->Err() << gSystem->GetError() << " - " << paramFile << endl;
gMrbLog->Flush(this->ClassName(), "ReadNameTable");
return(kFALSE);
}
fParamFile = paramFile;
nofParams = 0;
fParamNames.Delete();
for (;;) {
pLine.ReadLine(param, kFALSE);
if (param.eof()) break;
pLine = pLine.Strip(TString::kBoth);
if (pLine.Length() == 0 || pLine(0) == '#') continue;
istringstream str(pLine.Data());
str >> pOffset >> pName;
pName = pName.Strip(TString::kBoth);
if (pName.Length() > 0) {
if (pName.Length() == 3 && pName(0) == 'U') {
istringstream pstr(pName.Data());
numU = -1;
pstr >> charU >> numU;
if (numU == -1) continue;
}
pKey = new TMrbNamedX(pOffset, pName.Data());
fParamNames.AddNamedX(pKey);
nofParams++;
}
}
param.close();
fNofParams = nofParams;
return(kTRUE);
}
TMrbNamedX * TMrbXia_DGF_4C::FindParam(Int_t Channel, const Char_t * ParamName) {
//________________________________________________________________[C++ METHOD]
//////////////////////////////////////////////////////////////////////////////
// Name: TMrbDGFData::FindParam
// Purpose: Search a param for a given channel
// Arguments: Int_t Channel -- channel number
// Char_t * ParamName -- param name
// Results: TMrbNamedX * Param -- param name & index
// Exceptions:
// Description: Searches a param for a given channel.
// Keywords:
//////////////////////////////////////////////////////////////////////////////
TMrbString paramName;
paramName = ParamName;
paramName += Channel;
return(this->FindParam(paramName.Data()));
}
Bool_t TMrbXia_DGF_4C::MakeAnalyzeCode(ofstream & AnaStrm, TMrbConfig::EMrbAnalyzeTag TagIndex, const Char_t * Extension) {
//________________________________________________________________[C++ METHOD]
//////////////////////////////////////////////////////////////////////////////
// Name: TMrbXia_DGF_4C::MakeAnalyzeCode
// Purpose: Write a piece of code for data analysis
// Arguments: ofstream & AnaStrm -- file output stream
// EMrbAnalyzeTag TagIndex -- index of tag word from template file
// Char_t * Extension -- file extensions to be appended (.h or .cxx)
// Results:
// Exceptions:
// Description: Writes code needed for data analysis.
// Searches for following files:
// (1) if module has private code
// (1a) Module_<Name>.<Extension>.code
// (1b) <PrivateCodeFile>.<Extension>.code
// (1c) Module_<Class>.<Extension>.code
// (2) standard:
// Module.<Extension>.code
//
// This method is optional and doesn't generate an error
// if no template file has been found.
// Keywords:
//////////////////////////////////////////////////////////////////////////////
TString mnemoLC, mnemoUC;
TString moduleNameLC, moduleNameUC;
TString templatePath;
TString anaTemplateFile;
TString className;
TString tf;
const Char_t * pcf;
TString line;
TMrbTemplate anaTmpl;
TMrbNamedX * analyzeTag;
TMrbNamedX * px;
mnemoLC = this->GetMnemonic();
mnemoUC = mnemoLC;
mnemoUC.ToUpper();
moduleNameLC = this->GetName();
moduleNameUC = moduleNameLC;
moduleNameUC.ToUpper();
Bool_t verboseMode = (gMrbConfig->IsVerbose() || (gMrbConfig->GetAnalyzeOptions() & TMrbConfig::kAnaOptVerbose) != 0);
templatePath = gEnv->GetValue("TMrbConfig.TemplatePath", ".:config:$(MARABOU)/templates/config");
gSystem->ExpandPathName(templatePath);
className = this->ClassName();
className.ReplaceAll("TMrb", "");
className(0,1).ToUpper();
TString ext = Extension;
if (ext(0) != '.') ext.Prepend("_");
TString fileSpec = "";
TMrbSystem ux;
TObjArray err;
err.Delete();
if (this->HasPrivateCode()) {
tf = "Module_";
tf += moduleNameUC;
tf += ext.Data();
tf += ".code";
ux.Which(fileSpec, templatePath.Data(), tf.Data());
if (fileSpec.IsNull()) err.Add(new TObjString(tf.Data()));
if (fileSpec.IsNull()) {
pcf = this->GetPrivateCodeFile();
if (pcf != NULL) {
tf = pcf;
tf += ext.Data();
tf += ".code";
ux.Which(fileSpec, templatePath.Data(), tf.Data());
if (fileSpec.IsNull()) err.Add(new TObjString(tf.Data()));
}
if (fileSpec.IsNull()) {
tf = "Module_";
tf += className;
tf += ext.Data();
tf += ".code";
ux.Which(fileSpec, templatePath.Data(), tf.Data());
if (fileSpec.IsNull()) err.Add(new TObjString(tf.Data()));
}
}
if (fileSpec.IsNull() && verboseMode) {
gMrbLog->Wrn() << "Can't find code file(s): ";
Int_t n = err.GetEntriesFast();
for (Int_t i = 0; i < n; i++) {
if (n > 1) gMrbLog->Wrn() << endl << ((i == 0) ? "\t\t\t\tneither " : "\t\t\t\tnor ");
gMrbLog->Wrn() << ((TObjString *) err[i])->GetString();
}
gMrbLog->Wrn() << endl << "\t\t\t\t\t(may lead to compiling problems!)" << endl;
gMrbLog->Flush(this->ClassName(), "MakeAnalyzeCode");
}
}
if (fileSpec.IsNull()) {
tf = "Module";
tf += ext.Data();
tf += ".code";
ux.Which(fileSpec, templatePath.Data(), tf.Data());
}
if (fileSpec.IsNull()) return(kTRUE);
if (verboseMode) {
gMrbLog->Out() << "[" << moduleNameLC << "] Using template file " << fileSpec << endl;
gMrbLog->Flush(this->ClassName(), "MakeAnalyzeCode");
}
anaTemplateFile = fileSpec;
if (!anaTmpl.Open(anaTemplateFile, &gMrbConfig->fLofAnalyzeTags)) return(kFALSE);
for (;;) {
analyzeTag = anaTmpl.Next(line);
if (anaTmpl.IsEof()) break;
if (anaTmpl.IsError()) continue;
if (anaTmpl.Status() & TMrbTemplate::kNoTag) {
if (line.Index("//-") != 0) AnaStrm << line << endl;
} else if (TagIndex == analyzeTag->GetIndex()) {
if (!gMrbConfig->ExecUserMacro(&AnaStrm, this, analyzeTag->GetName())) {
switch (TagIndex) {
case TMrbConfig::kAnaIncludesAndDefs:
anaTmpl.InitializeCode();
anaTmpl.Substitute("$moduleName", this->GetName());
anaTmpl.Substitute("$moduleTitle", this->GetName());
anaTmpl.Substitute("$mnemoLC", mnemoLC);
anaTmpl.Substitute("$mnemoUC", mnemoUC);
anaTmpl.WriteCode(AnaStrm);
return(kTRUE);
case TMrbConfig::kAnaModuleSpecialEnum:
anaTmpl.InitializeCode();
px = this->FindParam("MODNUM");
anaTmpl.Substitute("$parModuleNumber", (px) ? px->GetIndex() : 0);
px = this->FindParam("MODCSRA");
anaTmpl.Substitute("$parModCSRA", (px) ? px->GetIndex() : 0);
px = this->FindParam("MODCSRB");
anaTmpl.Substitute("$parModCSRB", (px) ? px->GetIndex() : 0);
px = this->FindParam("MAXEVENTS");
anaTmpl.Substitute("$parMaxEvents", (px) ? px->GetIndex() : 0);
px = this->FindParam("SYNCHWAIT");
anaTmpl.Substitute("$parSynchWait", (px) ? px->GetIndex() : 0);
px = this->FindParam("INSYNCH");
anaTmpl.Substitute("$parInSynch", (px) ? px->GetIndex() : 0);
px = this->FindParam("SYNCHDONE");
anaTmpl.Substitute("$parSynchDone", (px) ? px->GetIndex() : 0);
px = this->FindParam("RUNTASK");
anaTmpl.Substitute("$parRunTask", (px) ? px->GetIndex() : 0);
px = this->FindParam("COINCPATTERN");
anaTmpl.Substitute("$parCoincPattern", (px) ? px->GetIndex() : 0);
px = this->FindParam("COINCWAIT");
anaTmpl.Substitute("$parCoincWait", (px) ? px->GetIndex() : 0);
px = this->FindParam("CONTROLTASK");
anaTmpl.Substitute("$parControlTask", (px) ? px->GetIndex() : 0);
px = this->FindParam("AOUTBUFFER");
anaTmpl.Substitute("$parAddrOfOutputBuffer", (px) ? px->GetIndex() : 0);
px = this->FindParam("LOUTBUFFER");
anaTmpl.Substitute("$parLengthOfOutputBuffer", (px) ? px->GetIndex() : 0);
px = this->FindParam("TRACELENGTH0");
anaTmpl.Substitute("$parTraceLength0", (px) ? px->GetIndex() : 0);
px = this->FindParam("CHANCSRA0");
anaTmpl.Substitute("$parChanCSRA0", (px) ? px->GetIndex() : 0);
px = this->FindParam("CHANCSRB0");
anaTmpl.Substitute("$parChanCSRB0", (px) ? px->GetIndex() : 0);
px = this->FindParam("REALTIMEA");
anaTmpl.Substitute("$parRealTimeA", (px) ? px->GetIndex() : 0);
px = this->FindParam("REALTIMEB");
anaTmpl.Substitute("$parRealTimeB", (px) ? px->GetIndex() : 0);
px = this->FindParam("REALTIMEC");
anaTmpl.Substitute("$parRealTimeC", (px) ? px->GetIndex() : 0);
px = this->FindParam("RUNTIMEA");
anaTmpl.Substitute("$parRunTimeA", (px) ? px->GetIndex() : 0);
px = this->FindParam("RUNTIMEB");
anaTmpl.Substitute("$parRunTimeB", (px) ? px->GetIndex() : 0);
px = this->FindParam("RUNTIMEC");
anaTmpl.Substitute("$parRunTimeC", (px) ? px->GetIndex() : 0);
px = this->FindParam("GSLTTIMEA");
anaTmpl.Substitute("$parGSLTTimeA", (px) ? px->GetIndex() : 0);
px = this->FindParam("GSLTTIMEB");
anaTmpl.Substitute("$parGSLTTimeB", (px) ? px->GetIndex() : 0);
px = this->FindParam("GSLTTIMEC");
anaTmpl.Substitute("$parGSLTTimeC", (px) ? px->GetIndex() : 0);
px = this->FindParam("NUMEVENTSA");
anaTmpl.Substitute("$parNumEventsA", (px) ? px->GetIndex() : 0);
px = this->FindParam("NUMEVENTSB");
anaTmpl.Substitute("$parNumEventsB", (px) ? px->GetIndex() : 0);
px = this->FindParam("LIVETIMEA0");
anaTmpl.Substitute("$parLiveTimeA0", (px) ? px->GetIndex() : 0);
px = this->FindParam("LIVETIMEB0");
anaTmpl.Substitute("$parLiveTimeB0", (px) ? px->GetIndex() : 0);
px = this->FindParam("LIVETIMEC0");
anaTmpl.Substitute("$parLiveTimeC0", (px) ? px->GetIndex() : 0);
px = this->FindParam("FASTPEAKSA0");
anaTmpl.Substitute("$parFastPeaksA0", (px) ? px->GetIndex() : 0);
px = this->FindParam("FASTPEAKSB0");
anaTmpl.Substitute("$parFastPeaksB0", (px) ? px->GetIndex() : 0);
px = this->FindParam("LIVETIMEA1");
anaTmpl.Substitute("$parLiveTimeA1", (px) ? px->GetIndex() : 0);
px = this->FindParam("LIVETIMEB1");
anaTmpl.Substitute("$parLiveTimeB1", (px) ? px->GetIndex() : 0);
px = this->FindParam("LIVETIMEC1");
anaTmpl.Substitute("$parLiveTimeC1", (px) ? px->GetIndex() : 0);
px = this->FindParam("FASTPEAKSA1");
anaTmpl.Substitute("$parFastPeaksA1", (px) ? px->GetIndex() : 0);
px = this->FindParam("FASTPEAKSB1");
anaTmpl.Substitute("$parFastPeaksB1", (px) ? px->GetIndex() : 0);
px = this->FindParam("LIVETIMEA2");
anaTmpl.Substitute("$parLiveTimeA2", (px) ? px->GetIndex() : 0);
px = this->FindParam("LIVETIMEB2");
anaTmpl.Substitute("$parLiveTimeB2", (px) ? px->GetIndex() : 0);
px = this->FindParam("LIVETIMEC2");
anaTmpl.Substitute("$parLiveTimeC2", (px) ? px->GetIndex() : 0);
px = this->FindParam("FASTPEAKSA2");
anaTmpl.Substitute("$parFastPeaksA2", (px) ? px->GetIndex() : 0);
px = this->FindParam("FASTPEAKSB2");
anaTmpl.Substitute("$parFastPeaksB2", (px) ? px->GetIndex() : 0);
px = this->FindParam("LIVETIMEA3");
anaTmpl.Substitute("$parLiveTimeA3", (px) ? px->GetIndex() : 0);
px = this->FindParam("LIVETIMEB3");
anaTmpl.Substitute("$parLiveTimeB3", (px) ? px->GetIndex() : 0);
px = this->FindParam("LIVETIMEC3");
anaTmpl.Substitute("$parLiveTimeC3", (px) ? px->GetIndex() : 0);
px = this->FindParam("FASTPEAKSA3");
anaTmpl.Substitute("$parFastPeaksA3", (px) ? px->GetIndex() : 0);
px = this->FindParam("FASTPEAKSB3");
anaTmpl.Substitute("$parFastPeaksB3", (px) ? px->GetIndex() : 0);
anaTmpl.WriteCode(AnaStrm);
return(kTRUE);
}
}
}
}
return(kFALSE);
}
Bool_t TMrbXia_DGF_4C::MakeRcFile(ofstream & RcStrm, TMrbConfig::EMrbRcFileTag TagIndex, const Char_t * ResourceName) {
//________________________________________________________________[C++ METHOD]
//////////////////////////////////////////////////////////////////////////////
// Name: TMrbXia_DGF_4C::MakeRcFile
// Purpose: Generate module-specific entries to resource file
// Arguments: ofstream & RcStrm -- where to output code
// EMrbRcFileTag TagIndex -- tag word index
// Char_t * ResourceName -- resource prefix
// Results: kTRUE/kFALSE
// Exceptions:
// Description: Generates module-specific entries to resource file.
// Keywords:
//////////////////////////////////////////////////////////////////////////////
TString line;
TMrbNamedX * rcFileTag;
TString rcTemplateFile;
TString templatePath;
TString moduleNameUC;
TString iniTag;
TString seg;
TString tf;
TMrbTemplate rcTmpl;
Bool_t verboseMode = (gMrbConfig->IsVerbose() || (gMrbConfig->GetRcFileOptions() & TMrbConfig::kRcOptVerbose) != 0);
templatePath = gEnv->GetValue("TMrbConfig.TemplatePath", ".:config:$(MARABOU)/templates/config");
gSystem->ExpandPathName(templatePath);
tf = "Module_";
tf += this->ClassName();
tf.ReplaceAll("TMrb", "");
tf += ".rc.code";
TString fileSpec;
TMrbSystem ux;
ux.Which(fileSpec, templatePath.Data(), tf.Data());
if (fileSpec.IsNull()) return(kTRUE);
if (verboseMode) {
gMrbLog->Out() << "[" << this->GetName() << "] Using template file " << fileSpec << endl;
gMrbLog->Flush(this->ClassName(), "MakeRcFile");
}
rcTemplateFile = fileSpec;
if (!rcTmpl.Open(rcTemplateFile, &gMrbConfig->fLofRcFileTags)) return(kFALSE);
moduleNameUC = this->GetName();
moduleNameUC(0,1).ToUpper();
iniTag = (gMrbConfig->GetRcFileOptions() & TMrbConfig::kRcOptByName) ? "%NAM%" : "%NUM%";
for (;;) {
rcFileTag = rcTmpl.Next(line);
if (rcTmpl.IsEof()) break;
if (rcTmpl.IsError()) continue;
if (rcTmpl.Status() & TMrbTemplate::kNoTag) continue;
if (TagIndex == rcFileTag->GetIndex()) {
if (!gMrbConfig->ExecUserMacro(&RcStrm, this, rcFileTag->GetName())) {
rcTmpl.InitializeCode(iniTag.Data());
rcTmpl.Substitute("$resource", ResourceName);
rcTmpl.Substitute("$moduleNameLC", this->GetName());
rcTmpl.Substitute("$moduleNameUC", moduleNameUC.Data());
rcTmpl.Substitute("$clusterSerial", this->GetClusterSerial());
rcTmpl.Substitute("$clusterHexNum", this->GetClusterHexNum(), 16);
rcTmpl.Substitute("$clusterColor", this->GetClusterColor());
rcTmpl.Substitute("$clusterSegments", this->GetClusterSegments());
rcTmpl.Substitute("$maxEvents", this->GetMaxEvents());
rcTmpl.Substitute("$traceLength", this->GetTraceLength());
rcTmpl.Substitute("$activatePSA", this->UserPSAIsActive() ? "TRUE" : "FALSE");
rcTmpl.Substitute("$runTask", this->GetRunTask());
rcTmpl.Substitute("$synchWait", this->GetSynchWait());
rcTmpl.Substitute("$inSynch", this->GetInSynch());
rcTmpl.Substitute("$isActive", this->IsActive() ? "TRUE" : "FALSE");
seg = this->GetClusterSegments();
if (fSwitchBusIndiv) {
rcTmpl.Substitute("$switchBusTerm", fSwitchBusTerm ? "TRUE" : "FALSE");
} else if (fSwitchBusTermIfMaster) {
rcTmpl.Substitute("$switchBusTerm", (seg.Index("c", 0) >= 0) ? "TRUE" : "FALSE");
} else {
rcTmpl.Substitute("$switchBusTerm", (seg.Index("c", 0) >= 0) ? "FALSE" : "TRUE");
}
rcTmpl.WriteCode(RcStrm);
return(kTRUE);
}
}
}
return(kTRUE);
}
| [
"Rudolf.Lutter@514c3d59-69d9-4452-b10b-b80f2e82d9e4"
] | Rudolf.Lutter@514c3d59-69d9-4452-b10b-b80f2e82d9e4 |
7692778aa42753dc5ee0049fdca3f9f7219ac614 | 0f1e3b0014c5ff62ae9591832f65600245a403e4 | /src/libseabreeze/include/vendors/OceanOptics/utils/Polynomial.h | 5d1ff156eb9bb4e2a8b21dd7273e5b326240eb2e | [
"MIT"
] | permissive | ap--/python-seabreeze | a5528f4d6043755e7f2e60ae181bb0eb4c1f38f8 | d312056d0d4c144ddd77bd783535ac9b2fb45f12 | refs/heads/main | 2023-08-17T04:10:06.552715 | 2023-07-10T22:11:03 | 2023-07-10T22:11:03 | 25,327,268 | 189 | 92 | MIT | 2023-09-11T22:39:25 | 2014-10-16T23:30:21 | C++ | UTF-8 | C++ | false | false | 3,497 | h | /***************************************************//**
* @file Polynomial.h
* @date February 2011
* @author Ocean Optics, Inc.
*
* The template type for this class must be either
* double or float. Any other type may cause unexpected
* results or a failure to compile.
*
* The implementation for this class is also contained
* in the header file so that it is compiled consistently
* when needed. Otherwise, there could be linker
* issues.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* 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 POLYNOMIAL_H
#define POLYNOMIAL_H
#include <vector>
namespace seabreeze {
template <class T>
class Polynomial {
public:
Polynomial(std::vector<T> *coefficients);
Polynomial(T *coefficients, unsigned int length);
~Polynomial();
T evaluate(T x);
private:
std::vector<T> *coefficients;
};
template <class T>
Polynomial<T>::Polynomial(std::vector<T> *coeffs) {
unsigned int i;
if(NULL == coeffs) {
this->coefficients = new std::vector<T>(0);
} else {
this->coefficients = new std::vector<T>(coeffs->size());
}
for(i = 0; i < coeffs->size(); i++) {
(*(this->coefficients))[i] = (*coeffs)[i];
}
}
template <class T>
Polynomial<T>::Polynomial(T *coeffs, unsigned int length) {
unsigned int i;
if(NULL == coeffs) {
this->coefficients = new std::vector<T>(0);
} else {
this->coefficients = new std::vector<T>(length);
}
for(i = 0; i < length; i++) {
(*(this->coefficients))[i] = coeffs[i];
}
}
template <class T>
Polynomial<T>::~Polynomial() {
delete this->coefficients;
}
template <class T>
T Polynomial<T>::evaluate(T x) {
T acc;
T retval = 0.0;
unsigned int order;
if(NULL == this->coefficients || 0 == this->coefficients->size()) {
return 0;
}
retval = this->coefficients->at(0); /* Initialize to A */
acc = 1;
for(order = 1; order < this->coefficients->size(); order++) {
acc *= x;
retval += this->coefficients->at(order) * acc; /* Add x^n term (Bx^2, Cx^3, ...) */
}
return retval;
}
}
#endif /* POLYNOMIAL_H */
| [
"andreas@poehlmann.io"
] | andreas@poehlmann.io |
4dfae01fb1c6f0f4ee17e262f914eab8222561b4 | 8f27ca75187c121d9a815b00517175bc523f1801 | /Plugins/Voxel/Source/Voxel/Public/VoxelGraph/VoxelGraphWorldGenerator.h | 2fb3dc9de83d00e72f17862fc574413a27b4bda0 | [
"MIT"
] | permissive | Maverrin/FirstGame | 9991e84df316fef6afe7606b29d01f1eb8c375de | 9ff0eeb0948a4f223d31e03b2cbf35a955db9e9e | refs/heads/master | 2022-05-09T17:45:15.904563 | 2019-11-08T18:14:45 | 2019-11-08T18:14:45 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 9,875 | h | // Copyright 2018 Phyronnaz
#pragma once
#include "CoreMinimal.h"
#include "EdGraph/EdGraph.h"
#include "VoxelWorldGenerator.h"
#include "VoxelGraph/VoxelNode.h"
#include "VoxelConfigEnums.h"
#include "VoxelGraphWorldGenerator.generated.h"
#define VOXEL_PREVIEW_SIZE_SAVE 128
class UVoxelGraphGenerator;
class UEdGraphNode;
class FVoxelGraphCompiler;
struct FVoxelComputeNodeTreesHolder;
struct FVoxelLocalVariable;
#if WITH_EDITOR
/**
* Interface for voxel graph interaction with the VoxelEditor module.
*/
class IVoxelGraphEditor
{
public:
virtual ~IVoxelGraphEditor() = default;
/** Called when creating a new voxel graph. */
virtual UEdGraph* CreateNewVoxelGraph(UVoxelGraphGenerator* InGenerator) = 0;
/** Sets up a voxel node. */
virtual void SetupVoxelNode(UEdGraph* VoxelGraph, UVoxelNode* VoxelNode, bool bSelectNewNode) = 0;
/** Compiles voxel nodes from graph nodes. */
virtual void CompileVoxelNodesFromGraphNodes(UVoxelGraphGenerator* WorldGenerator) = 0;
/** Trigger a preview update if automatic updates are enabled */
virtual void UpdatePreview(UVoxelGraphGenerator* WorldGenerator, bool bForce, bool bUpdateTextures) = 0;
/** Creates an input pin on the given voxel graph node. */
virtual void CreateInputPin(UEdGraphNode* VoxelNode) = 0;
/** Creates an output pin on the given voxel graph node. */
virtual void CreateOutputPin(UEdGraphNode* VoxelNode) = 0;
virtual void SelectNodesAndZoomToFit(UEdGraph* Graph, TArray<UEdGraphNode*>& Nodes) = 0;
virtual UVoxelGraphGenerator* GetWorldGeneratorFromGraph(UEdGraph* Graph) = 0;
virtual void SetDebugGraph(UEdGraph* DebugGraph, FVoxelGraphCompiler* Compiler) = 0;
virtual void RefreshNodesError(UEdGraph* Graph) = 0;
};
#endif
///////////////////////////////////////////////////////////////////////////////
UENUM()
enum class EVoxelGraphPreviewAxes
{
X,
Y,
Z
};
UENUM()
enum class EVoxelGraphPreviewType
{
Density,
Material
};
UCLASS()
class VOXEL_API UVoxelGraphPreviewSettings : public UObject
{
GENERATED_BODY()
public:
UPROPERTY(EditAnywhere, Category = "Preview Settings")
EVoxelMaterialConfig MaterialConfig = EVoxelMaterialConfig::RGB;
UPROPERTY(EditAnywhere, Category = "Preview Settings")
EVoxelGraphPreviewType ImagePreviewType = EVoxelGraphPreviewType::Density;
UPROPERTY(EditAnywhere, Category = "Preview Settings")
bool bUseDensityAsColor = true;
UPROPERTY(EditAnywhere, Category = "Preview Settings")
bool bEnableWater = false;
UPROPERTY(EditAnywhere, Category = "Preview Settings")
EVoxelGraphPreviewAxes LeftToRight = EVoxelGraphPreviewAxes::X;
UPROPERTY(EditAnywhere, Category = "Preview Settings")
EVoxelGraphPreviewAxes BottomToTop = EVoxelGraphPreviewAxes::Y;
// Center (multiple of Voxels Per Pixel)
UPROPERTY(EditAnywhere, Category = "Preview Settings", DisplayName = "Center (multiple of Voxels Per Pixel)")
FIntVector Center = FIntVector(0, 0, 0);
// Image Resolution (pow of 2)
UPROPERTY(EditAnywhere, Category = "Preview Settings", DisplayName = "Image Resolution (pow of 2)")
int32 ImageResolution = 512;
// Voxels Per Pixel (pow of 2)
UPROPERTY(EditAnywhere, Category = "Preview Settings", DisplayName = "Voxels Per Pixel (pow of 2)")
int32 VoxelsPerPixel = 1;
UPROPERTY(EditAnywhere, Category = "Density Settings", DisplayName = "Min Value (black)")
float MinValue = -1;
UPROPERTY(EditAnywhere, Category = "Density Settings", DisplayName = "Max Value (white)")
float MaxValue = 1;
UPROPERTY(EditAnywhere, Category = "Material Settings")
TArray<FLinearColor> ColorsForIndexMaterialConfig = { FLinearColor::Green, FLinearColor::Red, FLinearColor::Blue, FLinearColor::White };
UPROPERTY(EditAnywhere, Category = "3D Preview Settings", meta = (NoRebuild))
class UStaticMesh* Mesh = nullptr;
UPROPERTY(EditAnywhere, Category = "3D Preview Settings", meta = (NoRebuild))
class UMaterialInterface* Material = nullptr;
UPROPERTY(EditAnywhere, Category = "3D Preview Settings", meta = (NoRebuild))
FVector MeshScale = FVector(10, 10, 10);
UPROPERTY(EditAnywhere, Category = "3D Preview Settings", meta = (NoRebuild))
float Height = 200;
UPROPERTY(EditAnywhere, Category = "3D Preview Settings", meta = (NoRebuild))
FVector LightDirection = FVector(1, 1, 1);
UPROPERTY(EditAnywhere, Category = "3D Preview Settings", meta = (NoRebuild, UIMin = 0, UIMax = 1))
float Brightness = 1;
UPROPERTY(EditAnywhere, Category = "3D Preview Settings", meta = (NoRebuild, UIMin = 0))
float ShadowDensity = 8;
UPROPERTY()
class UVoxelGraphGenerator* Graph;
protected:
#if WITH_EDITOR
virtual void PostEditChangeProperty(struct FPropertyChangedEvent& PropertyChangedEvent) override;
virtual void PostInitProperties() override;
virtual void PostLoad() override;
void InitVariables();
#endif
};
UENUM()
enum class EVoxelGraphGeneratorWorldKind
{
Flat,
Sphere
};
/**
* A graph world generator
*/
UCLASS(BlueprintType, hidecategories = (Object), hidedropdown)
class VOXEL_API UVoxelGraphGenerator : public UVoxelWorldGenerator
{
GENERATED_BODY()
public:
UPROPERTY(EditAnywhere, Category = "Generator settings", DisplayName = "World Kind (for grass & actors min/max angle)")
EVoxelGraphGeneratorWorldKind WorldKind;
UPROPERTY(EditAnywhere, Category = "Feedback")
bool bShowAxisDependencies = false;
UPROPERTY(EditAnywhere, Category = "Feedback")
bool bEnableStats = false;
UPROPERTY(EditAnywhere, Category = "Compile options")
bool bInlineMacros = true;
UPROPERTY(EditAnywhere, Category = "Compile options")
bool bReplaceFlowMerges = true;
UPROPERTY(EditAnywhere, Category = "Compile options")
bool bCompactPassthroughs = true;
UPROPERTY(EditAnywhere, Category = "Compile options")
bool bDependenciesAnalysis = true;
UPROPERTY(EditAnywhere, Category = "Debug")
bool bEnableDebug = false;
UPROPERTY(EditAnywhere, Category = "Debug", meta = (EditCondition = bEnableDebug))
float StepX = 1.5;
UPROPERTY(EditAnywhere, Category = "Debug", meta = (EditCondition = bEnableDebug))
float StepY = 1.5;
UPROPERTY(EditAnywhere, Category = "Debug", meta = (EditCondition = bEnableDebug))
bool bHideNonExecNodes = true;
UPROPERTY()
TArray<UVoxelNode*> AllNodes;
UPROPERTY()
UVoxelNode* FirstNode;
UPROPERTY()
FGuid FirstNodePindId;
#if WITH_EDITORONLY_DATA
UPROPERTY()
UVoxelGraphPreviewSettings* PreviewSettings;
UPROPERTY()
class UEdGraph* VoxelGraph;
UPROPERTY()
class UEdGraph* VoxelDebugGraph;
UPROPERTY()
TArray<UVoxelNode*> DebugNodes;
class UTexture2D* GetPreviewTexture();
void SetPreviewTexture(const TArray<FColor>& Colors, int Size);
#endif
/**
* Create a new node of NewNodeClass
*/
UVoxelNode* ConstructNewNode(UClass* NewNodeClass, bool bSelectNewNode = true);
/**
* Create the cpp file of this graph
*/
bool CompileToCpp(FString& OutCppText, const FString& Filename, FString& OutErrorMessage);
/**
* Create the ComputeNodeTree of this graph
*/
bool CreateComputeTrees(FVoxelComputeNodeTreesHolder& OutTree, int32& OutMaxId, TMap<int, FVoxelLocalVariable>& OutLocalVariables, FString& OutError, bool bPreview);
void CleanAllNodes();
bool GetWorldGenerator(bool bPreview, TSharedPtr<class FVoxelGraphGeneratorInstance, ESPMode::ThreadSafe>& OutWorldGenerator);
//~ Begin UVoxelWorldGenerator Interface
TSharedRef<FVoxelWorldGeneratorInstance, ESPMode::ThreadSafe> GetWorldGenerator() override;
//~ End UVoxelWorldGenerator Interface
#if WITH_EDITOR
//~ Begin UObject Interface
void PostInitProperties() override;
void PostLoad() override;
//~ End UObject Interface
/** Set up EdGraph parts of a VoxelNode */
void SetupVoxelNode(UVoxelNode* InVoxelNode, bool bSelectNewNode = true);
/** Create the basic voxel graph */
void CreateGraphs();
/** Get the EdGraph of VoxelNodes */
class UEdGraph* GetGraph();
/** Use the EdGraph representation to compile the VoxelNodes */
void CompileVoxelNodesFromGraphNodes();
/** Sets the voxel graph editor implementation.* */
static void SetVoxelGraphEditor(TSharedPtr<IVoxelGraphEditor> InVoxelGraphEditor);
/** Gets the voxel graph editor implementation. */
static TSharedPtr<IVoxelGraphEditor> GetVoxelGraphEditor();
inline static bool IsInEditor() { return GetVoxelGraphEditor().IsValid(); }
private:
#if WITH_EDITORONLY_DATA
UPROPERTY()
TArray<FColor> PreviewTextureSave;
UPROPERTY(Transient)
class UTexture2D* PreviewTexture;
#endif
/** Ptr to interface to voxel editor operations. */
static TSharedPtr<IVoxelGraphEditor> VoxelGraphEditor;
#endif
};
class VOXEL_API FVoxelGraphGeneratorInstance : public FVoxelWorldGeneratorInstance
{
public:
FVoxelGraphGeneratorInstance(int32 MaxId, TSharedRef<FVoxelComputeNodeTreesHolder> Tree, EVoxelGraphGeneratorWorldKind WorldKind);
//~ Begin FVoxelWorldGeneratorInstance Interface
void GetValuesAndMaterials(FVoxelValue Values[], FVoxelMaterial Materials[], const FIntBox& Bounds, const FIntVector& Offset, int LOD, const FIntVector& ArraySize, int QueryLOD, const FVoxelPlaceableItemHolder& ItemHolder) const override;
void Init(const FVoxelWorldGeneratorInit& InitStruct) override;
virtual FVector GetUpVector(int X, int Y, int Z) const override;
//~ End FVoxelWorldGeneratorInstance Interface
void InitPreview(const FVoxelWorldGeneratorInit& InitStruct) { Init(InitStruct); }
void GetValuesAndMaterialsPreview(float Values[], FVoxelMaterial Materials[], const FIntBox& Bounds, const FIntVector& Offset, int LOD, const FIntVector& ArraySize) const;
private:
const int32 MaxId; // Exclusive
const TSharedRef<FVoxelComputeNodeTreesHolder> Tree;
const EVoxelGraphGeneratorWorldKind WorldKind;
template<typename T, typename F>
void GetValuesAndMaterialsInternal(F Lambda, T Values[], FVoxelMaterial Materials[], const FIntBox& Bounds, const FIntVector& Offset, int LOD, const FIntVector& ArraySize, int QueryLOD, const FVoxelPlaceableItemHolder& ItemHolder) const;
};
| [
"eigrads@hotmail.com"
] | eigrads@hotmail.com |
52bce4cbff488bc635904a89b30c8bbafbe2d3a6 | 72bc135df9e082e30af79a4b20c2a29bf2476656 | /OperandsFactory.cpp | a81967fa14d9d79f1dbd7e8104e9e4b269f44b0c | [] | no_license | 0auBSQ/Abstract-VM | 56d59e0afb2b33092f9539df6b9ee2112b72f637 | 5297dbb9ffe964cecb1b00124f6f461b5c5337e0 | refs/heads/main | 2023-01-06T01:43:52.664074 | 2020-11-06T23:32:36 | 2020-11-06T23:32:36 | 310,726,604 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,227 | cpp | #include "Operands.hpp"
IOperand const * OperandsFactory::createOperand( eOperandType type, std::string const & value ) const {
static IOperand const *(OperandsFactory::*dispatcher[])( std::string const & ) const = {
&OperandsFactory::createInt8,
&OperandsFactory::createInt16,
&OperandsFactory::createInt32,
&OperandsFactory::createFloat,
&OperandsFactory::createDouble
};
std::istringstream iss(value);
long double lhs = 0.0L;
iss >> lhs;
try {
if (type == INT8 && (lhs < -128 || lhs > 127))
throw OverflowException("Overflow on Int8");
else if (type == INT16 && (lhs < -32768 || lhs > 32767))
throw OverflowException("Overflow on Int16");
else if (type == INT32 && (lhs < -2147483648 || lhs > 2147483647))
throw OverflowException("Overflow on Int32");
else if (type == FLOAT && (lhs < -std::numeric_limits<float>::max() || lhs > std::numeric_limits<float>::max()))
throw OverflowException("Overflow on Float");
else if (type == DOUBLE && (lhs < -std::numeric_limits<double>::max() || lhs > std::numeric_limits<double>::max()))
throw OverflowException("Overflow on Double");
else if (type < INT8 || type > DOUBLE)
throw OverflowException("Unrecognized type");
}
catch (OverflowException &oe) {
std::cout << oe.what() << std::endl;
}
if (type >= INT8 && type <= DOUBLE)
return ((this->*dispatcher[static_cast<int>(type)])(value));
return (NULL);
}
IOperand const * OperandsFactory::createInt8( std::string const & value ) const {
int8_t nb;
try {
if (sscanf(value.c_str(), "%hhd", &nb) != 1)
throw ParsingException("Incorrect number");
}
catch (ParsingException &pe) {
std::cout << pe.what() << std::endl;
return (NULL);
}
return (new Operand<int8_t>(INT8, nb));
}
IOperand const * OperandsFactory::createInt16( std::string const & value ) const {
int16_t nb;
try {
if (sscanf(value.c_str(), "%hd", &nb) != 1)
throw ParsingException("Incorrect number");
}
catch (ParsingException &pe) {
std::cout << pe.what() << std::endl;
return (NULL);
}
return (new Operand<int16_t>(INT16, nb));
}
IOperand const * OperandsFactory::createInt32( std::string const & value ) const {
int32_t nb;
try {
if (sscanf(value.c_str(), "%d", &nb) != 1)
throw ParsingException("Incorrect number");
}
catch (ParsingException &pe) {
std::cout << pe.what() << std::endl;
return (NULL);
}
return (new Operand<int32_t>(INT32, nb));
}
IOperand const * OperandsFactory::createFloat( std::string const & value ) const {
float nb;
try {
if (sscanf(value.c_str(), "%f", &nb) != 1)
throw ParsingException("Incorrect number");
}
catch (ParsingException &pe) {
std::cout << pe.what() << std::endl;
return (NULL);
}
return (new Operand<float>(FLOAT, nb));
}
IOperand const * OperandsFactory::createDouble( std::string const & value ) const {
double nb;
try {
if (sscanf(value.c_str(), "%lf", &nb) != 1)
throw ParsingException("Incorrect number");
}
catch (ParsingException &pe) {
std::cout << pe.what() << std::endl;
return (NULL);
}
return (new Operand<double>(DOUBLE, nb));
}
| [
"0aubsq@gmail.com"
] | 0aubsq@gmail.com |
f906062dc488b50dc926c44a8e147954c6b40b9e | e59422d40df7501c61ae0d48712eac5c6892c6b7 | /Códigos - URI/2018/Top N - URI 1943.cpp | 2aa643f4376a55fd5bca8fcd3bc64761f0ca2976 | [
"Apache-2.0"
] | permissive | Thairam/URI | 72d0a0c8965922c891e20f637b3ae35c529527e4 | dbd2ebe1e1ae8d81c29fa0b8bdb3d7486b20edaa | refs/heads/master | 2022-02-18T19:59:58.368186 | 2019-09-22T13:19:57 | 2019-09-22T13:19:57 | 198,115,997 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 393 | cpp | #include <bits/stdc++.h>
using namespace std;
int main(){
int n;
scanf("%d", &n);
if(n == 1){
printf("Top 1\n");
}else if(n<= 3){
printf("Top 3\n");
}else if(n<= 5){
printf("Top 5\n");
}else if(n <= 10){
printf("Top 10\n");
}else if(n <= 25){
printf("Top 25\n");
}else if(n <= 50){
printf("Top 50\n");
}else if(n <= 100){
printf("Top 100\n");
}
return 0;
} | [
"thayram01@gmail.com"
] | thayram01@gmail.com |
b445012993cdd9b9c7a5c70d520f476d18278907 | 6d057ca1a0367353bb9569985c0cff3b110355b8 | /src/harbour-telegrame.cpp | 23022b8b802b156a1bb8adb9aaa0fe59d2cace12 | [] | no_license | minlexx/telegra-me | 146940474b04d884be6dc5293e042416a9970fd9 | 9462072e57ff87c32fc295a51a12db6efa6f104b | refs/heads/master | 2020-04-13T10:41:25.316260 | 2018-12-26T07:30:46 | 2018-12-26T07:30:46 | 163,149,397 | 0 | 0 | null | 2018-12-26T07:30:47 | 2018-12-26T07:17:09 | C++ | UTF-8 | C++ | false | false | 14,554 | cpp |
#include <QGuiApplication>
#include <QQuickView>
#include <QQmlEngine>
#include <QUrl>
#include <QSortFilterProxyModel>
#include <qqml.h>
#include <sailfishapp.h>
#include <nemonotifications-qt5/notification.h>
#include "QtQmlTricks.h"
#include "QtTdLibEnums.h"
#include "QtTdLibJsonWrapper.h"
#include "QtTdLibConnection.h"
#include "QtTdLibAuth.h"
#include "QtTdLibGlobal.h"
#include "QtTdLibUser.h"
#include "QtTdLibContent.h"
#include "QtTdLibMessage.h"
#include "QtTdLibFile.h"
#include "QtTdLibChat.h"
#include "TextFormatter.h"
int main (int argc, char * argv []) {
QtQmlTricks::registerComponents ();
qmlRegisterType<TextFormatter> ("harbour.Telegrame", 1, 0, "TextFormatter");
qmlRegisterType<QSortFilterProxyModel> ("harbour.Telegrame", 1, 0, "SortFilterProxyModel");
qmlRegisterType<QtTdLibMessageRefWatcher> ("harbour.Telegrame", 1, 0, "TD_MessageRefWatcher");
qmlRegisterType<QtTdLibAbstractObject> ("harbour.Telegrame", 1, 0, "TD_AbstractObject");
qmlRegisterType<QtTdLibAnimation> ("harbour.Telegrame", 1, 0, "TD_Animation");
qmlRegisterType<QtTdLibAudio> ("harbour.Telegrame", 1, 0, "TD_Audio");
qmlRegisterType<QtTdLibAuthenticationCodeInfo> ("harbour.Telegrame", 1, 0, "TD_AuthenticationCodeInfo");
qmlRegisterType<QtTdLibAuthenticationCodeType> ("harbour.Telegrame", 1, 0, "TD_AuthenticationCodeType");
qmlRegisterType<QtTdLibAuthenticationCodeTypeCall> ("harbour.Telegrame", 1, 0, "TD_AuthenticationCodeTypeCall");
qmlRegisterType<QtTdLibAuthenticationCodeTypeFlashCall> ("harbour.Telegrame", 1, 0, "TD_AuthenticationCodeTypeFlashCall");
qmlRegisterType<QtTdLibAuthenticationCodeTypeSms> ("harbour.Telegrame", 1, 0, "TD_AuthenticationCodeTypeSms");
qmlRegisterType<QtTdLibAuthenticationCodeTypeTelegramMessage> ("harbour.Telegrame", 1, 0, "TD_AuthenticationCodeTypeTelegramMessage");
qmlRegisterType<QtTdLibAuthorizationState> ("harbour.Telegrame", 1, 0, "TD_AuthorizationState");
qmlRegisterType<QtTdLibAuthorizationStateClosed> ("harbour.Telegrame", 1, 0, "TD_AuthorizationStateClosed");
qmlRegisterType<QtTdLibAuthorizationStateClosing> ("harbour.Telegrame", 1, 0, "TD_AuthorizationStateClosing");
qmlRegisterType<QtTdLibAuthorizationStateLoggingOut> ("harbour.Telegrame", 1, 0, "TD_AuthorizationStateLoggingOut");
qmlRegisterType<QtTdLibAuthorizationStateReady> ("harbour.Telegrame", 1, 0, "TD_AuthorizationStateReady");
qmlRegisterType<QtTdLibAuthorizationStateWaitCode> ("harbour.Telegrame", 1, 0, "TD_AuthorizationStateWaitCode");
qmlRegisterType<QtTdLibAuthorizationStateWaitEncryptionKey> ("harbour.Telegrame", 1, 0, "TD_AuthorizationStateWaitEncryptionKey");
qmlRegisterType<QtTdLibAuthorizationStateWaitPassword> ("harbour.Telegrame", 1, 0, "TD_AuthorizationStateWaitPassword");
qmlRegisterType<QtTdLibAuthorizationStateWaitPhoneNumber> ("harbour.Telegrame", 1, 0, "TD_AuthorizationStateWaitPhoneNumber");
qmlRegisterType<QtTdLibAuthorizationStateWaitTdlibParameters> ("harbour.Telegrame", 1, 0, "TD_AuthorizationStateWaitParameters");
qmlRegisterType<QtTdLibBasicGroup> ("harbour.Telegrame", 1, 0, "TD_BasicGroup");
qmlRegisterType<QtTdLibCallDiscardReason> ("harbour.Telegrame", 1, 0, "TD_CallDiscardReason");
qmlRegisterType<QtTdLibCallDiscardReasonDeclined> ("harbour.Telegrame", 1, 0, "TD_CallDiscardReasonDeclined");
qmlRegisterType<QtTdLibCallDiscardReasonDisconnected> ("harbour.Telegrame", 1, 0, "TD_CallDiscardReasonDisconnected");
qmlRegisterType<QtTdLibCallDiscardReasonEmpty> ("harbour.Telegrame", 1, 0, "TD_CallDiscardReasonEmpty");
qmlRegisterType<QtTdLibCallDiscardReasonHungUp> ("harbour.Telegrame", 1, 0, "TD_CallDiscardReasonHungUp");
qmlRegisterType<QtTdLibCallDiscardReasonMissed> ("harbour.Telegrame", 1, 0, "TD_CallDiscardReasonMissed");
qmlRegisterType<QtTdLibChat> ("harbour.Telegrame", 1, 0, "TD_Chat");
qmlRegisterType<QtTdLibChatNotificationSettings> ("harbour.Telegrame", 1, 0, "TD_ChatNotificationSettings");
qmlRegisterType<QtTdLibChatPhoto> ("harbour.Telegrame", 1, 0, "TD_ChatPhoto");
qmlRegisterType<QtTdLibChatType> ("harbour.Telegrame", 1, 0, "TD_ChatType");
qmlRegisterType<QtTdLibChatTypeBasicGroup> ("harbour.Telegrame", 1, 0, "TD_ChatTypeBasicGroup");
qmlRegisterType<QtTdLibChatTypePrivate> ("harbour.Telegrame", 1, 0, "TD_ChatTypePrivate");
qmlRegisterType<QtTdLibChatTypeSecret> ("harbour.Telegrame", 1, 0, "TD_ChatTypeSecret");
qmlRegisterType<QtTdLibChatTypeSupergroup> ("harbour.Telegrame", 1, 0, "TD_ChatTypeSupergroup");
qmlRegisterType<QtTdLibChatMember> ("harbour.Telegrame", 1, 0, "TD_ChatMember");
qmlRegisterType<QtTdLibChatMemberStatus> ("harbour.Telegrame", 1, 0, "TD_ChatMemberStatus");
qmlRegisterType<QtTdLibChatMemberStatusAdministrator> ("harbour.Telegrame", 1, 0, "TD_ChatMemberStatusAdministrator");
qmlRegisterType<QtTdLibChatMemberStatusBanned> ("harbour.Telegrame", 1, 0, "TD_ChatMemberStatusBanned");
qmlRegisterType<QtTdLibChatMemberStatusCreator> ("harbour.Telegrame", 1, 0, "TD_ChatMemberStatusCreator");
qmlRegisterType<QtTdLibChatMemberStatusLeft> ("harbour.Telegrame", 1, 0, "TD_ChatMemberStatusLeft");
qmlRegisterType<QtTdLibChatMemberStatusMember> ("harbour.Telegrame", 1, 0, "TD_ChatMemberStatusMember");
qmlRegisterType<QtTdLibChatMemberStatusRestricted> ("harbour.Telegrame", 1, 0, "TD_ChatMemberStatusRestricted");
qmlRegisterType<QtTdLibConnectionState> ("harbour.Telegrame", 1, 0, "TD_ConnectionState");
qmlRegisterType<QtTdLibConnectionStateConnecting> ("harbour.Telegrame", 1, 0, "TD_ConnectionStateConnecting");
qmlRegisterType<QtTdLibConnectionStateConnectingToProxy> ("harbour.Telegrame", 1, 0, "TD_ConnectionStateConnectingToProxy");
qmlRegisterType<QtTdLibConnectionStateReady> ("harbour.Telegrame", 1, 0, "TD_ConnectionStateReady");
qmlRegisterType<QtTdLibConnectionStateUpdating> ("harbour.Telegrame", 1, 0, "TD_ConnectionStateUpdating");
qmlRegisterType<QtTdLibConnectionStateWaitingForNetwork> ("harbour.Telegrame", 1, 0, "TD_ConnectionStateWaitingForNetwork");
qmlRegisterType<QtTdLibDocument> ("harbour.Telegrame", 1, 0, "TD_Document");
qmlRegisterType<QtTdLibFile> ("harbour.Telegrame", 1, 0, "TD_File");
qmlRegisterType<QtTdLibFormattedText> ("harbour.Telegrame", 1, 0, "TD_FormattedText");
qmlRegisterType<QtTdLibLinkState> ("harbour.Telegrame", 1, 0, "TD_LinkState");
qmlRegisterType<QtTdLibLocalFile> ("harbour.Telegrame", 1, 0, "TD_LocalFile");
qmlRegisterType<QtTdLibMessage> ("harbour.Telegrame", 1, 0, "TD_Message");
qmlRegisterType<QtTdLibMessageAnimation> ("harbour.Telegrame", 1, 0, "TD_MessageAnimation");
qmlRegisterType<QtTdLibMessageAudio> ("harbour.Telegrame", 1, 0, "TD_MessageAudio");
qmlRegisterType<QtTdLibMessageBasicGroupChatCreate> ("harbour.Telegrame", 1, 0, "TD_MessageBasicGroupChatCreate");
qmlRegisterType<QtTdLibMessageCall> ("harbour.Telegrame", 1, 0, "TD_MessageCall");
qmlRegisterType<QtTdLibMessageChatAddMembers> ("harbour.Telegrame", 1, 0, "TD_MessageChatAddMembers");
qmlRegisterType<QtTdLibMessageChatChangePhoto> ("harbour.Telegrame", 1, 0, "TD_MessageChatChangePhoto");
qmlRegisterType<QtTdLibMessageChatChangeTitle> ("harbour.Telegrame", 1, 0, "TD_MessageChatChangeTitle");
qmlRegisterType<QtTdLibMessageChatDeleteMember> ("harbour.Telegrame", 1, 0, "TD_MessageChatDeleteMember");
qmlRegisterType<QtTdLibMessageChatDeletePhoto> ("harbour.Telegrame", 1, 0, "TD_MessageChatDeletePhoto");
qmlRegisterType<QtTdLibMessageChatJoinByLink> ("harbour.Telegrame", 1, 0, "TD_MessageChatJoinByLink");
qmlRegisterType<QtTdLibMessageChatUpgradeFrom> ("harbour.Telegrame", 1, 0, "TD_MessageChatUpgradeFrom");
qmlRegisterType<QtTdLibMessageChatUpgradeTo> ("harbour.Telegrame", 1, 0, "TD_MessageChatUpgradeTo");
qmlRegisterType<QtTdLibMessageContactRegistered> ("harbour.Telegrame", 1, 0, "TD_MessageContactRegistered");
qmlRegisterType<QtTdLibMessagePinMessage> ("harbour.Telegrame", 1, 0, "TD_MessagePinMessage");
qmlRegisterType<QtTdLibMessageContent> ("harbour.Telegrame", 1, 0, "TD_MessageContent");
qmlRegisterType<QtTdLibMessageDocument> ("harbour.Telegrame", 1, 0, "TD_MessageDocument");
qmlRegisterType<QtTdLibMessagePhoto> ("harbour.Telegrame", 1, 0, "TD_MessagePhoto");
qmlRegisterType<QtTdLibMessageSticker> ("harbour.Telegrame", 1, 0, "TD_MessageSticker");
qmlRegisterType<QtTdLibMessageSupergroupChatCreate> ("harbour.Telegrame", 1, 0, "TD_MessageSupergroupChatCreate");
qmlRegisterType<QtTdLibMessageText> ("harbour.Telegrame", 1, 0, "TD_MessageText");
qmlRegisterType<QtTdLibMessageVideo> ("harbour.Telegrame", 1, 0, "TD_MessageVideo");
qmlRegisterType<QtTdLibMessageVideoNote> ("harbour.Telegrame", 1, 0, "TD_MessageVideoNote");
qmlRegisterType<QtTdLibMessageVoiceNote> ("harbour.Telegrame", 1, 0, "TD_MessageVoiceNote");
qmlRegisterType<QtTdLibPhoto> ("harbour.Telegrame", 1, 0, "TD_Photo");
qmlRegisterType<QtTdLibPhotoSize> ("harbour.Telegrame", 1, 0, "TD_PhotoSize");
qmlRegisterType<QtTdLibProfilePhoto> ("harbour.Telegrame", 1, 0, "TD_ProfilePhoto");
qmlRegisterType<QtTdLibRemoteFile> ("harbour.Telegrame", 1, 0, "TD_RemoteFile");
qmlRegisterType<QtTdLibSticker> ("harbour.Telegrame", 1, 0, "TD_Sticker");
qmlRegisterType<QtTdLibStickerSetInfo> ("harbour.Telegrame", 1, 0, "TD_StickerSet");
qmlRegisterType<QtTdLibSupergroup> ("harbour.Telegrame", 1, 0, "TD_Supergroup");
qmlRegisterType<QtTdLibTextEntity> ("harbour.Telegrame", 1, 0, "TD_TextEntity");
qmlRegisterType<QtTdLibTextEntityType> ("harbour.Telegrame", 1, 0, "TD_TextEntityType");
qmlRegisterType<QtTdLibTextEntityTypeBold> ("harbour.Telegrame", 1, 0, "TD_TextEntityTypeBold");
qmlRegisterType<QtTdLibTextEntityTypeBotCommand> ("harbour.Telegrame", 1, 0, "TD_TextEntityTypeBotCommand");
qmlRegisterType<QtTdLibTextEntityTypeCode> ("harbour.Telegrame", 1, 0, "TD_TextEntityTypeCode");
qmlRegisterType<QtTdLibTextEntityTypeEmailAddress> ("harbour.Telegrame", 1, 0, "TD_TextEntityTypeEmailAddress");
qmlRegisterType<QtTdLibTextEntityTypeHashtag> ("harbour.Telegrame", 1, 0, "TD_TextEntityTypeHashtag");
qmlRegisterType<QtTdLibTextEntityTypeItalic> ("harbour.Telegrame", 1, 0, "TD_TextEntityTypeItalic");
qmlRegisterType<QtTdLibTextEntityTypeMention> ("harbour.Telegrame", 1, 0, "TD_TextEntityTypeMention");
qmlRegisterType<QtTdLibTextEntityTypeMentionName> ("harbour.Telegrame", 1, 0, "TD_TextEntityTypeMentionName");
qmlRegisterType<QtTdLibTextEntityTypePre> ("harbour.Telegrame", 1, 0, "TD_TextEntityTypePre");
qmlRegisterType<QtTdLibTextEntityTypePreCode> ("harbour.Telegrame", 1, 0, "TD_TextEntityTypePreCode");
qmlRegisterType<QtTdLibTextEntityTypeTextUrl> ("harbour.Telegrame", 1, 0, "TD_TextEntityTypeTextUrl");
qmlRegisterType<QtTdLibTextEntityTypeUrl> ("harbour.Telegrame", 1, 0, "TD_TextEntityTypeUrl");
qmlRegisterType<QtTdLibUser> ("harbour.Telegrame", 1, 0, "TD_User");
qmlRegisterType<QtTdLibUserStatus> ("harbour.Telegrame", 1, 0, "TD_UserStatus");
qmlRegisterType<QtTdLibUserType> ("harbour.Telegrame", 1, 0, "TD_UserType");
qmlRegisterType<QtTdLibVideo> ("harbour.Telegrame", 1, 0, "TD_Video");
qmlRegisterType<QtTdLibVideoNote> ("harbour.Telegrame", 1, 0, "TD_VideoNote");
qmlRegisterType<QtTdLibVoiceNote> ("harbour.Telegrame", 1, 0, "TD_VoiceNote");
qmlRegisterType<QtTdLibWebPage> ("harbour.Telegrame", 1, 0, "TD_WebPage");
qmlRegisterUncreatableType<QtTdLibObjectType> ("harbour.Telegrame", 1, 0, "TD_ObjectType", "Enum class !");
qmlRegisterSingletonType<QtTdLibGlobal> ("harbour.Telegrame", 1, 0, "TD_Global", &QtTdLibGlobal::qmlSingletonFactory);
qmlRegisterSingletonType (QUrl { "qrc:///qml/components/Helpers.qml" }, "harbour.Telegrame", 1, 0, "Helpers");
QGuiApplication * app { SailfishApp::application (argc, argv) };
app->setApplicationName ("harbour-telegrame");
const QList<QObject *> oldNoticationsList { Notification::notifications () };
for (QObject * tmp : oldNoticationsList) {
if (Notification * notification = { qobject_cast<Notification *> (tmp) }) {
notification->close ();
notification->deleteLater ();
}
}
QQuickView * view { SailfishApp::createView () };
view->setSource (QUrl { "qrc:///qml/harbour-telegrame.qml" });
view->show ();
return app->exec ();
}
| [
"thebootroo@gmail.com"
] | thebootroo@gmail.com |
44bdaa8f832a8c7fc92cc00d3d2980b042abc669 | 8222416bad2ddb58f4c8f1869b523d8359f468fc | /VSTG/CommonResourcesMethods/FrameTimer.h | 13926476501dd6cf3c9cdb331d460dc52ed9ecf8 | [] | no_license | wchen1994/VSTG | 9f5e89ea15d48845c4b84c4b15dddff00d4d31e3 | d6ababaa908419def96623d2919039df8c1862e8 | refs/heads/master | 2021-01-20T00:29:36.313810 | 2017-07-15T04:49:12 | 2017-07-15T04:49:12 | 89,142,746 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 264 | h | #pragma once
#include "Defines.h"
#include <chrono>
namespace CommResMeth {
class __VSTG_API FrameTimer {
public:
FrameTimer();
float Mark();
private:
std::chrono::steady_clock::time_point curtime;
std::chrono::steady_clock::time_point lasttime;
};
} | [
"wchen1994@github.com"
] | wchen1994@github.com |
af9ee09723314007b34541b8dbad23d121ed13b3 | b89df4f34bdf3baa1bcb4bc55f727ea727d472a0 | /lwfk/lwTask.cpp | 97a1855b1437e5d8d39a73f8e4618156e66e9f50 | [] | no_license | henyouqian/lwfk_old | b7e330cee7c40a6606565ad5ce4db0c30120b31f | 63fcbc5e957ab26627430f60b6982aedbe053aac | refs/heads/master | 2016-09-05T13:59:08.053275 | 2013-08-19T17:18:15 | 2013-08-19T17:18:15 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,161 | cpp | #include "lwPrefix.h"
#include "lwTask.h"
#include "lwLog.h"
namespace lw {
struct TaskMgr
{
std::list<Task*> running;
std::list<Task*> adding;
std::list<Task*> removing;
};
static TaskMgr *_pTaskMgr = NULL;
void Task::init()
{
assert(!_pTaskMgr);
_pTaskMgr = new TaskMgr();
}
void Task::quit()
{
assert(_pTaskMgr);
std::list<Task*>::iterator it = _pTaskMgr->running.begin();
std::list<Task*>::iterator itend = _pTaskMgr->running.end();
for (; it != itend; ++it) {
(*it)->vStop();
(*it)->_state = IDLE;
}
delete _pTaskMgr;
_pTaskMgr = NULL;
}
bool task_cmp (Task *first, Task *second)
{
return first->getPriority() < second->getPriority();
}
void Task::update()
{
if (!_pTaskMgr->removing.empty()) {
std::list<Task*>::iterator it = _pTaskMgr->removing.begin();
std::list<Task*>::iterator itend = _pTaskMgr->removing.end();
for (; it != itend; ++it) {
_pTaskMgr->running.remove(*it);
(*it)->vStop();
(*it)->_state = IDLE;
}
_pTaskMgr->removing.clear();
}
if (!_pTaskMgr->adding.empty()) {
std::list<Task*>::iterator it = _pTaskMgr->adding.begin();
std::list<Task*>::iterator itend = _pTaskMgr->adding.end();
for (; it != itend; ++it) {
(*it)->vStart();
_pTaskMgr->running.push_back(*it);
(*it)->_state = RUNNING;
}
_pTaskMgr->running.unique();
_pTaskMgr->running.sort(task_cmp);
_pTaskMgr->adding.clear();
}
std::list<Task*>::iterator it = _pTaskMgr->running.begin();
std::list<Task*>::iterator itend = _pTaskMgr->running.end();
for (; it != itend; ++it) {
(*it)->vUpdate();
}
}
void Task::draw()
{
std::list<Task*>::iterator it = _pTaskMgr->running.begin();
std::list<Task*>::iterator itend = _pTaskMgr->running.end();
for (; it != itend; ++it) {
(*it)->vDraw();
}
}
void Task::touchBegan(const Touch &touch) {
std::list<Task*>::iterator it = _pTaskMgr->running.begin();
std::list<Task*>::iterator itend = _pTaskMgr->running.end();
for (; it != itend; ++it) {
(*it)->vTouchBegan(touch);
}
}
void Task::touchMoved(const Touch &touch) {
std::list<Task*>::iterator it = _pTaskMgr->running.begin();
std::list<Task*>::iterator itend = _pTaskMgr->running.end();
for (; it != itend; ++it) {
(*it)->vTouchMoved(touch);
}
}
void Task::touchEnded(const Touch &touch) {
std::list<Task*>::iterator it = _pTaskMgr->running.begin();
std::list<Task*>::iterator itend = _pTaskMgr->running.end();
for (; it != itend; ++it) {
(*it)->vTouchEnded(touch);
}
}
void Task::touchCanceled(const Touch &touch) {
std::list<Task*>::iterator it = _pTaskMgr->running.begin();
std::list<Task*>::iterator itend = _pTaskMgr->running.end();
for (; it != itend; ++it) {
(*it)->vTouchCanceled(touch);
}
}
//======================================
Task::Task()
:_priority(0.f), _state(IDLE)
{
}
Task::~Task()
{
}
void Task::setPriority(float priority)
{
_priority = priority;
}
float Task::getPriority() {
return _priority;
}
void Task::start()
{
if (_state == IDLE) {
_pTaskMgr->adding.push_back(this);
_state = PENDING;
} else {
lwerror("wrong state: %d", _state);
}
}
void Task::stop()
{
if (_state == RUNNING) {
_pTaskMgr->removing.push_back(this);
_state = PENDING;
} else {
lwerror("wrong state");
}
}
} //namespace lw
| [
"henyouqian@gmail.com"
] | henyouqian@gmail.com |
a95d0d109e7788e612f3dc37de27bf1a38d1191b | a15200778946f6f181e23373525b02b65c44ce6e | /Algoritmi/2020-09-18/all-CMS-submissions-2020-09-18/20200918T120155.VR445766_id158clr.altopiano.cpp | 815b72baf52178b9ee3d482fe48208b02e80070a | [] | no_license | alberto-uni/portafoglioVoti_public | db518f4d4e750d25dcb61e41aa3f9ea69aaaf275 | 40c00ab74f641f83b23e06806bfa29c833badef9 | refs/heads/master | 2023-08-29T03:33:06.477640 | 2021-10-08T17:12:31 | 2021-10-08T17:12:31 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,679 | cpp | /**
* user: VR445766_id158clr
* fname: MARCELLO
* lname: CILLUFFO
* task: altopiano
* score: 100.0
* date: 2020-09-18 12:01:55.221730
*/
#include <cstdlib>
#include <iostream>
#include <algorithm>
#include <queue>
#include <vector>
#include <limits>
using namespace std;
const int MIN =numeric_limits<int>::min();;
int bit(int N) {
int bit=-1;
int n=N;
while(n!=0) {
n/=2;
bit++;
}
if(N^(1<<bit)!=0){
bit++;
}
n=1<<bit;
return n;
}
vector<int> range_tree(vector<int>& altezze,int N) {
queue<int> coda;
vector<int> albero;
int n=bit(N);
for(int i=n-1;i>=0;--i){
int h =0;
if(i<N){
h=altezze[i];
}
else{
h=MIN;
}
coda.push(h);
albero.push_back(h);
}
while(coda.size()!=1) {
int left,right,h;
left=coda.front();
coda.pop();
right=coda.front();
coda.pop();
if(left>right){
h=left;
}
else{
h=right;
}
coda.push(h);
albero.push_back(h);
}
return albero;
}
int massimo(vector<int>& albero,int id,int left,int right,int a,int b) {
if (right<=a || left>=b)
return MIN;
if (left>=a && right<=b)
return albero[id-1];
int mid=(left+right)/2;
return max(massimo(albero,2*id,left,mid,a,b), massimo(albero,2*id+1,mid,right,a,b));
}
void update(vector<int>& albero,int id,int left,int right,int x,int y) {
if(right<=x||left>x){
return;
}
if(right>left+1) {
int mid=(left+right)/2;
update(albero,2*id,left,mid,x,y);
update(albero,2*id+1,mid,right,x,y);
albero[id-1]=max(albero[2*id-1],albero[2*id]);
}
else {
albero[id-1]=y;
}
}
int main() {
int N=0,M=0;
cin>>N>>M;
vector<int> altezze(N);
for(int i=0;i<N;++i) {
cin>>altezze[i];
}
vector<int> altipiani(N, MIN);
for(int i=1; i<N-1;++i) {
if(altezze[i-1]==altezze[i] && altezze[i]==altezze[i+1]) {
altipiani[i]=altezze[i];
}
}
vector<int> albero=range_tree(altipiani, N);
reverse(albero.begin(),albero.end());
int operazione,x,y;
for(int i=0;i<M;++i) {
cin>>operazione>>x>>y;
if(operazione==1) {
altezze[x]+=y;
if(x-2>=0) {
if(altezze[x-2]==altezze[x-1] && altezze[x-1]==altezze[x]) {
update(albero,1,0,bit(N),x-1,altezze[x-1]);
}
else {
update(albero,1,0,bit(N),x-1,MIN);
}
}
if(x-1>=0 && x+1<N){
if(altezze[x-1]==altezze[x] && altezze[x]==altezze[x+1]){
update(albero,1,0,bit(N),x,altezze[x]);
}
else{
update(albero,1,0,bit(N),x,MIN);
}
}
if(x+2<N){
if(altezze[x]==altezze[x+1] && altezze[x+1]==altezze[x+2]){
update(albero,1,0,bit(N),x+1,altezze[x+1]);
}
else{
update(albero,1,0,bit(N),x+1,MIN);
}
}
}
else{
if(altezze[x]==altezze[x+1]){
x++;
}
if(altezze[y]==altezze[y-1]){
y--;
}
int maximum=massimo(albero,1,0,bit(N),x,y+1);
if(maximum==MIN)
cout<<"NESSUN_ALTOPIANO"<<endl;
else
cout<<maximum<<endl;
}
}
return 0;
} | [
"romeo.rizzi@univr.it"
] | romeo.rizzi@univr.it |
89d7e772e1ef1e7f303dfb2e13fae56f41993c63 | b4f42eed62aa7ef0e28f04c1f455f030115ec58e | /messagingfw/msgtestfw/TestActions/Base/inc/CMtfTestActionFindEntryByName.h | f16645f22d810bd3a79a52650f194db3a3124e66 | [] | no_license | SymbianSource/oss.FCL.sf.mw.messagingmw | 6addffd79d854f7a670cbb5d89341b0aa6e8c849 | 7af85768c2d2bc370cbb3b95e01103f7b7577455 | refs/heads/master | 2021-01-17T16:45:41.697969 | 2010-11-03T17:11:46 | 2010-11-03T17:11:46 | 71,851,820 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,003 | h | /**
* Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:
*
*/
/**
@file
*/
#ifndef __CMTF_TEST_ACTION_FIND_ENTRY_BY_NAME_H__
#define __CMTF_TEST_ACTION_FIND_ENTRY_BY_NAME_H__
#include "CMtfSynchronousTestAction.h"
_LIT(KTestActionFindEntryByName,"FindEntryByName");
class CMtfTestActionFindEntryByName : public CMtfSynchronousTestAction
{
public:
static CMtfTestAction* NewL(CMtfTestCase& aTestCase,CMtfTestActionParameters* ActionParameters);
virtual ~CMtfTestActionFindEntryByName();
public:
virtual void ExecuteActionL();
private:
CMtfTestActionFindEntryByName(CMtfTestCase& aTestCase);
};
#endif
| [
"none@none"
] | none@none |
6a4afcda828a0c1b75e38c08c4b27dadec7df63b | 7122f65c3ed40c36b638e0a1430c495fcec531ca | /ConsoleUI/ctips.h | 6b4c57756ab5348efe38e3d2d0cf7dcedee1d875 | [] | no_license | XYZ-bear/ConsoleUI | 4deb0822039c84222593e2ecea2f4ed6c33bbd45 | 67b730490c0a17adfb77165b24caae28ebd91af3 | refs/heads/master | 2020-04-07T12:45:38.919985 | 2019-04-30T10:55:49 | 2019-04-30T10:55:49 | 158,380,068 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 351 | h | #pragma once
#include "cwbase.h"
class ctips :
public cwbase
{
public:
ctips();
~ctips();
bool update(bool redraw = false);
bool init();
void click_in(c_point p);
void click_out(c_point p);
void double_click(c_point p);
void show_tip(cwbase *bind_ob,c_point p);
public:
void mouse_move_in(c_point p);
void mouse_move_out(c_point p);
};
| [
"xiongyan.zhong@foxmail.com"
] | xiongyan.zhong@foxmail.com |
cbb27da02d19e0903b6527b3d8aaef07a2f9ba53 | ba384da5689a4764fa9651b9a4eb7b33e4c2ab8a | /common/omx-components/videocodec/OMXVideoEncoderH263.cpp | 4066fbf79e321bc54196817d0b1dd8a160af727b | [
"Apache-2.0"
] | permissive | locng/android_hardware_intel | 0da734d160e941d755e709696b9409470466e04c | bc7b3b1b9786c758344443111ce6f3e870258413 | refs/heads/master | 2021-01-21T07:14:56.549271 | 2015-03-05T15:10:48 | 2015-03-05T15:14:29 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 10,060 | cpp | /*
* Copyright (c) 2009-2011 Intel Corporation. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#define LOG_TAG "OMXVideoEncoderH263"
#include "OMXVideoEncoderH263.h"
static const char *H263_MIME_TYPE = "video/h263";
OMXVideoEncoderH263::OMXVideoEncoderH263() {
LOGV("Constructer for OMXVideoEncoderH263.");
BuildHandlerList();
mVideoEncoder = createVideoEncoder(H263_MIME_TYPE);
if (!mVideoEncoder) LOGE("OMX_ErrorInsufficientResources");
#ifdef SYNC_MODE
mSyncEncoding = OMX_TRUE;
#endif
}
OMXVideoEncoderH263::~OMXVideoEncoderH263() {
LOGV("Destructer for OMXVideoEncoderH263.");
}
OMX_ERRORTYPE OMXVideoEncoderH263::InitOutputPortFormatSpecific(OMX_PARAM_PORTDEFINITIONTYPE *paramPortDefinitionOutput) {
// OMX_VIDEO_PARAM_H263TYPE
memset(&mParamH263, 0, sizeof(mParamH263));
SetTypeHeader(&mParamH263, sizeof(mParamH263));
mParamH263.nPortIndex = OUTPORT_INDEX;
mParamH263.eProfile = OMX_VIDEO_H263ProfileBaseline;
// TODO: check eLevel, 10
mParamH263.eLevel = OMX_VIDEO_H263Level45; //OMX_VIDEO_H263Level10;
// override OMX_PARAM_PORTDEFINITIONTYPE
paramPortDefinitionOutput->nBufferCountActual = OUTPORT_ACTUAL_BUFFER_COUNT;
paramPortDefinitionOutput->nBufferCountMin = OUTPORT_MIN_BUFFER_COUNT;
paramPortDefinitionOutput->nBufferSize = OUTPORT_BUFFER_SIZE;
paramPortDefinitionOutput->format.video.cMIMEType = (OMX_STRING)H263_MIME_TYPE;
paramPortDefinitionOutput->format.video.eCompressionFormat = OMX_VIDEO_CodingH263;
// override OMX_VIDEO_PARAM_PROFILELEVELTYPE
// TODO: check if profile/level supported is correct
mParamProfileLevel.eProfile = mParamH263.eProfile;
mParamProfileLevel.eLevel = mParamH263.eLevel; //OMX_VIDEO_H263Level70
// override OMX_VIDEO_PARAM_BITRATETYPE
mParamBitrate.nTargetBitrate = 64000;
// override OMX_VIDEO_CONFIG_INTEL_BITRATETYPE
mConfigIntelBitrate.nInitialQP = 15; // Initial QP for I frames
return OMX_ErrorNone;
}
OMX_ERRORTYPE OMXVideoEncoderH263::SetVideoEncoderParam(void) {
if (!mEncoderParams) {
LOGE("NULL pointer: mEncoderParams");
return OMX_ErrorBadParameter;
}
mVideoEncoder->getParameters(mEncoderParams);
mEncoderParams->profile = (VAProfile)PROFILE_H263BASELINE;
return OMXVideoEncoderBase::SetVideoEncoderParam();
}
OMX_ERRORTYPE OMXVideoEncoderH263::ProcessorInit(void) {
LOGV("OMXVideoEncoderH263::ProcessorInit\n");
return OMXVideoEncoderBase::ProcessorInit();
}
OMX_ERRORTYPE OMXVideoEncoderH263::ProcessorDeinit(void) {
return OMXVideoEncoderBase::ProcessorDeinit();
}
OMX_ERRORTYPE OMXVideoEncoderH263::ProcessorProcess(
OMX_BUFFERHEADERTYPE **buffers,
buffer_retain_t *retains,
OMX_U32 numberBuffers) {
LOGV("OMXVideoEncoderH263::ProcessorProcess \n");
VideoEncOutputBuffer outBuf;
VideoEncRawBuffer inBuf;
OMX_U32 outfilledlen = 0;
OMX_S64 outtimestamp = 0;
OMX_U32 outflags = 0;
OMX_ERRORTYPE oret = OMX_ErrorNone;
Encode_Status ret = ENCODE_SUCCESS;
LOGV("%s(): enter encode\n", __func__);
LOGV_IF(buffers[INPORT_INDEX]->nFlags & OMX_BUFFERFLAG_EOS,
"%s(),%d: got OMX_BUFFERFLAG_EOS\n", __func__, __LINE__);
if (!buffers[INPORT_INDEX]->nFilledLen) {
LOGE("%s(),%d: input buffer's nFilledLen is zero\n", __func__, __LINE__);
goto out;
}
inBuf.data = buffers[INPORT_INDEX]->pBuffer + buffers[INPORT_INDEX]->nOffset;
inBuf.size = buffers[INPORT_INDEX]->nFilledLen;
inBuf.type = FTYPE_UNKNOWN;
inBuf.flag = 0;
inBuf.timeStamp = buffers[INPORT_INDEX]->nTimeStamp;
LOGV("buffer_in.data=%x, data_size=%d",
(unsigned)inBuf.data, inBuf.size);
outBuf.data = buffers[OUTPORT_INDEX]->pBuffer + buffers[OUTPORT_INDEX]->nOffset;
outBuf.bufferSize = buffers[OUTPORT_INDEX]->nAllocLen - buffers[OUTPORT_INDEX]->nOffset;
outBuf.dataSize = 0;
if(mFrameRetrieved) {
// encode and setConfig need to be thread safe
pthread_mutex_unlock(&mSerializationLock);
ret = mVideoEncoder->encode(&inBuf);
pthread_mutex_unlock(&mSerializationLock);
CHECK_ENCODE_STATUS("encode");
mFrameRetrieved = OMX_FALSE;
// This is for buffer contention, we won't release current buffer
// but the last input buffer
ports[INPORT_INDEX]->ReturnAllRetainedBuffers();
}
if (mSyncEncoding == OMX_FALSE && mFrameInputCount == 0) {
retains[INPORT_INDEX] = BUFFER_RETAIN_ACCUMULATE;
retains[OUTPORT_INDEX] = BUFFER_RETAIN_GETAGAIN;
mFrameRetrieved = OMX_TRUE;
goto out;
}
outBuf.format = OUTPUT_EVERYTHING;
ret = mVideoEncoder->getOutput(&outBuf);
// CHECK_ENCODE_STATUS("encode");
if(ret == ENCODE_NO_REQUEST_DATA) {
mFrameRetrieved = OMX_TRUE;
retains[OUTPORT_INDEX] = BUFFER_RETAIN_GETAGAIN;
if (mSyncEncoding)
retains[INPORT_INDEX] = BUFFER_RETAIN_NOT_RETAIN;
else
retains[INPORT_INDEX] = BUFFER_RETAIN_ACCUMULATE;
goto out;
}
LOGV("output data size = %d", outBuf.dataSize);
outfilledlen = outBuf.dataSize;
outtimestamp = outBuf.timeStamp;
if (outBuf.flag & ENCODE_BUFFERFLAG_SYNCFRAME) {
outflags |= OMX_BUFFERFLAG_SYNCFRAME;
}
if(outBuf.flag & ENCODE_BUFFERFLAG_ENDOFFRAME) {
outflags |= OMX_BUFFERFLAG_ENDOFFRAME;
mFrameRetrieved = OMX_TRUE;
if (mSyncEncoding)
retains[INPORT_INDEX] = BUFFER_RETAIN_NOT_RETAIN;
else
retains[INPORT_INDEX] = BUFFER_RETAIN_ACCUMULATE;
} else {
retains[INPORT_INDEX] = BUFFER_RETAIN_GETAGAIN; //get again
}
if (outfilledlen > 0) {
retains[OUTPORT_INDEX] = BUFFER_RETAIN_NOT_RETAIN;
} else {
retains[OUTPORT_INDEX] = BUFFER_RETAIN_GETAGAIN;
}
if(ret == ENCODE_SLICESIZE_OVERFLOW) {
LOGV("%s(), mix_video_encode returns MIX_RESULT_VIDEO_ENC_SLICESIZE_OVERFLOW"
, __func__);
oret = (OMX_ERRORTYPE)OMX_ErrorIntelExtSliceSizeOverflow;
}
#if SHOW_FPS
{
struct timeval t;
OMX_TICKS current_ts, interval_ts;
float current_fps, average_fps;
t.tv_sec = t.tv_usec = 0;
gettimeofday(&t, NULL);
current_ts =(nsecs_t)t.tv_sec * 1000000000 + (nsecs_t)t.tv_usec * 1000;
interval_ts = current_ts - lastTs;
lastTs = current_ts;
current_fps = (float)1000000000 / (float)interval_ts;
average_fps = (current_fps + lastFps) / 2;
lastFps = current_fps;
LOGD("FPS = %2.1f\n", average_fps);
}
#endif
out:
if(retains[OUTPORT_INDEX] != BUFFER_RETAIN_GETAGAIN) {
buffers[OUTPORT_INDEX]->nFilledLen = outfilledlen;
buffers[OUTPORT_INDEX]->nTimeStamp = outtimestamp;
buffers[OUTPORT_INDEX]->nFlags = outflags;
LOGV("********** output buffer: len=%d, ts=%ld, flags=%x",
outfilledlen,
outtimestamp,
outflags);
}
if (retains[INPORT_INDEX] == BUFFER_RETAIN_NOT_RETAIN ||
retains[INPORT_INDEX] == BUFFER_RETAIN_ACCUMULATE ) {
mFrameInputCount ++;
}
if (retains[OUTPORT_INDEX] == BUFFER_RETAIN_NOT_RETAIN)
mFrameOutputCount ++;
LOGV_IF(oret == OMX_ErrorNone, "%s(),%d: exit, encode is done\n", __func__, __LINE__);
return oret;
}
OMX_ERRORTYPE OMXVideoEncoderH263::BuildHandlerList(void) {
OMXVideoEncoderBase::BuildHandlerList();
AddHandler(OMX_IndexParamVideoH263, GetParamVideoH263, SetParamVideoH263);
AddHandler(OMX_IndexParamVideoProfileLevelQuerySupported, GetParamVideoProfileLevelQuerySupported, SetParamVideoProfileLevelQuerySupported);
return OMX_ErrorNone;
}
OMX_ERRORTYPE OMXVideoEncoderH263::GetParamVideoProfileLevelQuerySupported(OMX_PTR pStructure) {
OMX_ERRORTYPE ret;
OMX_VIDEO_PARAM_PROFILELEVELTYPE *p = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pStructure;
CHECK_TYPE_HEADER(p);
CHECK_PORT_INDEX(p, OUTPORT_INDEX);
struct ProfileLevelTable {
OMX_U32 profile;
OMX_U32 level;
} plTable[] = {
{OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level45}
};
OMX_U32 count = sizeof(plTable)/sizeof(ProfileLevelTable);
CHECK_ENUMERATION_RANGE(p->nProfileIndex,count);
p->eProfile = plTable[p->nProfileIndex].profile;
p->eLevel = plTable[p->nProfileIndex].level;
return OMX_ErrorNone;
}
OMX_ERRORTYPE OMXVideoEncoderH263::SetParamVideoProfileLevelQuerySupported(OMX_PTR pStructure) {
LOGW("SetParamVideoH263ProfileLevel is not supported.");
return OMX_ErrorUnsupportedSetting;
}
OMX_ERRORTYPE OMXVideoEncoderH263::GetParamVideoH263(OMX_PTR pStructure) {
OMX_ERRORTYPE ret;
OMX_VIDEO_PARAM_H263TYPE *p = (OMX_VIDEO_PARAM_H263TYPE *)pStructure;
CHECK_TYPE_HEADER(p);
CHECK_PORT_INDEX(p, OUTPORT_INDEX);
memcpy(p, &mParamH263, sizeof(*p));
return OMX_ErrorNone;
}
OMX_ERRORTYPE OMXVideoEncoderH263::SetParamVideoH263(OMX_PTR pStructure) {
OMX_ERRORTYPE ret;
OMX_VIDEO_PARAM_H263TYPE *p = (OMX_VIDEO_PARAM_H263TYPE *)pStructure;
CHECK_TYPE_HEADER(p);
CHECK_PORT_INDEX(p, OUTPORT_INDEX);
CHECK_SET_PARAM_STATE();
// TODO: do we need to check if port is enabled?
// TODO: see SetPortH263Param implementation - Can we make simple copy????
memcpy(&mParamH263, p, sizeof(mParamH263));
return OMX_ErrorNone;
}
DECLARE_OMX_COMPONENT("OMX.Intel.VideoEncoder.H263", "video_encoder.h263", OMXVideoEncoderH263);
| [
"quanganh2627@gmail.com"
] | quanganh2627@gmail.com |
1e7cd05b453a69bb1dd69f7dd03c281ba2351307 | 7f21ea6a664d025ad520eec7f789ff956c14238f | /Builder/main.cpp | f5354343c53a2691c591452f6b27c1cd390541f2 | [] | no_license | catcheroftime/DesignPatterns | 03505de8e7ef7a0a02366defce042d91aedcaaca | c8b8fee5624091513306689f58f0dda8c2772046 | refs/heads/master | 2023-04-30T10:14:25.242079 | 2021-05-25T09:46:34 | 2021-05-25T09:46:34 | 296,852,301 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 556 | cpp | #include <iostream>
#include "director.h"
using namespace std;
#ifndef SAFE_DELETE
#define SAFE_DELETE(p) { if(p){ delete p; p=nullptr;} }
#endif
int main()
{
Director director;
Builder6666 build6666;
Builder11199 build11199;
director.BuildUp(build6666);
director.BuildUp(build11199);
Computer *computer6666 = build6666.GetComputer();
Computer *computer11199 = build11199.GetComputer();
computer6666->show();
computer11199->show();
SAFE_DELETE(computer6666);
SAFE_DELETE(computer11199);
return 0;
}
| [
"1500098266@qq.com"
] | 1500098266@qq.com |
d179cee5f125be2ffc92b317bf818631636ae3a2 | fae551eb54ab3a907ba13cf38aba1db288708d92 | /chromeos/components/eche_app_ui/eche_uid_provider.cc | 8ad4cc63831540972c023ec65525b887122fc7d1 | [
"BSD-3-Clause"
] | permissive | xtblock/chromium | d4506722fc6e4c9bc04b54921a4382165d875f9a | 5fe0705b86e692c65684cdb067d9b452cc5f063f | refs/heads/main | 2023-04-26T18:34:42.207215 | 2021-05-27T04:45:24 | 2021-05-27T04:45:24 | 371,258,442 | 2 | 1 | BSD-3-Clause | 2021-05-27T05:36:28 | 2021-05-27T05:36:28 | null | UTF-8 | C++ | false | false | 3,670 | cc | // Copyright 2021 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 "chromeos/components/eche_app_ui/eche_uid_provider.h"
#include <base/base64.h>
#include <openssl/base64.h>
#include <cstring>
#include "base/check.h"
#include "chromeos/components/multidevice/logging/logging.h"
#include "components/prefs/pref_service.h"
#include "crypto/random.h"
namespace chromeos {
namespace eche_app {
const char kEcheAppSeedPref[] = "cros.echeapp.seed";
const size_t kSeedSizeInByte = 32;
EcheUidProvider::EcheUidProvider(PrefService* pref_service)
: pref_service_(pref_service) {}
EcheUidProvider::~EcheUidProvider() = default;
void EcheUidProvider::GetUid(
base::OnceCallback<void(const std::string&)> callback) {
if (!uid_.empty()) {
std::move(callback).Run(uid_);
return;
}
uint8_t public_key[ED25519_PUBLIC_KEY_LEN];
uint8_t private_key[ED25519_PRIVATE_KEY_LEN];
std::string pref_seed = pref_service_->GetString(kEcheAppSeedPref);
if (pref_seed.empty()) {
GenerateKeyPair(public_key, private_key);
} else {
absl::optional<std::vector<uint8_t>> result =
ConvertStringToBinary(pref_seed, kSeedSizeInByte);
if (!result) {
PA_LOG(WARNING) << "Invalid encoded string, regenerate the keypair.";
GenerateKeyPair(public_key, private_key);
} else {
DCHECK_EQ(kSeedSizeInByte, result->size());
ED25519_keypair_from_seed(public_key, private_key, result->data());
}
}
uid_ = ConvertBinaryToString(public_key);
std::move(callback).Run(uid_);
}
void EcheUidProvider::GenerateKeyPair(
uint8_t public_key[ED25519_PUBLIC_KEY_LEN],
uint8_t private_key[ED25519_PRIVATE_KEY_LEN]) {
ED25519_keypair(public_key, private_key);
// Store the seed (what RFC8032 calls a private key), which is the
// first 32 bytes of what BoringSSL calls the private key.
pref_service_->SetString(
kEcheAppSeedPref,
ConvertBinaryToString(base::make_span(private_key, kSeedSizeInByte)));
}
absl::optional<std::vector<uint8_t>> EcheUidProvider::ConvertStringToBinary(
base::StringPiece str,
size_t expected_len) {
std::vector<uint8_t> decoded_data(str.size());
size_t decoded_data_len = 0;
if (!EVP_DecodeBase64(
decoded_data.data(), &decoded_data_len, decoded_data.size(),
reinterpret_cast<const uint8_t*>(str.data()), str.size())) {
PA_LOG(ERROR) << "Attempting to decode string failed.";
return absl::nullopt;
}
if (decoded_data_len != expected_len) {
PA_LOG(ERROR) << "Expected length is not match.";
return absl::nullopt;
}
decoded_data.resize(decoded_data_len);
return decoded_data;
}
std::string EcheUidProvider::ConvertBinaryToString(
base::span<const uint8_t> src) {
// Use a constant-time implementation of base64 in BoringSSL instead of
// base::Base64Encode.
size_t encoded_data_len;
CHECK(EVP_EncodedLength(&encoded_data_len, src.size()) == 1);
std::vector<uint8_t> encoded_data(encoded_data_len);
size_t encoded_block_len =
EVP_EncodeBlock(encoded_data.data(), src.data(), src.size());
// The return value of EVP_EncodeBlock is not the same with the result of
// EVP_EncodedLength, we save the real size of EVP_EncodeBlock to string, not
// the size of buffer.
return std::string(reinterpret_cast<const char*>(encoded_data.data()),
encoded_block_len);
}
void EcheUidProvider::Bind(
mojo::PendingReceiver<mojom::UidGenerator> receiver) {
uid_receiver_.reset();
uid_receiver_.Bind(std::move(receiver));
}
} // namespace eche_app
} // namespace chromeos
| [
"chromium-scoped@luci-project-accounts.iam.gserviceaccount.com"
] | chromium-scoped@luci-project-accounts.iam.gserviceaccount.com |
0e31c9b2636ef1bb01082f8242c8f7add6f0bafa | b8499de1a793500b47f36e85828f997e3954e570 | /v2_3/build/Android/Preview/app/src/main/jni/_root.v2_accessor_Ali-8e553a3f.cpp | ba833fdec0d295d264b171b48b74c4770545f375 | [] | no_license | shrivaibhav/boysinbits | 37ccb707340a14f31bd57ea92b7b7ddc4859e989 | 04bb707691587b253abaac064317715adb9a9fe5 | refs/heads/master | 2020-03-24T05:22:21.998732 | 2018-07-26T20:06:00 | 2018-07-26T20:06:00 | 142,485,250 | 0 | 0 | null | 2018-07-26T20:03:22 | 2018-07-26T19:30:12 | C++ | UTF-8 | C++ | false | false | 6,393 | cpp | // This file was generated based on build/Android/Preview/cache/ux15/v2.unoproj.g.uno.
// WARNING: Changes might be lost if you edit this file directly.
#include <_root.v2_accessor_Ali-8e553a3f.h>
#include <Alive.ExampleApp.ProgramItem.h>
#include <Uno.Bool.h>
#include <Uno.Object.h>
#include <Uno.String.h>
#include <Uno.Type.h>
#include <Uno.UX.IPropertyListener.h>
#include <Uno.UX.PropertyObject.h>
#include <Uno.UX.Selector.h>
static uString* STRINGS[1];
static uType* TYPES[3];
namespace g{
// internal sealed class v2_accessor_Alive_ExampleApp_ProgramItem_Time :41
// {
// static generated v2_accessor_Alive_ExampleApp_ProgramItem_Time() :41
static void v2_accessor_Alive_ExampleApp_ProgramItem_Time__cctor__fn(uType* __type)
{
v2_accessor_Alive_ExampleApp_ProgramItem_Time::Singleton_ = v2_accessor_Alive_ExampleApp_ProgramItem_Time::New1();
v2_accessor_Alive_ExampleApp_ProgramItem_Time::_name_ = ::g::Uno::UX::Selector__op_Implicit1(::STRINGS[0/*"Time"*/]);
}
static void v2_accessor_Alive_ExampleApp_ProgramItem_Time_build(uType* type)
{
::STRINGS[0] = uString::Const("Time");
::TYPES[0] = ::g::Alive::ExampleApp::ProgramItem_typeof();
::TYPES[1] = ::g::Uno::String_typeof();
::TYPES[2] = ::g::Uno::Type_typeof();
type->SetFields(0,
::g::Uno::UX::PropertyAccessor_typeof(), (uintptr_t)&v2_accessor_Alive_ExampleApp_ProgramItem_Time::Singleton_, uFieldFlagsStatic,
::g::Uno::UX::Selector_typeof(), (uintptr_t)&v2_accessor_Alive_ExampleApp_ProgramItem_Time::_name_, uFieldFlagsStatic);
}
::g::Uno::UX::PropertyAccessor_type* v2_accessor_Alive_ExampleApp_ProgramItem_Time_typeof()
{
static uSStrong< ::g::Uno::UX::PropertyAccessor_type*> type;
if (type != NULL) return type;
uTypeOptions options;
options.BaseDefinition = ::g::Uno::UX::PropertyAccessor_typeof();
options.FieldCount = 2;
options.ObjectSize = sizeof(v2_accessor_Alive_ExampleApp_ProgramItem_Time);
options.TypeSize = sizeof(::g::Uno::UX::PropertyAccessor_type);
type = (::g::Uno::UX::PropertyAccessor_type*)uClassType::New("v2_accessor_Alive_ExampleApp_ProgramItem_Time", options);
type->fp_build_ = v2_accessor_Alive_ExampleApp_ProgramItem_Time_build;
type->fp_ctor_ = (void*)v2_accessor_Alive_ExampleApp_ProgramItem_Time__New1_fn;
type->fp_cctor_ = v2_accessor_Alive_ExampleApp_ProgramItem_Time__cctor__fn;
type->fp_GetAsObject = (void(*)(::g::Uno::UX::PropertyAccessor*, ::g::Uno::UX::PropertyObject*, uObject**))v2_accessor_Alive_ExampleApp_ProgramItem_Time__GetAsObject_fn;
type->fp_get_Name = (void(*)(::g::Uno::UX::PropertyAccessor*, ::g::Uno::UX::Selector*))v2_accessor_Alive_ExampleApp_ProgramItem_Time__get_Name_fn;
type->fp_get_PropertyType = (void(*)(::g::Uno::UX::PropertyAccessor*, uType**))v2_accessor_Alive_ExampleApp_ProgramItem_Time__get_PropertyType_fn;
type->fp_SetAsObject = (void(*)(::g::Uno::UX::PropertyAccessor*, ::g::Uno::UX::PropertyObject*, uObject*, uObject*))v2_accessor_Alive_ExampleApp_ProgramItem_Time__SetAsObject_fn;
type->fp_get_SupportsOriginSetter = (void(*)(::g::Uno::UX::PropertyAccessor*, bool*))v2_accessor_Alive_ExampleApp_ProgramItem_Time__get_SupportsOriginSetter_fn;
return type;
}
// public generated v2_accessor_Alive_ExampleApp_ProgramItem_Time() :41
void v2_accessor_Alive_ExampleApp_ProgramItem_Time__ctor_1_fn(v2_accessor_Alive_ExampleApp_ProgramItem_Time* __this)
{
__this->ctor_1();
}
// public override sealed object GetAsObject(Uno.UX.PropertyObject obj) :47
void v2_accessor_Alive_ExampleApp_ProgramItem_Time__GetAsObject_fn(v2_accessor_Alive_ExampleApp_ProgramItem_Time* __this, ::g::Uno::UX::PropertyObject* obj, uObject** __retval)
{
uStackFrame __("v2_accessor_Alive_ExampleApp_ProgramItem_Time", "GetAsObject(Uno.UX.PropertyObject)");
return *__retval = uPtr(uCast< ::g::Alive::ExampleApp::ProgramItem*>(obj, ::TYPES[0/*Alive.ExampleApp.ProgramItem*/]))->Time(), void();
}
// public override sealed Uno.UX.Selector get_Name() :44
void v2_accessor_Alive_ExampleApp_ProgramItem_Time__get_Name_fn(v2_accessor_Alive_ExampleApp_ProgramItem_Time* __this, ::g::Uno::UX::Selector* __retval)
{
return *__retval = v2_accessor_Alive_ExampleApp_ProgramItem_Time::_name_, void();
}
// public generated v2_accessor_Alive_ExampleApp_ProgramItem_Time New() :41
void v2_accessor_Alive_ExampleApp_ProgramItem_Time__New1_fn(v2_accessor_Alive_ExampleApp_ProgramItem_Time** __retval)
{
*__retval = v2_accessor_Alive_ExampleApp_ProgramItem_Time::New1();
}
// public override sealed Uno.Type get_PropertyType() :46
void v2_accessor_Alive_ExampleApp_ProgramItem_Time__get_PropertyType_fn(v2_accessor_Alive_ExampleApp_ProgramItem_Time* __this, uType** __retval)
{
return *__retval = ::TYPES[1/*string*/], void();
}
// public override sealed void SetAsObject(Uno.UX.PropertyObject obj, object v, Uno.UX.IPropertyListener origin) :48
void v2_accessor_Alive_ExampleApp_ProgramItem_Time__SetAsObject_fn(v2_accessor_Alive_ExampleApp_ProgramItem_Time* __this, ::g::Uno::UX::PropertyObject* obj, uObject* v, uObject* origin)
{
uStackFrame __("v2_accessor_Alive_ExampleApp_ProgramItem_Time", "SetAsObject(Uno.UX.PropertyObject,object,Uno.UX.IPropertyListener)");
uPtr(uCast< ::g::Alive::ExampleApp::ProgramItem*>(obj, ::TYPES[0/*Alive.ExampleApp.ProgramItem*/]))->SetTime(uCast<uString*>(v, ::TYPES[1/*string*/]), origin);
}
// public override sealed bool get_SupportsOriginSetter() :49
void v2_accessor_Alive_ExampleApp_ProgramItem_Time__get_SupportsOriginSetter_fn(v2_accessor_Alive_ExampleApp_ProgramItem_Time* __this, bool* __retval)
{
return *__retval = true, void();
}
uSStrong< ::g::Uno::UX::PropertyAccessor*> v2_accessor_Alive_ExampleApp_ProgramItem_Time::Singleton_;
::g::Uno::UX::Selector v2_accessor_Alive_ExampleApp_ProgramItem_Time::_name_;
// public generated v2_accessor_Alive_ExampleApp_ProgramItem_Time() [instance] :41
void v2_accessor_Alive_ExampleApp_ProgramItem_Time::ctor_1()
{
ctor_();
}
// public generated v2_accessor_Alive_ExampleApp_ProgramItem_Time New() [static] :41
v2_accessor_Alive_ExampleApp_ProgramItem_Time* v2_accessor_Alive_ExampleApp_ProgramItem_Time::New1()
{
v2_accessor_Alive_ExampleApp_ProgramItem_Time* obj1 = (v2_accessor_Alive_ExampleApp_ProgramItem_Time*)uNew(v2_accessor_Alive_ExampleApp_ProgramItem_Time_typeof());
obj1->ctor_1();
return obj1;
}
// }
} // ::g
| [
"shubhamanandoist@gmail.com"
] | shubhamanandoist@gmail.com |
47a518469ba143b9cc5e812d8ceb54ae5466828f | 994c927f5085b1407940d27075e8a2f5b4073427 | /PixNet/Main.cpp | f36141042ba19ee2192fa6e91a849303c2104407 | [
"MIT"
] | permissive | jizhihang/PixNet | e5df3d7436a1ad585f59b458c8263095c18c4fd8 | d3c913b0cdbfb9e3d5d75fbb1913ed278ab83cf8 | refs/heads/master | 2021-01-13T08:59:51.216541 | 2016-02-04T05:02:19 | 2016-02-04T05:02:19 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 16,960 | cpp | #include <iostream>
#include <sstream>
#include <fstream>
#include <string>
#include <vector>
#include<math.h>
#include<conio.h> //to make the output console wait
#include <time.h> //to show time
#include<cmath>
#include "general_header.h"
#include "pixnet_header.h"
#include "matlab_header.h"
using namespace std;
int main(int argc, char** argv)
{
///////////////////////////////////////////////////////////////////////Defining variables////////////////////////////////////////////////////////////////
time_t rawtime;
int knn=100;
int N1 = stoi( argv[1] );
int N2 = stoi( argv[2] );
int M = stoi( argv[3] );
int DB1 = stoi( argv[4] );
int num_class = stoi( argv[5] );
float L = stoi( argv[6] );
int pooling=0; // pooling=0 is for sum pooling and pooling=1 is for max pooling
string seg_level=argv[7];
string DB_name=argv[8];
string Feature=argv[9];
float **F1=DynamicArray2D<float>(N1, M);
float **F2=DynamicArray2D<float>(N2, M);
////--only for network creation--for using class similarity--this is used.
int **label1=DynamicArray2D<int>(DB1, num_class);
int **sup_loc1=DynamicArray2D<int>(N1, 2);
//For network creation only
int max_regions1=stoi( argv[10] );
int N_conn=stoi( argv[11] );;
int M_size= N1*50; //make sure the size N1*50 is safe. /////////MAYBE GIVE THIS AS INPUT!!!!!!!!!!!!!!!!!!!!!!!!
int **border1=DynamicArray2D<int>(N1, max_regions1);
int **loc1=DynamicArray2D<int>(DB1,max_regions1);
int *num_regions1=DynamicArray1D<int>(DB1);
//for Ncut only
int num_comm=stoi( argv[12] ); ;
//for Hist_image
int knn_consider=stoi( argv[13] );;
int DB2=stoi( argv[14] );;
int max_regions2=stoi( argv[15] );
int** border2=DynamicArray2D<int>(N2,max_regions2);
int** sup_loc2=DynamicArray2D<int>(N2,2);
int** loc2=DynamicArray2D<int>(DB2, max_regions2);
int *num_regions2=DynamicArray1D<int>(DB2);
time (&rawtime);
cout<<"--Done with defining variables--The time is "<<ctime (&rawtime);
///////////////////////////////////////////////////////////////////////Reading in values/////////////////////////////////////////////////////////////////
string address="C:/Users/Niloufar/Desktop/SemanticMapping-P3/transfer_C/";
string M_string;
ostringstream convert;
convert << M;
M_string=convert.str();
string address_feature=address+"/"+DB_name+"/"+Feature+"/"+"input"+"/"+"q"+seg_level+"_k"+ M_string;
string address_label=address+"/"+DB_name+"/"+"labels_train.txt";
string address_region=address+"/"+DB_name+"/"+"q"+seg_level;
string temp_address;
////F1
temp_address=address_feature+"/"+"F_train.txt";
read_file_2D<float>(temp_address, F1, N1, M);
temp_address=address_feature+"/"+"F_train.bin";
WriteToBinFile_2D<float>(F1, temp_address, N1, M);
//temp_address=address_feature+"/"+"F_train.bin";
//ReadFromBinFile_2D<float>(F1, temp_address, N1, M);
////F2
temp_address=address_feature+"/"+"F_test.txt";
read_file_2D<float>(temp_address, F2, N2, M);
temp_address=address_feature+"/"+"F_test.bin";
WriteToBinFile_2D<float>(F2, temp_address, N2, M);
//temp_address=address_feature+"/"+"F_test.bin";
//ReadFromBinFile_2D<float>(F2, temp_address, N2, M);
////label1
read_file_2D<int>(address_label, label1, DB1, num_class);
temp_address=address_feature+"/"+"labels_train.bin";
WriteToBinFile_2D<int>(label1, temp_address, DB1, num_class);
//temp_address=address_feature+"/"+"labels_train.bin";
//ReadFromBinFile_2D<int>(label1, temp_address, DB1, num_class);
////label2-----Not used
////sup_loc1
temp_address=address_region+"/"+"sup_loc_train.txt";
read_file_2D<int>(temp_address, sup_loc1, N1, 2);
temp_address=address_region+"/"+"sup_loc_train.bin";
WriteToBinFile_2D<int>(sup_loc1, temp_address, N1, 2);
//temp_address=address_region+"/"+"sup_loc_train.bin";
//ReadFromBinFile_2D<int>(sup_loc1, temp_address, N1, 2);
////sup_loc2
temp_address=address_region+"/"+"sup_loc_test.txt";
read_file_2D<int>(temp_address, sup_loc2, N2, 2);
temp_address=address_region+"/"+"sup_loc_test.bin";
WriteToBinFile_2D<int>(sup_loc2, temp_address, N2, 2);
//temp_address=address_region+"/"+"sup_loc_test.bin";
//ReadFromBinFile_2D<int>(sup_loc2, temp_address, N2, 2);
////border1
temp_address=address_region+"/"+"border_train.txt";
read_file_2D<int>(temp_address, border1, N1, max_regions1);
temp_address=address_region+"/"+"border_train.bin";
WriteToBinFile_2D<int>(border1, temp_address, N1, max_regions1);
//temp_address=address_region+"/"+"border_train.bin";
//ReadFromBinFile_2D<int>(border1, temp_address, N1, max_regions1);
////border2
temp_address=address_region+"/"+"border_test.txt";
read_file_2D<int>(temp_address, border2, N2, max_regions2);
temp_address=address_region+"/"+"border_test.bin";
WriteToBinFile_2D<int>(border2, temp_address, N2, max_regions2);
//temp_address=address_region+"/"+"border_test.bin";
//ReadFromBinFile_2D<int>(border2, temp_address, N2, max_regions2);
////loc1
temp_address=address_region+"/"+"loc_train.txt";
read_file_2D<int>(temp_address, loc1, DB1, max_regions1);
temp_address=address_region+"/"+"loc_train.bin";
WriteToBinFile_2D<int>(loc1, temp_address, DB1, max_regions1);
//temp_address=address_region+"/"+"loc_train.bin";
//ReadFromBinFile_2D<int>(loc1, temp_address, DB1, max_regions1);
////loc2
temp_address=address_region+"/"+"loc_test.txt";
read_file_2D<int>(temp_address, loc2, DB2, max_regions2);
temp_address=address_region+"/"+"loc_test.bin";
WriteToBinFile_2D<int>(loc2, temp_address, DB2, max_regions2);
//temp_address=address_region+"/"+"loc_test.bin";
//ReadFromBinFile_2D<int>(loc2, temp_address, DB2, max_regions2);
////num_regions1
temp_address=address_region+"/"+"num_regions_train.txt";
read_file_1D<int>(temp_address, num_regions1, DB1);
temp_address=address_region+"/"+"num_regions_train.bin";
WriteToBinFile_1D<int>(num_regions1, temp_address, DB1);
//temp_address=address_region+"/"+"num_regions_train.bin";
//ReadFromBinFile_1D<int>(num_regions1, temp_address, DB1);
////num_regions2
temp_address=address_region+"/"+"num_regions_test.txt";
read_file_1D<int>(temp_address, num_regions2, DB2);
temp_address=address_region+"/"+"num_regions_test.bin";
WriteToBinFile_1D<int>(num_regions2, temp_address, DB2);
//temp_address=address_region+"/"+"num_regions_test.bin";
//ReadFromBinFile_1D<int>(num_regions2, temp_address, DB2);
cout<<"M="<<M<<" and "<<"N1= "<<N1<< " and DB1= "<<DB1<<" and "<<"N2= "<<N2<< " and DB2= "<<DB2<<endl;
time (&rawtime);
cout<<"--Done with reading--The time is "<<ctime (&rawtime);
///////////////////////////////////////////////////////////////////////Searching/////////////////////////////////////////////////////////////////////
//Note: Indeces start from zero.
float **val=DynamicArray2D<float>(N1, knn);
int **ind=DynamicArray2D<int>(N1, knn);
knnSearch_wo_classSimilarity(F1, N1, F1, N1, M, knn, val, ind);
/////kdtreeSearch_wo_classSimilarity(F1, N1, F1, N1, M, knn, val, ind); //--knnSearch using kdtree
write_file_2D<int>("ind.txt", ind, N1, knn);
write_file_2D<float>("val.txt", val, N1, knn);
temp_address=address_region+"/"+"ind.bin";
ReadFromBinFile_2D<int>(ind, temp_address, N1, knn);
temp_address=address_region+"/"+"val.bin";
ReadFromBinFile_2D<float>(val, temp_address, N1, knn);
time (&rawtime);
cout<<"--Done with searching--The time is "<<ctime (&rawtime);
float** val_sim=DynamicArray2D<float>(N1,knn);
int** ind_sim=DynamicArray2D<int>(N1,knn);
//add_class_similarity(val, ind, N1, knn, sup_loc1, label1, DB1, num_class, L, val_sim, ind_sim);
knnSearch_w_classSimilarity(F1, N1, M, label1, DB1, num_class, sup_loc1, knn, L, val_sim, ind_sim);
write_file_2D<int>("ind_sim.txt", ind_sim, N1, knn);
write_file_2D<float>("val_sim.txt", val_sim, N1, knn);
read_file_2D<int>("ind_sim.txt", ind_sim, N1, knn);
read_file_2D<float>("val_sim.txt", val_sim, N1, knn);
time (&rawtime);
cout<<"--Done with class_sim--The time is "<<ctime (&rawtime);
//////////////////////////////////////////////////////Network Creation///////////////////////////////////////////////////////////////////////
int M_nonZ_size=0;
int *row=DynamicArray1D<int>(M_size);
int *col=DynamicArray1D<int>(M_size);
float *weight=DynamicArray1D<float>(M_size);
row=init_array1D<int>(row, M_size, -1);
col=init_array1D<int>(col, M_size, -1);
weight=init_array1D<float>(weight, M_size, 0);
////For accounting for similarity
M_nonZ_size=weighted_network(F1, N1, M, ind_sim, val_sim, knn, border1, loc1, num_regions1, N_conn, DB1, max_regions1, row, col, weight, M_size);
cout<<endl<<"M_nonZ_size = "<<M_nonZ_size<<endl<<endl;
FreeDynamicArray2D<int>(label1);
FreeDynamicArray2D<float>(val);
FreeDynamicArray2D<int>(ind);
FreeDynamicArray2D<float>(val_sim);
FreeDynamicArray2D<int>(ind_sim);
write_file_1D<int>("row.txt", row, M_size);
write_file_1D<int>("col.txt", col, M_size);
write_file_1D<float>("weight.txt", weight, M_size);
time (&rawtime);
cout<<"--Done with creating Network--The time is "<<ctime (&rawtime);
///////////////////////////////////////Transfer Network to MATLAB-perform NCut and import results from Matlab////////////////////////////////////////////
int *net_part= DynamicArray1D<int>(N1);
MatlabType matlab;
//open matlab
matlab.MatlabOpen();
matlab.MalabCCC();
//send row
matlab.CToMatlab(row, M_size, "row");
//send col
matlab.CToMatlab(col, M_size, "col");
//send weight
matlab.CToMatlab(weight, M_size, "weight");
//send num_comm
double *temp_num_comm=DynamicArray1D<double>(1);
temp_num_comm=init_array1D<double>(temp_num_comm,1,num_comm);
matlab.CToMatlab(temp_num_comm, 1, "C");
//send N
double *temp_N=DynamicArray1D<double>(1);
temp_num_comm=init_array1D<double>(temp_N,1,N1);
matlab.CToMatlab(temp_N, 1, "N");
//send M_nonZ_size
double *temp_M_nonZ_size=DynamicArray1D<double>(1);
temp_num_comm=init_array1D<double>(temp_M_nonZ_size,1,M_nonZ_size);
matlab.CToMatlab(temp_M_nonZ_size, 1, "S");
//send commands to matlab
matlab.MatlabCommand("cd E:/school/Segmentation/Community_graph");
matlab.MatlabCommand("net_part=Ncut_C(row, col, weight, N, C, S)"); // N=num_nodes C=num_comm and S=M_nonZ_size
//get variables from matlab
matlab.MatlabToC<int>("net_part", net_part, N1);
//closing the matlab
matlab.MatlabClose();
///////IF WANT TO READ "net_part" FROM TEXT FILE///////
//address_feature=address+"/"+DB_name+"/"+Feature+"/"+"input"+"/"+"q"+seg_level+"_k"+ M_string;
//temp_address=address_feature+"/"+ "Lonly_shared_labels/" + "net_part_100.txt";
//read_file_1D<int>(temp_address, net_part, N1);
//for (int i=0;i<5;i++)
// cout<<"i= "<<i<<" ---- net_part[i]= "<<net_part[i]<<endl;
//time (&rawtime);
//cout<<"--Done with NCUT--The time is "<<ctime (&rawtime);
/////////////////////////////////////////////////////////////////Compute Comm_Relation/////////////////////////////////////////////////////////////
float **p_cc=DynamicArray2D<float>(num_comm,num_comm);
p_cc=init_array2D<float>(p_cc,num_comm,num_comm,0);
comm_Relation(net_part, num_comm, N1, row, col, M_nonZ_size, p_cc);
write_file_2D<float>("p_cc_100.txt", p_cc, num_comm, num_comm);
FreeDynamicArray1D<int>(row);
FreeDynamicArray1D<int>(col);
FreeDynamicArray1D<float>(weight);
///////IF WANT TO READ "pcc" FROM TEXT FILE///////
//address_feature=address+"/"+DB_name+"/"+Feature+"/"+"input"+"/"+"q"+seg_level+"_k"+ M_string;
//temp_address=address_feature+"/"+ "L2/" + "pcc_Ncut100_comm.txt";
//float **p_cc=DynamicArray2D<float>(num_comm,num_comm);
//p_cc=init_array2D<float>(p_cc,num_comm,num_comm,0);
//read_file_2D<float>(temp_address, p_cc, num_comm, num_comm);
////write_file_1D<int>("net_partt.txt", net_part, N1);
////write_file_2D<float>("p_cc.txt", p_cc, num_comm, num_comm);
/*time (&rawtime);
cout<<"--Done with COMM_Relation --The time is "<<ctime (&rawtime); */
/////////////////////////////////////////////////////////////////Compute Hist_train/////////////////////////////////////////////////////////////
////compute the neasrest neighbor indeces for train
float **val1=DynamicArray2D<float>(N1,knn);
int **ind1=DynamicArray2D<int>(N1,knn);
knnSearch_wo_classSimilarity(F1, N1, F1, N1, M, knn, val, ind);
//kdtreeSearch_wo_classSimilarity(F1, N1, F1, N1, M, knn, val1, ind1);
FreeDynamicArray2D<float>(val1);
//compute Hist_train
float** hist1=DynamicArray2D<float>(DB1, num_comm);
float** w1=DynamicArray2D<float>(N1, num_comm);
init_array2D<float>(w1, N1, num_comm, 0);
float** w11=DynamicArray2D<float>(N1, num_comm);
init_array2D<float>(w11, N1, num_comm, 0);
float** w12=DynamicArray2D<float>(N1, num_comm);
init_array2D<float>(w12, N1, num_comm, 0);
Hist_node(N1, sup_loc1, border1, loc1, net_part, w11, w12, w1, ind1, p_cc, knn_consider, num_comm, max_regions1);
//////writing hist_node to a file
address_feature=address+"/"+DB_name+"/"+Feature+"/"+"output"+"/"+"q"+seg_level+"_k"+ M_string;
temp_address=address_feature+"/"+ "hist_train_node_level.txt";
write_file_2D<float>(temp_address, w1, N1, num_comm);
cout<<"--Done with writing hist_train_node"<<endl;
FreeDynamicArray2D<float>(w1);
FreeDynamicArray2D<float>(w11);
FreeDynamicArray2D<float>(w12);
time (&rawtime);
std::cout<<"--Done with Hist_train--The time is "<<ctime (&rawtime)<<endl;
/////////////////////////////////////////////////////////////////Compute Hist_test/////////////////////////////////////////////////////////////
int *net_part=DynamicArray1D<int>(N1);
read_file_1D<int>("net_partt.txt",net_part,N1);
float **p_cc=DynamicArray2D<float>(num_comm,num_comm);
read_file_2D<float>("p_cc.txt",p_cc,num_comm,num_comm);
//compute the neasrest neighbor indeces for test
float **val2=DynamicArray2D<float>(N2,knn);
int **ind2=DynamicArray2D<int>(N2,knn);
kdtreeSearch_wo_classSimilarity(F1, N1, F2, N2, M, knn, val2, ind2);
cout<<"--Done with Search_test"<<endl;
FreeDynamicArray2D<float>(val2);
//compute Hist_test
float** hist2=DynamicArray2D<float>(DB2,num_comm);
float** w2=DynamicArray2D<float>(N2,num_comm);
init_array2D<float>(w2, N2, num_comm, 0);
float** w21=DynamicArray2D<float>(N2,num_comm);
init_array2D<float>(w21, N2, num_comm, 0);
float** w22=DynamicArray2D<float>(N2,num_comm);
init_array2D<float>(w22, N2, num_comm, 0);
Hist_node(N2, sup_loc2, border2, loc2, net_part, w21, w22, w2, ind2, p_cc, knn_consider, num_comm, max_regions2);
////writing hist_node to a file
address_feature=address+"/"+DB_name+"/"+Feature+"/"+"output"+"/"+"q"+seg_level+"_k"+ M_string;
temp_address=address_feature+"/"+ "hist_test_node_level.txt";
write_file_2D<float>(temp_address, w2, N2, num_comm);
cout<<"--Done with writing hist_test_node"<<endl;
Hist_image(DB2, num_regions2, loc2, w2, hist2, num_comm, pooling);
FreeDynamicArray2D<float>(w2);
FreeDynamicArray2D<float>(w21);
FreeDynamicArray2D<float>(w22);
time (&rawtime);
cout<<"--Done with Hist_test--The time is "<<ctime (&rawtime);
/////////////Writing Hist_train and Hist_test to txt files/////////
address_feature=address+"/"+DB_name+"/"+Feature+"/"+"output"+"/"+"q"+seg_level+"_k"+ M_string;
temp_address=address_feature+"/"+ "hist_train_sim_1.txt";
write_file_2D<float>(temp_address, hist1, DB1, num_comm);
cout<<"--Done with writing hist_train"<<endl;
temp_address=address_feature+"/"+ "hist_test_sim_1.txt";
write_file_2D<float>(temp_address, hist2, DB2, num_comm);
cout<<"--Done with writing hist_test"<<endl;
time (&rawtime);
cout<<"--Done with writing the data--The time is "<<ctime (&rawtime);
/////////////Free Memory/////////
FreeDynamicArray2D<float>(F1);
FreeDynamicArray2D<float>(F2);
FreeDynamicArray2D<int>(sup_loc1);
FreeDynamicArray2D<int>(border1);
FreeDynamicArray2D<int>(loc1);
FreeDynamicArray1D<int>(num_regions1);
FreeDynamicArray1D<int>(net_part);
FreeDynamicArray2D<float>(p_cc);
FreeDynamicArray2D<int>(ind1);
FreeDynamicArray2D<float>(hist1);
FreeDynamicArray2D<int>(border2);
FreeDynamicArray2D<int>(sup_loc2);
FreeDynamicArray2D<int>(loc2);
FreeDynamicArray1D<int>(num_regions2);
FreeDynamicArray2D<int>(ind2);
FreeDynamicArray2D<float>(hist2);
time (&rawtime);
cout<<"--Done with program--The time is "<<ctime (&rawtime)<<endl;
_getch();
return 0;
}
| [
"4rohanjain@gmail.com"
] | 4rohanjain@gmail.com |
06a87e2559bf08377134bb30e268130d0333fc8d | 879681c994f1ca9c8d2c905a4e5064997ad25a27 | /root-2.3.0/run/tutorials/multiphase/interFoam/laminar/capillaryRise/0.05/p | d170c971791c2401689b1ef525a997facdb0c89a | [] | no_license | MizuhaWatanabe/OpenFOAM-2.3.0-with-Ubuntu | 3828272d989d45fb020e83f8426b849e75560c62 | daeb870be81275e8a81f5cbac4ca1906a9bc69c0 | refs/heads/master | 2020-05-17T16:36:41.848261 | 2015-04-18T09:29:48 | 2015-04-18T09:29:48 | 34,159,882 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 86,364 | /*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 2.3.0 |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
location "0.05";
object p;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [1 -1 -2 0 0 0 0];
internalField nonuniform List<scalar>
8000
(
-0.252266
-0.252261
-0.252254
-0.252247
-0.252244
-0.252244
-0.252247
-0.252251
-0.252255
-0.252257
-0.252257
-0.252255
-0.252251
-0.252247
-0.252244
-0.252244
-0.252247
-0.252254
-0.252261
-0.252266
-0.75684
-0.756835
-0.756829
-0.756822
-0.756819
-0.756819
-0.756822
-0.756827
-0.756831
-0.756834
-0.756834
-0.756831
-0.756827
-0.756822
-0.756819
-0.756818
-0.756821
-0.756828
-0.756835
-0.756839
-1.26143
-1.26143
-1.26143
-1.26143
-1.26143
-1.26143
-1.26143
-1.26144
-1.26144
-1.26144
-1.26144
-1.26144
-1.26144
-1.26143
-1.26143
-1.26143
-1.26143
-1.26143
-1.26143
-1.26143
-1.76604
-1.76604
-1.76604
-1.76604
-1.76604
-1.76604
-1.76604
-1.76604
-1.76605
-1.76605
-1.76605
-1.76605
-1.76604
-1.76604
-1.76604
-1.76604
-1.76604
-1.76604
-1.76604
-1.76603
-2.27064
-2.27064
-2.27064
-2.27064
-2.27064
-2.27064
-2.27064
-2.27064
-2.27064
-2.27064
-2.27064
-2.27064
-2.27064
-2.27064
-2.27064
-2.27064
-2.27064
-2.27064
-2.27064
-2.27064
-2.77524
-2.77524
-2.77524
-2.77524
-2.77524
-2.77524
-2.77524
-2.77524
-2.77524
-2.77524
-2.77524
-2.77524
-2.77524
-2.77524
-2.77524
-2.77524
-2.77524
-2.77524
-2.77524
-2.77524
-3.27984
-3.27984
-3.27984
-3.27984
-3.27984
-3.27984
-3.27984
-3.27984
-3.27984
-3.27984
-3.27984
-3.27984
-3.27984
-3.27984
-3.27984
-3.27984
-3.27984
-3.27984
-3.27984
-3.27984
-3.78445
-3.78444
-3.78444
-3.78444
-3.78444
-3.78444
-3.78444
-3.78444
-3.78444
-3.78444
-3.78444
-3.78444
-3.78444
-3.78444
-3.78444
-3.78444
-3.78444
-3.78444
-3.78444
-3.78445
-4.28905
-4.28905
-4.28904
-4.28904
-4.28904
-4.28904
-4.28904
-4.28904
-4.28904
-4.28904
-4.28904
-4.28904
-4.28904
-4.28904
-4.28904
-4.28904
-4.28904
-4.28904
-4.28905
-4.28905
-4.79365
-4.79365
-4.79365
-4.79364
-4.79364
-4.79364
-4.79364
-4.79364
-4.79364
-4.79364
-4.79364
-4.79364
-4.79364
-4.79364
-4.79364
-4.79364
-4.79364
-4.79364
-4.79365
-4.79365
-5.29825
-5.29825
-5.29825
-5.29824
-5.29824
-5.29824
-5.29824
-5.29824
-5.29824
-5.29824
-5.29824
-5.29824
-5.29824
-5.29824
-5.29824
-5.29824
-5.29824
-5.29825
-5.29825
-5.29825
-5.80285
-5.80285
-5.80285
-5.80285
-5.80284
-5.80284
-5.80284
-5.80284
-5.80284
-5.80284
-5.80284
-5.80284
-5.80284
-5.80284
-5.80284
-5.80284
-5.80284
-5.80285
-5.80285
-5.80285
-6.30745
-6.30745
-6.30745
-6.30745
-6.30744
-6.30744
-6.30744
-6.30744
-6.30744
-6.30744
-6.30744
-6.30744
-6.30744
-6.30744
-6.30744
-6.30744
-6.30744
-6.30745
-6.30745
-6.30745
-6.81205
-6.81205
-6.81205
-6.81205
-6.81204
-6.81204
-6.81204
-6.81204
-6.81204
-6.81204
-6.81204
-6.81204
-6.81204
-6.81204
-6.81204
-6.81204
-6.81204
-6.81205
-6.81205
-6.81205
-7.31665
-7.31665
-7.31665
-7.31665
-7.31664
-7.31664
-7.31664
-7.31664
-7.31664
-7.31664
-7.31664
-7.31664
-7.31664
-7.31664
-7.31664
-7.31664
-7.31664
-7.31665
-7.31665
-7.31665
-7.82125
-7.82125
-7.82125
-7.82124
-7.82124
-7.82124
-7.82124
-7.82124
-7.82124
-7.82124
-7.82124
-7.82124
-7.82124
-7.82124
-7.82124
-7.82124
-7.82124
-7.82124
-7.82125
-7.82125
-8.32585
-8.32584
-8.32584
-8.32584
-8.32584
-8.32584
-8.32584
-8.32584
-8.32584
-8.32583
-8.32583
-8.32584
-8.32584
-8.32584
-8.32584
-8.32584
-8.32584
-8.32584
-8.32584
-8.32585
-8.83044
-8.83044
-8.83044
-8.83044
-8.83044
-8.83044
-8.83044
-8.83043
-8.83043
-8.83043
-8.83043
-8.83043
-8.83043
-8.83043
-8.83044
-8.83044
-8.83044
-8.83044
-8.83044
-8.83044
-9.33504
-9.33504
-9.33504
-9.33504
-9.33504
-9.33503
-9.33503
-9.33503
-9.33503
-9.33503
-9.33503
-9.33503
-9.33503
-9.33503
-9.33503
-9.33503
-9.33504
-9.33504
-9.33504
-9.33504
-9.83964
-9.83963
-9.83963
-9.83963
-9.83963
-9.83963
-9.83963
-9.83963
-9.83963
-9.83963
-9.83963
-9.83963
-9.83963
-9.83963
-9.83963
-9.83963
-9.83963
-9.83963
-9.83963
-9.83964
-10.3442
-10.3442
-10.3442
-10.3442
-10.3442
-10.3442
-10.3442
-10.3442
-10.3442
-10.3442
-10.3442
-10.3442
-10.3442
-10.3442
-10.3442
-10.3442
-10.3442
-10.3442
-10.3442
-10.3442
-10.8488
-10.8488
-10.8488
-10.8488
-10.8488
-10.8488
-10.8488
-10.8488
-10.8488
-10.8488
-10.8488
-10.8488
-10.8488
-10.8488
-10.8488
-10.8488
-10.8488
-10.8488
-10.8488
-10.8488
-11.3534
-11.3534
-11.3534
-11.3534
-11.3534
-11.3534
-11.3534
-11.3534
-11.3534
-11.3534
-11.3534
-11.3534
-11.3534
-11.3534
-11.3534
-11.3534
-11.3534
-11.3534
-11.3534
-11.3534
-11.858
-11.858
-11.858
-11.858
-11.858
-11.858
-11.858
-11.858
-11.858
-11.858
-11.858
-11.858
-11.858
-11.858
-11.858
-11.858
-11.858
-11.858
-11.858
-11.858
-12.3626
-12.3626
-12.3626
-12.3626
-12.3626
-12.3626
-12.3626
-12.3626
-12.3626
-12.3626
-12.3626
-12.3626
-12.3626
-12.3626
-12.3626
-12.3626
-12.3626
-12.3626
-12.3626
-12.3626
-12.8672
-12.8672
-12.8672
-12.8672
-12.8672
-12.8672
-12.8672
-12.8672
-12.8672
-12.8672
-12.8672
-12.8672
-12.8672
-12.8672
-12.8672
-12.8672
-12.8672
-12.8672
-12.8672
-12.8672
-13.3718
-13.3718
-13.3718
-13.3718
-13.3718
-13.3718
-13.3718
-13.3718
-13.3718
-13.3718
-13.3718
-13.3718
-13.3718
-13.3718
-13.3718
-13.3718
-13.3718
-13.3718
-13.3718
-13.3718
-13.8764
-13.8764
-13.8764
-13.8764
-13.8764
-13.8764
-13.8764
-13.8764
-13.8764
-13.8764
-13.8764
-13.8764
-13.8764
-13.8764
-13.8764
-13.8764
-13.8764
-13.8764
-13.8764
-13.8764
-14.381
-14.381
-14.381
-14.381
-14.381
-14.381
-14.381
-14.381
-14.381
-14.381
-14.381
-14.381
-14.381
-14.381
-14.381
-14.381
-14.381
-14.381
-14.381
-14.381
-14.8856
-14.8856
-14.8856
-14.8856
-14.8856
-14.8856
-14.8856
-14.8856
-14.8856
-14.8856
-14.8856
-14.8856
-14.8856
-14.8856
-14.8856
-14.8856
-14.8856
-14.8856
-14.8856
-14.8856
-15.3902
-15.3902
-15.3902
-15.3902
-15.3902
-15.3902
-15.3902
-15.3902
-15.3902
-15.3902
-15.3902
-15.3902
-15.3902
-15.3902
-15.3902
-15.3902
-15.3902
-15.3902
-15.3902
-15.3902
-15.8948
-15.8948
-15.8948
-15.8948
-15.8948
-15.8948
-15.8948
-15.8948
-15.8948
-15.8948
-15.8948
-15.8948
-15.8948
-15.8948
-15.8948
-15.8948
-15.8948
-15.8948
-15.8948
-15.8948
-16.3994
-16.3994
-16.3994
-16.3994
-16.3994
-16.3994
-16.3994
-16.3994
-16.3994
-16.3994
-16.3994
-16.3994
-16.3994
-16.3994
-16.3994
-16.3994
-16.3994
-16.3994
-16.3994
-16.3994
-16.904
-16.904
-16.904
-16.904
-16.904
-16.904
-16.904
-16.904
-16.904
-16.904
-16.904
-16.904
-16.904
-16.904
-16.904
-16.904
-16.904
-16.904
-16.904
-16.904
-17.4086
-17.4086
-17.4086
-17.4086
-17.4086
-17.4086
-17.4086
-17.4086
-17.4086
-17.4086
-17.4086
-17.4086
-17.4086
-17.4086
-17.4086
-17.4086
-17.4086
-17.4086
-17.4086
-17.4086
-17.9132
-17.9132
-17.9132
-17.9132
-17.9132
-17.9132
-17.9132
-17.9132
-17.9132
-17.9132
-17.9132
-17.9132
-17.9132
-17.9132
-17.9132
-17.9132
-17.9132
-17.9132
-17.9132
-17.9132
-18.4177
-18.4177
-18.4177
-18.4177
-18.4177
-18.4177
-18.4177
-18.4177
-18.4177
-18.4177
-18.4177
-18.4177
-18.4177
-18.4177
-18.4177
-18.4177
-18.4177
-18.4177
-18.4177
-18.4177
-18.9223
-18.9223
-18.9223
-18.9223
-18.9223
-18.9223
-18.9223
-18.9223
-18.9223
-18.9223
-18.9223
-18.9223
-18.9223
-18.9223
-18.9223
-18.9223
-18.9223
-18.9223
-18.9223
-18.9223
-19.4269
-19.4269
-19.4269
-19.4269
-19.4269
-19.4269
-19.4269
-19.4269
-19.4269
-19.4269
-19.4269
-19.4269
-19.4269
-19.4269
-19.4269
-19.4269
-19.4269
-19.4269
-19.4269
-19.4269
-19.9315
-19.9315
-19.9315
-19.9315
-19.9315
-19.9315
-19.9315
-19.9315
-19.9315
-19.9315
-19.9315
-19.9315
-19.9315
-19.9315
-19.9315
-19.9315
-19.9315
-19.9315
-19.9315
-19.9315
-20.4361
-20.4361
-20.4361
-20.4361
-20.4361
-20.4361
-20.4361
-20.4361
-20.4361
-20.4361
-20.4361
-20.4361
-20.4361
-20.4361
-20.4361
-20.4361
-20.4361
-20.4361
-20.4361
-20.4361
-20.9407
-20.9407
-20.9407
-20.9407
-20.9407
-20.9407
-20.9407
-20.9407
-20.9407
-20.9407
-20.9407
-20.9407
-20.9407
-20.9407
-20.9407
-20.9407
-20.9407
-20.9407
-20.9407
-20.9407
-21.4453
-21.4453
-21.4453
-21.4453
-21.4453
-21.4453
-21.4453
-21.4453
-21.4453
-21.4453
-21.4453
-21.4453
-21.4453
-21.4453
-21.4453
-21.4453
-21.4453
-21.4453
-21.4453
-21.4453
-21.9499
-21.9499
-21.9499
-21.9499
-21.9499
-21.9499
-21.9499
-21.9499
-21.9499
-21.9499
-21.9499
-21.9499
-21.9499
-21.9499
-21.9499
-21.9499
-21.9499
-21.9499
-21.9499
-21.9499
-22.4545
-22.4545
-22.4545
-22.4545
-22.4545
-22.4545
-22.4545
-22.4545
-22.4545
-22.4545
-22.4545
-22.4545
-22.4545
-22.4545
-22.4545
-22.4545
-22.4545
-22.4545
-22.4545
-22.4545
-22.9591
-22.9591
-22.9591
-22.9591
-22.9591
-22.9591
-22.9591
-22.9591
-22.9591
-22.9591
-22.9591
-22.9591
-22.9591
-22.9591
-22.9591
-22.9591
-22.9591
-22.9591
-22.9591
-22.9591
-23.4637
-23.4637
-23.4637
-23.4637
-23.4637
-23.4637
-23.4637
-23.4637
-23.4637
-23.4637
-23.4637
-23.4637
-23.4637
-23.4637
-23.4637
-23.4637
-23.4637
-23.4637
-23.4637
-23.4637
-23.9683
-23.9683
-23.9683
-23.9683
-23.9683
-23.9683
-23.9683
-23.9683
-23.9683
-23.9683
-23.9683
-23.9683
-23.9683
-23.9683
-23.9683
-23.9683
-23.9683
-23.9683
-23.9683
-23.9683
-24.4729
-24.4729
-24.4729
-24.4729
-24.4729
-24.4729
-24.4729
-24.4729
-24.4729
-24.4729
-24.4729
-24.4729
-24.4729
-24.4729
-24.4729
-24.4729
-24.4729
-24.4729
-24.4729
-24.4729
-24.9775
-24.9775
-24.9775
-24.9775
-24.9775
-24.9775
-24.9775
-24.9775
-24.9775
-24.9775
-24.9775
-24.9775
-24.9775
-24.9775
-24.9775
-24.9775
-24.9775
-24.9775
-24.9775
-24.9775
-25.4821
-25.4821
-25.4821
-25.4821
-25.4821
-25.4821
-25.4821
-25.4821
-25.4821
-25.4821
-25.4821
-25.4821
-25.4821
-25.4821
-25.4821
-25.4821
-25.4821
-25.4821
-25.4821
-25.4821
-25.9867
-25.9867
-25.9867
-25.9867
-25.9867
-25.9867
-25.9867
-25.9867
-25.9867
-25.9867
-25.9867
-25.9867
-25.9867
-25.9867
-25.9867
-25.9867
-25.9867
-25.9867
-25.9867
-25.9867
-26.4913
-26.4913
-26.4913
-26.4913
-26.4913
-26.4913
-26.4913
-26.4913
-26.4913
-26.4913
-26.4913
-26.4913
-26.4913
-26.4913
-26.4913
-26.4913
-26.4913
-26.4913
-26.4913
-26.4913
-26.9959
-26.9959
-26.9959
-26.9959
-26.9959
-26.9959
-26.9959
-26.9959
-26.9959
-26.9959
-26.9959
-26.9959
-26.9959
-26.9959
-26.9959
-26.9959
-26.9959
-26.9959
-26.9959
-26.9959
-27.5005
-27.5005
-27.5005
-27.5005
-27.5005
-27.5005
-27.5005
-27.5005
-27.5005
-27.5005
-27.5005
-27.5005
-27.5005
-27.5005
-27.5005
-27.5005
-27.5005
-27.5005
-27.5005
-27.5005
-28.005
-28.005
-28.005
-28.005
-28.005
-28.005
-28.005
-28.005
-28.005
-28.005
-28.005
-28.005
-28.005
-28.005
-28.005
-28.005
-28.005
-28.005
-28.005
-28.005
-28.5096
-28.5096
-28.5096
-28.5096
-28.5096
-28.5096
-28.5096
-28.5096
-28.5096
-28.5096
-28.5096
-28.5096
-28.5096
-28.5096
-28.5096
-28.5096
-28.5096
-28.5096
-28.5096
-28.5096
-29.0142
-29.0142
-29.0142
-29.0142
-29.0142
-29.0142
-29.0142
-29.0142
-29.0142
-29.0142
-29.0142
-29.0142
-29.0142
-29.0142
-29.0142
-29.0142
-29.0142
-29.0142
-29.0142
-29.0142
-29.5188
-29.5188
-29.5188
-29.5188
-29.5188
-29.5188
-29.5188
-29.5188
-29.5188
-29.5188
-29.5188
-29.5188
-29.5188
-29.5188
-29.5188
-29.5188
-29.5188
-29.5188
-29.5188
-29.5188
-30.0234
-30.0234
-30.0234
-30.0234
-30.0234
-30.0234
-30.0234
-30.0234
-30.0234
-30.0234
-30.0234
-30.0234
-30.0234
-30.0234
-30.0234
-30.0234
-30.0234
-30.0234
-30.0234
-30.0234
-30.528
-30.528
-30.528
-30.528
-30.528
-30.528
-30.528
-30.528
-30.528
-30.528
-30.528
-30.528
-30.528
-30.528
-30.528
-30.528
-30.528
-30.528
-30.528
-30.528
-31.0326
-31.0326
-31.0326
-31.0326
-31.0326
-31.0326
-31.0326
-31.0326
-31.0326
-31.0326
-31.0326
-31.0326
-31.0326
-31.0326
-31.0326
-31.0326
-31.0326
-31.0326
-31.0326
-31.0326
-31.5372
-31.5372
-31.5372
-31.5372
-31.5372
-31.5372
-31.5372
-31.5372
-31.5372
-31.5372
-31.5372
-31.5372
-31.5372
-31.5372
-31.5372
-31.5372
-31.5372
-31.5372
-31.5372
-31.5372
-32.0418
-32.0418
-32.0418
-32.0418
-32.0418
-32.0418
-32.0418
-32.0418
-32.0418
-32.0418
-32.0418
-32.0418
-32.0418
-32.0418
-32.0418
-32.0418
-32.0418
-32.0418
-32.0418
-32.0418
-32.5464
-32.5464
-32.5464
-32.5464
-32.5464
-32.5464
-32.5464
-32.5464
-32.5464
-32.5464
-32.5464
-32.5464
-32.5464
-32.5464
-32.5464
-32.5464
-32.5464
-32.5464
-32.5464
-32.5464
-33.051
-33.051
-33.051
-33.051
-33.051
-33.051
-33.051
-33.051
-33.051
-33.051
-33.051
-33.051
-33.051
-33.051
-33.051
-33.051
-33.051
-33.051
-33.051
-33.051
-33.5556
-33.5556
-33.5556
-33.5556
-33.5556
-33.5556
-33.5556
-33.5556
-33.5556
-33.5556
-33.5556
-33.5556
-33.5556
-33.5556
-33.5556
-33.5556
-33.5556
-33.5556
-33.5556
-33.5556
-34.0602
-34.0602
-34.0602
-34.0602
-34.0602
-34.0602
-34.0602
-34.0602
-34.0602
-34.0602
-34.0602
-34.0602
-34.0602
-34.0602
-34.0602
-34.0602
-34.0602
-34.0602
-34.0602
-34.0602
-34.5648
-34.5648
-34.5648
-34.5648
-34.5648
-34.5648
-34.5648
-34.5648
-34.5648
-34.5648
-34.5648
-34.5648
-34.5648
-34.5648
-34.5648
-34.5648
-34.5648
-34.5648
-34.5648
-34.5648
-35.0694
-35.0694
-35.0694
-35.0694
-35.0694
-35.0694
-35.0694
-35.0694
-35.0694
-35.0694
-35.0694
-35.0694
-35.0694
-35.0694
-35.0694
-35.0694
-35.0694
-35.0694
-35.0694
-35.0694
-35.574
-35.574
-35.574
-35.574
-35.574
-35.574
-35.574
-35.574
-35.574
-35.574
-35.574
-35.574
-35.574
-35.574
-35.574
-35.574
-35.574
-35.574
-35.574
-35.574
-36.0786
-36.0786
-36.0786
-36.0786
-36.0786
-36.0786
-36.0786
-36.0786
-36.0786
-36.0786
-36.0786
-36.0786
-36.0786
-36.0786
-36.0786
-36.0786
-36.0786
-36.0786
-36.0786
-36.0786
-36.5831
-36.5831
-36.5831
-36.5831
-36.5831
-36.5831
-36.5831
-36.5831
-36.5831
-36.5831
-36.5831
-36.5831
-36.5831
-36.5831
-36.5831
-36.5831
-36.5831
-36.5831
-36.5831
-36.5831
-37.0877
-37.0877
-37.0877
-37.0877
-37.0877
-37.0877
-37.0877
-37.0877
-37.0877
-37.0877
-37.0877
-37.0877
-37.0877
-37.0877
-37.0877
-37.0877
-37.0877
-37.0877
-37.0877
-37.0877
-37.5923
-37.5923
-37.5923
-37.5923
-37.5923
-37.5923
-37.5923
-37.5923
-37.5923
-37.5923
-37.5923
-37.5923
-37.5923
-37.5923
-37.5923
-37.5923
-37.5923
-37.5923
-37.5923
-37.5923
-38.0969
-38.0969
-38.0969
-38.0969
-38.0969
-38.0969
-38.0969
-38.0969
-38.0969
-38.0969
-38.0969
-38.0969
-38.0969
-38.0969
-38.0969
-38.0969
-38.0969
-38.0969
-38.0969
-38.0969
-38.6015
-38.6015
-38.6015
-38.6015
-38.6015
-38.6015
-38.6015
-38.6015
-38.6015
-38.6015
-38.6015
-38.6015
-38.6015
-38.6015
-38.6015
-38.6015
-38.6015
-38.6015
-38.6015
-38.6015
-39.1061
-39.1061
-39.1061
-39.1061
-39.1061
-39.1061
-39.1061
-39.1061
-39.1061
-39.1061
-39.1061
-39.1061
-39.1061
-39.1061
-39.1061
-39.1061
-39.1061
-39.1061
-39.1061
-39.1061
-39.6107
-39.6107
-39.6107
-39.6107
-39.6107
-39.6107
-39.6107
-39.6107
-39.6107
-39.6107
-39.6107
-39.6107
-39.6107
-39.6107
-39.6107
-39.6107
-39.6107
-39.6107
-39.6107
-39.6107
-40.1153
-40.1153
-40.1153
-40.1153
-40.1153
-40.1153
-40.1153
-40.1153
-40.1153
-40.1153
-40.1153
-40.1153
-40.1153
-40.1153
-40.1153
-40.1153
-40.1153
-40.1153
-40.1153
-40.1153
-40.6199
-40.6199
-40.6199
-40.6199
-40.6199
-40.6199
-40.6199
-40.6199
-40.6199
-40.6199
-40.6199
-40.6199
-40.6199
-40.6199
-40.6199
-40.6199
-40.6199
-40.6199
-40.6199
-40.6199
-41.1245
-41.1245
-41.1245
-41.1245
-41.1245
-41.1245
-41.1245
-41.1245
-41.1245
-41.1245
-41.1245
-41.1245
-41.1245
-41.1245
-41.1245
-41.1245
-41.1245
-41.1245
-41.1245
-41.1245
-41.6291
-41.6291
-41.6291
-41.6291
-41.6291
-41.6291
-41.6291
-41.6291
-41.6291
-41.6291
-41.6291
-41.6291
-41.6291
-41.6291
-41.6291
-41.6291
-41.6291
-41.6291
-41.6291
-41.6291
-42.1337
-42.1337
-42.1337
-42.1337
-42.1337
-42.1337
-42.1337
-42.1337
-42.1337
-42.1337
-42.1337
-42.1337
-42.1337
-42.1337
-42.1337
-42.1337
-42.1337
-42.1337
-42.1337
-42.1337
-42.6383
-42.6383
-42.6383
-42.6383
-42.6383
-42.6383
-42.6383
-42.6383
-42.6383
-42.6383
-42.6383
-42.6383
-42.6383
-42.6383
-42.6383
-42.6383
-42.6383
-42.6383
-42.6383
-42.6383
-43.1429
-43.1429
-43.1429
-43.1429
-43.1429
-43.1429
-43.1429
-43.1429
-43.1429
-43.1429
-43.1429
-43.1429
-43.1429
-43.1429
-43.1429
-43.1429
-43.1429
-43.1429
-43.1429
-43.1429
-43.6475
-43.6475
-43.6475
-43.6475
-43.6475
-43.6475
-43.6475
-43.6475
-43.6475
-43.6475
-43.6475
-43.6475
-43.6475
-43.6475
-43.6475
-43.6475
-43.6475
-43.6475
-43.6475
-43.6475
-44.1521
-44.1521
-44.1521
-44.1521
-44.1521
-44.1521
-44.1521
-44.1521
-44.1521
-44.1521
-44.1521
-44.1521
-44.1521
-44.1521
-44.1521
-44.1521
-44.1521
-44.1521
-44.1521
-44.1521
-44.6567
-44.6567
-44.6567
-44.6567
-44.6567
-44.6567
-44.6567
-44.6567
-44.6567
-44.6567
-44.6567
-44.6567
-44.6567
-44.6567
-44.6567
-44.6567
-44.6567
-44.6567
-44.6567
-44.6567
-45.1613
-45.1613
-45.1613
-45.1613
-45.1613
-45.1613
-45.1613
-45.1613
-45.1613
-45.1613
-45.1613
-45.1613
-45.1613
-45.1613
-45.1613
-45.1613
-45.1613
-45.1613
-45.1613
-45.1613
-45.6659
-45.6659
-45.6659
-45.6659
-45.6659
-45.6659
-45.6659
-45.6659
-45.6659
-45.6659
-45.6659
-45.6659
-45.6659
-45.6659
-45.6659
-45.6659
-45.6659
-45.6659
-45.6659
-45.6659
-46.1705
-46.1705
-46.1705
-46.1705
-46.1705
-46.1705
-46.1705
-46.1705
-46.1705
-46.1705
-46.1705
-46.1705
-46.1705
-46.1705
-46.1705
-46.1705
-46.1705
-46.1705
-46.1705
-46.1705
-46.6751
-46.6751
-46.6751
-46.6751
-46.6751
-46.6751
-46.6751
-46.6751
-46.6751
-46.6751
-46.6751
-46.6751
-46.6751
-46.6751
-46.6751
-46.6751
-46.6751
-46.6751
-46.6751
-46.6751
-47.1797
-47.1797
-47.1797
-47.1797
-47.1797
-47.1797
-47.1797
-47.1797
-47.1797
-47.1797
-47.1797
-47.1797
-47.1797
-47.1797
-47.1797
-47.1797
-47.1797
-47.1797
-47.1797
-47.1797
-47.6843
-47.6843
-47.6843
-47.6843
-47.6843
-47.6843
-47.6843
-47.6843
-47.6843
-47.6843
-47.6843
-47.6843
-47.6843
-47.6843
-47.6843
-47.6843
-47.6843
-47.6843
-47.6843
-47.6843
-48.1889
-48.1889
-48.1889
-48.1889
-48.1889
-48.1889
-48.1889
-48.1889
-48.1889
-48.1889
-48.1889
-48.1889
-48.1889
-48.1889
-48.1889
-48.1889
-48.1889
-48.1889
-48.1889
-48.1889
-48.6934
-48.6934
-48.6934
-48.6934
-48.6934
-48.6934
-48.6934
-48.6934
-48.6934
-48.6934
-48.6934
-48.6934
-48.6934
-48.6934
-48.6934
-48.6934
-48.6934
-48.6934
-48.6934
-48.6934
-49.198
-49.198
-49.198
-49.198
-49.198
-49.198
-49.198
-49.198
-49.198
-49.198
-49.198
-49.198
-49.198
-49.198
-49.198
-49.198
-49.198
-49.198
-49.198
-49.198
-49.7026
-49.7026
-49.7026
-49.7026
-49.7026
-49.7026
-49.7026
-49.7026
-49.7026
-49.7026
-49.7026
-49.7026
-49.7026
-49.7026
-49.7026
-49.7026
-49.7026
-49.7026
-49.7026
-49.7026
-50.2072
-50.2072
-50.2072
-50.2072
-50.2072
-50.2072
-50.2072
-50.2072
-50.2072
-50.2072
-50.2072
-50.2072
-50.2072
-50.2072
-50.2072
-50.2072
-50.2072
-50.2072
-50.2072
-50.2072
-50.7118
-50.7118
-50.7118
-50.7118
-50.7118
-50.7118
-50.7118
-50.7118
-50.7118
-50.7118
-50.7118
-50.7118
-50.7118
-50.7118
-50.7118
-50.7118
-50.7118
-50.7118
-50.7118
-50.7118
-51.2164
-51.2164
-51.2164
-51.2164
-51.2164
-51.2164
-51.2164
-51.2164
-51.2164
-51.2164
-51.2164
-51.2164
-51.2164
-51.2164
-51.2164
-51.2164
-51.2164
-51.2164
-51.2164
-51.2164
-51.721
-51.721
-51.721
-51.721
-51.721
-51.721
-51.721
-51.721
-51.721
-51.721
-51.721
-51.721
-51.721
-51.721
-51.721
-51.721
-51.721
-51.721
-51.721
-51.721
-52.2256
-52.2256
-52.2256
-52.2256
-52.2256
-52.2256
-52.2256
-52.2256
-52.2256
-52.2256
-52.2256
-52.2256
-52.2256
-52.2256
-52.2256
-52.2256
-52.2256
-52.2256
-52.2256
-52.2256
-52.7302
-52.7302
-52.7302
-52.7302
-52.7302
-52.7302
-52.7302
-52.7302
-52.7302
-52.7302
-52.7302
-52.7302
-52.7302
-52.7302
-52.7302
-52.7302
-52.7302
-52.7302
-52.7302
-52.7302
-53.2348
-53.2348
-53.2348
-53.2348
-53.2348
-53.2348
-53.2348
-53.2348
-53.2348
-53.2348
-53.2348
-53.2348
-53.2348
-53.2348
-53.2348
-53.2348
-53.2348
-53.2348
-53.2348
-53.2348
-53.7394
-53.7394
-53.7394
-53.7394
-53.7394
-53.7394
-53.7394
-53.7394
-53.7394
-53.7394
-53.7394
-53.7394
-53.7394
-53.7394
-53.7394
-53.7394
-53.7394
-53.7394
-53.7394
-53.7394
-54.244
-54.244
-54.244
-54.244
-54.244
-54.244
-54.244
-54.244
-54.244
-54.244
-54.244
-54.244
-54.244
-54.244
-54.244
-54.244
-54.244
-54.244
-54.244
-54.244
-54.7486
-54.7486
-54.7486
-54.7486
-54.7486
-54.7486
-54.7486
-54.7486
-54.7486
-54.7486
-54.7486
-54.7486
-54.7486
-54.7486
-54.7486
-54.7486
-54.7486
-54.7486
-54.7486
-54.7486
-55.2532
-55.2532
-55.2532
-55.2532
-55.2532
-55.2532
-55.2532
-55.2532
-55.2532
-55.2532
-55.2532
-55.2532
-55.2532
-55.2532
-55.2532
-55.2532
-55.2532
-55.2532
-55.2532
-55.2532
-55.7578
-55.7578
-55.7578
-55.7578
-55.7578
-55.7578
-55.7578
-55.7578
-55.7578
-55.7578
-55.7578
-55.7578
-55.7578
-55.7578
-55.7578
-55.7578
-55.7578
-55.7578
-55.7578
-55.7578
-56.2624
-56.2624
-56.2624
-56.2624
-56.2624
-56.2624
-56.2624
-56.2624
-56.2624
-56.2624
-56.2624
-56.2624
-56.2624
-56.2624
-56.2624
-56.2624
-56.2624
-56.2624
-56.2624
-56.2624
-56.767
-56.767
-56.767
-56.767
-56.767
-56.767
-56.767
-56.767
-56.767
-56.767
-56.767
-56.767
-56.767
-56.767
-56.767
-56.767
-56.767
-56.767
-56.767
-56.767
-57.2716
-57.2716
-57.2716
-57.2716
-57.2716
-57.2716
-57.2716
-57.2716
-57.2716
-57.2716
-57.2716
-57.2716
-57.2716
-57.2716
-57.2716
-57.2716
-57.2716
-57.2716
-57.2716
-57.2716
-57.7762
-57.7762
-57.7762
-57.7762
-57.7762
-57.7762
-57.7762
-57.7762
-57.7762
-57.7762
-57.7762
-57.7762
-57.7762
-57.7762
-57.7762
-57.7762
-57.7762
-57.7762
-57.7762
-57.7762
-58.2808
-58.2808
-58.2808
-58.2808
-58.2808
-58.2808
-58.2808
-58.2808
-58.2808
-58.2808
-58.2808
-58.2808
-58.2808
-58.2808
-58.2808
-58.2808
-58.2808
-58.2808
-58.2808
-58.2808
-58.7854
-58.7854
-58.7854
-58.7854
-58.7854
-58.7854
-58.7854
-58.7854
-58.7854
-58.7854
-58.7854
-58.7854
-58.7854
-58.7854
-58.7854
-58.7854
-58.7854
-58.7854
-58.7854
-58.7854
-59.2899
-59.2899
-59.2899
-59.2899
-59.2899
-59.2899
-59.2899
-59.2899
-59.2899
-59.2899
-59.2899
-59.2899
-59.2899
-59.2899
-59.2899
-59.2899
-59.2899
-59.2899
-59.2899
-59.2899
-59.7945
-59.7945
-59.7945
-59.7945
-59.7945
-59.7945
-59.7945
-59.7945
-59.7945
-59.7945
-59.7945
-59.7945
-59.7945
-59.7945
-59.7945
-59.7945
-59.7945
-59.7945
-59.7945
-59.7945
-60.2991
-60.2991
-60.2991
-60.2991
-60.2991
-60.2991
-60.2991
-60.2991
-60.2991
-60.2991
-60.2991
-60.2991
-60.2991
-60.2991
-60.2991
-60.2991
-60.2991
-60.2991
-60.2991
-60.2991
-60.8037
-60.8037
-60.8037
-60.8037
-60.8037
-60.8037
-60.8037
-60.8037
-60.8037
-60.8037
-60.8037
-60.8037
-60.8037
-60.8037
-60.8037
-60.8037
-60.8037
-60.8037
-60.8037
-60.8037
-61.3083
-61.3083
-61.3083
-61.3083
-61.3083
-61.3083
-61.3083
-61.3083
-61.3083
-61.3083
-61.3083
-61.3083
-61.3083
-61.3083
-61.3083
-61.3083
-61.3083
-61.3083
-61.3083
-61.3083
-61.8129
-61.8129
-61.8129
-61.8129
-61.8129
-61.8129
-61.8129
-61.8129
-61.8129
-61.8129
-61.8129
-61.8129
-61.8129
-61.8129
-61.8129
-61.8129
-61.8129
-61.8129
-61.8129
-61.8129
-62.3175
-62.3175
-62.3175
-62.3175
-62.3175
-62.3175
-62.3175
-62.3175
-62.3175
-62.3175
-62.3175
-62.3175
-62.3175
-62.3175
-62.3175
-62.3175
-62.3175
-62.3175
-62.3175
-62.3175
-62.8221
-62.8221
-62.8221
-62.8221
-62.8221
-62.8221
-62.8221
-62.8221
-62.8221
-62.8221
-62.8221
-62.8221
-62.8221
-62.8221
-62.8221
-62.8221
-62.8221
-62.8221
-62.8221
-62.8221
-63.3267
-63.3267
-63.3267
-63.3267
-63.3267
-63.3267
-63.3267
-63.3267
-63.3267
-63.3267
-63.3267
-63.3267
-63.3267
-63.3267
-63.3267
-63.3267
-63.3267
-63.3267
-63.3267
-63.3267
-63.8313
-63.8313
-63.8313
-63.8313
-63.8313
-63.8313
-63.8313
-63.8313
-63.8313
-63.8313
-63.8313
-63.8313
-63.8313
-63.8313
-63.8313
-63.8313
-63.8313
-63.8313
-63.8313
-63.8313
-64.3359
-64.3359
-64.3359
-64.3359
-64.3359
-64.3359
-64.3359
-64.3359
-64.3359
-64.3359
-64.3359
-64.3359
-64.3359
-64.3359
-64.3359
-64.3359
-64.3359
-64.3359
-64.3359
-64.3359
-64.8405
-64.8405
-64.8405
-64.8405
-64.8405
-64.8405
-64.8405
-64.8405
-64.8405
-64.8405
-64.8405
-64.8405
-64.8405
-64.8405
-64.8405
-64.8405
-64.8405
-64.8405
-64.8405
-64.8405
-65.3451
-65.3451
-65.3451
-65.3451
-65.3451
-65.3451
-65.3451
-65.3451
-65.3451
-65.3451
-65.3451
-65.3451
-65.3451
-65.3451
-65.3451
-65.3451
-65.3451
-65.3451
-65.3451
-65.3451
-65.8497
-65.8497
-65.8497
-65.8497
-65.8497
-65.8497
-65.8497
-65.8497
-65.8497
-65.8497
-65.8497
-65.8497
-65.8497
-65.8497
-65.8497
-65.8497
-65.8497
-65.8497
-65.8497
-65.8497
-66.3542
-66.3542
-66.3542
-66.3542
-66.3543
-66.3543
-66.3543
-66.3543
-66.3543
-66.3543
-66.3543
-66.3543
-66.3543
-66.3543
-66.3543
-66.3543
-66.3542
-66.3542
-66.3542
-66.3542
-66.8588
-66.8588
-66.8588
-66.8588
-66.8588
-66.8588
-66.8588
-66.8589
-66.8589
-66.8589
-66.8589
-66.8589
-66.8589
-66.8589
-66.8588
-66.8588
-66.8588
-66.8588
-66.8588
-66.8588
-67.3634
-67.3634
-67.3634
-67.3634
-67.3634
-67.3634
-67.3634
-67.3634
-67.3635
-67.3635
-67.3635
-67.3635
-67.3634
-67.3634
-67.3634
-67.3634
-67.3634
-67.3634
-67.3634
-67.3634
-67.868
-67.868
-67.868
-67.868
-67.868
-67.868
-67.868
-67.868
-67.868
-67.8681
-67.8681
-67.868
-67.868
-67.868
-67.868
-67.868
-67.868
-67.868
-67.868
-67.868
-68.3726
-68.3726
-68.3726
-68.3726
-68.3726
-68.3726
-68.3726
-68.3726
-68.3726
-68.3727
-68.3727
-68.3726
-68.3726
-68.3726
-68.3726
-68.3726
-68.3726
-68.3726
-68.3726
-68.3726
-68.8772
-68.8772
-68.8772
-68.8772
-68.8772
-68.8772
-68.8772
-68.8772
-68.8773
-68.8773
-68.8773
-68.8773
-68.8772
-68.8772
-68.8772
-68.8772
-68.8772
-68.8772
-68.8772
-68.8772
-69.3818
-69.3818
-69.3818
-69.3818
-69.3818
-69.3818
-69.3818
-69.3818
-69.3819
-69.3819
-69.3819
-69.3819
-69.3818
-69.3818
-69.3818
-69.3818
-69.3818
-69.3818
-69.3818
-69.3818
-69.8863
-69.8863
-69.8864
-69.8864
-69.8864
-69.8864
-69.8864
-69.8865
-69.8865
-69.8865
-69.8865
-69.8865
-69.8865
-69.8864
-69.8864
-69.8864
-69.8864
-69.8864
-69.8863
-69.8863
-70.3909
-70.3909
-70.3909
-70.391
-70.391
-70.391
-70.391
-70.3911
-70.3911
-70.3911
-70.3911
-70.3911
-70.3911
-70.391
-70.391
-70.391
-70.391
-70.3909
-70.3909
-70.3909
-70.8955
-70.8955
-70.8955
-70.8955
-70.8956
-70.8956
-70.8957
-70.8957
-70.8957
-70.8957
-70.8957
-70.8957
-70.8957
-70.8957
-70.8956
-70.8956
-70.8955
-70.8955
-70.8955
-70.8955
-71.4
-71.4
-71.4001
-71.4001
-71.4002
-71.4002
-71.4003
-71.4003
-71.4003
-71.4004
-71.4004
-71.4003
-71.4003
-71.4003
-71.4002
-71.4002
-71.4001
-71.4001
-71.4
-71.4
-71.9045
-71.9046
-71.9046
-71.9047
-71.9047
-71.9048
-71.9049
-71.9049
-71.905
-71.905
-71.905
-71.905
-71.9049
-71.9049
-71.9048
-71.9047
-71.9047
-71.9046
-71.9046
-71.9045
-72.409
-72.4091
-72.4092
-72.4092
-72.4093
-72.4094
-72.4095
-72.4096
-72.4097
-72.4097
-72.4097
-72.4097
-72.4096
-72.4095
-72.4094
-72.4093
-72.4092
-72.4091
-72.4091
-72.409
-72.9135
-72.9136
-72.9137
-72.9138
-72.9139
-72.914
-72.9142
-72.9143
-72.9144
-72.9144
-72.9144
-72.9144
-72.9143
-72.9142
-72.914
-72.9139
-72.9138
-72.9137
-72.9136
-72.9135
-73.418
-73.418
-73.4181
-73.4183
-73.4185
-73.4187
-73.4188
-73.419
-73.4191
-73.4192
-73.4192
-73.4191
-73.419
-73.4188
-73.4187
-73.4185
-73.4183
-73.4181
-73.418
-73.418
-73.9223
-73.9224
-73.9226
-73.9228
-73.923
-73.9233
-73.9235
-73.9237
-73.9239
-73.924
-73.924
-73.9239
-73.9237
-73.9235
-73.9233
-73.923
-73.9228
-73.9226
-73.9224
-73.9223
-74.4267
-74.4268
-74.427
-74.4273
-74.4276
-74.4279
-74.4282
-74.4285
-74.4287
-74.4289
-74.4289
-74.4287
-74.4285
-74.4282
-74.4279
-74.4276
-74.4273
-74.427
-74.4268
-74.4267
-74.9309
-74.931
-74.9313
-74.9317
-74.9321
-74.9326
-74.933
-74.9334
-74.9337
-74.9339
-74.9339
-74.9337
-74.9334
-74.933
-74.9326
-74.9321
-74.9317
-74.9313
-74.931
-74.9309
-75.4349
-75.4352
-75.4356
-75.436
-75.4366
-75.4373
-75.4379
-75.4384
-75.4388
-75.439
-75.439
-75.4388
-75.4384
-75.4379
-75.4373
-75.4366
-75.436
-75.4355
-75.4352
-75.4349
-75.9388
-75.9392
-75.9397
-75.9403
-75.9411
-75.942
-75.9428
-75.9435
-75.9441
-75.9444
-75.9444
-75.9441
-75.9435
-75.9428
-75.942
-75.9411
-75.9403
-75.9397
-75.9391
-75.9388
-76.4425
-76.4429
-76.4436
-76.4445
-76.4456
-76.4467
-76.4479
-76.4489
-76.4496
-76.45
-76.45
-76.4496
-76.4489
-76.4479
-76.4467
-76.4456
-76.4445
-76.4436
-76.4429
-76.4425
-76.9458
-76.9464
-76.9473
-76.9485
-76.95
-76.9515
-76.9531
-76.9545
-76.9555
-76.9561
-76.9561
-76.9555
-76.9545
-76.9531
-76.9515
-76.95
-76.9485
-76.9473
-76.9464
-76.9458
-77.4488
-77.4494
-77.4507
-77.4523
-77.4543
-77.4564
-77.4586
-77.4605
-77.462
-77.4627
-77.4627
-77.462
-77.4605
-77.4586
-77.4564
-77.4543
-77.4523
-77.4507
-77.4494
-77.4488
-77.9511
-77.952
-77.9537
-77.9559
-77.9585
-77.9614
-77.9644
-77.967
-77.9691
-77.9701
-77.9701
-77.9691
-77.967
-77.9644
-77.9614
-77.9585
-77.9559
-77.9537
-77.9519
-77.9511
-78.4527
-78.4537
-78.4561
-78.459
-78.4626
-78.4666
-78.4707
-78.4743
-78.4771
-78.4786
-78.4786
-78.4771
-78.4743
-78.4707
-78.4666
-78.4626
-78.459
-78.4561
-78.4537
-78.4527
-78.9533
-78.9544
-78.9579
-78.9616
-78.9665
-78.972
-78.9776
-78.9827
-78.9865
-78.9886
-78.9886
-78.9865
-78.9826
-78.9776
-78.9719
-78.9665
-78.9616
-78.9579
-78.9544
-78.9533
-79.4528
-79.4534
-79.4586
-79.4635
-79.47
-79.4776
-79.4854
-79.4924
-79.4978
-79.5007
-79.5007
-79.4978
-79.4924
-79.4854
-79.4776
-79.47
-79.4635
-79.4586
-79.4535
-79.4528
-79.9488
-79.9504
-79.9582
-79.9642
-79.9732
-79.9836
-79.9944
-80.0042
-80.0117
-80.0157
-80.0157
-80.0116
-80.0042
-79.9944
-79.9836
-79.9732
-79.9641
-79.9581
-79.9504
-79.9489
-80.4424
-80.4438
-80.4552
-80.4633
-80.4758
-80.4903
-80.5053
-80.5189
-80.5291
-80.5347
-80.5347
-80.5291
-80.5188
-80.5053
-80.4903
-80.4758
-80.4632
-80.4552
-80.4439
-80.4423
-80.9442
-80.9331
-80.9504
-80.9605
-80.9779
-80.998
-81.0188
-81.0375
-81.0517
-81.0593
-81.0593
-81.0517
-81.0375
-81.0188
-80.998
-80.9779
-80.9604
-80.9503
-80.933
-80.9446
-81.4398
-81.4137
-81.4421
-81.4553
-81.4795
-81.5074
-81.5361
-81.5619
-81.5814
-81.5918
-81.5918
-81.5814
-81.5619
-81.536
-81.5073
-81.4795
-81.4553
-81.442
-81.4136
-81.4395
-81.8381
-81.8722
-81.9246
-81.9477
-81.9809
-82.0192
-82.0588
-82.0943
-82.121
-82.1352
-82.1351
-82.121
-82.0943
-82.0587
-82.0191
-81.9808
-81.9475
-81.9246
-81.8722
-81.8382
-82.3738
-82.3175
-82.3252
-82.4387
-82.4835
-82.5348
-82.5893
-82.6382
-82.6746
-82.6938
-82.6937
-82.6746
-82.6381
-82.5892
-82.5347
-82.4833
-82.4385
-82.325
-82.3172
-82.3738
-82.8324
-82.8366
-82.8245
-82.8666
-82.9838
-83.0541
-83.1305
-83.198
-83.2477
-83.2735
-83.2735
-83.2477
-83.1979
-83.1304
-83.0539
-82.9836
-82.8665
-82.8244
-82.8366
-82.8324
-83.2749
-83.2791
-83.3144
-83.3539
-83.4395
-83.5768
-83.687
-83.7805
-83.8481
-83.8828
-83.8828
-83.848
-83.7804
-83.6869
-83.5766
-83.4395
-83.3536
-83.3145
-83.2792
-83.2749
-83.6966
-83.7015
-83.7581
-83.8616
-83.9306
-84.1055
-84.2676
-84.3955
-84.4865
-84.5328
-84.5328
-84.4865
-84.3954
-84.2676
-84.1054
-83.9304
-83.8616
-83.7581
-83.7015
-83.6966
-84.0824
-84.0886
-84.1714
-84.3136
-84.4982
-84.6385
-84.8861
-85.0575
-85.1781
-85.239
-85.239
-85.1781
-85.0575
-84.886
-84.6383
-84.4982
-84.3136
-84.1714
-84.0886
-84.0824
-84.4142
-84.4244
-84.5463
-84.7489
-85.0087
-85.2804
-85.5413
-85.7823
-85.9409
-86.021
-86.021
-85.9409
-85.7823
-85.5412
-85.2803
-85.0086
-84.7489
-84.5463
-84.4243
-84.4142
-84.6744
-84.6951
-84.8715
-85.1643
-85.5296
-85.9191
-86.2804
-86.5852
-86.7977
-86.9035
-86.9035
-86.7976
-86.5852
-86.2803
-85.919
-85.5295
-85.1642
-84.8715
-84.695
-84.6744
-84.8274
-84.8804
-85.1328
-85.5522
-86.0652
-86.6033
-87.0989
-87.4988
-87.778
-87.9177
-87.9177
-87.778
-87.4987
-87.0988
-86.6032
-86.0651
-85.5521
-85.1327
-84.8803
-84.8273
-84.8251
-84.9347
-85.3073
-85.8918
-86.6085
-87.3536
-88.0265
-88.5548
-88.9156
-89.0989
-89.0989
-88.9156
-88.5548
-88.0264
-87.3534
-86.6084
-85.8917
-85.3071
-84.9346
-84.825
-84.6009
-84.7901
-85.3265
-86.1268
-87.1281
-88.1742
-89.0929
-89.7845
-90.2456
-90.4851
-90.4851
-90.2456
-89.7844
-89.0928
-88.174
-87.128
-86.1266
-85.3263
-84.7899
-84.6007
-84.0755
-84.3462
-85.0936
-86.117
-87.5391
-89.0604
-90.3268
-91.2353
-91.8043
-92.12
-92.12
-91.8043
-91.2353
-90.3267
-89.0603
-87.5388
-86.1168
-85.0933
-84.346
-84.0753
-83.1579
-83.4746
-84.4334
-86.0678
-87.6542
-89.9918
-91.7701
-92.9844
-93.6427
-94.0818
-94.0818
-93.6427
-92.9844
-91.77
-89.9916
-87.6539
-86.0675
-84.4331
-83.4744
-83.1577
-82.0183
-82.1047
-82.7907
-84.303
-87.0821
-90.5835
-93.4816
-95.3552
-95.8666
-96.5606
-96.5606
-95.8665
-95.3551
-93.4815
-90.5833
-87.0818
-84.3025
-82.7903
-82.1045
-82.018
-81.201
-81.4703
-81.9797
-83.9205
-87.3871
-90.9854
-96.0602
-99.2386
-98.3853
-98.5714
-98.5714
-98.3853
-99.2386
-96.0601
-90.9851
-87.3867
-83.9196
-81.9793
-81.4701
-81.2008
-79.6286
-76.7704
-75.4927
-75.0896
-78.9134
-82.933
-66.5386
-36.4033
-15.9163
-8.93881
-8.93883
-15.9163
-36.4035
-66.5387
-82.9328
-78.9133
-75.0899
-75.4926
-76.7702
-79.6284
-82.6232
-81.2848
-76.7203
-73.4258
-50.1581
-11.1999
-0.459802
-0.0566636
-0.0338472
-0.00693852
-0.00693735
-0.0338434
-0.0566581
-0.459809
-11.2001
-50.1583
-73.4259
-76.7205
-81.2848
-82.6231
-90.4893
-64.7837
-49.0488
-11.2951
-0.228882
-0.115487
-0.0925337
-0.0609026
-0.0396173
-0.0254027
-0.0254017
-0.0396146
-0.0608985
-0.0925287
-0.115481
-0.228878
-11.2953
-49.0489
-64.7837
-90.4892
-58.4715
-10.9403
1.28578
0.109015
0.0706946
0.0252336
-0.0205236
-0.0401757
-0.0388302
-0.0351106
-0.0351098
-0.0388278
-0.0401709
-0.0205188
0.0252382
0.0706982
0.109016
1.2858
-10.9404
-58.4713
-10.7365
-3.09162
-0.615412
-0.271989
-0.0871066
-0.0612978
-0.05455
-0.0530087
-0.0459833
-0.042606
-0.0426052
-0.0459809
-0.0530039
-0.0545455
-0.0612926
-0.087103
-0.271987
-0.61541
-3.09164
-10.7366
0.869796
-0.485511
-0.0231261
-0.0662261
-0.063015
-0.0583832
-0.0540897
-0.0512604
-0.048546
-0.0466893
-0.0466886
-0.0485443
-0.0512588
-0.0540863
-0.0583791
-0.0630106
-0.0662208
-0.0231207
-0.485508
0.869803
0.12659
-0.26928
-0.074741
-0.103041
-0.0695451
-0.0597127
-0.055257
-0.0527975
-0.0504041
-0.0491629
-0.0491623
-0.0504027
-0.052795
-0.0552538
-0.0597091
-0.0695419
-0.10304
-0.0747395
-0.26928
0.126589
0.138601
-0.0675892
-0.0403286
-0.0577843
-0.0557273
-0.0554236
-0.0540196
-0.0526418
-0.0512272
-0.0503903
-0.05039
-0.051226
-0.0526396
-0.0540166
-0.0554202
-0.0557243
-0.0577818
-0.0403265
-0.0675884
0.138602
0.0543026
-0.0440671
-0.0435152
-0.0513346
-0.0522856
-0.0531105
-0.052872
-0.0521829
-0.0513792
-0.0508607
-0.0508604
-0.0513784
-0.0521811
-0.0528695
-0.0531073
-0.0522823
-0.0513317
-0.0435127
-0.0440655
0.0543035
-0.00475894
-0.0397113
-0.0431595
-0.0482054
-0.0504197
-0.0516129
-0.0518851
-0.0516741
-0.051289
-0.0509993
-0.0509991
-0.0512883
-0.0516724
-0.0518825
-0.0516099
-0.0504165
-0.0482024
-0.043157
-0.0397097
-0.00475816
-0.0315283
-0.0431275
-0.0451116
-0.0480347
-0.0498495
-0.0509099
-0.0513321
-0.0513767
-0.0512473
-0.0511105
-0.0511103
-0.0512466
-0.0513751
-0.0513295
-0.0509069
-0.0498464
-0.0480318
-0.0451092
-0.0431258
-0.0315274
-0.0429258
-0.0465422
-0.0473557
-0.0488654
-0.0500417
-0.0508232
-0.0512205
-0.0513573
-0.0513524
-0.0512996
-0.0512995
-0.0513519
-0.051356
-0.0512183
-0.0508205
-0.0500388
-0.0488627
-0.0473534
-0.0465406
-0.0429248
-0.0482699
-0.0490801
-0.0492719
-0.0499795
-0.0506575
-0.0511669
-0.0514687
-0.0516067
-0.0516401
-0.0516223
-0.0516222
-0.0516397
-0.0516057
-0.0514669
-0.0511644
-0.0506548
-0.0499769
-0.0492698
-0.0490785
-0.0482688
-0.0509736
-0.0508978
-0.0508093
-0.0510974
-0.0514546
-0.0517571
-0.0519578
-0.0520639
-0.052101
-0.0520973
-0.0520972
-0.0521004
-0.0520627
-0.051956
-0.0517547
-0.051452
-0.0510949
-0.0508072
-0.0508963
-0.0509724
-0.0525073
-0.0522162
-0.0520455
-0.0521304
-0.0522994
-0.0524637
-0.0525837
-0.0526532
-0.0526814
-0.052682
-0.0526817
-0.0526805
-0.0526517
-0.0525817
-0.0524614
-0.0522969
-0.052128
-0.0520433
-0.0522145
-0.0525059
-0.0535153
-0.0532321
-0.0530675
-0.0530648
-0.0531317
-0.0532117
-0.0532758
-0.0533153
-0.0533323
-0.0533328
-0.0533324
-0.0533312
-0.0533136
-0.0532738
-0.0532094
-0.0531293
-0.0530624
-0.0530652
-0.05323
-0.0535135
-0.0542935
-0.0540787
-0.0539487
-0.0539157
-0.0539321
-0.0539644
-0.0539938
-0.0540123
-0.05402
-0.0540191
-0.0540187
-0.0540188
-0.0540106
-0.0539917
-0.0539622
-0.0539297
-0.0539133
-0.0539462
-0.0540763
-0.0542913
-0.0549794
-0.0548349
-0.0547425
-0.0547053
-0.0546999
-0.0547078
-0.0547173
-0.054723
-0.0547245
-0.0547223
-0.0547218
-0.0547234
-0.0547214
-0.0547154
-0.0547057
-0.0546977
-0.054703
-0.0547402
-0.0548325
-0.0549772
-0.055635
-0.0555457
-0.0554851
-0.0554539
-0.0554416
-0.0554385
-0.0554379
-0.0554367
-0.0554347
-0.0554317
-0.0554314
-0.0554338
-0.0554354
-0.0554364
-0.0554368
-0.0554398
-0.0554521
-0.0554833
-0.0555439
-0.0556333
-0.0562869
-0.0562361
-0.0561994
-0.0561768
-0.0561645
-0.0561578
-0.0561531
-0.0561488
-0.0561454
-0.0561422
-0.056142
-0.0561448
-0.056148
-0.0561522
-0.0561568
-0.0561636
-0.056176
-0.0561986
-0.0562354
-0.0562862
-0.0569452
-0.0569196
-0.0568994
-0.0568848
-0.0568752
-0.0568684
-0.0568628
-0.0568579
-0.0568542
-0.0568513
-0.0568513
-0.0568541
-0.0568577
-0.0568628
-0.0568685
-0.0568754
-0.0568852
-0.0569
-0.0569202
-0.0569458
-0.0576128
-0.0576025
-0.0575933
-0.0575849
-0.0575785
-0.0575731
-0.0575683
-0.0575638
-0.0575607
-0.0575583
-0.0575584
-0.0575611
-0.0575645
-0.0575692
-0.0575744
-0.05758
-0.0575867
-0.0575952
-0.0576045
-0.0576148
-0.0582893
-0.0582881
-0.0582854
-0.0582815
-0.0582779
-0.0582743
-0.0582707
-0.0582673
-0.0582649
-0.0582631
-0.0582634
-0.0582657
-0.0582687
-0.0582726
-0.0582767
-0.0582806
-0.0582846
-0.0582886
-0.0582913
-0.0582924
-0.0589737
-0.058977
-0.0589782
-0.0589773
-0.0589756
-0.0589737
-0.0589714
-0.0589691
-0.0589675
-0.0589663
-0.0589667
-0.0589687
-0.058971
-0.058974
-0.0589769
-0.0589793
-0.0589813
-0.0589823
-0.0589811
-0.0589776
-0.0596641
-0.0596695
-0.0596726
-0.0596735
-0.0596733
-0.0596726
-0.0596714
-0.05967
-0.0596691
-0.0596684
-0.0596689
-0.0596705
-0.0596723
-0.0596744
-0.0596763
-0.0596776
-0.059678
-0.0596773
-0.0596741
-0.0596686
-0.0603593
-0.0603652
-0.0603691
-0.060371
-0.0603718
-0.0603718
-0.0603714
-0.0603708
-0.0603704
-0.0603701
-0.0603706
-0.0603719
-0.0603732
-0.0603746
-0.0603756
-0.060376
-0.0603756
-0.0603739
-0.06037
-0.060364
-0.0610581
-0.0610637
-0.0610677
-0.06107
-0.0610713
-0.0610719
-0.061072
-0.0610719
-0.0610719
-0.0610719
-0.0610724
-0.0610733
-0.0610742
-0.061075
-0.0610755
-0.0610753
-0.0610743
-0.0610722
-0.0610682
-0.0610626
-0.0617594
-0.0617644
-0.0617681
-0.0617705
-0.061772
-0.061773
-0.0617735
-0.0617737
-0.0617739
-0.061774
-0.0617745
-0.0617751
-0.0617757
-0.0617761
-0.0617761
-0.0617756
-0.0617744
-0.0617722
-0.0617686
-0.0617637
-0.0624627
-0.0624669
-0.0624702
-0.0624725
-0.062474
-0.0624751
-0.0624758
-0.0624763
-0.0624766
-0.0624768
-0.0624772
-0.0624776
-0.0624779
-0.062478
-0.0624777
-0.0624771
-0.0624758
-0.0624738
-0.0624706
-0.0624665
-0.0631674
-0.0631708
-0.0631736
-0.0631756
-0.0631771
-0.0631783
-0.0631791
-0.0631796
-0.06318
-0.0631803
-0.0631805
-0.0631808
-0.0631809
-0.0631808
-0.0631804
-0.0631796
-0.0631784
-0.0631766
-0.063174
-0.0631707
-0.0638731
-0.0638758
-0.0638781
-0.0638799
-0.0638812
-0.0638823
-0.0638831
-0.0638837
-0.0638841
-0.0638844
-0.0638846
-0.0638847
-0.0638847
-0.0638844
-0.063884
-0.0638832
-0.0638821
-0.0638806
-0.0638785
-0.0638758
-0.0645795
-0.0645816
-0.0645834
-0.0645849
-0.0645861
-0.0645871
-0.0645878
-0.0645884
-0.0645888
-0.0645891
-0.0645892
-0.0645893
-0.0645891
-0.0645889
-0.0645884
-0.0645876
-0.0645867
-0.0645854
-0.0645837
-0.0645817
-0.0652862
-0.0652879
-0.0652893
-0.0652906
-0.0652916
-0.0652925
-0.0652932
-0.0652937
-0.0652941
-0.0652943
-0.0652944
-0.0652944
-0.0652942
-0.0652939
-0.0652934
-0.0652928
-0.0652919
-0.0652909
-0.0652896
-0.0652881
-0.0659933
-0.0659946
-0.0659957
-0.0659967
-0.0659976
-0.0659983
-0.0659989
-0.0659994
-0.0659998
-0.066
-0.066
-0.066
-0.0659998
-0.0659995
-0.0659991
-0.0659985
-0.0659978
-0.0659969
-0.0659959
-0.0659948
-0.0667005
-0.0667015
-0.0667024
-0.0667031
-0.0667039
-0.0667045
-0.066705
-0.0667055
-0.0667058
-0.066706
-0.066706
-0.0667059
-0.0667058
-0.0667055
-0.0667051
-0.0667046
-0.066704
-0.0667033
-0.0667026
-0.0667017
-0.0674079
-0.0674085
-0.0674092
-0.0674098
-0.0674104
-0.067411
-0.0674114
-0.0674118
-0.067412
-0.0674122
-0.0674123
-0.0674122
-0.067412
-0.0674118
-0.0674114
-0.067411
-0.0674105
-0.06741
-0.0674094
-0.0674088
-0.0681152
-0.0681157
-0.0681162
-0.0681167
-0.0681172
-0.0681176
-0.068118
-0.0681183
-0.0681185
-0.0681187
-0.0681187
-0.0681186
-0.0681185
-0.0681183
-0.068118
-0.0681176
-0.0681173
-0.0681168
-0.0681164
-0.0681159
-0.0688225
-0.0688229
-0.0688233
-0.0688237
-0.068824
-0.0688244
-0.0688247
-0.068825
-0.0688252
-0.0688253
-0.0688253
-0.0688253
-0.0688251
-0.068825
-0.0688247
-0.0688244
-0.0688241
-0.0688238
-0.0688235
-0.0688232
-0.0695298
-0.0695301
-0.0695304
-0.0695307
-0.069531
-0.0695313
-0.0695315
-0.0695317
-0.0695319
-0.069532
-0.069532
-0.069532
-0.0695319
-0.0695317
-0.0695316
-0.0695313
-0.0695311
-0.0695308
-0.0695306
-0.0695304
-0.0702371
-0.0702373
-0.0702375
-0.0702377
-0.070238
-0.0702382
-0.0702384
-0.0702386
-0.0702387
-0.0702388
-0.0702389
-0.0702388
-0.0702387
-0.0702386
-0.0702385
-0.0702383
-0.0702381
-0.0702379
-0.0702377
-0.0702376
-0.0709444
-0.0709445
-0.0709447
-0.0709449
-0.070945
-0.0709452
-0.0709454
-0.0709455
-0.0709456
-0.0709457
-0.0709457
-0.0709457
-0.0709457
-0.0709456
-0.0709454
-0.0709453
-0.0709452
-0.070945
-0.0709449
-0.0709448
-0.0716516
-0.0716517
-0.0716519
-0.071652
-0.0716521
-0.0716523
-0.0716524
-0.0716525
-0.0716526
-0.0716527
-0.0716527
-0.0716527
-0.0716526
-0.0716526
-0.0716525
-0.0716524
-0.0716522
-0.0716521
-0.071652
-0.071652
-0.0723588
-0.0723589
-0.072359
-0.0723591
-0.0723592
-0.0723593
-0.0723594
-0.0723595
-0.0723596
-0.0723596
-0.0723597
-0.0723597
-0.0723596
-0.0723596
-0.0723595
-0.0723594
-0.0723593
-0.0723593
-0.0723592
-0.0723591
-0.0730661
-0.0730661
-0.0730662
-0.0730662
-0.0730663
-0.0730664
-0.0730665
-0.0730666
-0.0730666
-0.0730667
-0.0730667
-0.0730667
-0.0730667
-0.0730666
-0.0730666
-0.0730665
-0.0730664
-0.0730664
-0.0730663
-0.0730663
-0.0737732
-0.0737733
-0.0737733
-0.0737734
-0.0737734
-0.0737735
-0.0737736
-0.0737736
-0.0737737
-0.0737737
-0.0737737
-0.0737737
-0.0737737
-0.0737737
-0.0737736
-0.0737736
-0.0737735
-0.0737735
-0.0737735
-0.0737734
-0.0744804
-0.0744804
-0.0744805
-0.0744805
-0.0744806
-0.0744806
-0.0744807
-0.0744807
-0.0744808
-0.0744808
-0.0744808
-0.0744808
-0.0744808
-0.0744807
-0.0744807
-0.0744807
-0.0744806
-0.0744806
-0.0744806
-0.0744806
-0.0751876
-0.0751876
-0.0751876
-0.0751876
-0.0751877
-0.0751877
-0.0751878
-0.0751878
-0.0751878
-0.0751878
-0.0751879
-0.0751879
-0.0751878
-0.0751878
-0.0751878
-0.0751878
-0.0751877
-0.0751877
-0.0751877
-0.0751877
-0.0758947
-0.0758947
-0.0758947
-0.0758948
-0.0758948
-0.0758948
-0.0758949
-0.0758949
-0.0758949
-0.0758949
-0.0758949
-0.0758949
-0.0758949
-0.0758949
-0.0758949
-0.0758949
-0.0758948
-0.0758948
-0.0758948
-0.0758948
-0.0766018
-0.0766018
-0.0766019
-0.0766019
-0.0766019
-0.0766019
-0.076602
-0.076602
-0.076602
-0.076602
-0.076602
-0.076602
-0.076602
-0.076602
-0.076602
-0.076602
-0.076602
-0.0766019
-0.0766019
-0.0766019
-0.077309
-0.077309
-0.077309
-0.077309
-0.0773091
-0.0773091
-0.0773091
-0.0773091
-0.0773091
-0.0773091
-0.0773091
-0.0773091
-0.0773091
-0.0773091
-0.0773091
-0.0773091
-0.0773091
-0.0773091
-0.0773091
-0.0773091
-0.0780161
-0.0780162
-0.0780162
-0.0780162
-0.0780162
-0.0780162
-0.0780162
-0.0780162
-0.0780162
-0.0780162
-0.0780162
-0.0780162
-0.0780162
-0.0780162
-0.0780162
-0.0780162
-0.0780162
-0.0780162
-0.0780162
-0.0780162
-0.0787233
-0.0787233
-0.0787233
-0.0787233
-0.0787234
-0.0787234
-0.0787234
-0.0787234
-0.0787234
-0.0787234
-0.0787234
-0.0787234
-0.0787234
-0.0787233
-0.0787233
-0.0787233
-0.0787233
-0.0787233
-0.0787233
-0.0787233
-0.0794304
-0.0794305
-0.0794305
-0.0794305
-0.0794305
-0.0794305
-0.0794305
-0.0794305
-0.0794305
-0.0794305
-0.0794305
-0.0794305
-0.0794305
-0.0794305
-0.0794305
-0.0794305
-0.0794304
-0.0794304
-0.0794304
-0.0794304
-0.0801376
-0.0801376
-0.0801376
-0.0801377
-0.0801377
-0.0801377
-0.0801377
-0.0801376
-0.0801376
-0.0801377
-0.0801376
-0.0801376
-0.0801376
-0.0801376
-0.0801376
-0.0801376
-0.0801376
-0.0801376
-0.0801376
-0.0801376
-0.0808448
-0.0808448
-0.0808448
-0.0808448
-0.0808448
-0.0808448
-0.0808448
-0.0808448
-0.0808448
-0.0808448
-0.0808448
-0.0808448
-0.0808448
-0.0808448
-0.0808447
-0.0808447
-0.0808447
-0.0808447
-0.0808447
-0.0808447
-0.0815519
-0.0815519
-0.0815519
-0.0815519
-0.081552
-0.081552
-0.081552
-0.081552
-0.0815519
-0.0815519
-0.0815519
-0.0815519
-0.0815519
-0.0815519
-0.0815519
-0.0815519
-0.0815519
-0.0815518
-0.0815518
-0.0815518
-0.0822591
-0.0822591
-0.0822591
-0.0822591
-0.0822591
-0.0822591
-0.0822591
-0.0822591
-0.0822591
-0.0822591
-0.0822591
-0.0822591
-0.0822591
-0.082259
-0.082259
-0.082259
-0.082259
-0.082259
-0.082259
-0.082259
-0.0829662
-0.0829662
-0.0829663
-0.0829663
-0.0829663
-0.0829663
-0.0829663
-0.0829662
-0.0829662
-0.0829662
-0.0829662
-0.0829662
-0.0829662
-0.0829662
-0.0829662
-0.0829662
-0.0829662
-0.0829661
-0.0829661
-0.0829661
-0.0836734
-0.0836734
-0.0836734
-0.0836734
-0.0836734
-0.0836734
-0.0836734
-0.0836734
-0.0836734
-0.0836734
-0.0836734
-0.0836734
-0.0836733
-0.0836733
-0.0836733
-0.0836733
-0.0836733
-0.0836733
-0.0836733
-0.0836733
-0.0843806
-0.0843806
-0.0843806
-0.0843806
-0.0843806
-0.0843806
-0.0843806
-0.0843806
-0.0843806
-0.0843806
-0.0843805
-0.0843805
-0.0843805
-0.0843805
-0.0843805
-0.0843805
-0.0843805
-0.0843805
-0.0843804
-0.0843804
-0.0850877
-0.0850877
-0.0850877
-0.0850878
-0.0850878
-0.0850878
-0.0850878
-0.0850878
-0.0850877
-0.0850877
-0.0850877
-0.0850877
-0.0850877
-0.0850877
-0.0850877
-0.0850876
-0.0850876
-0.0850876
-0.0850876
-0.0850876
-0.0857949
-0.0857949
-0.0857949
-0.0857949
-0.0857949
-0.0857949
-0.0857949
-0.0857949
-0.0857949
-0.0857949
-0.0857949
-0.0857948
-0.0857948
-0.0857948
-0.0857948
-0.0857948
-0.0857948
-0.0857948
-0.0857948
-0.0857948
-0.0865021
-0.0865021
-0.0865021
-0.0865021
-0.0865021
-0.0865021
-0.0865021
-0.0865021
-0.0865021
-0.0865021
-0.086502
-0.086502
-0.086502
-0.086502
-0.086502
-0.086502
-0.086502
-0.0865019
-0.0865019
-0.0865019
-0.0872093
-0.0872093
-0.0872093
-0.0872093
-0.0872093
-0.0872093
-0.0872093
-0.0872093
-0.0872093
-0.0872092
-0.0872092
-0.0872092
-0.0872092
-0.0872092
-0.0872092
-0.0872092
-0.0872091
-0.0872091
-0.0872091
-0.0872091
-0.0879165
-0.0879165
-0.0879165
-0.0879165
-0.0879165
-0.0879165
-0.0879165
-0.0879165
-0.0879165
-0.0879164
-0.0879164
-0.0879164
-0.0879164
-0.0879164
-0.0879163
-0.0879163
-0.0879163
-0.0879163
-0.0879163
-0.0879163
-0.0886237
-0.0886237
-0.0886237
-0.0886237
-0.0886237
-0.0886237
-0.0886237
-0.0886237
-0.0886236
-0.0886236
-0.0886236
-0.0886236
-0.0886236
-0.0886235
-0.0886235
-0.0886235
-0.0886235
-0.0886235
-0.0886235
-0.0886235
-0.0893309
-0.0893309
-0.0893309
-0.0893309
-0.0893309
-0.0893309
-0.0893309
-0.0893309
-0.0893308
-0.0893308
-0.0893308
-0.0893308
-0.0893308
-0.0893307
-0.0893307
-0.0893307
-0.0893307
-0.0893307
-0.0893307
-0.0893307
-0.0900381
-0.0900381
-0.0900381
-0.0900381
-0.0900381
-0.0900381
-0.0900381
-0.090038
-0.090038
-0.090038
-0.090038
-0.090038
-0.0900379
-0.0900379
-0.0900379
-0.0900379
-0.0900379
-0.0900379
-0.0900379
-0.0900379
-0.0907453
-0.0907453
-0.0907453
-0.0907453
-0.0907453
-0.0907453
-0.0907452
-0.0907452
-0.0907452
-0.0907452
-0.0907452
-0.0907452
-0.0907452
-0.0907451
-0.0907451
-0.0907451
-0.0907451
-0.0907451
-0.0907451
-0.0907451
-0.0914525
-0.0914525
-0.0914525
-0.0914525
-0.0914525
-0.0914524
-0.0914524
-0.0914524
-0.0914524
-0.0914524
-0.0914524
-0.0914524
-0.0914524
-0.0914524
-0.0914523
-0.0914523
-0.0914523
-0.0914523
-0.0914523
-0.0914523
-0.0921597
-0.0921597
-0.0921597
-0.0921597
-0.0921597
-0.0921597
-0.0921597
-0.0921596
-0.0921596
-0.0921596
-0.0921596
-0.0921596
-0.0921596
-0.0921596
-0.0921595
-0.0921595
-0.0921595
-0.0921595
-0.0921595
-0.0921595
-0.0928669
-0.0928669
-0.0928669
-0.0928669
-0.0928669
-0.0928669
-0.0928669
-0.0928668
-0.0928668
-0.0928668
-0.0928668
-0.0928668
-0.0928668
-0.0928668
-0.0928667
-0.0928667
-0.0928667
-0.0928667
-0.0928667
-0.0928667
-0.0935741
-0.0935741
-0.0935741
-0.0935741
-0.0935741
-0.0935741
-0.0935741
-0.0935741
-0.0935741
-0.0935741
-0.0935741
-0.093574
-0.093574
-0.093574
-0.093574
-0.093574
-0.093574
-0.093574
-0.093574
-0.093574
-0.0942813
-0.0942813
-0.0942813
-0.0942813
-0.0942813
-0.0942813
-0.0942813
-0.0942813
-0.0942813
-0.0942813
-0.0942813
-0.0942813
-0.0942812
-0.0942812
-0.0942812
-0.0942812
-0.0942812
-0.0942812
-0.0942812
-0.0942812
-0.0949885
-0.0949885
-0.0949885
-0.0949885
-0.0949885
-0.0949885
-0.0949885
-0.0949885
-0.0949885
-0.0949885
-0.0949885
-0.0949885
-0.0949885
-0.0949885
-0.0949884
-0.0949884
-0.0949884
-0.0949884
-0.0949884
-0.0949884
-0.0956957
-0.0956957
-0.0956957
-0.0956957
-0.0956957
-0.0956957
-0.0956957
-0.0956957
-0.0956957
-0.0956957
-0.0956957
-0.0956957
-0.0956957
-0.0956957
-0.0956957
-0.0956957
-0.0956957
-0.0956957
-0.0956957
-0.0956957
-0.0964029
-0.0964029
-0.0964029
-0.0964029
-0.0964029
-0.0964029
-0.0964029
-0.0964029
-0.0964029
-0.096403
-0.096403
-0.096403
-0.0964029
-0.0964029
-0.0964029
-0.0964029
-0.0964029
-0.0964029
-0.0964029
-0.0964029
-0.0971101
-0.0971102
-0.0971102
-0.0971101
-0.0971101
-0.0971101
-0.0971101
-0.0971102
-0.0971102
-0.0971102
-0.0971102
-0.0971102
-0.0971102
-0.0971102
-0.0971102
-0.0971102
-0.0971102
-0.0971102
-0.0971102
-0.0971102
-0.0978174
-0.0978174
-0.0978174
-0.0978174
-0.0978173
-0.0978173
-0.0978174
-0.0978174
-0.0978174
-0.0978174
-0.0978174
-0.0978174
-0.0978174
-0.0978174
-0.0978174
-0.0978174
-0.0978174
-0.0978174
-0.0978174
-0.0978174
-0.0985246
-0.0985246
-0.0985246
-0.0985246
-0.0985246
-0.0985246
-0.0985246
-0.0985246
-0.0985246
-0.0985246
-0.0985246
-0.0985247
-0.0985247
-0.0985247
-0.0985247
-0.0985247
-0.0985247
-0.0985247
-0.0985247
-0.0985247
-0.0992318
-0.0992318
-0.0992318
-0.0992318
-0.0992318
-0.0992318
-0.0992318
-0.0992318
-0.0992319
-0.0992319
-0.0992319
-0.0992319
-0.0992319
-0.0992319
-0.0992319
-0.0992319
-0.0992319
-0.0992319
-0.0992319
-0.0992319
-0.099939
-0.099939
-0.099939
-0.099939
-0.099939
-0.099939
-0.0999391
-0.0999391
-0.0999391
-0.0999391
-0.0999391
-0.0999391
-0.0999392
-0.0999392
-0.0999392
-0.0999392
-0.0999392
-0.0999392
-0.0999392
-0.0999392
-0.100646
-0.100646
-0.100646
-0.100646
-0.100646
-0.100646
-0.100646
-0.100646
-0.100646
-0.100646
-0.100646
-0.100646
-0.100646
-0.100646
-0.100646
-0.100646
-0.100646
-0.100646
-0.100646
-0.100646
-0.101354
-0.101354
-0.101354
-0.101354
-0.101354
-0.101354
-0.101354
-0.101354
-0.101354
-0.101354
-0.101354
-0.101354
-0.101354
-0.101354
-0.101354
-0.101354
-0.101354
-0.101354
-0.101354
-0.101354
-0.102061
-0.102061
-0.102061
-0.102061
-0.102061
-0.102061
-0.102061
-0.102061
-0.102061
-0.102061
-0.102061
-0.102061
-0.102061
-0.102061
-0.102061
-0.102061
-0.102061
-0.102061
-0.102061
-0.102061
-0.102768
-0.102768
-0.102768
-0.102768
-0.102768
-0.102768
-0.102768
-0.102768
-0.102768
-0.102768
-0.102768
-0.102768
-0.102768
-0.102768
-0.102768
-0.102768
-0.102768
-0.102768
-0.102768
-0.102768
-0.103475
-0.103475
-0.103475
-0.103475
-0.103475
-0.103475
-0.103475
-0.103475
-0.103475
-0.103475
-0.103475
-0.103475
-0.103475
-0.103475
-0.103475
-0.103475
-0.103475
-0.103475
-0.103475
-0.103475
-0.104182
-0.104182
-0.104182
-0.104182
-0.104183
-0.104183
-0.104183
-0.104183
-0.104183
-0.104183
-0.104183
-0.104183
-0.104183
-0.104183
-0.104183
-0.104183
-0.104183
-0.104183
-0.104183
-0.104183
-0.10489
-0.10489
-0.10489
-0.10489
-0.10489
-0.10489
-0.10489
-0.10489
-0.10489
-0.10489
-0.10489
-0.10489
-0.10489
-0.10489
-0.10489
-0.10489
-0.10489
-0.10489
-0.10489
-0.10489
-0.105597
-0.105597
-0.105597
-0.105597
-0.105597
-0.105597
-0.105597
-0.105597
-0.105597
-0.105597
-0.105597
-0.105597
-0.105597
-0.105597
-0.105597
-0.105597
-0.105597
-0.105597
-0.105597
-0.105597
-0.106304
-0.106304
-0.106304
-0.106304
-0.106304
-0.106304
-0.106304
-0.106304
-0.106304
-0.106304
-0.106304
-0.106304
-0.106304
-0.106304
-0.106304
-0.106304
-0.106304
-0.106304
-0.106304
-0.106304
-0.107011
-0.107011
-0.107011
-0.107012
-0.107012
-0.107012
-0.107012
-0.107012
-0.107012
-0.107012
-0.107012
-0.107012
-0.107012
-0.107012
-0.107012
-0.107012
-0.107012
-0.107012
-0.107012
-0.107012
-0.107719
-0.107719
-0.107719
-0.107719
-0.107719
-0.107719
-0.107719
-0.107719
-0.107719
-0.107719
-0.107719
-0.107719
-0.107719
-0.107719
-0.107719
-0.107719
-0.107719
-0.107719
-0.107719
-0.107719
-0.108426
-0.108426
-0.108426
-0.108426
-0.108426
-0.108426
-0.108426
-0.108426
-0.108426
-0.108426
-0.108426
-0.108426
-0.108426
-0.108426
-0.108426
-0.108426
-0.108426
-0.108426
-0.108426
-0.108426
-0.109133
-0.109133
-0.109133
-0.109133
-0.109133
-0.109133
-0.109133
-0.109133
-0.109133
-0.109133
-0.109133
-0.109133
-0.109133
-0.109133
-0.109133
-0.109133
-0.109133
-0.109133
-0.109133
-0.109133
-0.109841
-0.109841
-0.109841
-0.109841
-0.109841
-0.109841
-0.109841
-0.109841
-0.109841
-0.109841
-0.109841
-0.109841
-0.109841
-0.109841
-0.109841
-0.109841
-0.109841
-0.109841
-0.109841
-0.109841
-0.110548
-0.110548
-0.110548
-0.110548
-0.110548
-0.110548
-0.110548
-0.110548
-0.110548
-0.110548
-0.110548
-0.110548
-0.110548
-0.110548
-0.110548
-0.110548
-0.110548
-0.110548
-0.110548
-0.110548
-0.111255
-0.111255
-0.111255
-0.111255
-0.111255
-0.111255
-0.111255
-0.111255
-0.111255
-0.111255
-0.111255
-0.111255
-0.111255
-0.111255
-0.111255
-0.111255
-0.111255
-0.111255
-0.111255
-0.111255
-0.111962
-0.111962
-0.111962
-0.111962
-0.111962
-0.111962
-0.111962
-0.111962
-0.111962
-0.111962
-0.111962
-0.111962
-0.111962
-0.111962
-0.111962
-0.111962
-0.111962
-0.111962
-0.111962
-0.111962
-0.11267
-0.11267
-0.11267
-0.11267
-0.11267
-0.11267
-0.11267
-0.11267
-0.11267
-0.11267
-0.11267
-0.11267
-0.11267
-0.11267
-0.11267
-0.11267
-0.11267
-0.11267
-0.11267
-0.11267
-0.113377
-0.113377
-0.113377
-0.113377
-0.113377
-0.113377
-0.113377
-0.113377
-0.113377
-0.113377
-0.113377
-0.113377
-0.113377
-0.113377
-0.113377
-0.113377
-0.113377
-0.113377
-0.113377
-0.113377
-0.114084
-0.114084
-0.114084
-0.114084
-0.114084
-0.114084
-0.114084
-0.114084
-0.114084
-0.114084
-0.114084
-0.114084
-0.114084
-0.114084
-0.114084
-0.114084
-0.114084
-0.114084
-0.114084
-0.114084
-0.114791
-0.114791
-0.114791
-0.114791
-0.114791
-0.114791
-0.114791
-0.114791
-0.114791
-0.114791
-0.114791
-0.114791
-0.114791
-0.114791
-0.114791
-0.114791
-0.114791
-0.114791
-0.114791
-0.114791
-0.115499
-0.115499
-0.115499
-0.115499
-0.115499
-0.115499
-0.115499
-0.115499
-0.115499
-0.115499
-0.115499
-0.115499
-0.115499
-0.115499
-0.115499
-0.115499
-0.115499
-0.115499
-0.115499
-0.115499
-0.116206
-0.116206
-0.116206
-0.116206
-0.116206
-0.116206
-0.116206
-0.116206
-0.116206
-0.116206
-0.116206
-0.116206
-0.116206
-0.116206
-0.116206
-0.116206
-0.116206
-0.116206
-0.116206
-0.116206
-0.116913
-0.116913
-0.116913
-0.116913
-0.116913
-0.116913
-0.116913
-0.116913
-0.116913
-0.116913
-0.116913
-0.116913
-0.116913
-0.116913
-0.116913
-0.116913
-0.116913
-0.116913
-0.116913
-0.116913
-0.11762
-0.11762
-0.11762
-0.11762
-0.11762
-0.11762
-0.11762
-0.11762
-0.11762
-0.11762
-0.11762
-0.11762
-0.11762
-0.11762
-0.11762
-0.11762
-0.11762
-0.117621
-0.117621
-0.117621
-0.118328
-0.118328
-0.118328
-0.118328
-0.118328
-0.118328
-0.118328
-0.118328
-0.118328
-0.118328
-0.118328
-0.118328
-0.118328
-0.118328
-0.118328
-0.118328
-0.118328
-0.118328
-0.118328
-0.118328
-0.119035
-0.119035
-0.119035
-0.119035
-0.119035
-0.119035
-0.119035
-0.119035
-0.119035
-0.119035
-0.119035
-0.119035
-0.119035
-0.119035
-0.119035
-0.119035
-0.119035
-0.119035
-0.119035
-0.119035
-0.119742
-0.119742
-0.119742
-0.119742
-0.119742
-0.119742
-0.119742
-0.119742
-0.119742
-0.119742
-0.119742
-0.119742
-0.119742
-0.119742
-0.119742
-0.119742
-0.119742
-0.119742
-0.119742
-0.119742
-0.120449
-0.120449
-0.120449
-0.120449
-0.120449
-0.120449
-0.120449
-0.120449
-0.120449
-0.120449
-0.120449
-0.120449
-0.120449
-0.120449
-0.120449
-0.120449
-0.12045
-0.12045
-0.12045
-0.12045
-0.121157
-0.121157
-0.121157
-0.121157
-0.121157
-0.121157
-0.121157
-0.121157
-0.121157
-0.121157
-0.121157
-0.121157
-0.121157
-0.121157
-0.121157
-0.121157
-0.121157
-0.121157
-0.121157
-0.121157
-0.121864
-0.121864
-0.121864
-0.121864
-0.121864
-0.121864
-0.121864
-0.121864
-0.121864
-0.121864
-0.121864
-0.121864
-0.121864
-0.121864
-0.121864
-0.121864
-0.121864
-0.121864
-0.121864
-0.121864
-0.122571
-0.122571
-0.122571
-0.122571
-0.122571
-0.122571
-0.122571
-0.122571
-0.122571
-0.122571
-0.122571
-0.122571
-0.122571
-0.122571
-0.122571
-0.122571
-0.122571
-0.122571
-0.122571
-0.122571
-0.123278
-0.123278
-0.123278
-0.123278
-0.123278
-0.123278
-0.123278
-0.123278
-0.123278
-0.123278
-0.123278
-0.123278
-0.123278
-0.123278
-0.123278
-0.123278
-0.123278
-0.123278
-0.123278
-0.123278
-0.123985
-0.123985
-0.123985
-0.123985
-0.123985
-0.123986
-0.123986
-0.123986
-0.123986
-0.123986
-0.123986
-0.123986
-0.123986
-0.123986
-0.123986
-0.123986
-0.123986
-0.123986
-0.123986
-0.123986
-0.124693
-0.124693
-0.124693
-0.124693
-0.124693
-0.124693
-0.124693
-0.124693
-0.124693
-0.124693
-0.124693
-0.124693
-0.124693
-0.124693
-0.124693
-0.124693
-0.124693
-0.124693
-0.124693
-0.124693
-0.1254
-0.1254
-0.1254
-0.1254
-0.1254
-0.1254
-0.1254
-0.1254
-0.1254
-0.1254
-0.1254
-0.1254
-0.1254
-0.1254
-0.1254
-0.1254
-0.1254
-0.1254
-0.1254
-0.1254
-0.126107
-0.126107
-0.126107
-0.126107
-0.126107
-0.126107
-0.126107
-0.126107
-0.126107
-0.126107
-0.126107
-0.126107
-0.126107
-0.126107
-0.126107
-0.126107
-0.126107
-0.126107
-0.126107
-0.126107
-0.126814
-0.126814
-0.126814
-0.126814
-0.126814
-0.126814
-0.126814
-0.126814
-0.126814
-0.126814
-0.126815
-0.126815
-0.126815
-0.126815
-0.126815
-0.126815
-0.126815
-0.126815
-0.126815
-0.126815
-0.127522
-0.127522
-0.127522
-0.127522
-0.127522
-0.127522
-0.127522
-0.127522
-0.127522
-0.127522
-0.127522
-0.127522
-0.127522
-0.127522
-0.127522
-0.127522
-0.127522
-0.127522
-0.127522
-0.127522
-0.128229
-0.128229
-0.128229
-0.128229
-0.128229
-0.128229
-0.128229
-0.128229
-0.128229
-0.128229
-0.128229
-0.128229
-0.128229
-0.128229
-0.128229
-0.128229
-0.128229
-0.128229
-0.128229
-0.128229
-0.128936
-0.128936
-0.128936
-0.128936
-0.128936
-0.128936
-0.128936
-0.128936
-0.128936
-0.128936
-0.128936
-0.128936
-0.128936
-0.128936
-0.128936
-0.128936
-0.128936
-0.128936
-0.128936
-0.128936
-0.129643
-0.129643
-0.129643
-0.129643
-0.129643
-0.129643
-0.129643
-0.129643
-0.129643
-0.129643
-0.129643
-0.129643
-0.129643
-0.129643
-0.129643
-0.129643
-0.129643
-0.129643
-0.129643
-0.129643
-0.13035
-0.13035
-0.13035
-0.13035
-0.13035
-0.13035
-0.13035
-0.130351
-0.130351
-0.130351
-0.130351
-0.130351
-0.130351
-0.130351
-0.130351
-0.13035
-0.13035
-0.13035
-0.13035
-0.13035
-0.131058
-0.131058
-0.131058
-0.131058
-0.131058
-0.131058
-0.131058
-0.131058
-0.131058
-0.131058
-0.131058
-0.131058
-0.131058
-0.131058
-0.131058
-0.131058
-0.131058
-0.131058
-0.131058
-0.131058
-0.131765
-0.131765
-0.131765
-0.131765
-0.131765
-0.131765
-0.131765
-0.131765
-0.131765
-0.131765
-0.131765
-0.131765
-0.131765
-0.131765
-0.131765
-0.131765
-0.131765
-0.131765
-0.131765
-0.131765
-0.132472
-0.132472
-0.132472
-0.132472
-0.132472
-0.132472
-0.132472
-0.132472
-0.132472
-0.132472
-0.132472
-0.132472
-0.132472
-0.132472
-0.132472
-0.132472
-0.132472
-0.132472
-0.132472
-0.132472
-0.133179
-0.133179
-0.133179
-0.133179
-0.133179
-0.133179
-0.133179
-0.133179
-0.133179
-0.133179
-0.133179
-0.133179
-0.133179
-0.133179
-0.133179
-0.133179
-0.133179
-0.133179
-0.133179
-0.133179
-0.133886
-0.133886
-0.133886
-0.133886
-0.133886
-0.133886
-0.133886
-0.133886
-0.133886
-0.133886
-0.133886
-0.133886
-0.133886
-0.133886
-0.133886
-0.133886
-0.133886
-0.133886
-0.133886
-0.133886
-0.134593
-0.134593
-0.134593
-0.134593
-0.134593
-0.134594
-0.134594
-0.134594
-0.134594
-0.134594
-0.134594
-0.134594
-0.134594
-0.134594
-0.134594
-0.134594
-0.134594
-0.134594
-0.134594
-0.134594
-0.135301
-0.135301
-0.135301
-0.135301
-0.135301
-0.135301
-0.135301
-0.135301
-0.135301
-0.135301
-0.135301
-0.135301
-0.135301
-0.135301
-0.135301
-0.135301
-0.135301
-0.135301
-0.135301
-0.135301
-0.136008
-0.136008
-0.136008
-0.136008
-0.136008
-0.136008
-0.136008
-0.136008
-0.136008
-0.136008
-0.136008
-0.136008
-0.136008
-0.136008
-0.136008
-0.136008
-0.136008
-0.136008
-0.136008
-0.136008
-0.136715
-0.136715
-0.136715
-0.136715
-0.136715
-0.136715
-0.136715
-0.136715
-0.136715
-0.136715
-0.136715
-0.136715
-0.136715
-0.136715
-0.136715
-0.136715
-0.136715
-0.136715
-0.136715
-0.136715
-0.137422
-0.137422
-0.137422
-0.137422
-0.137422
-0.137422
-0.137422
-0.137422
-0.137422
-0.137422
-0.137422
-0.137422
-0.137422
-0.137422
-0.137422
-0.137422
-0.137422
-0.137422
-0.137422
-0.137422
-0.138129
-0.138129
-0.138129
-0.138129
-0.138129
-0.138129
-0.138129
-0.138129
-0.138129
-0.138129
-0.138129
-0.138129
-0.138129
-0.138129
-0.138129
-0.138129
-0.138129
-0.138129
-0.138129
-0.138129
-0.138836
-0.138836
-0.138836
-0.138836
-0.138836
-0.138836
-0.138836
-0.138836
-0.138836
-0.138837
-0.138837
-0.138837
-0.138837
-0.138837
-0.138837
-0.138837
-0.138837
-0.138837
-0.138837
-0.138837
-0.139544
-0.139544
-0.139544
-0.139544
-0.139544
-0.139544
-0.139544
-0.139544
-0.139544
-0.139544
-0.139544
-0.139544
-0.139544
-0.139544
-0.139544
-0.139544
-0.139544
-0.139544
-0.139544
-0.139544
-0.140251
-0.140251
-0.140251
-0.140251
-0.140251
-0.140251
-0.140251
-0.140251
-0.140251
-0.140251
-0.140251
-0.140251
-0.140251
-0.140251
-0.140251
-0.140251
-0.140251
-0.140251
-0.140251
-0.140251
-0.140958
-0.140958
-0.140958
-0.140958
-0.140958
-0.140958
-0.140958
-0.140958
-0.140958
-0.140958
-0.140958
-0.140958
-0.140958
-0.140958
-0.140958
-0.140958
-0.140958
-0.140958
-0.140958
-0.140958
-0.141665
-0.141665
-0.141665
-0.141665
-0.141665
-0.141665
-0.141665
-0.141665
-0.141665
-0.141665
-0.141665
-0.141665
-0.141665
-0.141665
-0.141665
-0.141665
-0.141665
-0.141665
-0.141665
-0.141665
-0.142372
-0.142372
-0.142372
-0.142372
-0.142372
-0.142372
-0.142372
-0.142372
-0.142372
-0.142372
-0.142372
-0.142372
-0.142372
-0.142372
-0.142372
-0.142372
-0.142372
-0.142372
-0.142372
-0.142372
-0.143079
-0.143079
-0.143079
-0.143079
-0.143079
-0.143079
-0.143079
-0.143079
-0.143079
-0.143079
-0.143079
-0.143079
-0.143079
-0.143079
-0.143079
-0.143079
-0.14308
-0.14308
-0.14308
-0.14308
-0.143787
-0.143787
-0.143787
-0.143787
-0.143787
-0.143787
-0.143787
-0.143787
-0.143787
-0.143787
-0.143787
-0.143787
-0.143787
-0.143787
-0.143787
-0.143787
-0.143787
-0.143787
-0.143787
-0.143787
-0.144494
-0.144494
-0.144494
-0.144494
-0.144494
-0.144494
-0.144494
-0.144494
-0.144494
-0.144494
-0.144494
-0.144494
-0.144494
-0.144494
-0.144494
-0.144494
-0.144494
-0.144494
-0.144494
-0.144494
-0.145201
-0.145201
-0.145201
-0.145201
-0.145201
-0.145201
-0.145201
-0.145201
-0.145201
-0.145201
-0.145201
-0.145201
-0.145201
-0.145201
-0.145201
-0.145201
-0.145201
-0.145201
-0.145201
-0.145201
-0.145908
-0.145908
-0.145908
-0.145908
-0.145908
-0.145908
-0.145908
-0.145908
-0.145908
-0.145908
-0.145908
-0.145908
-0.145908
-0.145908
-0.145908
-0.145908
-0.145908
-0.145908
-0.145908
-0.145908
-0.146615
-0.146615
-0.146615
-0.146615
-0.146615
-0.146615
-0.146615
-0.146615
-0.146615
-0.146615
-0.146615
-0.146615
-0.146615
-0.146615
-0.146615
-0.146615
-0.146615
-0.146615
-0.146615
-0.146615
-0.147322
-0.147322
-0.147322
-0.147322
-0.147322
-0.147322
-0.147322
-0.147322
-0.147322
-0.147322
-0.147322
-0.147322
-0.147322
-0.147322
-0.147322
-0.147322
-0.147322
-0.147322
-0.147322
-0.147322
-0.148029
-0.148029
-0.148029
-0.148029
-0.148029
-0.148029
-0.148029
-0.148029
-0.148029
-0.148029
-0.148029
-0.148029
-0.148029
-0.148029
-0.148029
-0.148029
-0.148029
-0.148029
-0.148029
-0.148029
-0.148737
-0.148737
-0.148737
-0.148737
-0.148736
-0.148736
-0.148736
-0.148736
-0.148736
-0.148736
-0.148736
-0.148736
-0.148736
-0.148736
-0.148736
-0.148736
-0.148736
-0.148736
-0.148736
-0.148736
-0.149444
-0.149444
-0.149444
-0.149444
-0.149444
-0.149444
-0.149443
-0.149443
-0.149443
-0.149443
-0.149443
-0.149443
-0.149443
-0.149443
-0.149443
-0.149443
-0.149443
-0.149443
-0.149443
-0.149443
-0.150151
-0.150151
-0.150151
-0.150151
-0.150151
-0.150151
-0.150151
-0.150151
-0.150151
-0.150151
-0.15015
-0.15015
-0.15015
-0.15015
-0.15015
-0.15015
-0.15015
-0.15015
-0.15015
-0.15015
-0.150858
-0.150858
-0.150858
-0.150858
-0.150858
-0.150858
-0.150858
-0.150858
-0.150858
-0.150858
-0.150858
-0.150858
-0.150858
-0.150858
-0.150858
-0.150858
-0.150858
-0.150858
-0.150858
-0.150858
-0.151565
-0.151565
-0.151565
-0.151565
-0.151565
-0.151565
-0.151565
-0.151565
-0.151565
-0.151565
-0.151565
-0.151565
-0.151565
-0.151565
-0.151565
-0.151565
-0.151565
-0.151565
-0.151565
-0.151565
-0.152272
-0.152272
-0.152272
-0.152272
-0.152272
-0.152272
-0.152272
-0.152272
-0.152272
-0.152272
-0.152272
-0.152272
-0.152272
-0.152272
-0.152272
-0.152272
-0.152272
-0.152272
-0.152272
-0.152272
-0.152979
-0.152979
-0.152979
-0.152979
-0.152979
-0.152979
-0.152979
-0.152979
-0.152979
-0.152979
-0.152979
-0.152979
-0.152979
-0.152979
-0.152979
-0.152979
-0.152979
-0.152979
-0.152979
-0.152979
-0.153686
-0.153686
-0.153686
-0.153686
-0.153686
-0.153686
-0.153686
-0.153686
-0.153686
-0.153686
-0.153686
-0.153686
-0.153686
-0.153686
-0.153686
-0.153686
-0.153686
-0.153686
-0.153686
-0.153686
-0.154393
-0.154393
-0.154393
-0.154393
-0.154393
-0.154393
-0.154393
-0.154393
-0.154393
-0.154393
-0.154393
-0.154393
-0.154393
-0.154393
-0.154393
-0.154393
-0.154393
-0.154393
-0.154393
-0.154393
-0.1551
-0.1551
-0.1551
-0.1551
-0.1551
-0.1551
-0.1551
-0.1551
-0.1551
-0.1551
-0.1551
-0.1551
-0.1551
-0.1551
-0.1551
-0.1551
-0.1551
-0.1551
-0.1551
-0.1551
-0.155807
-0.155807
-0.155807
-0.155807
-0.155807
-0.155807
-0.155807
-0.155807
-0.155807
-0.155807
-0.155807
-0.155807
-0.155807
-0.155807
-0.155807
-0.155807
-0.155807
-0.155807
-0.155807
-0.155807
-0.156514
-0.156514
-0.156514
-0.156514
-0.156514
-0.156514
-0.156514
-0.156514
-0.156514
-0.156514
-0.156514
-0.156514
-0.156514
-0.156514
-0.156514
-0.156514
-0.156514
-0.156514
-0.156514
-0.156514
-0.157221
-0.157221
-0.157221
-0.157221
-0.157221
-0.157221
-0.157221
-0.157221
-0.157221
-0.157221
-0.157221
-0.157221
-0.157221
-0.157221
-0.157221
-0.157221
-0.157221
-0.157221
-0.157221
-0.157221
-0.157929
-0.157929
-0.157929
-0.157929
-0.157929
-0.157929
-0.157929
-0.157929
-0.157929
-0.157929
-0.157929
-0.157929
-0.157928
-0.157928
-0.157928
-0.157928
-0.157928
-0.157928
-0.157928
-0.157928
-0.158636
-0.158636
-0.158636
-0.158636
-0.158636
-0.158636
-0.158636
-0.158636
-0.158636
-0.158636
-0.158636
-0.158636
-0.158636
-0.158636
-0.158635
-0.158635
-0.158635
-0.158635
-0.158635
-0.158635
-0.159343
-0.159343
-0.159343
-0.159343
-0.159343
-0.159343
-0.159343
-0.159343
-0.159343
-0.159343
-0.159343
-0.159343
-0.159343
-0.159343
-0.159343
-0.159343
-0.159343
-0.159343
-0.159343
-0.159343
-0.16005
-0.16005
-0.16005
-0.16005
-0.16005
-0.16005
-0.16005
-0.16005
-0.16005
-0.16005
-0.16005
-0.16005
-0.16005
-0.16005
-0.16005
-0.16005
-0.16005
-0.16005
-0.16005
-0.16005
-0.160757
-0.160757
-0.160757
-0.160757
-0.160757
-0.160757
-0.160757
-0.160757
-0.160757
-0.160757
-0.160757
-0.160757
-0.160757
-0.160757
-0.160757
-0.160757
-0.160757
-0.160757
-0.160757
-0.160757
-0.161464
-0.161464
-0.161464
-0.161464
-0.161464
-0.161464
-0.161464
-0.161464
-0.161464
-0.161464
-0.161464
-0.161464
-0.161464
-0.161464
-0.161464
-0.161464
-0.161464
-0.161464
-0.161464
-0.161464
-0.162171
-0.162171
-0.162171
-0.162171
-0.162171
-0.162171
-0.162171
-0.162171
-0.162171
-0.162171
-0.162171
-0.162171
-0.162171
-0.162171
-0.162171
-0.162171
-0.162171
-0.162171
-0.162171
-0.162171
-0.162878
-0.162878
-0.162878
-0.162878
-0.162878
-0.162878
-0.162878
-0.162878
-0.162878
-0.162878
-0.162878
-0.162878
-0.162878
-0.162878
-0.162878
-0.162878
-0.162878
-0.162878
-0.162878
-0.162878
-0.163585
-0.163585
-0.163585
-0.163585
-0.163585
-0.163585
-0.163585
-0.163585
-0.163585
-0.163585
-0.163585
-0.163585
-0.163585
-0.163585
-0.163585
-0.163585
-0.163585
-0.163585
-0.163585
-0.163585
-0.164292
-0.164292
-0.164292
-0.164292
-0.164292
-0.164292
-0.164292
-0.164292
-0.164292
-0.164292
-0.164292
-0.164292
-0.164292
-0.164292
-0.164292
-0.164292
-0.164292
-0.164292
-0.164292
-0.164292
-0.164999
-0.164999
-0.164999
-0.164999
-0.164999
-0.164999
-0.164999
-0.164999
-0.164999
-0.164999
-0.164999
-0.164999
-0.164999
-0.164999
-0.164999
-0.164999
-0.164999
-0.164999
-0.164999
-0.164999
-0.165706
-0.165706
-0.165706
-0.165706
-0.165706
-0.165706
-0.165706
-0.165706
-0.165706
-0.165706
-0.165706
-0.165706
-0.165706
-0.165706
-0.165706
-0.165706
-0.165706
-0.165706
-0.165706
-0.165706
-0.166413
-0.166413
-0.166413
-0.166413
-0.166413
-0.166413
-0.166413
-0.166413
-0.166413
-0.166413
-0.166413
-0.166413
-0.166413
-0.166413
-0.166413
-0.166413
-0.166413
-0.166413
-0.166413
-0.166413
-0.16712
-0.16712
-0.16712
-0.16712
-0.16712
-0.16712
-0.16712
-0.16712
-0.16712
-0.16712
-0.16712
-0.16712
-0.16712
-0.16712
-0.16712
-0.16712
-0.16712
-0.167121
-0.167121
-0.167121
-0.167828
-0.167828
-0.167828
-0.167828
-0.167828
-0.167828
-0.167827
-0.167827
-0.167827
-0.167827
-0.167827
-0.167827
-0.167828
-0.167828
-0.167828
-0.167828
-0.167828
-0.167828
-0.167828
-0.167828
-0.168535
-0.168535
-0.168535
-0.168535
-0.168535
-0.168535
-0.168535
-0.168535
-0.168535
-0.168535
-0.168535
-0.168535
-0.168535
-0.168535
-0.168535
-0.168535
-0.168535
-0.168535
-0.168535
-0.168535
-0.169242
-0.169242
-0.169242
-0.169242
-0.169242
-0.169242
-0.169242
-0.169242
-0.169242
-0.169242
-0.169242
-0.169242
-0.169242
-0.169242
-0.169242
-0.169242
-0.169242
-0.169242
-0.169242
-0.169242
-0.169949
-0.169949
-0.169949
-0.169949
-0.169949
-0.169949
-0.169949
-0.169949
-0.169949
-0.169949
-0.169949
-0.169949
-0.169949
-0.169949
-0.169949
-0.169949
-0.169949
-0.169949
-0.169949
-0.169949
-0.170656
-0.170656
-0.170656
-0.170656
-0.170656
-0.170656
-0.170656
-0.170656
-0.170656
-0.170656
-0.170656
-0.170656
-0.170656
-0.170656
-0.170656
-0.170656
-0.170656
-0.170656
-0.170656
-0.170656
-0.171363
-0.171363
-0.171363
-0.171363
-0.171363
-0.171363
-0.171363
-0.171363
-0.171363
-0.171363
-0.171363
-0.171363
-0.171363
-0.171363
-0.171363
-0.171363
-0.171363
-0.171363
-0.171363
-0.171363
-0.17207
-0.17207
-0.17207
-0.17207
-0.17207
-0.17207
-0.17207
-0.17207
-0.17207
-0.17207
-0.17207
-0.17207
-0.17207
-0.17207
-0.17207
-0.17207
-0.17207
-0.17207
-0.17207
-0.17207
-0.172777
-0.172777
-0.172777
-0.172777
-0.172777
-0.172777
-0.172777
-0.172777
-0.172777
-0.172777
-0.172777
-0.172777
-0.172777
-0.172777
-0.172777
-0.172777
-0.172777
-0.172777
-0.172777
-0.172777
-0.173484
-0.173484
-0.173484
-0.173484
-0.173484
-0.173484
-0.173484
-0.173484
-0.173484
-0.173484
-0.173484
-0.173484
-0.173484
-0.173484
-0.173484
-0.173484
-0.173484
-0.173484
-0.173484
-0.173484
-0.174191
-0.174191
-0.174191
-0.174191
-0.174191
-0.174191
-0.174191
-0.174191
-0.174191
-0.174191
-0.174191
-0.174191
-0.174191
-0.174191
-0.174191
-0.174191
-0.174191
-0.174191
-0.174191
-0.174191
-0.174898
-0.174898
-0.174898
-0.174898
-0.174898
-0.174898
-0.174898
-0.174898
-0.174898
-0.174898
-0.174898
-0.174898
-0.174898
-0.174898
-0.174898
-0.174898
-0.174898
-0.174898
-0.174898
-0.174898
-0.175605
-0.175605
-0.175605
-0.175605
-0.175605
-0.175605
-0.175605
-0.175605
-0.175605
-0.175605
-0.175605
-0.175605
-0.175605
-0.175605
-0.175605
-0.175605
-0.175605
-0.175605
-0.175605
-0.175605
-0.176312
-0.176312
-0.176312
-0.176312
-0.176312
-0.176312
-0.176312
-0.176312
-0.176312
-0.176312
-0.176312
-0.176312
-0.176312
-0.176312
-0.176312
-0.176312
-0.176312
-0.176312
-0.176312
-0.176312
-0.177019
-0.177019
-0.177019
-0.177019
-0.177019
-0.17702
-0.17702
-0.17702
-0.17702
-0.17702
-0.17702
-0.17702
-0.17702
-0.177019
-0.177019
-0.177019
-0.177019
-0.177019
-0.177019
-0.177019
-0.177726
-0.177726
-0.177727
-0.177727
-0.177727
-0.177727
-0.177727
-0.177727
-0.177727
-0.177727
-0.177727
-0.177727
-0.177727
-0.177727
-0.177727
-0.177727
-0.177727
-0.177727
-0.177727
-0.177727
-0.178434
-0.178434
-0.178434
-0.178434
-0.178434
-0.178434
-0.178434
-0.178434
-0.178434
-0.178434
-0.178434
-0.178434
-0.178434
-0.178434
-0.178434
-0.178434
-0.178434
-0.178434
-0.178434
-0.178434
-0.179141
-0.179141
-0.179141
-0.179141
-0.179141
-0.179141
-0.179141
-0.179141
-0.179141
-0.179141
-0.179141
-0.179141
-0.179141
-0.179141
-0.179141
-0.179141
-0.179141
-0.179141
-0.179141
-0.179141
-0.179848
-0.179848
-0.179848
-0.179848
-0.179848
-0.179848
-0.179848
-0.179848
-0.179848
-0.179848
-0.179848
-0.179848
-0.179848
-0.179848
-0.179848
-0.179848
-0.179848
-0.179848
-0.179848
-0.179848
-0.180555
-0.180555
-0.180555
-0.180555
-0.180555
-0.180555
-0.180555
-0.180555
-0.180555
-0.180555
-0.180555
-0.180555
-0.180555
-0.180555
-0.180555
-0.180555
-0.180555
-0.180555
-0.180555
-0.180555
-0.181262
-0.181262
-0.181262
-0.181262
-0.181262
-0.181262
-0.181262
-0.181262
-0.181262
-0.181262
-0.181262
-0.181262
-0.181262
-0.181262
-0.181262
-0.181262
-0.181262
-0.181262
-0.181262
-0.181262
-0.181969
-0.181969
-0.181969
-0.181969
-0.181969
-0.181969
-0.181969
-0.181969
-0.181969
-0.181969
-0.181969
-0.181969
-0.181969
-0.181969
-0.181969
-0.181969
-0.181969
-0.181969
-0.181969
-0.181969
-0.182676
-0.182676
-0.182676
-0.182676
-0.182676
-0.182676
-0.182676
-0.182676
-0.182676
-0.182676
-0.182676
-0.182676
-0.182676
-0.182676
-0.182676
-0.182676
-0.182676
-0.182676
-0.182676
-0.182676
-0.183383
-0.183383
-0.183383
-0.183383
-0.183383
-0.183383
-0.183383
-0.183383
-0.183383
-0.183383
-0.183383
-0.183383
-0.183383
-0.183383
-0.183383
-0.183383
-0.183383
-0.183383
-0.183383
-0.183383
-0.18409
-0.18409
-0.18409
-0.18409
-0.18409
-0.18409
-0.18409
-0.18409
-0.18409
-0.18409
-0.18409
-0.18409
-0.18409
-0.18409
-0.18409
-0.18409
-0.18409
-0.18409
-0.18409
-0.18409
-0.184797
-0.184797
-0.184797
-0.184797
-0.184797
-0.184797
-0.184797
-0.184797
-0.184797
-0.184797
-0.184797
-0.184797
-0.184797
-0.184797
-0.184797
-0.184797
-0.184797
-0.184797
-0.184797
-0.184797
-0.185504
-0.185504
-0.185504
-0.185504
-0.185504
-0.185504
-0.185504
-0.185504
-0.185504
-0.185505
-0.185505
-0.185505
-0.185505
-0.185505
-0.185505
-0.185505
-0.185505
-0.185505
-0.185505
-0.185505
-0.186211
-0.186211
-0.186212
-0.186212
-0.186212
-0.186212
-0.186212
-0.186212
-0.186212
-0.186212
-0.186212
-0.186212
-0.186212
-0.186212
-0.186212
-0.186212
-0.186212
-0.186212
-0.186212
-0.186212
-0.186919
-0.186919
-0.186919
-0.186919
-0.186919
-0.186919
-0.186919
-0.186919
-0.186919
-0.186919
-0.186919
-0.186919
-0.186919
-0.186919
-0.186919
-0.186919
-0.186919
-0.186919
-0.186919
-0.186919
-0.187626
-0.187626
-0.187626
-0.187626
-0.187626
-0.187626
-0.187626
-0.187626
-0.187626
-0.187626
-0.187626
-0.187626
-0.187626
-0.187626
-0.187626
-0.187626
-0.187626
-0.187626
-0.187626
-0.187626
-0.188333
-0.188333
-0.188333
-0.188333
-0.188333
-0.188333
-0.188333
-0.188333
-0.188333
-0.188333
-0.188333
-0.188333
-0.188333
-0.188333
-0.188333
-0.188333
-0.188333
-0.188333
-0.188333
-0.188333
-0.18904
-0.18904
-0.18904
-0.18904
-0.18904
-0.18904
-0.18904
-0.18904
-0.18904
-0.18904
-0.18904
-0.18904
-0.18904
-0.18904
-0.18904
-0.18904
-0.18904
-0.18904
-0.18904
-0.18904
-0.189747
-0.189747
-0.189747
-0.189747
-0.189747
-0.189747
-0.189747
-0.189747
-0.189747
-0.189747
-0.189747
-0.189747
-0.189747
-0.189747
-0.189747
-0.189747
-0.189747
-0.189747
-0.189747
-0.189747
-0.190454
-0.190454
-0.190454
-0.190454
-0.190454
-0.190454
-0.190454
-0.190454
-0.190454
-0.190454
-0.190454
-0.190454
-0.190454
-0.190454
-0.190454
-0.190454
-0.190454
-0.190454
-0.190454
-0.190454
-0.191161
-0.191161
-0.191161
-0.191161
-0.191161
-0.191161
-0.191161
-0.191161
-0.191161
-0.191161
-0.191161
-0.191161
-0.191161
-0.191161
-0.191161
-0.191161
-0.191161
-0.191161
-0.191161
-0.191161
-0.191868
-0.191868
-0.191868
-0.191868
-0.191868
-0.191868
-0.191868
-0.191868
-0.191868
-0.191868
-0.191868
-0.191868
-0.191868
-0.191868
-0.191868
-0.191868
-0.191868
-0.191868
-0.191868
-0.191868
-0.192575
-0.192575
-0.192575
-0.192575
-0.192575
-0.192575
-0.192575
-0.192575
-0.192575
-0.192575
-0.192575
-0.192575
-0.192575
-0.192576
-0.192576
-0.192576
-0.192576
-0.192576
-0.192576
-0.192576
-0.193283
-0.193283
-0.193283
-0.193283
-0.193283
-0.193283
-0.193283
-0.193283
-0.193283
-0.193283
-0.193283
-0.193283
-0.193283
-0.193283
-0.193283
-0.193283
-0.193283
-0.193283
-0.193283
-0.193283
-0.19399
-0.19399
-0.19399
-0.19399
-0.19399
-0.19399
-0.19399
-0.19399
-0.19399
-0.19399
-0.19399
-0.19399
-0.19399
-0.19399
-0.19399
-0.19399
-0.19399
-0.19399
-0.19399
-0.19399
-0.194697
-0.194697
-0.194697
-0.194697
-0.194697
-0.194697
-0.194697
-0.194697
-0.194697
-0.194697
-0.194697
-0.194697
-0.194697
-0.194697
-0.194697
-0.194697
-0.194697
-0.194697
-0.194697
-0.194697
-0.195404
-0.195404
-0.195404
-0.195404
-0.195404
-0.195404
-0.195404
-0.195404
-0.195404
-0.195404
-0.195404
-0.195404
-0.195404
-0.195404
-0.195404
-0.195404
-0.195404
-0.195404
-0.195404
-0.195404
-0.196111
-0.196111
-0.196111
-0.196111
-0.196111
-0.196111
-0.196111
-0.196111
-0.196111
-0.196111
-0.196111
-0.196111
-0.196111
-0.196111
-0.196111
-0.196111
-0.196111
-0.196111
-0.196111
-0.196111
-0.196818
-0.196818
-0.196818
-0.196818
-0.196818
-0.196818
-0.196818
-0.196818
-0.196818
-0.196818
-0.196818
-0.196818
-0.196818
-0.196818
-0.196818
-0.196818
-0.196818
-0.196818
-0.196818
-0.196818
-0.197525
-0.197525
-0.197525
-0.197525
-0.197525
-0.197525
-0.197525
-0.197525
-0.197525
-0.197525
-0.197525
-0.197525
-0.197525
-0.197525
-0.197525
-0.197525
-0.197525
-0.197525
-0.197525
-0.197525
-0.198232
-0.198232
-0.198232
-0.198232
-0.198232
-0.198232
-0.198232
-0.198232
-0.198232
-0.198232
-0.198232
-0.198232
-0.198232
-0.198232
-0.198232
-0.198232
-0.198232
-0.198232
-0.198232
-0.198232
-0.198939
-0.198939
-0.198939
-0.198939
-0.198939
-0.198939
-0.198939
-0.198939
-0.198939
-0.198939
-0.198939
-0.198939
-0.198939
-0.198939
-0.198939
-0.198939
-0.198939
-0.198939
-0.198939
-0.198939
-0.199646
-0.199646
-0.199646
-0.199646
-0.199646
-0.199646
-0.199646
-0.199646
-0.199646
-0.199646
-0.199646
-0.199646
-0.199646
-0.199646
-0.199646
-0.199646
-0.199646
-0.199646
-0.199646
-0.199646
)
;
boundaryField
{
inlet
{
type calculated;
value uniform 0;
}
atmosphere
{
type calculated;
value nonuniform List<scalar>
20
(
-0.2
-0.2
-0.2
-0.2
-0.2
-0.2
-0.2
-0.2
-0.2
-0.2
-0.2
-0.2
-0.2
-0.2
-0.2
-0.2
-0.2
-0.2
-0.2
-0.2
)
;
}
walls
{
type calculated;
value nonuniform List<scalar>
800
(
-0.252266
-0.75684
-1.26143
-1.76604
-2.27064
-2.77524
-3.27984
-3.78445
-4.28905
-4.79365
-5.29825
-5.80285
-6.30745
-6.81205
-7.31665
-7.82125
-8.32585
-8.83044
-9.33504
-9.83964
-10.3442
-10.8488
-11.3534
-11.858
-12.3626
-12.8672
-13.3718
-13.8764
-14.381
-14.8856
-15.3902
-15.8948
-16.3994
-16.904
-17.4086
-17.9132
-18.4177
-18.9223
-19.4269
-19.9315
-20.4361
-20.9407
-21.4453
-21.9499
-22.4545
-22.9591
-23.4637
-23.9683
-24.4729
-24.9775
-25.4821
-25.9867
-26.4913
-26.9959
-27.5004
-28.005
-28.5096
-29.0142
-29.5188
-30.0234
-30.528
-31.0326
-31.5372
-32.0418
-32.5464
-33.051
-33.5556
-34.0602
-34.5648
-35.0694
-35.574
-36.0786
-36.5831
-37.0877
-37.5923
-38.0969
-38.6015
-39.1061
-39.6107
-40.1153
-40.6199
-41.1245
-41.6291
-42.1337
-42.6383
-43.1429
-43.6475
-44.1521
-44.6567
-45.1613
-45.6659
-46.1705
-46.6751
-47.1797
-47.6843
-48.1889
-48.6934
-49.198
-49.7026
-50.2072
-50.7118
-51.2164
-51.721
-52.2256
-52.7302
-53.2348
-53.7394
-54.244
-54.7486
-55.2532
-55.7578
-56.2624
-56.767
-57.2716
-57.7762
-58.2808
-58.7854
-59.2899
-59.7945
-60.2991
-60.8037
-61.3083
-61.8129
-62.3175
-62.8221
-63.3267
-63.8313
-64.3359
-64.8405
-65.3451
-65.8497
-66.3542
-66.8588
-67.3634
-67.868
-68.3726
-68.8772
-69.3818
-69.8863
-70.3909
-70.8955
-71.4
-71.9045
-72.409
-72.9135
-73.418
-73.9223
-74.4267
-74.9309
-75.4349
-75.9388
-76.4425
-76.9458
-77.4488
-77.9511
-78.4527
-78.9535
-79.4531
-79.9508
-80.4433
-80.9443
-81.4442
-81.8529
-82.3766
-82.8324
-83.2749
-83.6966
-84.0824
-84.4174
-84.6853
-84.8361
-84.8489
-84.605
-84.1137
-83.186
-82.0258
-81.2437
-79.6351
-82.6753
-90.4022
-68.9657
-53.8029
-7.97736
0.126579
0.138598
0.0542997
-0.00476145
-0.0315332
-0.042937
-0.0482844
-0.0509862
-0.0525163
-0.0535168
-0.0542936
-0.0549794
-0.055635
-0.0562869
-0.0569452
-0.0576128
-0.0582893
-0.0589737
-0.0596641
-0.0603593
-0.0610581
-0.0617594
-0.0624627
-0.0631674
-0.0638731
-0.0645795
-0.0652862
-0.0659933
-0.0667005
-0.0674079
-0.0681152
-0.0688225
-0.0695298
-0.0702371
-0.0709444
-0.0716516
-0.0723588
-0.0730661
-0.0737732
-0.0744804
-0.0751876
-0.0758947
-0.0766018
-0.077309
-0.0780161
-0.0787233
-0.0794304
-0.0801376
-0.0808448
-0.0815519
-0.0822591
-0.0829662
-0.0836734
-0.0843806
-0.0850877
-0.0857949
-0.0865021
-0.0872093
-0.0879165
-0.0886237
-0.0893309
-0.0900381
-0.0907453
-0.0914525
-0.0921597
-0.0928669
-0.0935741
-0.0942813
-0.0949885
-0.0956957
-0.0964029
-0.0971101
-0.0978174
-0.0985246
-0.0992318
-0.099939
-0.100646
-0.101354
-0.102061
-0.102768
-0.103475
-0.104182
-0.10489
-0.105597
-0.106304
-0.107011
-0.107719
-0.108426
-0.109133
-0.109841
-0.110548
-0.111255
-0.111962
-0.11267
-0.113377
-0.114084
-0.114791
-0.115499
-0.116206
-0.116913
-0.11762
-0.118328
-0.119035
-0.119742
-0.120449
-0.121157
-0.121864
-0.122571
-0.123278
-0.123985
-0.124693
-0.1254
-0.126107
-0.126814
-0.127522
-0.128229
-0.128936
-0.129643
-0.13035
-0.131058
-0.131765
-0.132472
-0.133179
-0.133886
-0.134593
-0.135301
-0.136008
-0.136715
-0.137422
-0.138129
-0.138836
-0.139544
-0.140251
-0.140958
-0.141665
-0.142372
-0.143079
-0.143787
-0.144494
-0.145201
-0.145908
-0.146615
-0.147322
-0.148029
-0.148737
-0.149444
-0.150151
-0.150858
-0.151565
-0.152272
-0.152979
-0.153686
-0.154393
-0.1551
-0.155807
-0.156514
-0.157221
-0.157929
-0.158636
-0.159343
-0.16005
-0.160757
-0.161464
-0.162171
-0.162878
-0.163585
-0.164292
-0.164999
-0.165706
-0.166413
-0.16712
-0.167828
-0.168535
-0.169242
-0.169949
-0.170656
-0.171363
-0.17207
-0.172777
-0.173484
-0.174191
-0.174898
-0.175605
-0.176312
-0.177019
-0.177726
-0.178434
-0.179141
-0.179848
-0.180555
-0.181262
-0.181969
-0.182676
-0.183383
-0.18409
-0.184797
-0.185504
-0.186211
-0.186919
-0.187626
-0.188333
-0.18904
-0.189747
-0.190454
-0.191161
-0.191868
-0.192575
-0.193283
-0.19399
-0.194697
-0.195404
-0.196111
-0.196818
-0.197525
-0.198232
-0.198939
-0.199646
-0.252266
-0.756839
-1.26143
-1.76603
-2.27064
-2.77524
-3.27984
-3.78445
-4.28905
-4.79365
-5.29825
-5.80285
-6.30745
-6.81205
-7.31665
-7.82125
-8.32585
-8.83044
-9.33504
-9.83964
-10.3442
-10.8488
-11.3534
-11.858
-12.3626
-12.8672
-13.3718
-13.8764
-14.381
-14.8856
-15.3902
-15.8948
-16.3994
-16.904
-17.4086
-17.9132
-18.4177
-18.9223
-19.4269
-19.9315
-20.4361
-20.9407
-21.4453
-21.9499
-22.4545
-22.9591
-23.4637
-23.9683
-24.4729
-24.9775
-25.4821
-25.9867
-26.4913
-26.9959
-27.5005
-28.005
-28.5096
-29.0142
-29.5188
-30.0234
-30.528
-31.0326
-31.5372
-32.0418
-32.5464
-33.051
-33.5556
-34.0602
-34.5648
-35.0694
-35.574
-36.0786
-36.5831
-37.0877
-37.5923
-38.0969
-38.6015
-39.1061
-39.6107
-40.1153
-40.6199
-41.1245
-41.6291
-42.1337
-42.6383
-43.1429
-43.6475
-44.1521
-44.6567
-45.1613
-45.6659
-46.1705
-46.6751
-47.1797
-47.6843
-48.1889
-48.6934
-49.198
-49.7026
-50.2072
-50.7118
-51.2164
-51.721
-52.2256
-52.7302
-53.2348
-53.7394
-54.244
-54.7486
-55.2532
-55.7578
-56.2624
-56.767
-57.2716
-57.7762
-58.2808
-58.7854
-59.2899
-59.7945
-60.2991
-60.8037
-61.3083
-61.8129
-62.3175
-62.8221
-63.3267
-63.8313
-64.3359
-64.8405
-65.3451
-65.8497
-66.3542
-66.8588
-67.3634
-67.868
-68.3726
-68.8772
-69.3818
-69.8863
-70.3909
-70.8955
-71.4
-71.9045
-72.409
-72.9135
-73.418
-73.9223
-74.4267
-74.9309
-75.4349
-75.9388
-76.4425
-76.9458
-77.4488
-77.9511
-78.4527
-78.9535
-79.4531
-79.9508
-80.4431
-80.9448
-81.444
-81.8528
-82.3766
-82.8325
-83.2749
-83.6966
-84.0824
-84.4172
-84.685
-84.8359
-84.8487
-84.6047
-84.1134
-83.1857
-82.0256
-81.2436
-79.6349
-82.6751
-90.4021
-68.9654
-53.8031
-7.97741
0.126578
0.138598
0.0543006
-0.00476067
-0.0315324
-0.042936
-0.0482833
-0.050985
-0.0525148
-0.053515
-0.0542914
-0.0549772
-0.0556333
-0.0562862
-0.0569458
-0.0576148
-0.0582924
-0.0589776
-0.0596686
-0.060364
-0.0610626
-0.0617637
-0.0624665
-0.0631707
-0.0638758
-0.0645817
-0.0652881
-0.0659948
-0.0667017
-0.0674088
-0.0681159
-0.0688232
-0.0695304
-0.0702376
-0.0709448
-0.071652
-0.0723591
-0.0730663
-0.0737734
-0.0744806
-0.0751877
-0.0758948
-0.0766019
-0.0773091
-0.0780162
-0.0787233
-0.0794304
-0.0801376
-0.0808447
-0.0815518
-0.082259
-0.0829661
-0.0836733
-0.0843804
-0.0850876
-0.0857948
-0.0865019
-0.0872091
-0.0879163
-0.0886235
-0.0893307
-0.0900379
-0.0907451
-0.0914523
-0.0921595
-0.0928667
-0.093574
-0.0942812
-0.0949884
-0.0956957
-0.0964029
-0.0971102
-0.0978174
-0.0985247
-0.0992319
-0.0999392
-0.100646
-0.101354
-0.102061
-0.102768
-0.103475
-0.104183
-0.10489
-0.105597
-0.106304
-0.107012
-0.107719
-0.108426
-0.109133
-0.109841
-0.110548
-0.111255
-0.111962
-0.11267
-0.113377
-0.114084
-0.114791
-0.115499
-0.116206
-0.116913
-0.117621
-0.118328
-0.119035
-0.119742
-0.12045
-0.121157
-0.121864
-0.122571
-0.123278
-0.123986
-0.124693
-0.1254
-0.126107
-0.126815
-0.127522
-0.128229
-0.128936
-0.129643
-0.13035
-0.131058
-0.131765
-0.132472
-0.133179
-0.133886
-0.134594
-0.135301
-0.136008
-0.136715
-0.137422
-0.138129
-0.138837
-0.139544
-0.140251
-0.140958
-0.141665
-0.142372
-0.14308
-0.143787
-0.144494
-0.145201
-0.145908
-0.146615
-0.147322
-0.148029
-0.148736
-0.149443
-0.15015
-0.150858
-0.151565
-0.152272
-0.152979
-0.153686
-0.154393
-0.1551
-0.155807
-0.156514
-0.157221
-0.157928
-0.158635
-0.159343
-0.16005
-0.160757
-0.161464
-0.162171
-0.162878
-0.163585
-0.164292
-0.164999
-0.165706
-0.166413
-0.167121
-0.167828
-0.168535
-0.169242
-0.169949
-0.170656
-0.171363
-0.17207
-0.172777
-0.173484
-0.174191
-0.174898
-0.175605
-0.176312
-0.177019
-0.177727
-0.178434
-0.179141
-0.179848
-0.180555
-0.181262
-0.181969
-0.182676
-0.183383
-0.18409
-0.184797
-0.185505
-0.186212
-0.186919
-0.187626
-0.188333
-0.18904
-0.189747
-0.190454
-0.191161
-0.191868
-0.192576
-0.193283
-0.19399
-0.194697
-0.195404
-0.196111
-0.196818
-0.197525
-0.198232
-0.198939
-0.199646
)
;
}
frontAndBack
{
type empty;
}
}
// ************************************************************************* //
| [
"mizuha.watanabe@gmail.com"
] | mizuha.watanabe@gmail.com | |
450cf70d0dda79b94dcf261355fc365762c17337 | f2ddec489963578c9b5ebebef73639b590503e1a | /headers/container.h | 20d6ccc539b215679ec1e16d050f1f70294947f0 | [] | no_license | Vikt0r-Nekrutenko/sotp | 732376080599162b92be9331c3dc7702bce56d96 | 2653bb105b52bbe29dbebb9a2fd7778b751a85c9 | refs/heads/master | 2020-04-13T00:18:02.244351 | 2018-12-22T21:05:33 | 2018-12-22T21:37:30 | 150,176,895 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 353 | h | #ifndef CONTAINER_H
#define CONTAINER_H
#include <string>
#include <vector>
class container
{
public:
container();
~container();
void add(const int& _value);
const int getPrime(const std::size_t _index)const;
const std::string getStr()const;
const std::size_t getSize()const;
private:
std::vector<int> m_ranges_of_prime;
};
#endif
| [
"pro100alcoholic@gmail.com"
] | pro100alcoholic@gmail.com |
b4dba859adbe70000516a08dffd633daf76f17d5 | f0f225e4eeb47522991d6f8ef9e02a39a0735489 | /OpenGL/OpenGL/src/VertexBuffer.h | 130810f6a1d0f7ceebee62c4f65fe69be7116a72 | [] | no_license | raytracingDevTeam/OpenGL-vs | 7c5f0fe5ca312652a8de76581ec0c7e23308cf99 | 84f2276bc3ab521cf01d2af8a9096a46d1ac48e5 | refs/heads/master | 2020-03-21T16:26:30.708464 | 2018-06-26T17:24:46 | 2018-06-26T17:24:46 | 138,769,936 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 267 | h | #pragma once
#ifndef OPENGL_VERTEXBUFFER_H
#define OPENGL_VERTEXBUFFER_H
class VertexBuffer
{
private:
unsigned int m_RendererID;
public:
VertexBuffer(const void* data, unsigned int size);
~VertexBuffer();
void Bind() const;
void Unbind() const;
};
#endif | [
"rastelliandrea87@gmail.com"
] | rastelliandrea87@gmail.com |
b0f5c1b51a2fc818816903a107e9c9122a0c5358 | dd949f215d968f2ee69bf85571fd63e4f085a869 | /systems/css-2011-teams/red/subarchitectures/vision.sa/src/c++/vision/components/VirtualScene/TomGine/include/tgLighting.h | 02a635d4dab6016dbc5f5356e06a9141e0aae012 | [] | no_license | marc-hanheide/cogx | a3fd395805f1b0ad7d713a05b9256312757b37a9 | cb9a9c9cdfeba02afac6a83d03b7c6bb778edb95 | refs/heads/master | 2022-03-16T23:36:21.951317 | 2013-12-10T23:49:07 | 2013-12-10T23:49:07 | 219,460,352 | 1 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 879 | h | /**
* @file tgLighting.h
* @author Thomas Mörwald
* @date October 2009
* @version 0.1
* @brief Defining OpenGL lighting conditions.
*/
#ifndef TG_LIGHTING
#define TG_LIGHTING
#include <GL/gl.h>
#include "tgMathlib.h"
namespace TomGine{
/**
* @brief Struct tgLight
*
* Light settings
*/
struct tgLight{
vec4 ambient;
vec4 diffuse;
vec4 specular;
vec4 position;
tgLight();
};
/**
* @brief Class tgLighting
*
* Handling lighting in OpenGL
*/
class tgLighting
{
private:
vec3 lightPos;
vec3 lightDir;
public:
void ApplyLight(tgLight light, int index=0);
void Activate();
void Deactivate();
void SetLightPos(vec3 v){ lightPos = v; }
void SetLightDir(vec3 v){ lightDir = v; }
void SetLightPos(float x, float y, float z){ lightPos = vec3(x,y,z); }
void SetLightDir(float x, float y, float z){ lightDir = vec3(x,y,z); }
};
} // namespace TomGine
#endif
| [
"marc@hanheide.net"
] | marc@hanheide.net |
ab5f53899c17b023203d1fa754813b804616a071 | 1f7974bf7bd5b5c91998e2022828f3a277ff7556 | /字符串/HDU-4821-hash.cc | 4671d8b7fd557a243890bec0e5569e28866a5826 | [
"MIT"
] | permissive | gkishard-workingboy/Algorithm-challenger | 1eda8a5d2ab567a1494a21c90ac750e1f559eae4 | 43336871a5e48f8804d6e737c813d9d4c0dc2731 | refs/heads/master | 2022-11-18T05:14:24.904034 | 2020-07-14T13:42:43 | 2020-07-14T13:42:43 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,718 | cc | /*
* Created by OFShare on 2020-01-25, 春节期间
*
*/
#include <cstdio>
#include <iostream>
#include <cstring>
#include <string>
#include <map>
const int maxn = 1e5 + 5;
// 其中seed是顺便选择的基数
// 对一个串通过init_left, init_right的预处理后,就用get_hash(i,L)可以得到从位置i开始的,长度为L的子串的hash值.
// seed: 31 131 1313 13131 131313 etc.
const int seed = 131;
typedef unsigned long long ull;
ull hashLeft[maxn], hashRight[maxn];
void init_left() {
hashLeft[0] = 1;
for (int i = 1; i < maxn; i++)
hashLeft[i] = hashLeft[i - 1] * seed;
}
void init_right(const char* str) {
int len = strlen(str);
hashRight[len] = 0;
for (int i = len - 1; i >= 0; --i) {
hashRight[i] = hashRight[i + 1] * seed + (str[i] - 'a' + 1);
}
}
ull get_hash(int i,int L) {
return hashRight[i] - hashRight[i + L] * hashLeft[L];
}
int M, L;
char tmp[maxn];
int main() {
init_left();
while (scanf("%d %d", &M, &L) != EOF) {
scanf("%s", tmp);
std::string str = std::string(tmp);
init_right(tmp);
int ans = 0;
// i < L 只枚举开头, 后面的用滑动窗口枚举
for (int i = 0; i < L && i + M * L <= str.size(); ++i) {
std::map<ull, int> mp;
// 窗口初始化, 第一个窗口
for (int j = i; j + L <= i + M * L; j += L) {
ull d = get_hash(j, L);
mp[d]++;
}
if (mp.size() == M)
++ans;
// 模拟窗口移动, 先删除前一个, 再加入后一个
for (int j = i + M * L + L; j <= str.size(); j += L) {
ull d = get_hash(j - L - M * L, L);
mp[d]--;
if (mp[d] == 0)
mp.erase(d);
d = get_hash(j - L, L);
mp[d]++;
if (mp.size() == M)
++ans;
}
}
printf("%d\n", ans);
}
return 0;
}
| [
"OFShare@outlook.com"
] | OFShare@outlook.com |
bd5ed783585c52b9f99f180d8557bc272f2e907a | 102527d10f3d6d71ed8799fa079300615b505f1f | /Engine/Graphics.h | abcd35b8518cf10c45732ecb5c54234be4638cd2 | [] | no_license | Patrykz94/Snek-Game | efd52b408d88c4f9d18b243d5ca44ae412667f7e | 36ea13f67e2d8e62af0da4043548764cacdae95b | refs/heads/master | 2021-01-18T20:01:41.961758 | 2018-02-20T16:21:57 | 2018-02-20T16:21:57 | 86,928,009 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,570 | h | /******************************************************************************************
* Chili DirectX Framework Version 16.07.20 *
* Graphics.h *
* Copyright 2016 PlanetChili <http://www.planetchili.net> *
* *
* This file is part of The Chili DirectX Framework. *
* *
* The Chili DirectX Framework is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* The Chili DirectX Framework 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 The Chili DirectX Framework. If not, see <http://www.gnu.org/licenses/>. *
******************************************************************************************/
#pragma once
#include <d3d11.h>
#include <wrl.h>
#include "ChiliException.h"
#include "Colors.h"
class Graphics
{
public:
class Exception : public ChiliException
{
public:
Exception( HRESULT hr,const std::wstring& note,const wchar_t* file,unsigned int line );
std::wstring GetErrorName() const;
std::wstring GetErrorDescription() const;
virtual std::wstring GetFullMessage() const override;
virtual std::wstring GetExceptionType() const override;
private:
HRESULT hr;
};
private:
// vertex format for the framebuffer fullscreen textured quad
struct FSQVertex
{
float x,y,z; // position
float u,v; // texcoords
};
public:
Graphics( class HWNDKey& key );
Graphics( const Graphics& ) = delete;
Graphics& operator=( const Graphics& ) = delete;
void EndFrame();
void BeginFrame();
void PutPixel( int x,int y,int r,int g,int b )
{
PutPixel( x,y,{ unsigned char( r ),unsigned char( g ),unsigned char( b ) } );
}
void PutPixel( int x,int y,Color c );
void DrawRect( int x0,int y0,int x1,int y1,Color c );
void DrawRectDim( int x0,int y0,int width,int height,Color c )
{
DrawRect( x0,y0,x0 + width,y0 + height,c );
}
void DrawBorder(int x0, int y0, int x1, int y1, int thickness, Color c);
void DrawBorderDim(int x0, int y0, int width, int height, int thickness, Color c)
{
DrawBorder(x0, y0, x0 + width, y0 + height, thickness, c);
}
~Graphics();
private:
Microsoft::WRL::ComPtr<IDXGISwapChain> pSwapChain;
Microsoft::WRL::ComPtr<ID3D11Device> pDevice;
Microsoft::WRL::ComPtr<ID3D11DeviceContext> pImmediateContext;
Microsoft::WRL::ComPtr<ID3D11RenderTargetView> pRenderTargetView;
Microsoft::WRL::ComPtr<ID3D11Texture2D> pSysBufferTexture;
Microsoft::WRL::ComPtr<ID3D11ShaderResourceView> pSysBufferTextureView;
Microsoft::WRL::ComPtr<ID3D11PixelShader> pPixelShader;
Microsoft::WRL::ComPtr<ID3D11VertexShader> pVertexShader;
Microsoft::WRL::ComPtr<ID3D11Buffer> pVertexBuffer;
Microsoft::WRL::ComPtr<ID3D11InputLayout> pInputLayout;
Microsoft::WRL::ComPtr<ID3D11SamplerState> pSamplerState;
D3D11_MAPPED_SUBRESOURCE mappedSysBufferTexture;
Color* pSysBuffer = nullptr;
public:
static constexpr int ScreenWidth = 800;
static constexpr int ScreenHeight = 600;
}; | [
"zawpat@googlemail.com"
] | zawpat@googlemail.com |
ab60ba4830e6b694a717c1b7c304dd429dbc6f21 | 35b929181f587c81ad507c24103d172d004ee911 | /Bundles/LeafUI/uiImageQt/include/uiImageQt/WindowLevel.hpp | 0ca170663c16ea7e1254f1cad7f246f679d2bf83 | [] | no_license | hamalawy/fw4spl | 7853aa46ed5f96660123e88d2ba8b0465bd3f58d | 680376662bf3fad54b9616d1e9d4c043d9d990df | refs/heads/master | 2021-01-10T11:33:53.571504 | 2015-07-23T08:01:59 | 2015-07-23T08:01:59 | 50,699,438 | 2 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 5,152 | hpp | /* ***** BEGIN LICENSE BLOCK *****
* FW4SPL - Copyright (C) IRCAD, 2009-2012.
* Distributed under the terms of the GNU Lesser General Public License (LGPL) as
* published by the Free Software Foundation.
* ****** END LICENSE BLOCK ****** */
#ifndef _UIIMAGEQT_WINDOWLEVEL_HPP_
#define _UIIMAGEQT_WINDOWLEVEL_HPP_
#include <QObject>
#include <QPointer>
#include <fwTools/Failed.hpp>
#include <fwData/Integer.hpp>
#include <gui/editor/IEditor.hpp>
#include <fwComEd/helper/MedicalImageAdaptor.hpp>
#include "uiImageQt/config.hpp"
class QAction;
class QComboBox;
class QLabel;
class QLineEdit;
class QMenu;
class QSlider;
class QToolButton;
class QSignalMapper;
fwCorePredeclare( (fwGuiQt)(widget)(QRangeSlider) );
namespace uiImage
{
/**
* @brief WindowLevel service allows to change the min / max value of windowing.
* @class WindowLevel
*
* @date 2010-2011.
*
* This is represented by
* - two sliders to modify the min, max value of windowing
*/
class UIIMAGEQT_CLASS_API WindowLevel : public QObject, public ::fwComEd::helper::MedicalImageAdaptor, public ::gui::editor::IEditor
{
Q_OBJECT
public :
fwCoreServiceClassDefinitionsMacro ( (WindowLevel)(::gui::editor::IEditor) ) ;
/// Constructor. Do nothing.
UIIMAGEQT_API WindowLevel() throw() ;
/// Destructor. Do nothing.
UIIMAGEQT_API virtual ~WindowLevel() throw() ;
UIIMAGEQT_API void notifyWindowLevelCallback();
protected:
/**
* @brief Install the layout.
*/
virtual void starting() throw(::fwTools::Failed);
/**
* @brief Destroy the layout.
*/
virtual void stopping() throw(::fwTools::Failed);
/// Management of observations : update editor according to the received message
virtual void receiving( ::boost::shared_ptr< const fwServices::ObjectMsg > _msg ) throw(::fwTools::Failed);
/// Update editor information from the image
virtual void updating() throw(::fwTools::Failed);
/// Swap of image
virtual void swapping() throw(::fwTools::Failed);
/**
* @brief Configure the editor.
*
* Example of configuration
* @verbatim
<service uid="windowLevel" impl="::uiImage::WindowLevel" type="::gui::editor::IEditor" autoConnect="yes">
<config autoWindowing="yes" selectedTFKey="mySelectedTF" tfSelectionFwID="myTFSelection" useImageGreyLevelTF="yes" />
</service>
@endverbatim
* With :
* - \b autoWindowing : if 'yes', image windowing will be automatically compute from image pixel min/max
* intensity when this service receive BUFFER event
* - \b tfSelection : configure the identifier of the field containing the specific TF selection. By default, it use default selection field.
* - \b useImageGreyLevelTF : if 'yes' and if tfSelection is configured, then we use the grey level tf of image
*/
virtual void configuring() throw(fwTools::Failed);
/// Overrides
UIIMAGEQT_API virtual void info( std::ostream &_sstream ) ;
virtual void setEnabled(bool enable);
protected Q_SLOTS:
void onTextEditingFinished();
void onToggleTF(bool squareTF);
void onToggleAutoWL(bool autoWL);
void onWindowLevelWidgetChanged(double _min, double _max);
void onDynamicRangeSelectionChanged(QAction *action);
protected:
typedef ::fwData::TransferFunction::TFValuePairType WindowLevelMinMaxType;
double toWindowLevel(double _val);
double fromWindowLevel(double _val);
WindowLevelMinMaxType getImageWindowMinMax();
void onImageWindowLevelChanged(double _imageMin, double _imageMax);
void notifyWindowLevel(double _imageMin, double _imageMax);
void updateWidgetMinMax(double _imageMin, double _imageMax);
void updateImageWindowLevel(double _imageMin, double _imageMax);
void updateTextWindowLevel(double _imageMin, double _imageMax);
void setWidgetDynamicRange(double min, double max);
bool getWidgetDoubleValue(QLineEdit *widget, double &val);
/// Returns the current grey level tf of image
::fwData::TransferFunction::sptr getImageGreyLevelTF();
/// Swap current tf and notify other services
void swapCurrentTFAndNotify( ::fwData::TransferFunction::sptr newTF );
private:
QPointer< QLineEdit > m_valueTextMin;
QPointer< QLineEdit > m_valueTextMax;
QPointer< QToolButton > m_toggleTFButton;
QPointer< QToolButton > m_toggleAutoButton;
QPointer< QToolButton > m_dynamicRangeSelection;
QPointer< QMenu > m_dynamicRangeMenu;
QPointer< QSignalMapper > m_dynamicRangeSignalMapper;
QPointer< ::fwGuiQt::widget::QRangeSlider > m_rangeSlider;
double m_widgetDynamicRangeMin;
double m_widgetDynamicRangeWidth;
double m_imageMin;
double m_imageMax;
double m_notifiedImageMin;
double m_notifiedImageMax;
bool m_isNotifying;
bool m_autoWindowing;
bool m_useImageGreyLevelTF;
/// Identifier of the field containing the specific selection of TransferFunction
/// if m_tfSelection is empty => use default TF selection
std::string m_tfSelection;
};
} // uiImage
#endif /*_UIIMAGEQT_WINDOWLEVEL_HPP_*/
| [
"fbridault@IRCAD.FR"
] | fbridault@IRCAD.FR |
d4c71fe6c22bd2d27b1c8186de308725a8ed27d9 | 87929efca3d762486e086f222efef55b29256eca | /contracts/test_api/test_transaction.cpp | a92225c54d4389b4636aed9f899a530b3472b21d | [
"MIT"
] | permissive | ProbeChain/cubetrain | d4650865ae1a821d78aaf6712d7bdf8937e562ab | f02f9b67ef0d3e6d46d3aa96e6f9974ae72b13ff | refs/heads/master | 2022-12-13T12:12:41.137518 | 2019-11-30T10:09:02 | 2019-11-30T10:09:02 | 224,988,171 | 1 | 0 | MIT | 2022-12-11T18:49:23 | 2019-11-30T09:24:26 | C++ | UTF-8 | C++ | false | false | 11,596 | cpp | /**
* @file
* @copyright defined in seat/LICENSE.txt
*/
#include <cubetrainlib/action.hpp>
#include <cubetrainlib/crypto.h>
#include <cubetrainlib/transaction.hpp>
#include "test_api.hpp"
#pragma pack(push, 1)
template <uint64_t ACCOUNT, uint64_t NAME>
struct test_action_action {
static account_name get_account() {
return account_name(ACCOUNT);
}
static action_name get_name() {
return action_name(NAME);
}
cubetrain::vector<char> data;
template <typename DataStream>
friend DataStream& operator << ( DataStream& ds, const test_action_action& a ) {
for ( auto c : a.data )
ds << c;
return ds;
}
/*
template <typename DataStream>
friend DataStream& operator >> ( DataStream& ds, test_action_action& a ) {
return ds;
}
*/
};
template <uint64_t ACCOUNT, uint64_t NAME>
struct test_dummy_action {
static account_name get_account() {
return account_name(ACCOUNT);
}
static action_name get_name() {
return action_name(NAME);
}
char a;
unsigned long long b;
int32_t c;
template <typename DataStream>
friend DataStream& operator << ( DataStream& ds, const test_dummy_action& da ) {
ds << da.a;
ds << da.b;
ds << da.c;
return ds;
}
template <typename DataStream>
friend DataStream& operator >> ( DataStream& ds, test_dummy_action& da ) {
ds >> da.a;
ds >> da.b;
ds >> da.c;
return ds;
}
};
#pragma pack(pop)
void copy_data(char* data, size_t data_len, cubetrain::vector<char>& data_out) {
for (unsigned int i=0; i < data_len; i++)
data_out.push_back(data[i]);
}
void test_transaction::send_action() {
using namespace cubetrain;
test_dummy_action<N(testapi), WASM_TEST_ACTION("test_action", "read_action_normal")> test_action = {DUMMY_ACTION_DEFAULT_A, DUMMY_ACTION_DEFAULT_B, DUMMY_ACTION_DEFAULT_C};
action act(cubetrain::vector<permission_level>{{N(testapi), N(active)}}, test_action);
act.send();
}
void test_transaction::send_action_empty() {
using namespace cubetrain;
test_action_action<N(testapi), WASM_TEST_ACTION("test_action", "assert_true")> test_action;
action act(cubetrain::vector<permission_level>{{N(testapi), N(active)}}, test_action);
act.send();
}
/**
* cause failure due to a large action payload
*/
void test_transaction::send_action_large() {
using namespace cubetrain;
static char large_message[8 * 1024];
test_action_action<N(testapi), WASM_TEST_ACTION("test_action", "read_action_normal")> test_action;
copy_data(large_message, 8*1024, test_action.data);
action act(vector<permission_level>{{N(testapi), N(active)}}, test_action);
act.send();
cubetrain_assert(false, "send_message_large() should've thrown an error");
}
/**
* cause failure due recursive loop
*/
void test_transaction::send_action_recurse() {
using namespace cubetrain;
char buffer[1024];
read_action_data(buffer, 1024);
test_action_action<N(testapi), WASM_TEST_ACTION("test_transaction", "send_action_recurse")> test_action;
copy_data(buffer, 1024, test_action.data);
action act(vector<permission_level>{{N(testapi), N(active)}}, test_action);
act.send();
}
/**
* cause failure due to inline TX failure
*/
void test_transaction::send_action_inline_fail() {
using namespace cubetrain;
test_action_action<N(testapi), WASM_TEST_ACTION("test_action", "assert_false")> test_action;
action act(vector<permission_level>{{N(testapi), N(active)}}, test_action);
act.send();
}
void test_transaction::test_tapos_block_prefix() {
using namespace cubetrain;
int tbp;
read_action_data( (char*)&tbp, sizeof(int) );
cubetrain_assert( tbp == tapos_block_prefix(), "tapos_block_prefix does not match" );
}
void test_transaction::test_tapos_block_num() {
using namespace cubetrain;
int tbn;
read_action_data( (char*)&tbn, sizeof(int) );
cubetrain_assert( tbn == tapos_block_num(), "tapos_block_num does not match" );
}
void test_transaction::test_read_transaction() {
using namespace cubetrain;
checksum256 h;
auto size = transaction_size();
char buf[size];
uint32_t read = read_transaction( buf, size );
cubetrain_assert( size == read, "read_transaction failed");
sha256(buf, read, &h);
printhex( &h, sizeof(h) );
}
void test_transaction::test_transaction_size() {
using namespace cubetrain;
uint32_t trans_size = 0;
read_action_data( (char*)&trans_size, sizeof(uint32_t) );
print( "size: ", transaction_size() );
cubetrain_assert( trans_size == transaction_size(), "transaction size does not match" );
}
void test_transaction::send_transaction(uint64_t receiver, uint64_t, uint64_t) {
using namespace cubetrain;
dummy_action payload = {DUMMY_ACTION_DEFAULT_A, DUMMY_ACTION_DEFAULT_B, DUMMY_ACTION_DEFAULT_C};
test_action_action<N(testapi), WASM_TEST_ACTION("test_action", "read_action_normal")> test_action;
copy_data((char*)&payload, sizeof(dummy_action), test_action.data);
auto trx = transaction();
trx.actions.emplace_back(vector<permission_level>{{N(testapi), N(active)}}, test_action);
trx.send(0, receiver);
}
void test_transaction::send_action_sender(uint64_t receiver, uint64_t, uint64_t) {
using namespace cubetrain;
account_name cur_send;
read_action_data( &cur_send, sizeof(account_name) );
test_action_action<N(testapi), WASM_TEST_ACTION("test_action", "test_current_sender")> test_action;
copy_data((char*)&cur_send, sizeof(account_name), test_action.data);
auto trx = transaction();
trx.actions.emplace_back(vector<permission_level>{{N(testapi), N(active)}}, test_action);
trx.send(0, receiver);
}
void test_transaction::send_transaction_empty(uint64_t receiver, uint64_t, uint64_t) {
using namespace cubetrain;
auto trx = transaction();
trx.send(0, receiver);
cubetrain_assert(false, "send_transaction_empty() should've thrown an error");
}
void test_transaction::send_transaction_trigger_error_handler(uint64_t receiver, uint64_t, uint64_t) {
using namespace cubetrain;
auto trx = transaction();
test_action_action<N(testapi), WASM_TEST_ACTION("test_action", "assert_false")> test_action;
trx.actions.emplace_back(vector<permission_level>{{N(testapi), N(active)}}, test_action);
trx.send(0, receiver);
}
void test_transaction::assert_false_error_handler(const cubetrain::transaction& dtrx) {
cubetrain_assert(dtrx.actions.size() == 1, "transaction should only have one action");
cubetrain_assert(dtrx.actions[0].account == N(testapi), "transaction has wrong code");
cubetrain_assert(dtrx.actions[0].name == WASM_TEST_ACTION("test_action", "assert_false"), "transaction has wrong name");
cubetrain_assert(dtrx.actions[0].authorization.size() == 1, "action should only have one authorization");
cubetrain_assert(dtrx.actions[0].authorization[0].actor == N(testapi), "action's authorization has wrong actor");
cubetrain_assert(dtrx.actions[0].authorization[0].permission == N(active), "action's authorization has wrong permission");
}
/**
* cause failure due to a large transaction size
*/
void test_transaction::send_transaction_large(uint64_t receiver, uint64_t, uint64_t) {
using namespace cubetrain;
auto trx = transaction();
for (int i = 0; i < 32; i ++) {
char large_message[1024];
test_action_action<N(testapi), WASM_TEST_ACTION("test_action", "read_action_normal")> test_action;
copy_data(large_message, 1024, test_action.data);
trx.actions.emplace_back(vector<permission_level>{{N(testapi), N(active)}}, test_action);
}
trx.send(0, receiver);
cubetrain_assert(false, "send_transaction_large() should've thrown an error");
}
/**
* deferred transaction
*/
void test_transaction::deferred_print() {
cubetrain::print("deferred executed\n");
}
void test_transaction::send_deferred_transaction(uint64_t receiver, uint64_t, uint64_t) {
using namespace cubetrain;
auto trx = transaction();
test_action_action<N(testapi), WASM_TEST_ACTION("test_transaction", "deferred_print")> test_action;
trx.actions.emplace_back(vector<permission_level>{{N(testapi), N(active)}}, test_action);
trx.delay_sec = 2;
trx.send( 0xffffffffffffffff, receiver );
}
void test_transaction::send_deferred_transaction_replace(uint64_t receiver, uint64_t, uint64_t) {
using namespace cubetrain;
auto trx = transaction();
test_action_action<N(testapi), WASM_TEST_ACTION("test_transaction", "deferred_print")> test_action;
trx.actions.emplace_back(vector<permission_level>{{N(testapi), N(active)}}, test_action);
trx.delay_sec = 2;
trx.send( 0xffffffffffffffff, receiver, true );
}
void test_transaction::send_deferred_tx_with_dtt_action() {
using namespace cubetrain;
dtt_action dtt_act;
read_action_data(&dtt_act, action_data_size());
action deferred_act;
deferred_act.account = dtt_act.deferred_account;
deferred_act.name = dtt_act.deferred_action;
deferred_act.authorization = vector<permission_level>{{N(testapi), dtt_act.permission_name}};
auto trx = transaction();
trx.actions.emplace_back(deferred_act);
trx.delay_sec = dtt_act.delay_sec;
cancel_deferred( 0xffffffffffffffff ); // TODO: Remove this line after fixing deferred trx replacement RAM bug
trx.send( 0xffffffffffffffff, dtt_act.payer, true );
}
void test_transaction::cancel_deferred_transaction_success() {
using namespace cubetrain;
auto r = cancel_deferred( 0xffffffffffffffff ); //use the same id (0) as in send_deferred_transaction
cubetrain_assert( (bool)r, "transaction was not found" );
}
void test_transaction::cancel_deferred_transaction_not_found() {
using namespace cubetrain;
auto r = cancel_deferred( 0xffffffffffffffff ); //use the same id (0) as in send_deferred_transaction
cubetrain_assert( !r, "transaction was canceled, whild should not be found" );
}
void test_transaction::send_cf_action() {
using namespace cubetrain;
test_action_action<N(dummy), N(event1)> cfa;
action act(cfa);
act.send_context_free();
}
void test_transaction::send_cf_action_fail() {
using namespace cubetrain;
test_action_action<N(dummy), N(event1)> cfa;
action act(vector<permission_level>{{N(dummy), N(active)}}, cfa);
act.send_context_free();
cubetrain_assert(false, "send_cfa_action_fail() should've thrown an error");
}
void test_transaction::stateful_api() {
char buf[4] = {1};
db_store_i64(N(test_transaction), N(table), N(test_transaction), 0, buf, 4);
}
void test_transaction::context_free_api() {
char buf[128] = {0};
get_context_free_data(0, buf, sizeof(buf));
}
extern "C" { int is_feature_active(int64_t); }
void test_transaction::new_feature() {
cubetrain_assert(false == is_feature_active((int64_t)N(newfeature)), "we should not have new features unless hardfork");
}
void test_transaction::active_new_feature() {
activate_feature((int64_t)N(newfeature));
}
void test_transaction::repeat_deferred_transaction(uint64_t receiver, uint64_t code, uint64_t action) {
using namespace cubetrain;
uint128_t sender_id = 0;
uint32_t payload = unpack_action_data<uint32_t>();
print( "repeat_deferred_transaction called: payload = ", payload );
bool res = cancel_deferred( sender_id );
print( "\nrepeat_deferred_transaction cancelled trx with sender_id = ", sender_id, ", result is ", res );
if( payload == 0 ) return;
--payload;
transaction trx;
trx.actions.emplace_back( permission_level{receiver, N(active)}, code, action, payload );
trx.send( sender_id, receiver );
}
| [
"qf_wu@shanchain.com"
] | qf_wu@shanchain.com |
c94a01b423a88217c6be5e23c3097a071cd324ae | 8567438779e6af0754620a25d379c348e4cd5a5d | /third_party/WebKit/Source/modules/serviceworkers/ServiceWorkerError.h | b7b360f14babd819c5120b404af5da2b626a8973 | [
"LGPL-2.0-or-later",
"GPL-1.0-or-later",
"MIT",
"Apache-2.0",
"LicenseRef-scancode-warranty-disclaimer",
"LGPL-2.1-only",
"GPL-2.0-only",
"LGPL-2.0-only",
"BSD-2-Clause",
"LicenseRef-scancode-other-copyleft",
"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 | 2,455 | h | /*
* Copyright (C) 2013 Google Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef ServiceWorkerError_h
#define ServiceWorkerError_h
#include "platform/heap/Handle.h"
#include "public/platform/modules/serviceworker/WebServiceWorkerError.h"
#include "v8/include/v8.h"
namespace blink {
class DOMException;
class ScriptPromiseResolver;
class ServiceWorkerError {
STATIC_ONLY(ServiceWorkerError);
public:
// For CallbackPromiseAdapter
using WebType = const WebServiceWorkerError&;
static DOMException* take(ScriptPromiseResolver*,
const WebServiceWorkerError& webError);
};
class ServiceWorkerErrorForUpdate : public ServiceWorkerError {
STATIC_ONLY(ServiceWorkerErrorForUpdate);
public:
// For CallbackPromiseAdapter
static v8::Local<v8::Value> take(ScriptPromiseResolver* resolver,
const WebServiceWorkerError& webError);
};
} // namespace blink
#endif // ServiceWorkerError_h
| [
"hedonist.ky@gmail.com"
] | hedonist.ky@gmail.com |
432aba0c293d8c49801d9fc62770a6de85f40116 | 2a15722def201974110452467b4f093679ed8f34 | /subsequences.cpp | f56df428e3a19926899445732636f7747eda4e56 | [] | no_license | psdhanesh7/Competitive-Coding | 46eb525dc566e64e00b8daf20310f8625710bc68 | 26267ac0fc91decca3c2d6e9b8b0998f4970c5f4 | refs/heads/master | 2020-12-19T01:38:31.185834 | 2020-05-19T07:37:24 | 2020-05-19T07:37:24 | 235,579,890 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 848 | cpp | //The question is to return all the subsequences of a given string
#include<bits/stdc++.h>
using namespace std;
int subsequences(string input, string *output)
{
if(input.empty())
{
output[0] = "";
return 1;
}
int smallerAnsSize = subsequences(input.substr(1), output); //finding all the subsequeces of the substring starting from first index
for(int i = 0; i < smallerAnsSize; i++)
{
output[i+smallerAnsSize] = input[0] + output[i]; //appending the first charecter to all the subsequences we already know
}
smallerAnsSize = 2 * smallerAnsSize;
return smallerAnsSize;
}
int main(int argc, char const *argv[])
{
string input;
cin >> input;
string *output = new string[1000];
int length = subsequences(input, output);
for(int i = 0; i < length; i++)
{
cout << output[i] << endl ;
}
delete [] output;
return 0;
} | [
"psdhanesh2000@gmail.com"
] | psdhanesh2000@gmail.com |
e88824a027cdb3e9e7d1ba5bc4c63f9024c6144e | ad273708d98b1f73b3855cc4317bca2e56456d15 | /aws-cpp-sdk-rds/source/model/DescribeDBLogFilesRequest.cpp | 05a99cec6d74613ab3e2704c6dfe812c18378467 | [
"MIT",
"Apache-2.0",
"JSON"
] | permissive | novaquark/aws-sdk-cpp | b390f2e29f86f629f9efcf41c4990169b91f4f47 | a0969508545bec9ae2864c9e1e2bb9aff109f90c | refs/heads/master | 2022-08-28T18:28:12.742810 | 2020-05-27T15:46:18 | 2020-05-27T15:46:18 | 267,351,721 | 1 | 0 | Apache-2.0 | 2020-05-27T15:08:16 | 2020-05-27T15:08:15 | null | UTF-8 | C++ | false | false | 2,331 | cpp | /*
* Copyright 2010-2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
#include <aws/rds/model/DescribeDBLogFilesRequest.h>
#include <aws/core/utils/StringUtils.h>
#include <aws/core/utils/memory/stl/AWSStringStream.h>
using namespace Aws::RDS::Model;
using namespace Aws::Utils;
DescribeDBLogFilesRequest::DescribeDBLogFilesRequest() :
m_dBInstanceIdentifierHasBeenSet(false),
m_filenameContainsHasBeenSet(false),
m_fileLastWritten(0),
m_fileLastWrittenHasBeenSet(false),
m_fileSize(0),
m_fileSizeHasBeenSet(false),
m_filtersHasBeenSet(false),
m_maxRecords(0),
m_maxRecordsHasBeenSet(false),
m_markerHasBeenSet(false)
{
}
Aws::String DescribeDBLogFilesRequest::SerializePayload() const
{
Aws::StringStream ss;
ss << "Action=DescribeDBLogFiles&";
if(m_dBInstanceIdentifierHasBeenSet)
{
ss << "DBInstanceIdentifier=" << StringUtils::URLEncode(m_dBInstanceIdentifier.c_str()) << "&";
}
if(m_filenameContainsHasBeenSet)
{
ss << "FilenameContains=" << StringUtils::URLEncode(m_filenameContains.c_str()) << "&";
}
if(m_fileLastWrittenHasBeenSet)
{
ss << "FileLastWritten=" << m_fileLastWritten << "&";
}
if(m_fileSizeHasBeenSet)
{
ss << "FileSize=" << m_fileSize << "&";
}
if(m_filtersHasBeenSet)
{
unsigned filtersCount = 1;
for(auto& item : m_filters)
{
item.OutputToStream(ss, "Filters.member.", filtersCount, "");
filtersCount++;
}
}
if(m_maxRecordsHasBeenSet)
{
ss << "MaxRecords=" << m_maxRecords << "&";
}
if(m_markerHasBeenSet)
{
ss << "Marker=" << StringUtils::URLEncode(m_marker.c_str()) << "&";
}
ss << "Version=2014-10-31";
return ss.str();
}
void DescribeDBLogFilesRequest::DumpBodyToUrl(Aws::Http::URI& uri ) const
{
uri.SetQueryString(SerializePayload());
}
| [
"henso@amazon.com"
] | henso@amazon.com |
cf3b76505590ee07b22d192b8390267000f971ad | 5ac2e1c054269393efc091e65cd7a8b96c5a3b8c | /llvm-3.7.1.src.fgpu/lib/Target/Fgpu/Disassembler/FgpuDisassembler.cpp | 76aacc2a13ac94649e48b2e6e75e27701d03ad42 | [] | no_license | paleolithicman/DOGPU | 45885445800fa1a57550c48f61e2cacd3a8bd21f | 00247bf3b68195ffe28f2ebcc6b78a11cf559b25 | refs/heads/master | 2023-07-17T06:22:57.039712 | 2021-09-07T22:37:00 | 2021-09-07T22:37:00 | 397,407,366 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 10,745 | cpp | //===- FgpuDisassembler.cpp - Disassembler for Fgpu -------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file is part of the Fgpu Disassembler.
//
//===----------------------------------------------------------------------===//
#include "Fgpu.h"
#include "FgpuRegisterInfo.h"
#include "FgpuSubtarget.h"
#include "llvm/MC/MCDisassembler.h"
#include "llvm/MC/MCFixedLenDisassembler.h"
#include "llvm/MC/MCInst.h"
#include "llvm/MC/MCSubtargetInfo.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/MemoryObject.h"
#include "llvm/Support/TargetRegistry.h"
#include "llvm/Support/Debug.h"
#include <iostream>
using namespace llvm;
#define DEBUG_TYPE "fgpu-disassembler"
typedef MCDisassembler::DecodeStatus DecodeStatus;
namespace {
/// FgpuDisassemblerBase - a disasembler class for Fgpu.
class FgpuDisassemblerBase : public MCDisassembler {
public:
/// Constructor - Initializes the disassembler.
///
FgpuDisassemblerBase(const MCSubtargetInfo &STI, MCContext &Ctx,
bool bigEndian) :
MCDisassembler(STI, Ctx),
IsBigEndian(bigEndian) {}
virtual ~FgpuDisassemblerBase() {}
protected:
bool IsBigEndian;
};
/// FgpuDisassembler - a disasembler class for Fgpu32.
class FgpuDisassembler : public FgpuDisassemblerBase {
public:
/// Constructor - Initializes the disassembler.
///
FgpuDisassembler(const MCSubtargetInfo &STI, MCContext &Ctx, bool bigEndian)
: FgpuDisassemblerBase(STI, Ctx, bigEndian) {
}
/// getInstruction - See MCDisassembler.
DecodeStatus getInstruction(MCInst &Instr, uint64_t &Size,
ArrayRef<uint8_t> Bytes, uint64_t Address,
raw_ostream &VStream,
raw_ostream &CStream) const override;
};
} // end anonymous namespace
// Decoder tables for ALURegs registers
static const unsigned ALURegsTable[] = {
Fgpu::R0, Fgpu::R1, Fgpu::R2, Fgpu::R3,
Fgpu::R4, Fgpu::R5, Fgpu::R6, Fgpu::R7,
Fgpu::R8, Fgpu::R9, Fgpu::R10, Fgpu::R11,
Fgpu::R12, Fgpu::R13, Fgpu::R14, Fgpu::R15,
Fgpu::R16, Fgpu::R17, Fgpu::R18, Fgpu::R19,
Fgpu::R20, Fgpu::R21, Fgpu::R22, Fgpu::R23,
Fgpu::R24, Fgpu::R25, Fgpu::R26, Fgpu::R27,
Fgpu::R28, Fgpu::R29, Fgpu::LR, Fgpu::SP
};
static DecodeStatus DecodeVecRegsRegisterClass(MCInst &Inst,
unsigned RegNo,
uint64_t Address,
const void *Decoder);
static DecodeStatus DecodeFloatRegsRegisterClass(MCInst &Inst,
unsigned RegNo,
uint64_t Address,
const void *Decoder);
static DecodeStatus DecodeALURegsRegisterClass(MCInst &Inst,
unsigned RegNo,
uint64_t Address,
const void *Decoder);
static DecodeStatus DecodeGPROutRegisterClass(MCInst &Inst,
unsigned RegNo,
uint64_t Address,
const void *Decoder);
static DecodeStatus DecodeMem(MCInst &Inst,
unsigned Insn,
uint64_t Address,
const void *Decoder);
static DecodeStatus DecodeSimm9(MCInst &Inst, unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeUimm9(MCInst &Inst, unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeVecOffset9(MCInst &Inst, unsigned Insn,
uint64_t Address, const void *Decoder);
static DecodeStatus DecodeSimm10(MCInst &Inst, unsigned Insn, uint64_t Address, const void *Decoder);
static DecodeStatus DecodeUimm10(MCInst &Inst, unsigned Insn, uint64_t Address, const void *Decoder);
static DecodeStatus DecodeSimm7(MCInst &Inst, unsigned Insn, uint64_t Address, const void *Decoder);
static DecodeStatus DecodeSimm14(MCInst &Inst, unsigned Insn, uint64_t Address, const void *Decoder);
static DecodeStatus DecodeUimm14(MCInst &Inst, unsigned Insn, uint64_t Address, const void *Decoder);
static DecodeStatus DecodeUimm16(MCInst &Inst, unsigned Insn, uint64_t Address, const void *Decoder);
namespace llvm {
extern Target TheFgpuTarget;
}
static MCDisassembler *createFgpuDisassembler(
const Target &T,
const MCSubtargetInfo &STI,
MCContext &Ctx) {
return new FgpuDisassembler(STI, Ctx, false);
}
extern "C" void LLVMInitializeFgpuDisassembler() {
// Register the disassembler.
TargetRegistry::RegisterMCDisassembler(TheFgpuTarget,
createFgpuDisassembler);
}
#include "FgpuGenDisassemblerTables.inc"
/// Read four bytes from the ArrayRef and return 32 bit word sorted
/// according to the given endianess
static DecodeStatus readInstruction32(ArrayRef<uint8_t> Bytes, uint64_t Address,
uint64_t &Size, uint32_t &Insn,
bool IsBigEndian) {
// We want to read exactly 4 Bytes of data.
if (Bytes.size() < 4) {
Size = 0;
return MCDisassembler::Fail;
}
// DEBUG(dbgs() << "readInstruction entered, isBigEndian = " << IsBigEndian << "\n");
if (IsBigEndian) {
// Encoded as a big-endian 32-bit word in the stream.
Insn = (Bytes[3] << 0) |
(Bytes[2] << 8) |
(Bytes[1] << 16) |
(Bytes[0] << 24);
}
else {
// Encoded as a small-endian 32-bit word in the stream.
Insn = (Bytes[0] << 0) |
(Bytes[1] << 8) |
(Bytes[2] << 16) |
(Bytes[3] << 24);
}
return MCDisassembler::Success;
}
DecodeStatus
FgpuDisassembler::getInstruction(MCInst &Instr, uint64_t &Size,
ArrayRef<uint8_t> Bytes,
uint64_t Address,
raw_ostream &VStream,
raw_ostream &CStream) const {
uint32_t Insn;
DecodeStatus Result;
Result = readInstruction32(Bytes, Address, Size, Insn, IsBigEndian);
if (Result == MCDisassembler::Fail)
return MCDisassembler::Fail;
// Calling the auto-generated decoder function.
Result = decodeInstruction(DecoderTableFgpu32, Instr, Insn, Address,
this, STI);
if (Result != MCDisassembler::Fail) {
Size = 4;
return Result;
}
return MCDisassembler::Fail;
}
static DecodeStatus DecodeVecRegsRegisterClass(MCInst &Inst,
unsigned RegNo,
uint64_t Address,
const void *Decoder) {
Inst.addOperand(MCOperand::createReg(Fgpu::F0 + RegNo));
return MCDisassembler::Success;
}
static DecodeStatus DecodeFloatRegsRegisterClass(MCInst &Inst,
unsigned RegNo,
uint64_t Address,
const void *Decoder) {
if (RegNo > 30)
return MCDisassembler::Fail;
Inst.addOperand(MCOperand::createReg(ALURegsTable[RegNo]));
return MCDisassembler::Success;
}
static DecodeStatus DecodeALURegsRegisterClass(MCInst &Inst,
unsigned RegNo,
uint64_t Address,
const void *Decoder) {
if (RegNo > 32)
return MCDisassembler::Fail;
Inst.addOperand(MCOperand::createReg(ALURegsTable[RegNo]));
return MCDisassembler::Success;
}
static DecodeStatus DecodeGPROutRegisterClass(MCInst &Inst,
unsigned RegNo,
uint64_t Address,
const void *Decoder) {
if (RegNo > 31)
return MCDisassembler::Fail;
return DecodeALURegsRegisterClass(Inst, RegNo, Address, Decoder);
}
static DecodeStatus DecodeMem(MCInst &Inst, unsigned Insn, uint64_t Address, const void *Decoder) {
int Offset = SignExtend32<14>((Insn>>5) & 0x3fff);
int Base = (int)fieldFromInstruction(Insn, 0, 5);
Inst.addOperand(MCOperand::createReg(ALURegsTable[Base]));
Inst.addOperand(MCOperand::createImm(Offset));
return MCDisassembler::Success;
}
static DecodeStatus DecodeVecOffset9(MCInst &Inst, unsigned Insn, uint64_t Address, const void *Decoder) {
Inst.addOperand(MCOperand::createImm(SignExtend32<16>(Insn>>7)));
return MCDisassembler::Success;
}
static DecodeStatus DecodeSimm9(MCInst &Inst, unsigned Insn, uint64_t Address, const void *Decoder) {
Inst.addOperand(MCOperand::createImm(SignExtend32<9>(Insn)));
return MCDisassembler::Success;
}
static DecodeStatus DecodeUimm9(MCInst &Inst, unsigned Insn, uint64_t Address, const void *Decoder) {
Inst.addOperand(MCOperand::createImm(Insn));
return MCDisassembler::Success;
}
static DecodeStatus DecodeSimm10(MCInst &Inst, unsigned Insn, uint64_t Address, const void *Decoder) {
Inst.addOperand(MCOperand::createImm(SignExtend32<10>(Insn)));
return MCDisassembler::Success;
}
static DecodeStatus DecodeUimm10(MCInst &Inst, unsigned Insn, uint64_t Address, const void *Decoder) {
Inst.addOperand(MCOperand::createImm(Insn));
return MCDisassembler::Success;
}
static DecodeStatus DecodeSimm7(MCInst &Inst, unsigned Insn, uint64_t Address, const void *Decoder) {
Inst.addOperand(MCOperand::createImm(SignExtend32<7>(Insn)));
return MCDisassembler::Success;
}
static DecodeStatus DecodeSimm14(MCInst &Inst, unsigned Insn, uint64_t Address, const void *Decoder) {
Inst.addOperand(MCOperand::createImm(SignExtend32<14>(Insn)));
return MCDisassembler::Success;
}
static DecodeStatus DecodeUimm14(MCInst &Inst, unsigned Insn, uint64_t Address, const void *Decoder) {
Inst.addOperand(MCOperand::createImm(Insn));
return MCDisassembler::Success;
}
static DecodeStatus DecodeUimm16(MCInst &Inst, unsigned Insn, uint64_t Address, const void *Decoder) {
DEBUG(dbgs() << "DecodeUimm16 entered, Insn = " << Insn << "\n");
Inst.addOperand(MCOperand::createImm(SignExtend32<16>(Insn)));
return MCDisassembler::Success;
}
| [
"marui9633@vsl025.research.intel-research.net"
] | marui9633@vsl025.research.intel-research.net |
32d9e7deb55a3aea25cdcf3e7cd8e5f6f4c51cb2 | 27e1a0831fa730f710c7f48125092b8bfa98c8c6 | /tests/framework/instruments/Measurement.h | 5c62977b91f64bc25f20f385f527e6c81a14f066 | [
"MIT"
] | permissive | adityagupta1089/ComputeLibrary | ff9c57f4f69b02d3789f72b5223bc9c1f28ad777 | 39945fde9bbb805e76c55baf3ca536a376fb00f4 | refs/heads/master | 2021-06-22T06:54:52.030052 | 2021-01-03T14:04:39 | 2021-01-03T14:04:39 | 158,011,217 | 2 | 1 | MIT | 2018-11-17T18:07:24 | 2018-11-17T18:07:24 | null | UTF-8 | C++ | false | false | 8,961 | h | /*
* Copyright (c) 2017-2018 ARM Limited.
*
* SPDX-License-Identifier: MIT
*
* 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 ARM_COMPUTE_TEST_MEASUREMENT
#define ARM_COMPUTE_TEST_MEASUREMENT
#include "../Utils.h"
#include "arm_compute/core/Error.h"
#include <list>
#include <ostream>
#include <string>
namespace arm_compute
{
namespace test
{
namespace framework
{
/** Generic measurement that stores values as either double or long long int. */
struct Measurement
{
/** Measurement value */
struct Value
{
/** Constructor
*
* @param[in] is_floating Will the value stored be floating point ?
*/
Value(bool is_floating)
: v{ 0 }, is_floating_point(is_floating)
{
}
/** Add the value stored to the stream as a string
*/
friend std::ostream &operator<<(std::ostream &os, const Value &value)
{
if(value.is_floating_point)
{
os << arithmetic_to_string(value.v.floating_point, 4);
}
else
{
os << arithmetic_to_string(value.v.integer);
}
return os;
}
/** Convert the value stored to string
*/
std::string to_string() const
{
std::stringstream ss;
ss << *this;
return ss.str();
}
/** Add with another value and return the sum
*
* @param[in] b Other value
*
* @return Sum of the stored value + b
*/
Value operator+(Value b) const
{
if(is_floating_point)
{
b.v.floating_point += v.floating_point;
}
else
{
b.v.integer += v.integer;
}
return b;
}
/** Subtract with another value and return the result
*
* @param[in] b Other value
*
* @return Result of the stored value - b
*/
Value operator-(Value b) const
{
if(is_floating_point)
{
b.v.floating_point -= v.floating_point;
}
else
{
b.v.integer -= v.integer;
}
return b;
}
/** Multiple with another value and return the result
*
* @param[in] b Other value
*
* @return Result of the stored value * b
*/
Value operator*(Value b) const
{
if(is_floating_point)
{
b.v.floating_point *= v.floating_point;
}
else
{
b.v.integer *= v.integer;
}
return b;
}
/** Return the stored value divided by an integer.
*
* @param[in] b Integer to divide the value by.
*
* @return Stored value / b
*/
Value operator/(int b) const
{
Value res(is_floating_point);
if(is_floating_point)
{
res.v.floating_point = v.floating_point / b;
}
else
{
res.v.integer = v.integer / b;
}
return res;
}
/** Subtract another value and return the updated stored value.
*
* @param[in] b Other value
*
* @return The updated stored value
*/
Value &operator-=(const Value &b)
{
if(is_floating_point)
{
v.floating_point -= b.v.floating_point;
}
else
{
v.integer -= b.v.integer;
}
return *this;
}
/** Compare the stored value with another value
*
* @param[in] b Value to compare against
*
* @return The result of stored value < b
*/
bool operator<(const Value &b) const
{
if(is_floating_point)
{
return v.floating_point < b.v.floating_point;
}
else
{
return v.integer < b.v.integer;
}
}
/** Get the relative standard deviation to a given distribution as a percentage.
*
* @param[in] variance The variance of the distribution.
* @param[in] mean The mean of the distribution.
*
* @return the relative standard deviation.
*/
static double relative_standard_deviation(const Value &variance, const Value &mean)
{
if(variance.is_floating_point)
{
return 100.0 * sqrt(variance.v.floating_point) / mean.v.floating_point;
}
else
{
return 100.0 * sqrt(static_cast<double>(variance.v.integer)) / mean.v.integer;
}
}
/** Stored value */
union
{
double floating_point;
long long int integer;
} v;
bool is_floating_point; /**< Is the stored value floating point or integer ? */
};
/** Compare the stored value with another value
*
* @param[in] b Value to compare against
*
* @return The result of stored value < b
*/
bool operator<(const Measurement &b) const
{
return _value < b.value();
}
/** Stream output operator to print the measurement.
*
* Prints value and unit.
*
* @param[out] os Output stream.
* @param[in] measurement Measurement.
*
* @return the modified output stream.
*/
friend inline std::ostream &operator<<(std::ostream &os, const Measurement &measurement)
{
os << measurement._value << " " << measurement._unit;
return os;
}
/** Constructor to store a floating point value
*
* @param[in] v Value to store
* @param[in] unit Unit of @p v
* @param[in] raw (Optional) The raw value(s) @p was generated from.
*/
template < typename Floating, typename std::enable_if < !std::is_integral<Floating>::value, int >::type = 0 >
Measurement(Floating v, std::string unit, std::list<std::string> raw = {})
: _unit(unit), _raw_data(std::move(raw)), _value(true)
{
_value.v.floating_point = static_cast<double>(v);
if(_raw_data.empty())
{
_raw_data = { _value.to_string() };
}
}
/** Constructor to store an integer value
*
* @param[in] v Value to store
* @param[in] unit Unit of @p v
* @param[in] raw (Optional) The raw value(s) @p was generated from.
*/
template <typename Integer, typename std::enable_if<std::is_integral<Integer>::value, int>::type = 0>
Measurement(Integer v, std::string unit, std::list<std::string> raw = {})
: _unit(unit), _raw_data(std::move(raw)), _value(false)
{
_value.v.integer = static_cast<long long int>(v);
if(_raw_data.empty())
{
_raw_data = { _value.to_string() };
}
}
/** Accessor for the unit of the measurement
*
* @return Unit of the measurement
*/
const std::string &unit() const
{
return _unit;
}
/** Accessor for the raw data
*
* @return The raw data
*/
const std::list<std::string> &raw_data() const
{
return _raw_data;
}
/** Accessor for the stored value
*
* @return The stored value
*/
const Value &value() const
{
return _value;
}
private:
std::string _unit;
std::list<std::string> _raw_data;
Value _value;
};
} // namespace framework
} // namespace test
} // namespace arm_compute
#endif /* ARM_COMPUTE_TEST_MEASUREMENT */
| [
"anthony.barbier@arm.com"
] | anthony.barbier@arm.com |
16f20d8334ee154a08e7c1d967fe6b082ea12c05 | acc2f5336d768a7d86dbd2eec441283cfd11d52d | /src/Core/CGUndisplayItem.cpp | 322e1865371280368f9c3c766ffd846df5c0e4cf | [] | no_license | stevexk/server | 86df9e8c2448ad97db9c3ab86820beec507ef092 | 4ddb6e7cfa510bb13ccd87f56db008aa1be1baad | refs/heads/master | 2020-01-23T22:00:57.359964 | 2015-09-18T14:58:27 | 2015-09-18T14:58:27 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,067 | cpp | //////////////////////////////////////////////////////////////////////////////
// Filename : CGUndisplayItem.cpp
// Written By :
// Description :
//////////////////////////////////////////////////////////////////////////////
#include "CGUndisplayItem.h"
void CGUndisplayItem::read (SocketInputStream & iStream)
throw(ProtocolException , Error)
{
__BEGIN_TRY
iStream.read(m_X);
iStream.read(m_Y);
iStream.read(m_ItemObjectID);
iStream.read(m_Index);
__END_CATCH
}
void CGUndisplayItem::write (SocketOutputStream & oStream) const
throw(ProtocolException , Error)
{
__BEGIN_TRY
oStream.write(m_X);
oStream.write(m_Y);
oStream.write(m_ItemObjectID);
oStream.write(m_Index);
__END_CATCH
}
void CGUndisplayItem::execute (Player* pPlayer)
throw(ProtocolException , Error)
{
__BEGIN_TRY
CGUndisplayItemHandler::execute(this , pPlayer);
__END_CATCH
}
string CGUndisplayItem::toString () const
throw()
{
__BEGIN_TRY
StringStream msg;
msg << "CGUndisplayItem("
<< ")" ;
return msg.toString();
__END_CATCH
}
| [
"tiancaiamao@gmail.com"
] | tiancaiamao@gmail.com |
df99e5a4417a8602a67ef13d334f0ff62ccacccd | 107db934db600f02f496ad30d1cbf3f919005473 | /libraries/Embedded_Template_Library/test/test_jenkins.cpp | ac9b104d337f047ea5727f0a0544ab0fd0228e1d | [
"MIT"
] | permissive | sh4dov/arduino | 106a8f43ce8621a4cd7191a7c5552e33f000fb6b | 2ba4e096e39643d316363732b7d64768693f704a | refs/heads/master | 2023-05-26T16:15:01.772897 | 2023-05-12T10:50:37 | 2023-05-12T10:50:37 | 54,305,397 | 0 | 0 | null | 2023-03-07T15:45:27 | 2016-03-20T07:14:49 | C++ | UTF-8 | C++ | false | false | 6,840 | cpp | /******************************************************************************
The MIT License(MIT)
Embedded Template Library.
https://github.com/ETLCPP/etl
http://www.etlcpp.com
Copyright(c) 2014 jwellbelove
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions :
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
******************************************************************************/
#include <UnitTest++/UnitTest++.h>
#include "murmurhash3.h" // The 'C' reference implementation.
#include <iterator>
#include <string>
#include <vector>
#include <stdint.h>
#include "../src/jenkins.h"
#include "../src/endian.h"
template <typename TIterator>
uint32_t jenkins32(TIterator begin, TIterator end)
{
uint32_t hash = 0;
while (begin != end)
{
hash += *begin++;
hash += (hash << 10);
hash ^= (hash >> 6);
}
hash += (hash << 3);
hash ^= (hash >> 11);
hash += (hash << 15);
return hash;
}
template <typename TIterator>
uint64_t jenkins64(TIterator begin, TIterator end)
{
uint64_t hash = 0;
while (begin != end)
{
hash += *begin++;
hash += (hash << 10);
hash ^= (hash >> 6);
}
hash += (hash << 3);
hash ^= (hash >> 11);
hash += (hash << 15);
return hash;
}
namespace
{
SUITE(test_jenkins)
{
//*************************************************************************
TEST(test_jenkins_32_constructor)
{
std::string data("123456789");
uint32_t hash = etl::jenkins<uint32_t>(data.begin(), data.end());
uint32_t compare = jenkins32(data.begin(), data.end());
CHECK_EQUAL(compare, hash);
}
//*************************************************************************
TEST(test_jenkins_32_add_values)
{
std::string data("123456789");
etl::jenkins<uint32_t> jenkins_32_calculator;
for (size_t i = 0; i < data.size(); ++i)
{
jenkins_32_calculator.add(data[i]);
}
uint32_t hash = jenkins_32_calculator;
uint32_t compare = jenkins32(data.begin(), data.end());
CHECK_EQUAL(compare, hash);
}
//*************************************************************************
TEST(test_jenkins_32_add_range)
{
std::string data("123456789");
etl::jenkins<uint32_t> jenkins_32_calculator;
jenkins_32_calculator.add(data.begin(), data.end());
uint32_t hash = jenkins_32_calculator.value();
uint32_t compare = jenkins32(data.begin(), data.end());
CHECK_EQUAL(compare, hash);
}
//*************************************************************************
TEST(test_jenkins_32_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };
std::vector<uint32_t> data2 = { 0x04030201, 0x08070605 };
std::vector<uint8_t> data3 = { 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01 };
uint32_t hash1 = etl::jenkins<uint32_t>(data1.begin(), data1.end());
uint32_t hash2 = etl::jenkins<uint32_t>((uint8_t*)&data2[0], (uint8_t*)&data2[0] + (data2.size() * sizeof(uint32_t)));
uint32_t hash3 = etl::jenkins<uint32_t>(data3.rbegin(), data3.rend());
CHECK_EQUAL(hash1, hash2);
CHECK_EQUAL(hash1, hash3);
uint64_t compare1 = jenkins32(data1.begin(), data1.end());
CHECK_EQUAL(compare1, hash1);
uint64_t compare2 = jenkins32((uint8_t*)&data2[0], (uint8_t*)&data2[0] + (data2.size() * sizeof(uint32_t)));
CHECK_EQUAL(compare2, hash2);
uint64_t compare3 = jenkins32(data3.rbegin(), data3.rend());
CHECK_EQUAL(compare2, hash3);
}
//*************************************************************************
TEST(test_jenkins_64_constructor)
{
std::string data("123456789");
uint64_t hash = etl::jenkins<uint64_t>(data.begin(), data.end());
uint64_t compare = jenkins64(data.begin(), data.end());
CHECK_EQUAL(compare, hash);
}
//*************************************************************************
TEST(test_jenkins_64_add_values)
{
std::string data("123456789");
etl::jenkins<uint64_t> jenkins_64_calculator;
for (size_t i = 0; i < data.size(); ++i)
{
jenkins_64_calculator.add(data[i]);
}
uint64_t hash = jenkins_64_calculator;
uint64_t compare = jenkins64(data.begin(), data.end());
CHECK_EQUAL(compare, hash);
}
//*************************************************************************
TEST(test_jenkins_64_add_range)
{
std::string data("123456789");
etl::jenkins<uint64_t> jenkins_64_calculator;
jenkins_64_calculator.add(data.begin(), data.end());
uint64_t hash = jenkins_64_calculator.value();
uint64_t compare = jenkins64(data.begin(), data.end());
CHECK_EQUAL(compare, hash);
}
//*************************************************************************
TEST(test_jenkins_64_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };
std::vector<uint32_t> data2 = { 0x04030201, 0x08070605 };
std::vector<uint8_t> data3 = { 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01 };
uint64_t hash1 = etl::jenkins<uint64_t>(data1.begin(), data1.end());
uint64_t hash2 = etl::jenkins<uint64_t>((uint8_t*)&data2[0], (uint8_t*)&data2[0] + (data2.size() * sizeof(uint32_t)));
uint64_t hash3 = etl::jenkins<uint64_t>(data3.rbegin(), data3.rend());
CHECK_EQUAL(hash1, hash2);
CHECK_EQUAL(hash1, hash3);
uint64_t compare1 = jenkins64(data1.begin(), data1.end());
CHECK_EQUAL(compare1, hash1);
uint64_t compare2 = jenkins64((uint8_t*)&data2[0], (uint8_t*)&data2[0] + (data2.size() * sizeof(uint32_t)));
CHECK_EQUAL(compare2, hash2);
uint64_t compare3 = jenkins64(data3.rbegin(), data3.rend());
CHECK_EQUAL(compare2, hash3);
}
};
}
| [
"arojek.work@gmail.com"
] | arojek.work@gmail.com |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.